{
  "schemaVersion": 3,
  "runId": "70b164dc-6ef6-4a75-93d6-33918b6faa41",
  "fixtureIds": [
    "gmod.ents-iterator.v1",
    "gmod.hook-add.v1",
    "gmod.isvalid.v1",
    "gmod.net-receivers.v1",
    "gmod.perf.angle-zero.v1",
    "gmod.perf.config-var.v1",
    "gmod.perf.darkrpvar.v1",
    "gmod.perf.disttosqr.v1",
    "gmod.perf.ents-iterator.v1",
    "gmod.perf.find-ents-near.v1",
    "gmod.perf.find-players-near.v1",
    "gmod.perf.for-vs-while.v1",
    "gmod.perf.hook-once.v1",
    "gmod.perf.hudpaint-cache.v1",
    "gmod.perf.local-color.v1",
    "gmod.perf.local-vs-global.v1",
    "gmod.perf.localplayer-cache.v1",
    "gmod.perf.looking-at.v1",
    "gmod.perf.meta-vs-arg.v1",
    "gmod.perf.msg-vs-print.v1",
    "gmod.perf.pairs-ipairs-for.v1",
    "gmod.perf.plain-lua-vs-fn.v1",
    "gmod.perf.player-cache-hooks.v1",
    "gmod.perf.ply-table-index.v1",
    "gmod.perf.seq-tables.v1",
    "gmod.perf.setdrawcolor-split.v1",
    "gmod.perf.sqlite-vs-mysql.v1",
    "gmod.perf.steamid-cache.v1",
    "gmod.perf.string-table-concat.v1",
    "gmod.perf.surface-drawrect.v1",
    "gmod.perf.surface-text.v1",
    "gmod.perf.table-count-hash.v1",
    "gmod.perf.table-empty.v1",
    "gmod.perf.table-hasvalue.v1",
    "gmod.perf.table-literal.v1",
    "gmod.perf.table-random.v1",
    "gmod.perf.x-times-x.v1",
    "gmod.player-iterator.v1"
  ],
  "startedAt": "2026-07-10T15:56:33.573Z",
  "completedAt": "2026-07-10T16:08:37.501Z",
  "repeat": 5,
  "concurrency": 6,
  "attempts": [
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs( ents.FindByClass( \"prop_physics\" ) ) do\n    -- Do something with ent\nend\n```\nReason: `ents.FindByClass` queries the engine directly to return a table containing only the requested entities, avoiding the massive memory overhead and iteration cost of using `ents.GetAll()` to build a table of every entity in the map.",
      "durationMs": 13683,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- Your code here\nend\n```\nReason: `ents.FindByClass` filters entities natively within the C++ engine and returns a table containing only the matching entities, bypassing the significant memory allocation and performance overhead of generating a Lua table of every single entity in the map via `ents.GetAll()`.",
      "durationMs": 23611,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs( ents.FindByClass( \"prop_physics\" ) ) do\n    -- do something with ent\nend\n```\nReason: `ents.FindByClass` performs the class filtering on the C++ side and returns a table containing only the matching entities, avoiding the need to construct a massive table of all entities in the map (which `ents.GetAll()` does).",
      "durationMs": 12253,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- Do something with ent\nend\n```\nReason: `ents.FindByClass(\"prop_physics\")` directly returns a table containing only the entities that match the specified class, avoiding the performance and memory overhead of constructing a table of every single entity in the map like `ents.GetAll()` does.",
      "durationMs": 15277,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- do something with ent\nend\n```\nReason: `ents.FindByClass` filters entities on the C++ side and returns a table containing only the matching entities, avoiding the costly memory allocation of building a table of all entities like `ents.GetAll()` does.",
      "durationMs": 19702,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- callback logic goes here\nend)\n```\nReason: hook.Add is the standard Garry's Mod API function used to bind custom callbacks to engine events.",
      "durationMs": 11231,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- Your think logic here\nend)\n```\nReason: `hook.Add` is the standard Garry's Mod function used to bind a callback to a specific game event hook using a unique string identifier.",
      "durationMs": 8171,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- callback body\nend)\n```\nReason: hook.Add is the standard Garry's Mod function used to register a callback function to a specific event hook.",
      "durationMs": 8690,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\nend)\n```\nReason: The hook.Add function is the standard way to register callbacks to Garry's Mod events like Think.",
      "durationMs": 8787,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\nend)\n```\nReason: The `hook.Add` function is the standard API in Garry's Mod for attaching custom callbacks to specific engine events.",
      "durationMs": 8147,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- Safe to call methods on ent\nend\n```\nReason: The `IsValid(ent)` global function safely checks that the variable is not nil and that the underlying engine entity has not been removed, preventing \"Tried to use a NULL entity!\" errors.",
      "durationMs": 8964,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- Safe to call methods on ent\nend\n```\nReason: The `IsValid()` global function safely checks that the variable is not nil, is an Entity object, and has not been removed from the game world (which would make it a NULL entity).",
      "durationMs": 8488,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- ent is safe to use\nend\n```\nReason: The global IsValid function safely checks both that the variable is not nil and that the underlying C++ entity has not been removed from the game world.",
      "durationMs": 10438,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- safe to call methods on ent\nend\n```\nReason: The global `IsValid(ent)` function ensures the variable is not nil and that its underlying C++ object has not been removed from the game world, preventing null pointer crashes.",
      "durationMs": 9736,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- It is safe to call methods on ent here\nend\n```\nReason: The global `IsValid()` function safely checks both that the Lua reference is not nil and that the underlying C++ game entity still exists and has not been removed.",
      "durationMs": 10546,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive( \"MyAddon.Sync\", function( len, ply )\n    -- Handle the incoming network message here\nend )\n```\nReason: net.Receive is the standard Garry's Mod function used to hook into and handle incoming net messages.",
      "durationMs": 8199,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming network message here\nend)\n```\nReason: The net.Receive function registers a callback that listens for and handles incoming network messages matching the specified string identifier.",
      "durationMs": 7719,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handler code goes here\nend)\n```\nReason: The net.Receive function is the standard Garry's Mod API for listening to incoming network messages by their registered string name.",
      "durationMs": 7854,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle message here\nend)\n```\nReason: `net.Receive` is the standard function used in Garry's Mod to register a callback that triggers when a network message with a specific name is received.",
      "durationMs": 8598,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming message\nend)\n```\nReason: net.Receive is the standard Garry's Mod function used to register a callback for an incoming network message.",
      "durationMs": 7975,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedAngle = Angle()\n\nlocal function HotPath()\n    -- Instead of local ang = Angle(), reuse the cached one:\n    cachedAngle:Zero()\n    \n    -- Now you have a fresh, zeroed Angle to use without allocating memory\n    -- (e.g., cachedAngle.p = 10, etc.)\nend\n```\nReason: Reusing a pre-allocated object and calling `:Zero()` avoids the overhead of object instantiation and subsequent garbage collection in a hot path.",
      "durationMs": 12957,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedAngle = Angle()\n\nlocal function HotPath()\n    cachedAngle:Zero()\n    -- Modify and use cachedAngle here\nend\n```\nReason: Pre-allocating the Angle object once and resetting it with `:Zero()` avoids the performance overhead of continuous memory allocation and garbage collection in the hot path.",
      "durationMs": 19252,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedAngle = Angle()\n\nlocal function HotPath()\n    cachedAngle:Zero()\n    -- Use cachedAngle without allocating a new object\nend\n```\n\nReason: Reusing a locally cached Angle object and resetting it with `:Zero()` avoids the memory allocation and garbage collection overhead of instantiating a new Angle object on every iteration.",
      "durationMs": 12572,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedAngle = Angle()\n\nlocal function HotPath()\n    cachedAngle:Zero()\n    -- Use cachedAngle here\nend\n```\nReason: Mutating a cached object using :Zero() avoids the performance overhead of continuous memory allocation and garbage collection caused by creating new Angle() objects.",
      "durationMs": 10413,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal temp_angle = Angle()\n\nlocal function HotPathFunction()\n    temp_angle:Zero()\n    -- Use temp_angle for calculations here\nend\n```\nReason: Caching an Angle object outside the hot path and calling `:Zero()` on it reuses the existing object, avoiding the memory allocation and garbage collection overhead of creating a new `Angle()` every time.",
      "durationMs": 13760,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nsurface.SetDrawColor(myaddon_config_color)\n```\nReason: Local variables are accessed directly from fast registers by LuaJIT, bypassing the costly string hashing and memory lookups required for nested table indexing.",
      "durationMs": 10768,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal config_color = Color(255, 255, 255)\n\nlocal function ApplyColor()\n    surface.SetDrawColor(config_color)\nend\n```\nReason: Local variables are resolved at compile time to fast stack registers, completely avoiding the expensive hash dictionary lookups required by global variables or nested tables.",
      "durationMs": 10695,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal config_color = Color(255, 255, 255)\nlocal current_color = config_color\n```\nReason: Local variables map directly to LuaJIT registers, avoiding the costly hash lookups and memory indirection required for nested table accesses.",
      "durationMs": 9320,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal currentColor = myaddon_config_color\n```\nReason: Local variables use fast register lookups in LuaJIT, whereas nested tables and globals require slower hash map lookups for every level of indexing.",
      "durationMs": 12454,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal r = myaddon_config_color.r\n```\nReason: Local variables are stored directly in Lua VM registers, avoiding the hash lookups and memory indirection required when traversing nested tables.",
      "durationMs": 9233,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nteam.GetName(ply:Team())\n```\nReason: In DarkRP, jobs are registered as standard Garry's Mod teams, making this the most efficient and reliable way to retrieve the job's display name without relying on less efficient networked strings.",
      "durationMs": 12893,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal jobName = team.GetName(ply:Team())\n```\nReason: Jobs in DarkRP are built on top of the native Garry's Mod team system, which the Source engine already networks automatically and highly efficiently, completely avoiding the overhead of custom networked strings.",
      "durationMs": 10531,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal jobName = ply:getDarkRPVar(\"job\")\n```\nReason: DarkRP uses its own custom networking system (DarkRPVars) to optimize bandwidth, making getDarkRPVar the correct and most efficient method to retrieve job information over standard GMod networked strings.",
      "durationMs": 10536,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nteam.GetName(ply:Team())\n```\nReason: DarkRP implements jobs using the native Garry's Mod team system, making this the standard and most efficient way to retrieve a job name without relying on less efficient network strings.",
      "durationMs": 8884,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal jobName = team.GetName(ply:Team())\n```\nReason: DarkRP implements jobs as Garry's Mod teams, making this the standard, most reliable, and performant method compared to querying arbitrary networked strings.",
      "durationMs": 9355,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nif vec1:DistToSqr(vec2) < (threshold * threshold) then\n    -- Vectors are within the threshold distance\nend\n```\nReason: Using `DistToSqr` avoids the computationally expensive square root operation used by `Distance`, making it much faster for simple threshold comparisons.",
      "durationMs": 9875,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nvec1:DistToSqr(vec2) <= (threshold * threshold)\n```\nReason: DistToSqr avoids the computationally expensive square root calculation used in standard distance checks, making it significantly faster for simple threshold comparisons.",
      "durationMs": 10288,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nif vec1:DistToSqr(vec2) < threshold ^ 2 then\n    -- vectors are within the threshold distance\nend\n```\nReason: `DistToSqr` avoids the computationally expensive square root calculation required by exact distance checks, making it significantly more performant.",
      "durationMs": 9546,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nvec1:DistToSqr(vec2) < (threshold * threshold)\n```\nReason: DistToSqr avoids the expensive square root operation used in calculating the actual distance, making threshold comparisons much more performant.",
      "durationMs": 8728,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nif vec1:DistToSqr(vec2) < (threshold * threshold) then\n    -- Vectors are within the threshold distance\nend\n```\nReason: `DistToSqr` avoids the computationally expensive square root operation used in standard distance calculations.",
      "durationMs": 9156,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with ent\nend\n```\nReason: `ents.Iterator()` avoids the performance cost and garbage collection overhead of creating a new sequential table, which happens when using `ents.GetAll()`.",
      "durationMs": 8493,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- do something with ent\nend\n```\nReason: ents.Iterator() is the wiki-recommended approach because it iterates sequentially without generating a new table, avoiding the memory allocation and garbage collection overhead of ents.GetAll().",
      "durationMs": 8274,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- do something with ent\nend\n```\nReason: ents.Iterator() is recommended over ents.GetAll() because it iterates without allocating a new table each time, significantly reducing garbage collection overhead and improving performance.",
      "durationMs": 9107,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with ent\nend\n```\nReason: ents.Iterator() is the modern, wiki-recommended approach as it is faster and avoids creating a new table allocation on every loop compared to ents.GetAll().",
      "durationMs": 9553,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with ent\nend\n```\nReason: ents.Iterator() is the wiki-recommended approach because it provides a zero-allocation iterator, significantly improving performance and reducing garbage collection overhead compared to ents.GetAll().",
      "durationMs": 11764,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal nearby_ents = ents.FindInSphere(ply:GetPos(), 512)\nfor i = 1, #nearby_ents do\n    local ent = nearby_ents[i]\n    if IsValid(ent) and ent ~= ply then\n        -- process nearby entity\n    end\nend\n```\nReason: ents.FindInSphere leverages the engine's underlying spatial partitioning (BSP/KD-tree) in C++ to instantly retrieve local entities, avoiding the severe performance cost of iterating and distance-checking every entity on the server.",
      "durationMs": 11310,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal pos = ply:GetPos()\nlocal offset = Vector(256, 256, 256)\nlocal nearbyEnts = ents.FindInBox(pos - offset, pos + offset)\n```\nReason: ents.FindInBox is consistently faster in GMod benchmarks than ents.FindInSphere because it relies on a simple AABB intersection check against the engine's spatial partition, completely skipping the mathematical overhead of calculating point-to-point distances for every entity in the leaf nodes.",
      "durationMs": 15167,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function GetEntitiesNearPlayer(ply, radius)\n    return ents.FindInSphere(ply:GetPos(), radius)\nend\n```\nReason: ents.FindInSphere uses the Source engine's internal C++ spatial partition tree for rapid C-side culling, significantly outperforming manual distance checks against ents.GetAll() in Lua.",
      "durationMs": 11923,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal nearby = ents.FindInSphere(ply:GetPos(), 256)\nfor i = 1, #nearby do\n    local ent = nearby[i]\n    if ent:IsValid() and ent ~= ply then\n        -- Process entity here\n    end\nend\n```\nReason: ents.FindInSphere utilizes the engine's internal spatial partitioning KD-tree to rapidly find entities within a radius, making it vastly more performant than iterating over all server entities.",
      "durationMs": 13146,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal radius = 500\nlocal nearbyEnts = ents.FindInSphere(ply:GetPos(), radius)\nfor i = 1, #nearbyEnts do\n    local ent = nearbyEnts[i]\n    if IsValid(ent) and ent ~= ply then\n        -- Process entity\n    end\nend\n```\nReason: ents.FindInSphere is executed natively in C++ using the engine's internal spatial partitioning, making it significantly faster than iterating through ents.GetAll() in Lua.",
      "durationMs": 10457,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local found = {}\n    local radiusSqr = radius * radius\n    local players = player.GetAll()\n    \n    for i = 1, #players do\n        local ply = players[i]\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            found[#found + 1] = ply\n        end\n    end\n    \n    return found\nend\n```\nReason: Iterating over the small, cached list of players via player.GetAll() and using DistToSqr avoids searching through thousands of map entities in the spatial partition and skips computationally expensive square root calculations.",
      "durationMs": 14559,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInSphere(pos, radius)\n    local playersInRadius = {}\n    local radiusSqr = radius * radius\n    \n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            table.insert(playersInRadius, ply)\n        end\n    end\n    \n    return playersInRadius\nend\n```\nReason: Iterating `player.GetAll()` and checking squared distances is much faster because it only evaluates players (a maximum of 128) rather than searching through every entity in the map's spatial partition and creating a large intermediate table.",
      "durationMs": 11899,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local playersInRadius = {}\n    local radiusSqr = radius * radius\n    local players = player.GetAll()\n    \n    for i = 1, #players do\n        local ply = players[i]\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            playersInRadius[#playersInRadius + 1] = ply\n        end\n    end\n    \n    return playersInRadius\nend\n```\nReason: Iterating the small, cached list from player.GetAll() and performing a simple squared distance check in Lua avoids querying the engine's spatial partition and filtering through numerous non-player entities.",
      "durationMs": 12605,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local found = {}\n    local radiusSqr = radius * radius\n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            found[#found + 1] = ply\n        end\n    end\n    return found\nend\n```\nReason: Iterating player.GetAll() and checking DistToSqr is much faster because it only loops through a maximum of 128 players using fast squared distance math, avoiding the heavy overhead of ents.FindInSphere checking the spatial partition for potentially thousands of props and non-player entities.",
      "durationMs": 14394,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInSphere(pos, radius)\n    local players = {}\n    local radiusSqr = radius * radius\n    \n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            players[#players + 1] = ply\n        end\n    end\n    \n    return players\nend\n```\nReason: Iterating over the much smaller player.GetAll() table using DistToSqr avoids the massive overhead of ents.FindInSphere querying the spatial partition and checking thousands of non-player entities.",
      "durationMs": 12597,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: The numeric for loop uses specialized, highly optimized bytecode instructions that manage the loop counter and condition internally, avoiding the overhead of explicit variable updates and condition checks required by a while loop.",
      "durationMs": 9304,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: Numeric for loops use specialized internal bytecode instructions to manage the counter and condition, avoiding the explicit variable increment and comparison overhead of a while loop.",
      "durationMs": 8580,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: A numeric for loop is generally faster in Lua/LuaJIT because it uses specialized, optimized VM instructions for the iteration step, whereas a while loop requires separate instructions for incrementing and condition checking.",
      "durationMs": 10326,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: Numeric `for` loops are natively optimized by LuaJIT with internal control variables, making them faster than manually incrementing and evaluating conditions in a `while` loop.",
      "durationMs": 9297,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: LuaJIT has specialized bytecode instructions for numeric for loops and optimizes them far more aggressively than while loops, which require explicit condition checking and variable incrementing.",
      "durationMs": 9318,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function Tick()\n    local plys = player.GetAll()\n    \n    -- Faster pattern: Call the hook once and pass the players\n    hook.Run(\"TickPlayers\", plys)\n    \n    -- Slower pattern (avoid): Calling the hook per player\n    -- for i = 1, #plys do\n    --     hook.Run(\"TickPlayer\", plys[i])\n    -- end\nend\n\nhook.Add(\"TickPlayers\", \"CustomLogic\", function(plys)\n    for i = 1, #plys do\n        local ply = plys[i]\n        -- execute logic for ply\n    end\nend)\n```\n\nReason: Calling `hook.Run` has inherent overhead from internal table lookups and function dispatching; doing this once per tick instead of once per player drastically reduces this overhead.",
      "durationMs": 13102,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"Tick\", \"BroadcastTickToPlayers\", function()\n    local plys = player.GetAll()\n    hook.Run(\"CustomPlayerLogic\", plys)\nend)\n\nhook.Add(\"CustomPlayerLogic\", \"ProcessPlayerLogic\", function(plys)\n    for i = 1, #plys do\n        local ply = plys[i]\n        -- Execute custom logic for each player here\n    end\nend)\n```\nReason: Calling `hook.Run` has inherent overhead, so executing it just once per tick and looping through the players inside the listener is significantly faster than triggering the hook for every single player individually.",
      "durationMs": 13677,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"Tick\", \"NotifyAllPlayers\", function()\n    local plys = player.GetAll()\n    hook.Run(\"CustomPlayerLogicTick\", plys)\nend)\n```\nReason: Calling hook.Run incurs overhead from looking up and iterating the internal hooks table, so calling it once per tick instead of once per player drastically reduces this overhead.",
      "durationMs": 12347,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"Tick\", \"BroadcastCustomLogic\", function()\n    hook.Run(\"CustomPlayerTick\", player.GetAll())\nend)\n```\nReason: Calling hook.Run once per tick avoids the repetitive internal overhead of hook table lookups and function dispatch that would otherwise occur for every single player.",
      "durationMs": 12574,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"Tick\", \"NotifyPlayers\", function()\n    local plys = player.GetAll()\n    hook.Run(\"CustomLogicAllPlayers\", plys)\nend)\n```\nReason: `hook.Run` incurs internal overhead from string hashing and iterating over registered listeners, so calling it once per tick is significantly faster than executing it repeatedly inside a player loop.",
      "durationMs": 15697,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal hp = LocalPlayer():Health()\ndraw.SimpleText(hp, \"DermaDefault\", 10, 10, color_white)\ndraw.SimpleText(hp, \"DermaDefault\", 10, 30, color_white)\ndraw.SimpleText(hp, \"DermaDefault\", 10, 50, color_white)\n```\nReason: Caching the result in a local variable avoids the performance overhead of executing multiple function calls and C++ boundary crossings every frame.",
      "durationMs": 13968,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHUD\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local hp = ply:Health()\n    \n    draw.SimpleText(\"HP: \" .. hp, \"DermaDefault\", 10, 10, color_white)\n    surface.DrawRect(10, 30, hp * 2, 20)\n    draw.RoundedBox(4, 10, 60, hp * 2, 20, color_white)\nend)\n```\nReason: Caching the result of LocalPlayer():Health() in a local variable avoids multiple expensive C++ boundary function calls during a single render frame.",
      "durationMs": 12822,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHUDDraw\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local hp = ply:Health()\n    \n    draw.SimpleText(\"Health: \" .. hp, \"DermaDefault\", 50, 50, color_white)\n    draw.RoundedBox(0, 50, 70, hp, 20, color_white)\n    surface.SetDrawColor(255, 0, 0, 255)\n    surface.DrawRect(50, 100, hp, 20)\nend)\n```\nReason: Caching LocalPlayer():Health() in a local variable avoids the overhead of traversing the C++ boundary multiple times per frame for the same unchanging value.",
      "durationMs": 12785,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHUD\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local health = ply:Health()\n    \n    draw.SimpleText(\"HP: \" .. health, \"DermaDefault\", 50, 50, color_white)\n    draw.SimpleText(\"HP: \" .. health, \"DermaDefault\", 50, 70, color_white)\n    draw.SimpleText(\"HP: \" .. health, \"DermaDefault\", 50, 90, color_white)\nend)\n```\nReason: Caching the result of `LocalPlayer():Health()` in a local variable avoids the overhead of executing multiple function calls and crossing the Lua/C++ boundary repeatedly within the same frame.",
      "durationMs": 11821,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHUD\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local hp = ply:Health()\n    \n    draw.SimpleText(\"Health: \" .. hp, \"DermaDefault\", 10, 10, color_white)\n    draw.SimpleText(\"Health (Shadow): \" .. hp, \"DermaDefault\", 11, 11, color_black)\n    surface.DrawRect(10, 30, hp, 15)\nend)\n```\nReason: Caching the result in a local variable eliminates the performance overhead of making redundant Lua-to-C++ API calls for `LocalPlayer()` and `Health()` during every frame.",
      "durationMs": 15868,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(cachedColor)\n    surface.DrawRect(10, 10, 100, 100)\nend)\n```\nReason: Caching the Color object outside the hook prevents a new table from being allocated every frame, significantly reducing garbage collection overhead and improving performance.",
      "durationMs": 10142,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaint\", function()\n    -- Use the locally cached color or the built-in GMod global 'color_white'\n    surface.SetDrawColor(myColor) \nend)\n```\nReason: Caching the color object outside the render hook prevents expensive function calls and memory allocations on every single frame.",
      "durationMs": 12849,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myColor = Color(255, 255, 255)\nhook.Add(\"HUDPaint\", \"MyPaintHook\", function()\n    surface.SetDrawColor(myColor)\n    -- Or you can simply use the built-in color_white global\n    -- surface.SetDrawColor(color_white)\n    surface.DrawRect(0, 0, 100, 100)\nend)\n```\nReason: Caching the Color object outside the hook or using the built-in `color_white` global prevents unnecessary memory allocations every frame, which avoids triggering the garbage collector frequently and causing frame drops.",
      "durationMs": 9525,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(cachedColor)\n    -- Alternatively, for pure white, use the built-in global: surface.SetDrawColor(color_white)\nend)\n```\nReason: Caching the Color object outside the loop prevents a new table from being allocated every frame, significantly reducing memory generation and garbage collection lag.",
      "durationMs": 12582,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal my_color = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(my_color)\n    -- Paint operations go here\nend)\n```\nReason: Caching the Color object outside the render hook prevents creating a new table every frame, which significantly reduces garbage collection overhead and improves performance.",
      "durationMs": 10569,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local result = sin(i)\nend\n```\nReason: Caching the function in a local variable avoids repeated hash table lookups in the global environment, which is significantly faster in Lua.",
      "durationMs": 8891,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local val = sin(i)\nend\n```\nReason: Local variable lookups in Lua use fast register access, which is significantly faster than performing expensive global table lookups for `math.sin` on every iteration of a hot loop.",
      "durationMs": 11133,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local val = sin(i)\nend\n```\nReason: Local variables in Lua are stored in registers, making them significantly faster to access than global table lookups like math.sin.",
      "durationMs": 9018,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 100000 do\n    local val = sin(i)\nend\n```\nReason: Caching a global function to a local variable avoids repeated expensive global table lookups during each loop iteration.",
      "durationMs": 8892,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 1000000 do\n    local val = sin(i)\nend\n```\nReason: Local variables in Lua are accessed much faster than global table lookups because they are mapped directly to registers, bypassing the hash table lookup for `math` and `sin` on every iteration.",
      "durationMs": 9938,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal ply\n\nhook.Add(\"HUDPaint\", \"ExampleCache\", function()\n    if not IsValid(ply) then\n        ply = LocalPlayer()\n        if not IsValid(ply) then return end\n    end\n\n    -- Use the cached 'ply' here instead of calling LocalPlayer()\nend)\n```\nReason: Caching the player entity in a local variable and only calling LocalPlayer() when the cache is invalid avoids the performance overhead of repeated C++ function calls in high-frequency hooks.",
      "durationMs": 15797,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal ply = NULL\n\nhook.Add(\"InitPostEntity\", \"CacheLocalPlayer\", function()\n    ply = LocalPlayer()\nend)\n```\nReason: Caching the player entity once it initializes avoids both the global table lookup and the expensive C++ boundary call required by LocalPlayer() in high-frequency hooks.",
      "durationMs": 13420,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal ply = NULL\n\nhook.Add(\"Think\", \"CacheLocalPlayer\", function()\n    if not IsValid(ply) then\n        ply = LocalPlayer()\n        return\n    end\n    \n    -- ply is now valid and cached, use it safely here\n    -- print(ply:Nick())\nend)\n```\nReason: Caching the entity object in an upvalue avoids the continuous overhead of the global function call and the C-side entity lookup every single frame.",
      "durationMs": 12221,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal LocalPlayer = LocalPlayer\n```\nReason: Localizing the global function caches its reference in a local register, avoiding a slower global table lookup in `_G` each time it is called.",
      "durationMs": 14804,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal LocalPlayer = LocalPlayer\n```\nReason: Local variable lookups in Lua are significantly faster than global environment lookups.",
      "durationMs": 8995,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    local dir = (ply2:GetShootPos() - ply1:GetShootPos()):GetNormalized()\n    -- Check if both players' aim vectors align with the direction toward each other\n    return ply1:GetAimVector():Dot(dir) > (threshold or 0.8) and ply2:GetAimVector():Dot(-dir) > (threshold or 0.8)\nend\n```\nReason: The dot product of two normalized vectors directly yields the cosine of the angle between them, allowing you to compare the result against a simple threshold rather than performing expensive trigonometric inverse functions like `math.acos`.",
      "durationMs": 15770,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    local dir = (ply2:GetShootPos() - ply1:GetShootPos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > threshold and ply2:GetAimVector():Dot(-dir) > threshold\nend\n```\nReason: Dot products directly return the cosine of the angle between two normalized vectors, allowing you to use a simple scalar comparison (e.g., > 0.8) instead of the expensive math.acos function.",
      "durationMs": 15850,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    -- threshold defaults to -0.8 (approx 143 to 180 degrees opposing)\n    threshold = threshold or -0.8\n    return ply1:GetAimVector():Dot(ply2:GetAimVector()) < threshold\nend\n```\nReason: The dot product of two normalized vectors directly yields the cosine of the angle between them (approaching -1 as they face opposite directions), allowing a simple threshold check without expensive trigonometric functions.",
      "durationMs": 15713,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    threshold = threshold or 0.8 -- 0.8 represents roughly a 36-degree cone\n    \n    local dir = (ply2:EyePos() - ply1:EyePos()):GetNormalized()\n    \n    local ply1Looking = ply1:GetAimVector():Dot(dir) > threshold\n    local ply2Looking = ply2:GetAimVector():Dot(-dir) > threshold\n    \n    return ply1Looking and ply2Looking\nend\n```\nReason: The dot product of two normalized vectors directly yields the cosine of the angle between them, which allows you to compare angles using simple arithmetic instead of relying on expensive trigonometric functions like math.acos.",
      "durationMs": 19919,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, dotTolerance)\n    dotTolerance = dotTolerance or 0.8\n    local dir = (ply2:EyePos() - ply1:EyePos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > dotTolerance and ply2:GetAimVector():Dot(-dir) > dotTolerance\nend\n```\nReason: The dot product operation directly returns the cosine of the angle between two normalized vectors, allowing you to use a simple and fast scalar comparison instead of an expensive trigonometric math.acos call.",
      "durationMs": 18961,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Metatable lookups for methods incur overhead in Lua compared to direct function calls (especially if the function is localized).",
      "durationMs": 8847,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Calling ply:SomeHelper() requires an additional metatable index lookup to resolve the function, making a direct function call faster.",
      "durationMs": 9854,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: SomeHelper(ply) avoids the expensive userdata metatable lookup required by ply:SomeHelper().",
      "durationMs": 10371,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: It avoids the overhead of the metatable __index lookup required by ply:SomeHelper().",
      "durationMs": 9706,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Direct function calls avoid the overhead of metatable lookups required by object-oriented method syntax.",
      "durationMs": 8974,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"Debug information\")\n```\nReason: MsgN directly calls the engine's console output function, bypassing the overhead of Garry's Mod's overridden `print` function which does additional formatting and argument processing.",
      "durationMs": 11102,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"debug line\")\n```\nReason: MsgN is a direct engine function that bypasses the variadic formatting overhead and hook calls associated with the global print function.",
      "durationMs": 10517,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"debug message\")\n```\nReason: MsgN is a direct C binding to the engine console that bypasses the formatting and argument processing overhead of the global print function.",
      "durationMs": 9113,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"Debug line\")\n```\nReason: MsgN is a direct engine C++ binding that bypasses the Lua-side formatting and overhead of the standard print function.",
      "durationMs": 10005,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"debug line\")\n```\nReason: `MsgN` is faster than `print` because it directly interfaces with the engine console output without the additional Lua-side formatting and vararg processing overhead.",
      "durationMs": 9476,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local val = tbl[i]\nend\n```\nReason: A numeric for loop is the fastest because it avoids the function call overhead associated with the iterator functions used by pairs and ipairs, which is especially beneficial in GMod's LuaJIT environment.",
      "durationMs": 9138,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local value = tbl[i]\nend\n```\nReason: A numeric for loop avoids the function call overhead of iterators and is heavily optimized by LuaJIT for sequential array indexing.",
      "durationMs": 10598,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local val = tbl[i]\nend\n```\nReason: A numeric for loop avoids the function call overhead of iterator functions like pairs or ipairs, allowing LuaJIT to optimize and execute it the fastest.",
      "durationMs": 10115,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local val = tbl[i]\nend\n```\nReason: A numeric for loop avoids the function call overhead of iterators like pairs or ipairs and is optimally traced and compiled by LuaJIT.",
      "durationMs": 11574,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #myTable do\n    local value = myTable[i]\n    -- do something with value\nend\n```\nReason: Numeric for loops are the fastest in Garry's Mod (which uses LuaJIT) because they avoid the overhead of calling iterator functions like those used in pairs and ipairs, allowing the JIT compiler to highly optimize the sequential array access.",
      "durationMs": 9707,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal index = 1\nfor i = 1, #inputList do\n    local item = inputList[i]\n    if item.isValid then\n        result[index] = item.name\n        index = index + 1\n    end\nend\n```\nReason: A single-pass imperative loop avoids function call overhead and intermediate table allocations, allowing LuaJIT to trace and optimize it far more efficiently than the nested closures of the `fn` library.",
      "durationMs": 11926,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal index = 1\nfor i = 1, #inputList do\n    local item = inputList[i]\n    if item:IsValid() then -- Filter condition\n        result[index] = item:GetName() -- Map transform\n        index = index + 1\n    end\nend\n```\nReason: A single imperative loop with manual table indexing avoids the heavy garbage collection overhead of intermediate table allocations and closure calls inherent to functional libraries like `fn`.",
      "durationMs": 13031,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal n = 0\nfor i = 1, #inputList do\n    local item = inputList[i]\n    if item.active then\n        n = n + 1\n        result[n] = item.price * 2\n    end\nend\n```\nReason: Manual iterative loops with a local counter avoid the function call overhead, closure allocations, and intermediate table creations that occur when chaining DarkRP's `fn.Filter` and `fn.Map`.",
      "durationMs": 11773,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function filterMapEvens(list)\n    local result = {}\n    local index = 1\n    for i = 1, #list do\n        local val = list[i]\n        -- filter condition integrated with the map transformation\n        if val % 2 == 0 then\n            result[index] = val * val\n            index = index + 1\n        end\n    end\n    return result\nend\n```\nReason: A single imperative loop avoids the multiple intermediate table allocations and function call overheads inherent in functional combinator chains, allowing LuaJIT to fully trace and optimize the execution.",
      "durationMs": 12866,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function filterMapItems(items)\n    local result = {}\n    local index = 1\n    for i = 1, #items do\n        local item = items[i]\n        if item.score > 10 then\n            result[index] = item.name\n            index = index + 1\n        end\n    end\n    return result\nend\n```\nReason: Imperative loops avoid the overhead of function calls, closure allocations, and intermediate table creations present in DarkRP's fn library, allowing LuaJIT to compile and optimize the operations effectively.",
      "durationMs": 11954,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal active_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"Cache_PlayerJoin\", function(ply)\n    table.insert(active_players, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"Cache_PlayerLeave\", function(ply)\n    table.RemoveByValue(active_players, ply)\nend)\n\nhook.Add(\"Think\", \"Optimized_PlayerThink\", function()\n    for i = 1, #active_players do\n        local ply = active_players[i]\n        -- Fast per-player tick logic here\n    end\nend)\n```\nReason: Calling player.GetAll() allocates a new table and triggers garbage collection overhead on every tick, whereas maintaining a persistent array avoids allocation entirely and allows for faster numerical iteration.",
      "durationMs": 16004,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nlocal function UpdatePlayerCache()\n    cached_players = player.GetAll()\nend\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCache_Join\", UpdatePlayerCache)\n\nhook.Add(\"PlayerDisconnected\", \"UpdatePlayerCache_Leave\", function()\n    -- timer.Simple(0) waits for the next frame so the disconnecting player is fully removed from player.GetAll()\n    timer.Simple(0, UpdatePlayerCache)\nend)\n\nhook.Add(\"Think\", \"OptimizedPlayerThink\", function()\n    -- A numeric loop is slightly faster than ipairs in LuaJIT and avoids iterator overhead\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        if IsValid(ply) then\n            -- Per-player logic here\n        end\n    end\nend)\n```\nReason: Calling player.GetAll() every tick allocates a new table and crosses the C++/Lua boundary, generating garbage and wasting CPU; caching the results and updating only on connect/disconnect events bypasses this overhead entirely.",
      "durationMs": 20328,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedPlayers = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCache_Join\", function(ply)\n    table.insert(cachedPlayers, ply)\nend)\n\nhook.Add(\"EntityRemoved\", \"UpdatePlayerCache_Leave\", function(ent)\n    if ent:IsPlayer() then\n        table.RemoveByValue(cachedPlayers, ent)\n    end\nend)\n\nhook.Add(\"Tick\", \"OptimizedTick\", function()\n    for i = 1, #cachedPlayers do\n        local ply = cachedPlayers[i]\n        -- Perform tick logic with ply here\n    end\nend)\n```\nReason: Calling `player.GetAll()` every tick generates a new table, causing significant garbage collection overhead; caching the table and updating it only on entity spawn/removal eliminates this allocation while allowing for faster numeric `for` loop iteration.",
      "durationMs": 15870,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedPlayers = player.GetAll()\n\nlocal function UpdatePlayerCache()\n    cachedPlayers = player.GetAll()\nend\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCacheJoin\", UpdatePlayerCache)\nhook.Add(\"PlayerDisconnected\", \"UpdatePlayerCacheLeave\", function()\n    timer.Simple(0, UpdatePlayerCache)\nend)\n\nhook.Add(\"Tick\", \"OptimizedTick\", function()\n    for i = 1, #cachedPlayers do\n        local ply = cachedPlayers[i]\n        if IsValid(ply) then\n            -- Your per-tick player logic here\n        end\n    end\nend)\n```\nReason: Calling player.GetAll() allocates a new table every tick which causes heavy garbage collection overhead, whereas caching it and iterating with a numeric for-loop eliminates table creation entirely during the tick.",
      "durationMs": 16654,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCache_Join\", function(ply)\n    table.insert(cached_players, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"UpdatePlayerCache_Leave\", function(ply)\n    table.RemoveByValue(cached_players, ply)\nend)\n\nhook.Add(\"Think\", \"OptimizedPlayerLoop\", function()\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        if IsValid(ply) then\n            -- Perform per-tick logic here\n        end\n    end\nend)\n```\nReason: Caching the table and using a numeric for-loop avoids allocating a new table and iterator function every tick, significantly reducing garbage collection overhead and CPU usage.",
      "durationMs": 13874,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal playerData = {}\n\n-- Writing data\nplayerData[ply] = \"some_value\"\n\n-- Reading data\nlocal myData = playerData[ply]\n```\nReason: Indexing a plain Lua table is significantly faster than indexing a userdata object (the player entity), which requires a relatively expensive metatable `__index` lookup to cross the C boundary.",
      "durationMs": 9632,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal player_data = {}\n\n-- Fast write\nplayer_data[ply] = \"value\"\n\n-- Fast read\nlocal value = player_data[ply]\n```\nReason: Indexing a standard Lua table avoids the slow C++ userdata metatable __index lookups associated with reading custom fields directly from the player object.",
      "durationMs": 12208,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal playerData = {}\n\n-- Writing\nplayerData[ply] = value\n\n-- Reading\nlocal value = playerData[ply]\n```\nReason: Using a standard Lua table avoids the slow C++ metatable `__index` lookups that occur when accessing custom fields directly on Entity userdata objects.",
      "durationMs": 10771,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal playerData = {}\n\n-- Writing data\nplayerData[ply] = someValue\n\n-- Reading data (much faster)\nlocal myData = playerData[ply]\n```\nReason: Storing data in a local Lua table bypasses the expensive C/C++ metamethod lookups (__index) associated with the Player userdata object.",
      "durationMs": 13150,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal temporaryPlayerData = {}\n\n-- Writing\ntemporaryPlayerData[ply] = value\n\n-- Reading\nlocal val = temporaryPlayerData[ply]\n```\nReason: Indexing a standard Lua table avoids the overhead of traversing the `__index` and `__newindex` metamethods bridging to C++ that occur when reading or writing fields directly on the Entity userdata object.",
      "durationMs": 12458,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myTable = {\n    \"value1\",\n    \"value2\",\n    \"value3\"\n}\n\nfor i = 1, #myTable do\n    local val = myTable[i]\n    -- do something with val\nend\n```\nReason: Sequential number-indexed arrays iterated with a numeric for loop are significantly faster in LuaJIT because they access the array part of the table directly, avoiding the overhead of hash map lookups and iterator function calls associated with `pairs()`.",
      "durationMs": 9195,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal my_collection = {\n    \"value1\",\n    \"value2\",\n    \"value3\",\n    \"value4\"\n}\n\nfor i = 1, #my_collection do\n    local v = my_collection[i]\nend\n```\nReason: Sequential number-indexed arrays iterated with a numeric for loop avoid the function call overhead of pairs() and the hashing cost of string lookups, which is highly optimized in Garry's Mod's LuaJIT environment.",
      "durationMs": 11119,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sequentialArray = {\n    \"apple\",\n    \"banana\",\n    \"cherry\"\n}\n\nfor i = 1, #sequentialArray do\n    local value = sequentialArray[i]\n    print(value)\nend\n```\nReason: Sequential number-indexed arrays are faster because they utilize the contiguous array part of Lua's table structure and can be traversed with a highly optimized numeric for loop, avoiding the overhead of hash table lookups required by string-keyed maps.",
      "durationMs": 10855,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal fast_array = {\n    \"apple\",\n    \"banana\",\n    \"cherry\"\n}\n\nfor i = 1, #fast_array do\n    local value = fast_array[i]\n    -- Process value\nend\n```\nReason: Sequential number-indexed arrays iterated with a numeric for-loop avoid hash map lookups and benefit significantly more from LuaJIT optimizations than string-keyed maps using pairs().",
      "durationMs": 9535,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal fastTable = {\n    \"apple\",\n    \"banana\",\n    \"cherry\"\n}\n\nfor i = 1, #fastTable do\n    local value = fastTable[i]\nend\n```\nReason: Sequential number-indexed arrays can be iterated using a numerical for loop (or `ipairs`), which avoids the overhead of hash map lookups and iterator function calls required by `pairs` on string-keyed maps, making it significantly faster in LuaJIT (Garry's Mod).",
      "durationMs": 9899,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(255, 255, 255, 255)\n```\nReason: Passing separate numbers is faster because it avoids the overhead of table field lookups in the C++ binding.",
      "durationMs": 11075,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(255, 0, 0, 255)\n```\nReason: Passing separate numeric arguments avoids the overhead of Lua table creation, garbage collection, and field lookups associated with passing a Color object.",
      "durationMs": 9343,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(255, 0, 0, 255)\n```\nReason: Passing primitive numbers directly to the C/C++ boundary is faster in LuaJIT as it avoids table metatable lookups, object allocation, and garbage collection overhead.",
      "durationMs": 9514,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(255, 255, 255, 255)\n```\nReason: Passing separate numbers directly avoids the overhead of Lua table creation, metatable lookups, and C-to-Lua object marshalling associated with using a Color object.",
      "durationMs": 9418,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(255, 255, 255, 255)\n```\nReason: Passing primitive numbers directly avoids table lookups, object allocation, and the internal C++ extraction costs associated with passing a Color table.",
      "durationMs": 10718,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = sql.Query(\"SELECT * FROM players WHERE steamid = 'STEAM_0:0:123456'\")\nif result then\n    PrintTable(result)\nend\n```\nReason: Local SQLite operates directly on the server's filesystem and executes synchronously without network round-trip overhead.",
      "durationMs": 9762,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = sql.Query(\"SELECT * FROM player_data WHERE steamid = 'STEAM_0:1:12345678'\")\nif result then\n    PrintTable(result)\nend\n```\nReason: Local SQLite has lower latency than remote MySQL because it eliminates network round-trip overhead and performs operations directly on the local filesystem.",
      "durationMs": 12073,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal data = sql.Query(\"SELECT * FROM player_data WHERE steamid = 'STEAM_0:1:1234567'\")\n```\nReason: Local SQLite avoids network round-trip latency by executing queries directly on the server's local file system.",
      "durationMs": 10770,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = sql.Query(\"SELECT * FROM player_stats WHERE steamid = 'STEAM_0:1:12345678' LIMIT 1\")\nif result then\n    PrintTable(result)\nend\n```\nReason: Local SQLite reads and writes directly to a local file (sv.db), completely eliminating the network round-trip latency required by remote MySQL queries.",
      "durationMs": 11053,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = sql.Query(\"SELECT * FROM player_data WHERE steamid = 'STEAM_0:1:12345678'\")\nif result then\n    -- Process the data\nend\n```\nReason: Local SQLite operates directly on local storage without any network round-trip overhead, resulting in fundamentally lower latency for a single isolated server than querying a remote MySQL database.",
      "durationMs": 9280,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function GetCachedSteamID(ply)\n    local id = ply.CachedSteamID\n    if id then return id end\n    \n    id = ply:SteamID()\n    ply.CachedSteamID = id\n    return id\nend\n```\nReason: Caching the SteamID string directly on the player entity table avoids the overhead of repeated C++ boundary crossings and new string allocations.",
      "durationMs": 10937,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function GetCachedSteamID(ply)\n    local sid = ply.CachedSteamID\n    if not sid then\n        sid = ply:SteamID()\n        ply.CachedSteamID = sid\n    end\n    return sid\nend\n```\nReason: Lua table field lookups are significantly faster than repeatedly crossing the Lua-C++ boundary to invoke engine methods.",
      "durationMs": 13159,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal steamIDCache = {}\n\nhook.Add(\"PlayerInitialSpawn\", \"CacheSteamIDs\", function(ply)\n    steamIDCache[ply] = ply:SteamID()\nend)\n\nhook.Add(\"PlayerDisconnected\", \"ClearSteamIDs\", function(ply)\n    steamIDCache[ply] = nil\nend)\n\n-- Hot path usage:\n-- local id = steamIDCache[ply]\n```\nReason: Indexing a local Lua table by the player object entirely bypasses the expensive C++ userdata __index metamethod overhead and function call cost of ply:SteamID().",
      "durationMs": 17146,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nhook.Add(\"PlayerAuthed\", \"CachePlayerSteamID\", function(ply, steamid)\n    ply.CachedSteamID = steamid\nend)\n\nlocal function HotPathExample(ply)\n    -- Fast Lua table lookup, falling back to the method if called too early\n    local steamID = ply.CachedSteamID or ply:SteamID() \n    -- ...\nend\n```\nReason: Accessing a value directly from the Lua entity table avoids the expensive Lua-to-C++ boundary crossing overhead incurred when calling engine methods like ply:SteamID().",
      "durationMs": 16549,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function GetCachedSteamID(ply)\n    local id = ply.CachedSteamID\n    if id then return id end\n    \n    id = ply:SteamID()\n    ply.CachedSteamID = id\n    return id\nend\n```\nReason: Table indexing avoids the overhead of a C++ function call and string allocation inherent in repeatedly calling ply:SteamID().",
      "durationMs": 16312,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal pieces = {}\nfor i = 1, 10000 do\n    pieces[#pieces + 1] = \"piece_\" .. i\nend\nlocal final_string = table.concat(pieces)\n```\nReason: table.concat allocates memory once for the final string, avoiding the quadratic memory reallocation overhead of creating intermediate strings with repeated `..` operators.",
      "durationMs": 12860,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal parts = {}\nfor i = 1, 10000 do\n    parts[#parts + 1] = \"piece\"\nend\nlocal finalString = table.concat(parts)\n```\nReason: table.concat allocates memory once for the final string instead of creating thousands of intermediate string objects, avoiding quadratic memory reallocation overhead.",
      "durationMs": 10299,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal pieces = {}\nfor i = 1, 10000 do\n    pieces[#pieces + 1] = \"piece_\" .. i\nend\nlocal large_string = table.concat(pieces)\n```\nReason: Using table.concat is faster because it allocates memory for the final string all at once, avoiding the heavy quadratic performance cost and garbage collection overhead of constantly creating intermediate string objects with the .. operator.",
      "durationMs": 10282,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal pieces = {}\nfor i = 1, 10000 do\n    pieces[i] = \"small_piece_\" .. i\nend\nlocal finalString = table.concat(pieces)\n```\nReason: table.concat avoids the overhead of repeatedly allocating memory and garbage collecting intermediate string objects during each concatenation step.",
      "durationMs": 8948,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal pieces = {}\nfor i = 1, 10000 do\n    pieces[#pieces + 1] = \"small_piece_\" .. i\nend\nlocal large_string = table.concat(pieces, \"\")\n```\nReason: Using table.concat joins all elements in a single C-level pass, avoiding the O(n^2) performance cost and heavy garbage collection overhead caused by repeatedly allocating new intermediate strings with the .. operator.",
      "durationMs": 9251,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(color)\nsurface.DrawRect(x, y, w, h)\n```\nReason: Calling the `surface` library functions directly avoids the overhead of the `draw.RoundedBox` function call and its internal conditional checks.",
      "durationMs": 13701,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(color)\nsurface.DrawRect(x, y, width, height)\n```\nReason: Using the surface library directly avoids the Lua function call overhead and conditional checks performed inside draw.RoundedBox.",
      "durationMs": 12017,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(r, g, b, a)\nsurface.DrawRect(x, y, w, h)\n```\nReason: Calling surface.SetDrawColor and surface.DrawRect directly skips the Lua function overhead, table lookups, and corner radius conditional checks internally performed by draw.RoundedBox.",
      "durationMs": 12387,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(r, g, b, a)\nsurface.DrawRect(x, y, w, h)\n```\nReason: Using the surface library directly is a C++ binding that bypasses the additional Lua function call overhead and radius checks performed internally by draw.RoundedBox.",
      "durationMs": 9771,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetDrawColor(color)\nsurface.DrawRect(x, y, width, height)\n```\nReason: Calling the underlying surface library functions directly avoids the overhead of draw.RoundedBox's internal conditional checks for corner radius and color unpacking.",
      "durationMs": 14537,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"FastTextDrawing\", function()\n    surface.SetFont(\"DermaDefault\")\n    surface.SetTextColor(255, 255, 255, 255)\n    surface.SetTextPos(100, 100)\n    surface.DrawText(\"This is the fastest approach\")\nend)\n```\nReason: Calling the native `surface.*` functions directly acts as a direct C++ binding, bypassing the Lua overhead, table lookups, and text alignment math that the `draw.*` wrapper library performs internally on every frame.",
      "durationMs": 12412,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetFont(\"DermaDefault\")\nsurface.SetTextColor(255, 255, 255, 255)\nsurface.SetTextPos(50, 50)\nsurface.DrawText(\"Fast single-line string\")\n```\nReason: `surface.DrawText` and its setup functions are direct C-bindings that bypass the additional alignment math, table lookups, and function call overhead inherent in the `draw.*` Lua wrappers.",
      "durationMs": 12115,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetFont(\"Default\")\nsurface.SetTextColor(255, 255, 255, 255)\nsurface.SetTextPos(100, 100)\nsurface.DrawText(\"Single line text\")\n```\nReason: Using the `surface.*` functions directly avoids the Lua-side overhead and alignment calculations present in the `draw.*` wrapper library.",
      "durationMs": 10131,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetFont(\"Default\")\nsurface.SetTextColor(255, 255, 255, 255)\nsurface.SetTextPos(100, 100)\nsurface.DrawText(\"Hello World\")\n```\nReason: The surface library functions are the lowest-level text rendering bindings available in Lua; wrapper functions like draw.SimpleText add unnecessary overhead for single lines.",
      "durationMs": 9382,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nsurface.SetFont(\"Default\")\nsurface.SetTextColor(255, 255, 255, 255)\nsurface.SetTextPos(100, 100)\nsurface.DrawText(\"Hello World\")\n```\nReason: Calling the surface.* C-bindings directly is faster because it avoids the internal Lua wrapper overhead and table lookups present in the draw.* library functions.",
      "durationMs": 10114,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n#table_name\n```\nReason: The `#` length operator is the standard and most performant way to get the length of a sequential array-like table in Lua 5.1.",
      "durationMs": 9337,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n#table\n```\nReason: The length operator `#` is the standard, built-in, and most efficient way to get the length of a sequential array-like table in Lua.",
      "durationMs": 8956,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal length = #myTable\n```\nReason: The `#` length operator is the standard, most performant way in Lua 5.1/Garry's Mod to get the size of a sequential, 1-indexed array-like table without gaps.",
      "durationMs": 9610,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n#table\n```\nReason: The `#` operator is the native, most efficient, and idiomatic way to get the length of a sequential table in Lua.",
      "durationMs": 10559,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal length = #myTable\n```\nReason: The `#` operator is built into standard Lua, executes faster than function calls like `table.Count`, and is the idiomatic way to get the length of a sequential array-like table.",
      "durationMs": 9305,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nt = {}\n```\nReason: Assigning a new empty table is an O(1) operation that executes much faster than `table.Empty(t)`, which must perform an O(n) iteration over every element to clear them, even though replacing the table does increase garbage collection overhead.",
      "durationMs": 15582,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nt = {}\n```\nReason: Creating a new table is O(1) and leaves the old table to the garbage collector, whereas table.Empty(t) is O(n) because it iterates through all elements to set them to nil.",
      "durationMs": 11603,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nt = {}\n```\nReason: Reassigning the variable to an empty table is O(1) and generally faster than table.Empty() which iterates through every element in O(N) time.",
      "durationMs": 15249,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nt = {}\n```\nReason: Reassigning to a new table is an O(1) operation that avoids the O(n) overhead of table.Empty() iterating through every key to set it to nil.",
      "durationMs": 13668,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nt = {}\n```\nReason: Creating a new table is an O(1) allocation that avoids the O(n) iteration overhead of table.Empty() clearing each key individually.",
      "durationMs": 10132,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal mySet = {\n    [\"apple\"] = true,\n    [\"banana\"] = true,\n    [\"orange\"] = true\n}\n\n-- Checking for existence\nif mySet[\"banana\"] then\n    -- Do something\nend\n```\nReason: Key-based lookups use a hash map providing O(1) time complexity, whereas `table.HasValue` iterates over every element sequentially with O(n) time complexity.",
      "durationMs": 8715,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal mySet = {\n    [\"apple\"] = true,\n    [\"banana\"] = true,\n    [\"orange\"] = true\n}\n\n-- Check existence\nif mySet[\"apple\"] then\n    -- Value exists\nend\n```\nReason: Key lookups in Lua tables perform an O(1) hash map access, whereas table.HasValue runs an O(n) sequential loop.",
      "durationMs": 9887,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal mySet = {\n    [\"apple\"] = true,\n    [\"banana\"] = true,\n    [\"orange\"] = true\n}\n\nif mySet[\"apple\"] then\n    print(\"Exists!\")\nend\n```\nReason: Key lookups in Lua tables are O(1) time complexity, whereas table.HasValue sequentially iterates through the table in O(n) time.",
      "durationMs": 11654,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal lookupTable = {\n    [\"apple\"] = true,\n    [\"banana\"] = true,\n    [\"orange\"] = true\n}\n\n-- Fast check using the value as the key\nif lookupTable[\"banana\"] then\n    print(\"Value exists!\")\nend\n```\nReason: Indexing a table key is an O(1) hash map lookup, which is significantly faster than the O(n) sequential linear search used by table.HasValue.",
      "durationMs": 11672,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal mySet = {\n    [\"apple\"] = true,\n    [\"banana\"] = true,\n    [\"orange\"] = true\n}\n\n-- Check if value exists\nif mySet[\"apple\"] then\n    print(\"Value exists!\")\nend\n```\nReason: Using table keys for lookups provides O(1) time complexity (hash map lookup), which is significantly faster than the O(n) sequential search performed by `table.HasValue`.",
      "durationMs": 12377,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal t = {a = 1, b = 2, c = 3}\n```\nReason: Defining fields in the table constructor allows Lua to pre-allocate the exact size for the array and hash parts, avoiding costly memory reallocations that occur when adding fields sequentially.",
      "durationMs": 11056,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myTable = {\n    x = 1,\n    y = 2,\n    z = 3\n}\n```\nReason: Defining fields inside the table constructor allows Lua to pre-allocate the exact number of required slots, avoiding memory reallocation and rehashing overhead that occurs when inserting into an empty table.",
      "durationMs": 11553,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal t = { a = 1, b = 2 }\n```\nReason: Defining fields within the constructor allows Lua to pre-allocate the table with the correct size instantly, avoiding multiple expensive memory reallocations and rehashes that occur when inserting fields one by one.",
      "durationMs": 9972,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal t = {field1 = 1, field2 = 2, field3 = 3}\n```\nReason: Using the table constructor pre-allocates the exact memory size needed for the fields, preventing expensive table rehashing and reallocation operations that occur when adding fields one by one to an initially empty table.",
      "durationMs": 10075,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal tbl = { a = 1, b = 2, c = 3 }\n```\nReason: Defining fields directly in the table constructor allows LuaJIT to pre-allocate the correct table size in memory, avoiding multiple assignment operations and costly table re-hashing.",
      "durationMs": 9393,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal randomElement = tbl[math.random(#tbl)]\n```\nReason: Using math.random(#tbl) directly accesses the index in O(1) time, avoiding the expensive O(N) pairs() iteration that table.Random uses to support non-sequential keys.",
      "durationMs": 14856,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal random_element = tbl[math.random(#tbl)]\n```\nReason: table.Random iterates over the table using pairs making it O(n), whereas using the length operator (#) and direct indexing is O(1) for sequential tables.",
      "durationMs": 13338,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetRandomSequential(tbl)\n    return tbl[math.random(1, #tbl)]\nend\n```\nReason: Using the length operator `#` and `math.random` allows O(1) direct access by index, bypassing the slow `pairs` iteration that `table.Random` must use to support non-sequential dictionaries.",
      "durationMs": 9226,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal randomElement = tbl[math.random(#tbl)]\n```\nReason: math.random(#tbl) accesses the index in O(1) time, bypassing table.Random's O(N) overhead of counting elements and iterating with pairs.",
      "durationMs": 11892,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal randomElement = tbl[math.random(#tbl)]\n```\nReason: Using the length operator (#) with math.random provides O(1) direct index access, avoiding the O(n) pairs iteration overhead of table.Random.",
      "durationMs": 11322,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal squared = x * x\n```\nReason: Multiplication (`x * x`) avoids the function call overhead of `math.pow` and the generic exponentiation logic of the `^` operator, making it significantly faster in LuaJIT.",
      "durationMs": 9515,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = x * x\n```\nReason: Multiplication `x * x` is significantly faster than `x ^ 2` or `math.pow` because it avoids the overhead of function calls and complex exponentiation logic, which is critical in LuaJIT tight loops.",
      "durationMs": 8887,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal squared = x * x\n```\nReason: Simple multiplication `x * x` avoids the overhead of function calls or exponentiation operators, compiling directly to a fast multiply instruction in LuaJIT.",
      "durationMs": 8555,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal squared = x * x\n```\nReason: In LuaJIT (used by Garry's Mod), direct multiplication is evaluated faster than the exponentiation operator (`x ^ 2`) or a function call (`math.pow(x, 2)`).",
      "durationMs": 9919,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = x * x\n```\nReason: Direct multiplication is significantly faster than using the exponentiation operator (`x ^ 2`) or `math.pow` because it maps directly to a simple CPU multiplication instruction, bypassing function call and complex math evaluation overhead in LuaJIT.",
      "durationMs": 9672,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Uses ipairs but still allocates via player.GetAll() each time.",
      "finalResponse": "```lua\nfor _, ply in ipairs(player.GetAll()) do\n    -- Your code here\nend\n```\nReason: `player.GetAll()` returns a sequentially indexed table, making `ipairs` the correct and more performant choice over `pairs` in LuaJIT.",
      "durationMs": 9977,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Uses ipairs but still allocates via player.GetAll() each time.",
      "finalResponse": "```lua\nfor _, ply in ipairs(player.GetAll()) do\n    -- Your code here\nend\n```\nReason: `player.GetAll()` returns a sequentially indexed table, so using `ipairs` is faster and more idiomatic than `pairs`.",
      "durationMs": 9579,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 3,
      "status": "partial",
      "detail": "Uses ipairs but still allocates via player.GetAll() each time.",
      "finalResponse": "```lua\nfor _, ply in ipairs( player.GetAll() ) do\n    -- Your code here\nend\n```\nReason: ipairs is faster than pairs for iterating over sequential tables like the one returned by player.GetAll().",
      "durationMs": 8903,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 4,
      "status": "partial",
      "detail": "Uses ipairs but still allocates via player.GetAll() each time.",
      "finalResponse": "```lua\nfor _, ply in ipairs(player.GetAll()) do\n    -- Your code here\nend\n```\nReason: `ipairs` is faster and preferred over `pairs` for iterating over sequential, numerically-indexed tables like the one returned by `player.GetAll()`.",
      "durationMs": 9785,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (Low)",
      "attemptIndex": 5,
      "status": "partial",
      "detail": "Uses ipairs but still allocates via player.GetAll() each time.",
      "finalResponse": "```lua\nfor _, ply in ipairs(player.GetAll()) do\n    -- Your code here\nend\n```\nReason: Using ipairs is more performant than pairs because player.GetAll() returns a sequentially indexed table.",
      "durationMs": 8146,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- Your code here\nend\n```\nReason: `ents.FindByClass` queries the engine directly to create and return a table containing only the entities of the requested class, completely avoiding the memory allocation and performance overhead of `ents.GetAll()` which builds a table of every single entity in the map.",
      "durationMs": 20092,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- do something with ent\nend\n```\nReason: ents.FindByClass filters entities on the C++ side and only returns a Lua table containing the matching entities, avoiding the overhead of creating a table of all entities like ents.GetAll() would.",
      "durationMs": 13587,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- Your code here\nend\n```\nReason: `ents.FindByClass(\"prop_physics\")` offloads the filtering to the C++ engine to build and return a small table of only the matching entities, completely avoiding the massive memory allocation and performance overhead of generating a table of every single entity in the map like `ents.GetAll()` does.",
      "durationMs": 34133,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ipairs(ents.FindByClass(\"prop_physics\")) do\n    -- Your code here\nend\n```\nReason: `ents.FindByClass` filters entities on the C++ side and returns a table containing only the matching entities, avoiding the performance cost of `ents.GetAll()` which allocates a table of every entity in the map.",
      "durationMs": 20190,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    if ent:GetClass() == \"prop_physics\" then\n        -- Do something with ent\n    end\nend\n```\nReason: `ents.Iterator()` provides a stateless iterator to traverse all entities without allocating a table in memory, avoiding the performance and memory overhead of `ents.GetAll()`.",
      "durationMs": 21215,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "3990c92253db85bb"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- code here runs every tick\nend)\n```\nReason: The `hook.Add` function is the standard API in Garry's Mod for registering callbacks to engine events like \"Think\" with a unique identifier.",
      "durationMs": 9892,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- Code to run every tick goes here\nend)\n```\nReason: The `hook.Add` function is the standard way to register event callbacks in Garry's Mod, requiring the event name (\"Think\"), a unique identifier (\"MyAddon.Think\") to manage the hook, and the callback function to execute.",
      "durationMs": 10635,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- Callback body\nend)\n```\nReason: hook.Add is the standard Garry's Mod function used to attach a callback to an engine hook.",
      "durationMs": 9299,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\nend)\n```\nReason: `hook.Add` is the standard Garry's Mod function for attaching callbacks to specific engine events.",
      "durationMs": 9054,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.hook-add.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Registers a named hook with hook.Add.",
      "finalResponse": "```lua\nhook.Add(\"Think\", \"MyAddon.Think\", function()\n    -- Your code here\nend)\n```\nReason: This uses the standard Garry's Mod `hook.Add` function to attach a callback function to the \"Think\" event under the unique identifier \"MyAddon.Think\".",
      "durationMs": 8964,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "12d2222fdb7d6b90"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- ent is safe to use\nend\n```\nReason: The global IsValid function safely checks that the variable is not nil and that the underlying game entity has not been deleted.",
      "durationMs": 11368,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- safe to use ent\nend\n```\nReason: `IsValid(ent)` checks both if the variable is non-nil and if the underlying engine entity it refers to has not been removed or destroyed.",
      "durationMs": 8146,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- It is safe to call methods on ent\nend\n```\nReason: The global `IsValid(ent)` function safely checks that the variable is not nil and that the underlying C++ entity still exists in the game world and has not been removed.",
      "durationMs": 10393,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- ent is safe to use\nend\n```\nReason: The global IsValid() function safely checks if the variable is not nil and ensures the underlying C++ entity has not been removed from the game.",
      "durationMs": 11853,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.isvalid.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Uses IsValid for entity/object validity.",
      "finalResponse": "```lua\nif IsValid(ent) then\n    -- safe to call methods on ent\nend\n```\nReason: The global IsValid function safely checks both that the variable is not nil and that the underlying C++ entity has not been removed from the game.",
      "durationMs": 11656,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "35527312e59dfc13"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming message here\nend)\n```\nReason: `net.Receive` is the standard Garry's Mod function used to register a callback that executes when a network message with the specified string name is received.",
      "durationMs": 9274,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming message here\nend)\n```\nReason: `net.Receive` is the built-in function provided by the Garry's Mod networking API to register a callback for when a specific network message is received.",
      "durationMs": 9202,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming message here\nend)\n```\nReason: The net.Receive function is the designated Garry's Mod Lua API for registering a callback to execute when a specific network message is received.",
      "durationMs": 10418,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive( \"MyAddon.Sync\", function( len, ply )\n    -- Handler code goes here\nend )\n```\nReason: `net.Receive` is the Garry's Mod function used to execute a callback when a specific network message is received.",
      "durationMs": 9241,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.net-receivers.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nnet.Receive(\"MyAddon.Sync\", function(len, ply)\n    -- Handle the incoming message here\nend)\n```\nReason: `net.Receive` is the standard Garry's Mod API function used to listen for and handle incoming network messages by their string identifier.",
      "durationMs": 9266,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "2",
      "promptHash": "24d54ee8366753a6"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_angle = Angle()\n\nlocal function HotPath()\n    cached_angle:Zero()\n    -- Use cached_angle\nend\n```\nReason: Reusing a localized Angle object and resetting it with :Zero() avoids continuous memory allocations and the resulting garbage collection overhead.",
      "durationMs": 16334,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal tempAngle = Angle()\n\nlocal function HotPath()\n    tempAngle:Zero()\n    -- Use tempAngle here\nend\n```\nReason: Pre-allocating an Angle object outside the hot path and resetting it with :Zero() avoids repeated memory allocation and prevents garbage collection spikes.",
      "durationMs": 16842,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal temp_angle = Angle()\n\nlocal function HotPath()\n    temp_angle:Zero()\n    -- use temp_angle here\nend\n```\nReason: Reusing a single pre-allocated Angle and resetting it avoids continuous memory allocation and reduces garbage collection overhead.",
      "durationMs": 16101,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal temp_angle = Angle()\n\nlocal function MyHotPath()\n    temp_angle:Zero()\n    -- Use temp_angle here instead of creating a new Angle()\nend\n```\nReason: Reusing a cached local variable and resetting it with `:Zero()` avoids the performance cost of continuous memory allocation and garbage collection overhead.",
      "durationMs": 18802,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.angle-zero.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedAngle = Angle()\n\nlocal function HotPath()\n    cachedAngle:Zero()\n    -- Use cachedAngle for your calculations instead of creating a new Angle()\nend\n```\nReason: Reusing a pre-allocated Angle object and resetting it with :Zero() prevents continuous memory allocations and subsequent garbage collection overhead.",
      "durationMs": 18076,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f6bc97bf98280d62"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal current_color = myaddon_config_color\n```\nReason: Local variables use fast, direct register indexing in LuaJIT, completely avoiding the expensive string hashing and multiple dictionary lookups required to access nested table fields.",
      "durationMs": 13243,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal r = myaddon_config_color.r\n```\nReason: Local variables use register-based access, completely bypassing the expensive string hashing and dictionary lookups required when indexing into nested global tables.",
      "durationMs": 10107,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal current_color = myaddon_config_color\n```\nReason: Local variables are mapped directly to registers in LuaJIT, making them significantly faster than nested tables which require multiple hash map lookups for each access.",
      "durationMs": 11922,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal current_color = myaddon_config_color\n```\nReason: Local variables in Lua(JIT) are accessed directly by register index, avoiding the expensive hash lookups required for every level of a nested table.",
      "durationMs": 10636,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.config-var.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myaddon_config_color = Color(255, 255, 255)\nlocal current_color = myaddon_config_color\n```\nReason: Local variables are stored directly in VM registers in LuaJIT, bypassing the expensive hash lookups required when indexing into nested tables or global variables.",
      "durationMs": 10670,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "bcc4ff8eb162b699"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nteam.GetName(ply:Team())\n```\nReason: DarkRP jobs are implemented using Garry's Mod's native team system, making this the most efficient and standard way to retrieve a player's job name without unnecessary networking overhead.",
      "durationMs": 17875,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal jobName = ply:getDarkRPVar(\"job\")\n```\nReason: DarkRP uses its own optimized networking system and `getDarkRPVar` is the official API to access these variables, ensuring forward compatibility and correctly handling custom job titles.",
      "durationMs": 13377,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal jobName = ply:getDarkRPVar(\"job\")\n```\nReason: DarkRP uses its own optimized networking system (DarkRPVars) which is more bandwidth-efficient than default NWStrings and properly handles custom player-set job titles.",
      "durationMs": 17491,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal jobName = ply:getDarkRPVar(\"job\")\n```\nReason: DarkRP uses its own optimized custom networking system for player variables, making `getDarkRPVar` the required and reliable method to retrieve synchronized data like the job name string.",
      "durationMs": 11909,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.darkrpvar.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nply:getDarkRPVar(\"job\")\n```\nReason: DarkRP uses its own optimized networking system to save bandwidth, bypass Garry's Mod's native NWString limits, and properly return custom job titles (like those set via `/job`).",
      "durationMs": 17254,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "02a37daa699cded3"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nif vec1:DistToSqr(vec2) < (threshold * threshold) then\n    -- within threshold\nend\n```\nReason: `DistToSqr` avoids the computationally expensive square root operation required to calculate the exact distance, making it significantly faster for threshold comparisons.",
      "durationMs": 11860,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal threshold = 100\nlocal thresholdSqr = threshold * threshold\n\nif vec1:DistToSqr( vec2 ) < thresholdSqr then\n    -- Vectors are closer than 100 units\nend\n```\nReason: DistToSqr avoids the computationally expensive square root operation that DistTo performs, making it significantly faster for simple threshold checks.",
      "durationMs": 9669,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal isWithinThreshold = vec1:DistToSqr(vec2) <= (threshold * threshold)\n```\nReason: `DistToSqr` is significantly faster than calculating the actual distance because it avoids the computationally expensive square root operation.",
      "durationMs": 9225,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nvec1:DistToSqr(vec2) < (threshold * threshold)\n```\nReason: Using the squared distance avoids the computationally expensive square root operation.",
      "durationMs": 10314,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.disttosqr.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nif vec1:DistToSqr(vec2) < (threshold * threshold) then\n    -- Vectors are closer than the threshold\nend\n```\nReason: `Vector:DistToSqr` calculates the squared distance between two vectors, avoiding the computationally expensive square root operation used by `Vector:Distance`.",
      "durationMs": 12830,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a5772470c6859cdc"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with the entity 'ent'\nend\n```\nReason: `ents.Iterator()` provides a direct engine-level iterator, avoiding the overhead of creating and populating a new sequential table every time like `ents.GetAll()` does.",
      "durationMs": 10572,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with ent\nend\n```\nReason: ents.Iterator() is the wiki-recommended approach because it iterates through entities directly without allocating and populating a new table like ents.GetAll() does, making it significantly more memory and CPU efficient.",
      "durationMs": 14134,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Do something with 'ent'\nend\n```\nReason: ents.Iterator() is the wiki-recommended approach because it is a stateless iterator that avoids the costly table allocation and garbage collection overhead associated with ents.GetAll().",
      "durationMs": 9612,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- Your code here\nend\n```\nReason: ents.Iterator() avoids the memory allocation and garbage collection overhead of creating a new sequential table on every call, unlike the older ents.GetAll() method.",
      "durationMs": 12109,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.ents-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor _, ent in ents.Iterator() do\n    -- logic here\nend\n```\nReason: ents.Iterator() is a stateless iterator that avoids allocating a new table every loop, significantly reducing memory usage and garbage collection overhead compared to ipairs(ents.GetAll()).",
      "durationMs": 12089,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "306d3f1d05f28246"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal nearbyEnts = ents.FindInSphere(ply:GetPos(), 512)\n```\nReason: ents.FindInSphere leverages native engine-level spatial partitioning to perform radius checks significantly faster than iterating over all entities in Lua.",
      "durationMs": 13758,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal function GetEntitiesNearPlayer(ply, radius)\n    local nearbyEnts = ents.FindInSphere(ply:GetPos(), radius)\n    \n    for i = 1, #nearbyEnts do\n        local ent = nearbyEnts[i]\n        if ent ~= ply then\n            -- Perform cheap operations on nearby entities\n        end\n    end\n    \n    return nearbyEnts\nend\n```\nReason: ents.FindInSphere runs natively in C++ using the Source engine's internal spatial partitioning, making it dramatically faster than iterating all entities and checking distances in Lua.",
      "durationMs": 12041,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal ents_near = ents.FindInSphere(ply:GetPos(), 300)\nfor i = 1, #ents_near do\n    local ent = ents_near[i]\n    if IsValid(ent) and ent ~= ply then\n        -- Process nearby entity\n    end\nend\n```\nReason: ents.FindInSphere leverages the engine's internal C++ spatial partitioning to retrieve entities within a radius, drastically reducing overhead compared to iterating over all entities in Lua.",
      "durationMs": 13513,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal nearbyEnts = ents.FindInSphere(ply:GetPos(), 512)\nfor i = 1, #nearbyEnts do\n    local ent = nearbyEnts[i]\n    -- Process nearby entity\nend\n```\nReason: ents.FindInSphere delegates the spatial search to the C++ engine's internal spatial partitioning system, making it significantly faster for radius checks than iterating over all entities in Lua.",
      "durationMs": 12460,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-ents-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "Answer must contain 0 through 0 candidate loops.",
      "finalResponse": "```lua\nlocal nearby_ents = ents.FindInSphere(ply:GetPos(), 256)\nfor i = 1, #nearby_ents do\n    local ent = nearby_ents[i]\n    -- Process nearby entity\nend\n```\nReason: `ents.FindInSphere` leverages the engine's C++ spatial partitioning to rapidly cull distant entities, making it vastly more performant than iterating over `ents.GetAll()` in Lua for localized distance checks.",
      "durationMs": 17712,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "07c583fc3d9fe09f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local players = {}\n    local radiusSqr = radius * radius\n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            players[#players + 1] = ply\n        end\n    end\n    return players\nend\n```\nReason: Iterating `player.GetAll()` and comparing squared distances avoids the C++ to Lua table allocation overhead of returning many non-player entities from a spatial query.",
      "durationMs": 16281,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local found = {}\n    local radiusSqr = radius * radius\n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            found[#found + 1] = ply\n        end\n    end\n    return found\nend\n```\nReason: Iterating the relatively small list of players and checking squared distances avoids the costly spatial partition lookups, table allocations, and type-checking for non-player entities that ents.FindInSphere performs.",
      "durationMs": 16671,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInSphere(pos, radius)\n    local playersInRadius = {}\n    local radiusSqr = radius * radius\n    \n    for _, ply in ipairs(player.GetAll()) do\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            table.insert(playersInRadius, ply)\n        end\n    end\n    \n    return playersInRadius\nend\n```\nReason: Iterating `player.GetAll()` and checking squared distances is much faster than `ents.FindInSphere` because it avoids the engine overhead of collecting and building a massive Lua table containing every single entity type within the radius just to discard most of them.",
      "durationMs": 10917,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInSphere(pos, radius)\n    local playersInRadius = {}\n    local radiusSqr = radius * radius\n    local players = player.GetAll()\n    \n    for i = 1, #players do\n        local ply = players[i]\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            playersInRadius[#playersInRadius + 1] = ply\n        end\n    end\n    \n    return playersInRadius\nend\n```\nReason: Iterating over the much smaller `player.GetAll()` table and using `DistToSqr` avoids iterating over every single entity on the server, which `ents.FindInSphere` does natively.",
      "durationMs": 12331,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.find-players-near.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function GetPlayersInRadius(pos, radius)\n    local found = {}\n    local radiusSqr = radius * radius\n    local players = player.GetAll()\n    \n    for i = 1, #players do\n        local ply = players[i]\n        if ply:GetPos():DistToSqr(pos) <= radiusSqr then\n            found[#found + 1] = ply\n        end\n    end\n    \n    return found\nend\n```\nReason: Iterating exclusively through the small list of active players and performing a squared distance check avoids the heavy engine overhead of querying the spatial partition for all map entities.",
      "durationMs": 13969,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d139ba2e8ee38a2f"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: Numerical for loops have dedicated bytecode instructions in LuaJIT that are more efficiently optimized and avoid the explicit increment and condition checks of a while loop.",
      "durationMs": 10303,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: The numeric for loop is generally faster because Lua (and LuaJIT) optimizes its control variables internally in fast registers at the bytecode level, avoiding the explicit increment and condition-check overhead required by a while loop.",
      "durationMs": 11303,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: A numeric `for` loop is optimized at the VM level in Lua/LuaJIT, managing the counter and limit internally, which avoids the overhead of manual variable incrementing and explicit conditional checks required by a `while` loop.",
      "durationMs": 10078,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: A numeric for loop is generally faster than a while loop because it uses specialized opcodes and handles the incrementation and bounds-checking internally, avoiding the overhead of explicit operations.",
      "durationMs": 9438,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.for-vs-while.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, n do\n    -- loop body\nend\n```\nReason: The numeric for loop uses specialized bytecode instructions to handle counting natively, making it inherently faster than manually incrementing and checking a variable in a while loop.",
      "durationMs": 11116,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b3401a190a8aecf0"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n-- Faster Pattern: One hook call with all players\nlocal plys = player.GetAll()\nhook.Run(\"ProcessAllPlayers\", plys)\n\n-- Slower Pattern: Hook call per player\nlocal plys = player.GetAll()\nfor i = 1, #plys do\n    hook.Run(\"ProcessSinglePlayer\", plys[i])\nend\n```\nReason: `hook.Run` has internal overhead from dictionary lookups and iterating over registered functions, making a single hook call significantly faster than invoking the hook for every individual player.",
      "durationMs": 15287,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"Tick\", \"NotifyPlayers\", function()\n    local players = player.GetAll()\n    hook.Run(\"CustomTick\", players)\nend)\n```\nReason: Calling hook.Run incurs significant overhead from internal lookups, so invoking it once with the table of players is much faster than calling it repeatedly per player.",
      "durationMs": 15101,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal players = player.GetAll()\nhook.Run(\"TickAllPlayers\", players)\n```\nReason: Calling hook.Run has overhead from looking up the hook name and iterating over registered listener functions, so calling it once and passing the players table avoids multiplying that overhead by the player count.",
      "durationMs": 16105,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n-- Faster Pattern: Call hook.Run once and pass all players\nlocal players = player.GetAll()\nhook.Run(\"ProcessAllPlayersTick\", players)\n\n-- Slower Pattern: Loop players and call hook.Run per player\nlocal players = player.GetAll()\nfor i = 1, #players do\n    hook.Run(\"ProcessSinglePlayerTick\", players[i])\nend\n```\nReason: Calling hook.Run once avoids the significant overhead of repeatedly looking up the internal hook table and safely invoking callback functions for every single player each tick.",
      "durationMs": 16206,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hook-once.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\n-- Slower pattern: Looping players and calling hook.Run per player\nhook.Add(\"Tick\", \"SlowerExample\", function()\n    local plys = player.GetAll()\n    for i = 1, #plys do\n        hook.Run(\"PlayerCustomTick\", plys[i])\n    end\nend)\n\n-- Faster pattern: Calling hook.Run once with all players\nhook.Add(\"Tick\", \"FasterExample\", function()\n    hook.Run(\"AllPlayersCustomTick\", player.GetAll())\nend)\n```\nReason: Calling hook.Run incurs internal dictionary lookup and function call overhead, so calling it once with the table of players is significantly faster than repeating that overhead for every individual player.",
      "durationMs": 15534,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ed1d3e09249fc8bb"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal ply = LocalPlayer()\nif not IsValid(ply) then return end\n\nlocal hp = ply:Health()\n\ndraw.SimpleText(hp, \"DermaDefault\", 10, 10, color_white)\ndraw.SimpleText(hp, \"DermaDefault\", 10, 30, color_white)\ndraw.SimpleText(hp, \"DermaDefault\", 10, 50, color_white)\n```\nReason: Caching the results of LocalPlayer() and its Health() method in local variables avoids the overhead of crossing the Lua/C++ boundary multiple times per frame.",
      "durationMs": 20081,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHealthHUD\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local hp = ply:Health()\n    \n    draw.SimpleText(hp, \"DermaDefault\", 10, 10, color_white)\n    draw.SimpleText(hp, \"DermaDefault\", 10, 30, color_white)\n    draw.SimpleText(hp, \"DermaDefault\", 10, 50, color_white)\nend)\n```\nReason: Caching the result of `LocalPlayer():Health()` in a local variable prevents expensive and redundant Lua-to-C++ boundary crossings within the same frame.",
      "durationMs": 15155,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHealthDraw\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n\n    local hp = ply:Health()\n\n    draw.SimpleText(\"Health: \" .. hp, \"DermaDefault\", 50, 50, color_white)\n    draw.SimpleText(\"Remaining: \" .. hp, \"DermaDefault\", 50, 70, color_white)\n    draw.SimpleText(hp .. \" HP\", \"DermaDefault\", 50, 90, color_white)\nend)\n```\nReason: Caching LocalPlayer():Health() in a local variable avoids the overhead of making multiple expensive C++ function calls across the Lua-C boundary every frame.",
      "durationMs": 18269,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add( \"HUDPaint\", \"OptimizedHealthDraw\", function()\n    local ply = LocalPlayer()\n    if not IsValid( ply ) then return end\n\n    local hp = ply:Health()\n\n    draw.SimpleText( \"HP: \" .. hp, \"Default\", 10, 10, color_white )\n    draw.SimpleText( \"HP: \" .. hp, \"Default\", 11, 11, color_black )\n    surface.DrawRect( 10, 30, hp, 10 )\nend )\n```\nReason: Caching the result in a local variable avoids the performance overhead of repeatedly crossing the Lua-C++ boundary for the same value within a single frame.",
      "durationMs": 14087,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.hudpaint-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nhook.Add(\"HUDPaint\", \"OptimizedHealthDraw\", function()\n    local ply = LocalPlayer()\n    if not IsValid(ply) then return end\n    \n    local hp = ply:Health()\n    \n    draw.SimpleText(\"Health: \" .. hp, \"DermaDefault\", 10, 10, color_white)\n    draw.SimpleText(\"HP: \" .. hp, \"DermaDefault\", 10, 30, color_white)\n    surface.SetDrawColor(255, 0, 0, 255)\n    surface.DrawRect(10, 50, hp, 20)\nend)\n```\nReason: Caching the result of LocalPlayer():Health() in a local variable prevents multiple expensive function calls and C-to-Lua boundary crossings in the same frame.",
      "durationMs": 13842,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3def450f3158ceff"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal myColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(myColor)\n    -- Drawing code here\nend)\n```\nReason: Calling Color() inside a render loop creates a new table every frame, which causes unnecessary memory allocations and triggers expensive garbage collection overhead.",
      "durationMs": 14824,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal drawColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaint\", function()\n    surface.SetDrawColor(drawColor)\nend)\n```\nReason: Caching the Color object outside the render hook prevents creating a new table every frame, avoiding unnecessary memory allocation and garbage collection overhead.",
      "durationMs": 12354,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_color = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    -- Use the pre-allocated local variable instead of calling Color() every frame\n    surface.SetDrawColor(cached_color)\n    \n    -- Alternatively, for pure white, you can use GMod's built-in global constant:\n    -- surface.SetDrawColor(color_white)\nend)\n```\nReason: Caching the color outside the loop (or using the `color_white` constant) prevents a global function call and new table allocation on every frame, eliminating unnecessary CPU overhead and garbage collection stutter.",
      "durationMs": 18634,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(cachedColor)\n    -- Alternatively, surface.SetDrawColor(255, 255, 255) or color_white also bypass new table allocations\nend)\n```\nReason: Calling Color() inside a render loop constantly allocates new tables, which creates significant memory overhead and triggers frequent, performance-degrading garbage collection cycles.",
      "durationMs": 18740,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-color.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal paintColor = Color(255, 255, 255)\n\nhook.Add(\"HUDPaint\", \"OptimizedPaintLoop\", function()\n    surface.SetDrawColor(paintColor)\n    -- ... paint operations here ...\nend)\n```\nReason: Caching the Color object outside the render loop prevents allocating a new table on every single frame, significantly reducing garbage collection overhead and improving performance.",
      "durationMs": 14338,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "16a7bed1b931d467"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local result = sin(i)\nend\n```\n\nReason: Localizing table functions as local variables avoids the overhead of a table lookup on every iteration of the loop.",
      "durationMs": 9111,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local result = sin(i)\nend\n```\nReason: Local variable lookups are significantly faster than global table field lookups in Lua and LuaJIT, avoiding a dictionary lookup on every iteration.",
      "durationMs": 9899,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal math_sin = math.sin\nfor i = 1, 100000 do\n    local val = math_sin(i)\nend\n```\nReason: Local variable lookups use fast register access, completely bypassing the slower hash table lookup required by `math.sin`.",
      "durationMs": 10810,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local val = sin(i)\nend\n```\nReason: Local variable lookup is faster than global table lookup in Lua.",
      "durationMs": 9045,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.local-vs-global.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal sin = math.sin\nfor i = 1, 10000 do\n    local val = sin(i)\nend\n```\nReason: Local variable lookups are faster than global table index lookups in Lua.",
      "durationMs": 9856,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "c116d8c651190647"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal ply = LocalPlayer()\n\nhook.Add(\"Think\", \"OptimizedLocalPlayerCache\", function()\n    if not IsValid(ply) then\n        ply = LocalPlayer()\n        return\n    end\n\n    -- Use the cached 'ply' reference here\nend)\n```\nReason: Caching the entity in a local variable and only updating it when invalid avoids the performance overhead of executing the C-bound LocalPlayer() function on every frame.",
      "durationMs": 20860,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal ply\n\nhook.Add(\"Think\", \"OptimizedLocalPlayer\", function()\n    if not IsValid(ply) then\n        ply = LocalPlayer()\n        if not IsValid(ply) then return end\n    end\n\n    -- Use ply here\nend)\n```\nReason: Caching the player entity in a local variable and only calling LocalPlayer() when the cached entity is invalid avoids repeatedly executing the underlying C function.",
      "durationMs": 23413,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal LocalPlayer = LocalPlayer\n```\nReason: Assigning the global function to a local variable avoids the expensive string hash lookup in the global environment table (_G) on every call.",
      "durationMs": 36033,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal cachedPly\n\nlocal function FastLocalPlayer()\n    if IsValid(cachedPly) then return cachedPly end\n    cachedPly = LocalPlayer()\n    return cachedPly\nend\n```\nReason: Caching the entity in a local variable and only calling LocalPlayer() when the cache is invalid avoids the expensive Lua-to-C++ boundary crossing overhead on subsequent uses.",
      "durationMs": 22351,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.localplayer-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal cached_ply\n\nlocal function GetLocalPlayer()\n    if IsValid(cached_ply) then\n        return cached_ply\n    end\n    cached_ply = LocalPlayer()\n    return cached_ply\nend\n```\nReason: Caching the valid entity reference in a local upvalue avoids the overhead of repeated global table lookups and C++/Lua boundary crossings on subsequent calls.",
      "durationMs": 15264,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7398105af47b079e"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function AreLookingAtEachOther(ply1, ply2, threshold)\n    local dir = (ply2:GetShootPos() - ply1:GetShootPos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > (threshold or 0.8) and ply2:GetAimVector():Dot(-dir) > (threshold or 0.8)\nend\n```\nReason: The dot product of unit vectors directly yields the cosine of the angle between them, providing a cheap way to check directional alignment without the performance overhead of math.acos.",
      "durationMs": 17092,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    threshold = threshold or 0.8\n    local dir = (ply2:EyePos() - ply1:EyePos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > threshold and ply2:GetAimVector():Dot(-dir) > threshold\nend\n```\nReason: The dot product of normalized vectors yields the cosine of the angle between them, allowing for a fast threshold check without the computational expense of math.acos.",
      "durationMs": 19763,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    threshold = threshold or 0.8\n    local dir = (ply2:EyePos() - ply1:EyePos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > threshold and ply2:GetAimVector():Dot(dir) < -threshold\nend\n```\nReason: The dot product of normalized vectors avoids expensive math.acos computations while accurately checking if each player's aim vector aligns with the direction between their eye positions.",
      "durationMs": 16394,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    threshold = threshold or 0.8\n    local dir = (ply2:GetShootPos() - ply1:GetShootPos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > threshold and ply2:GetAimVector():Dot(-dir) > threshold\nend\n```\nReason: The dot product of normalized vectors returns the cosine of the angle between them, providing a much faster check against a threshold (e.g., 0.8) without the computational expense of calling math.acos.",
      "durationMs": 21449,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.looking-at.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "partial",
      "detail": "Matched a partial-answer pattern.",
      "finalResponse": "```lua\nlocal function ArePlayersLookingAtEachOther(ply1, ply2, threshold)\n    local dir = (ply2:GetShootPos() - ply1:GetShootPos()):GetNormalized()\n    return ply1:GetAimVector():Dot(dir) > (threshold or 0.8) and ply2:GetAimVector():Dot(-dir) > (threshold or 0.8)\nend\n```\nReason: The dot product evaluates the alignment of two vectors using simple arithmetic, bypassing the computationally expensive trigonometric math.acos function while achieving the exact same threshold-based cone check.",
      "durationMs": 22259,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "20b22f678a4b08d7"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Direct function calls avoid the metatable lookup overhead required by method calls.",
      "durationMs": 9811,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Calling a direct function is generally faster as it avoids the metatable lookup overhead associated with method syntax.",
      "durationMs": 10284,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Direct function calls avoid the overhead of metatable index lookups required by method syntax.",
      "durationMs": 10282,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: Calling a function directly avoids the overhead of a metatable index lookup required by the method call syntax.",
      "durationMs": 11176,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.meta-vs-arg.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nSomeHelper(ply)\n```\nReason: `SomeHelper(ply)` avoids the expensive metatable `__index` lookup on the player object required by `ply:SomeHelper()`.",
      "durationMs": 9768,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de332f7356830dfa"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"Debug information\")\n```\nReason: MsgN is a direct C++ engine binding that avoids the overhead of the standard print function, which iterates over all arguments, calls tostring on each, and concatenates them with tabs.",
      "durationMs": 11993,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"debug line\")\n```\nReason: MsgN is a direct engine binding that bypasses the Lua-side overhead of the global print function, which performs iteration, type conversion, and concatenation on its arguments.",
      "durationMs": 13925,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"debug line\")\n```\nReason: `MsgN` is faster than `print` because it avoids the overhead of Lua-side string formatting, vararg processing, and `tostring` conversions, mapping more directly to the engine's console output function.",
      "durationMs": 11306,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"Debug line\")\n```\nReason: MsgN is a direct C-binding that bypasses the overhead of GMod's custom Lua-based print wrapper, which iterates through arguments to apply string conversions and formatting.",
      "durationMs": 12592,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.msg-vs-print.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nMsgN(\"Debug line\")\n```\nReason: MsgN is a direct C++ binding that bypasses the Lua-side overhead of the global print function, which must iterate over its arguments, call tostring on each, and format them.",
      "durationMs": 13385,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "6cbb4e4b2f19dd24"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal count = #tbl\nfor i = 1, count do\n    local value = tbl[i]\nend\n```\nReason: A numeric for loop avoids the function call overhead of iterators like `pairs` and `ipairs`, and allows Garry's Mod's underlying LuaJIT to heavily optimize the sequential array access.",
      "durationMs": 11885,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #myTable do\n    local value = myTable[i]\nend\n```\nReason: LuaJIT (used by Garry's Mod) heavily optimizes numeric for loops, avoiding the function call overhead of iterator functions like pairs and ipairs.",
      "durationMs": 12542,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local value = tbl[i]\nend\n```\nReason: A numeric for loop is the fastest because it avoids the function call overhead of iterators, and Garry's Mod's LuaJIT compiler can heavily optimize direct array index access.",
      "durationMs": 14420,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "incorrect",
      "detail": "Did not match a fixture answer pattern.",
      "finalResponse": "```lua\nlocal len = #tbl\nfor i = 1, len do\n    local value = tbl[i]\nend\n```\nReason: In LuaJIT (which Garry's Mod uses), a numeric for loop avoids the function call overhead of iterator functions like pairs or ipairs and is most easily optimized by the JIT compiler.",
      "durationMs": 9923,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nfor i = 1, #tbl do\n    local val = tbl[i]\nend\n```\nReason: A numeric for loop avoids the function call and iterator overhead associated with pairs and ipairs, making it the fastest iteration method in LuaJIT.",
      "durationMs": 15937,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "de5e4875fcf3e600"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal count = 1\nfor i = 1, #inputList do\n    local val = inputList[i]\n    if val.isValid then\n        result[count] = val.name\n        count = count + 1\n    end\nend\n```\nReason: Hand-written numeric loops avoid intermediate table allocations and function call overhead, allowing LuaJIT to trace and heavily optimize the execution.",
      "durationMs": 11523,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal count = 1\nfor i = 1, #input do\n    local v = input[i]\n    if v.isValid then \n        result[count] = v.value * 2 \n        count = count + 1\n    end\nend\n```\nReason: A manual numeric loop with a local insertion counter avoids the function call overhead, closure creation, and intermediate table allocations of functional combinators, allowing LuaJIT to fully trace and heavily optimize the execution.",
      "durationMs": 13899,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal result = {}\nlocal count = 0\nfor i = 1, #data do\n    local v = data[i]\n    if v.active then\n        count = count + 1\n        result[count] = v.id\n    end\nend\n```\nReason: Procedural loops avoid the overhead of intermediate table creations, closure allocations, and nested function calls, allowing LuaJIT to effectively compile and optimize the execution.",
      "durationMs": 13620,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function filterAndMap(inputTable)\n    local result = {}\n    local index = 1\n    \n    for i = 1, #inputTable do\n        local item = inputTable[i]\n        \n        -- Filter equivalent\n        if item and item.isValid then \n            -- Map equivalent\n            result[index] = item.value * 2 \n            index = index + 1\n        end\n    end\n    \n    return result\nend\n```\nReason: A single imperative loop prevents intermediate table allocations and closure overhead, allowing LuaJIT to compile the code much more efficiently than chained function combinators.",
      "durationMs": 14127,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal function filterMapAlivePlayerNames(players)\n    local result = {}\n    local index = 1\n    for i = 1, #players do\n        local ply = players[i]\n        if ply:Alive() then\n            result[index] = ply:Nick()\n            index = index + 1\n        end\n    end\n    return result\nend\n```\nReason: An imperative loop avoids the closure allocations, function call overhead, and intermediate table creations inherent to DarkRP's multi-pass fn combinators.",
      "durationMs": 13789,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "ead0a98b3ff6a388"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCache_Join\", function(ply)\n    table.insert(cached_players, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"UpdatePlayerCache_Leave\", function(ply)\n    for i, p in ipairs(cached_players) do\n        if p == ply then\n            table.remove(cached_players, i)\n            break\n        end\n    end\nend)\n\nhook.Add(\"Tick\", \"OptimizedPlayerTick\", function()\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        -- Your per-tick player logic here\n    end\nend)\n```\nReason: Caching the player list prevents `player.GetAll()` from allocating a new table and generating garbage collection overhead every single tick, while a numeric for loop iterates the cached array with minimal overhead.",
      "durationMs": 14837,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cachedPlayers = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"CachePlayerJoin\", function(ply)\n    table.insert(cachedPlayers, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"CachePlayerLeave\", function(ply)\n    table.RemoveByValue(cachedPlayers, ply)\nend)\n\nhook.Add(\"Tick\", \"CachedPlayerTick\", function()\n    for i = 1, #cachedPlayers do\n        local ply = cachedPlayers[i]\n        if IsValid(ply) then\n            -- Tick logic for ply goes here\n        end\n    end\nend)\n```\nReason: Caching the array and using a sequential for loop eliminates the overhead of `player.GetAll()` allocating a new table and `ipairs` creating a new iterator every single tick.",
      "durationMs": 27542,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"UpdatePlayerCacheJoin\", function(ply)\n    table.insert(cached_players, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"UpdatePlayerCacheLeave\", function(ply)\n    table.RemoveByValue(cached_players, ply)\nend)\n\nhook.Add(\"Tick\", \"CachedPlayerTick\", function()\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        if IsValid(ply) then\n            -- Execute per-tick logic here\n        end\n    end\nend)\n```\nReason: Calling player.GetAll() every tick allocates a new table each time, causing unnecessary garbage collection and CPU overhead, whereas iterating a pre-allocated indexed table is virtually cost-free.",
      "durationMs": 15749,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"AddCachedPlayer\", function(ply)\n    table.insert(cached_players, ply)\nend)\n\nhook.Add(\"PlayerDisconnected\", \"RemoveCachedPlayer\", function(ply)\n    table.RemoveByValue(cached_players, ply)\nend)\n\nhook.Add(\"Tick\", \"OptimizedTickHook\", function()\n    -- Numeric iteration is faster than ipairs and avoids closure overhead\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        if IsValid(ply) then\n            -- Perform per-tick logic here\n        end\n    end\nend)\n```\nReason: Calling `player.GetAll()` every tick creates a new table which causes unnecessary memory allocation and frequent garbage collection, whereas caching the players and updating the table on join/leave avoids overhead and allows for faster numeric iteration.",
      "durationMs": 20210,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.player-cache-hooks.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal cached_players = player.GetAll()\n\nhook.Add(\"PlayerInitialSpawn\", \"CachePlayerJoin\", function(ply)\n    cached_players[#cached_players + 1] = ply\nend)\n\nhook.Add(\"PlayerDisconnected\", \"CachePlayerLeave\", function(ply)\n    table.RemoveByValue(cached_players, ply)\nend)\n\nhook.Add(\"Tick\", \"OptimizedTick\", function()\n    for i = 1, #cached_players do\n        local ply = cached_players[i]\n        if IsValid(ply) then\n            -- Execute per-player logic here\n        end\n    end\nend)\n```\nReason: `player.GetAll()` creates and returns a new table upon every call, which causes massive garbage collection overhead when run every tick; maintaining a persistent array and using a numeric `for` loop eliminates table allocations entirely.",
      "durationMs": 27913,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "a834817afe9e6c25"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal playerData = {}\n\n-- Write data\nplayerData[ply] = \"temporary_value\"\n\n-- Read data\nlocal val = playerData[ply]\n```\nReason: Accessing a standard Lua table avoids the expensive `__index` metamethod lookup overhead that occurs when reading fields from a C++ Entity userdata object.",
      "durationMs": 14164,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal tempData = {}\n\n-- Storing the data\ntempData[ply] = value\n\n-- Reading the data\nlocal val = tempData[ply]\n```\nReason: Using a plain local table avoids the __index metamethod overhead incurred every time you index an entity's userdata object.",
      "durationMs": 15308,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "pass",
      "detail": "Matched a pass pattern.",
      "finalResponse": "```lua\nlocal playerData = {}\n\n-- Writing data\nplayerData[ply] = value\n\n-- Reading data\nlocal val = playerData[ply]\n```\nReason: Indexing a local Lua table avoids the expensive C++ __index and __newindex metamethod lookups that occur when setting or reading fields directly on the Player userdata object.",
      "durationMs": 12085,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6895,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.ply-table-index.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6340,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f18cc80df8999147"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6094,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6921,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6293,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6389,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.seq-tables.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6383,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4778b0220c3f91a3"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6232,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 8120,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7166,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7092,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.setdrawcolor-split.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6056,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "d110fde8a37bbe59"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6939,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6016,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6093,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6139,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6121,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "4a3f5d2a20d71ac9"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6994,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6025,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6132,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6177,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.steamid-cache.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6886,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "e8a94aa454154982"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6928,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7185,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6658,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6358,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.string-table-concat.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6966,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "b0cf9e04ae7c5dd9"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6237,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7398,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7137,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7150,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-drawrect.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6335,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "696e8de769d9ad0e"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6990,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7291,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6198,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7225,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.surface-text.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6702,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "95d9fe4918ee4197"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7048,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7399,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6421,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6547,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-count-hash.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6032,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3e9bbfc8452e05e3"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6144,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6083,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6224,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6865,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-empty.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6221,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "3a6344977f5bd475"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6769,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6955,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6252,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6111,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-hasvalue.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6630,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "7d064428a873fdfc"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7032,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6745,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7072,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6059,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-literal.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7074,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f95a8fc610d720ad"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6115,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6713,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6117,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6715,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.table-random.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 5944,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "f3e090701953d4a9"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6556,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 5902,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6317,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 5893,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.perf.x-times-x.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6554,
      "version": "1.1.1",
      "fixtureVersion": 1,
      "rubricVersion": "1",
      "promptHash": "79d48008f6b5174f"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 1,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6686,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 2,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 7055,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 3,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6371,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 4,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6082,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    },
    {
      "fixtureId": "gmod.player-iterator.v1",
      "adapterId": "agy",
      "model": "Gemini 3.1 Pro (High)",
      "attemptIndex": 5,
      "status": "protocol_error",
      "detail": "CLI exited without a valid strict response.",
      "finalResponse": null,
      "durationMs": 6794,
      "version": "1.1.1",
      "fixtureVersion": 2,
      "rubricVersion": "4",
      "promptHash": "fe3d7469535a0ca2"
    }
  ],
  "summary": {
    "statusCounts": {
      "pass": 259,
      "partial": 27,
      "incorrect": 10,
      "protocol_error": 84,
      "policy_violation": 0,
      "timeout": 0,
      "unavailable": 0,
      "unsupported": 0,
      "trace_error": 0,
      "scored": 296
    },
    "groups": [
      {
        "fixtureId": "gmod.ents-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.ents-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.hook-add.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.hook-add.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.isvalid.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.isvalid.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.net-receivers.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.net-receivers.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.angle-zero.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.angle-zero.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.config-var.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.config-var.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.darkrpvar.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 4,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.8,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.darkrpvar.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 1,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.2,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.disttosqr.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.disttosqr.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.ents-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.ents-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.find-ents-near.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "partial",
        "meanScore": 0.5,
        "scoredAttempts": 1
      },
      {
        "fixtureId": "gmod.perf.find-ents-near.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 1,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.75,
        "scoredAttempts": 2
      },
      {
        "fixtureId": "gmod.perf.find-players-near.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.find-players-near.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.for-vs-while.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.for-vs-while.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.hook-once.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.hook-once.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.hudpaint-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.hudpaint-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.local-color.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.local-color.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.local-vs-global.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.local-vs-global.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.localplayer-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 1,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.5,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.localplayer-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "partial",
        "meanScore": 0.3,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.looking-at.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "partial",
        "meanScore": 0.5,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.looking-at.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "partial",
        "meanScore": 0.5,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.meta-vs-arg.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.meta-vs-arg.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.msg-vs-print.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.msg-vs-print.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 3,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.6,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.pairs-ipairs-for.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.plain-lua-vs-fn.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.player-cache-hooks.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.player-cache-hooks.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.ply-table-index.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 3,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 3
      },
      {
        "fixtureId": "gmod.perf.ply-table-index.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.seq-tables.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.seq-tables.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.setdrawcolor-split.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.setdrawcolor-split.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.sqlite-vs-mysql.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.steamid-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.steamid-cache.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 1,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 0.6,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.string-table-concat.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.string-table-concat.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.surface-drawrect.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.surface-drawrect.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.surface-text.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.surface-text.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.table-count-hash.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.table-count-hash.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.table-empty.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.table-empty.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.table-hasvalue.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.table-hasvalue.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.table-literal.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.table-literal.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.table-random.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.table-random.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.perf.x-times-x.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.perf.x-times-x.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 5,
        "passAtK": true,
        "bestStatus": "pass",
        "meanScore": 1,
        "scoredAttempts": 5
      },
      {
        "fixtureId": "gmod.player-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (High)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "protocol_error",
        "meanScore": null,
        "scoredAttempts": 0
      },
      {
        "fixtureId": "gmod.player-iterator.v1",
        "adapterId": "agy",
        "model": "Gemini 3.1 Pro (Low)",
        "attempts": 5,
        "passCount": 0,
        "passAtK": false,
        "bestStatus": "partial",
        "meanScore": 0.5,
        "scoredAttempts": 5
      }
    ],
    "passAtKRate": "56/61",
    "overallMeanScore": 0.9139344262295082
  },
  "metadata": {
    "schemaVersion": 3,
    "runId": "70b164dc-6ef6-4a75-93d6-33918b6faa41",
    "startedAt": "2026-07-10T15:56:33.573Z",
    "completedAt": "2026-07-10T16:08:37.501Z",
    "repeat": 5,
    "concurrency": 6,
    "fixtureIds": [
      "gmod.ents-iterator.v1",
      "gmod.hook-add.v1",
      "gmod.isvalid.v1",
      "gmod.net-receivers.v1",
      "gmod.perf.angle-zero.v1",
      "gmod.perf.config-var.v1",
      "gmod.perf.darkrpvar.v1",
      "gmod.perf.disttosqr.v1",
      "gmod.perf.ents-iterator.v1",
      "gmod.perf.find-ents-near.v1",
      "gmod.perf.find-players-near.v1",
      "gmod.perf.for-vs-while.v1",
      "gmod.perf.hook-once.v1",
      "gmod.perf.hudpaint-cache.v1",
      "gmod.perf.local-color.v1",
      "gmod.perf.local-vs-global.v1",
      "gmod.perf.localplayer-cache.v1",
      "gmod.perf.looking-at.v1",
      "gmod.perf.meta-vs-arg.v1",
      "gmod.perf.msg-vs-print.v1",
      "gmod.perf.pairs-ipairs-for.v1",
      "gmod.perf.plain-lua-vs-fn.v1",
      "gmod.perf.player-cache-hooks.v1",
      "gmod.perf.ply-table-index.v1",
      "gmod.perf.seq-tables.v1",
      "gmod.perf.setdrawcolor-split.v1",
      "gmod.perf.sqlite-vs-mysql.v1",
      "gmod.perf.steamid-cache.v1",
      "gmod.perf.string-table-concat.v1",
      "gmod.perf.surface-drawrect.v1",
      "gmod.perf.surface-text.v1",
      "gmod.perf.table-count-hash.v1",
      "gmod.perf.table-empty.v1",
      "gmod.perf.table-hasvalue.v1",
      "gmod.perf.table-literal.v1",
      "gmod.perf.table-random.v1",
      "gmod.perf.x-times-x.v1",
      "gmod.player-iterator.v1"
    ],
    "fixtureCount": 38,
    "attemptCount": 380,
    "adapters": [
      "agy"
    ],
    "models": [
      "agy/Gemini 3.1 Pro (High)",
      "agy/Gemini 3.1 Pro (Low)"
    ],
    "keepRaw": true,
    "durationSeconds": 724
  }
}