| `mixed-lane`       | A partly priced run withholds the number.                         |

| `crashed-verifier` | Ungraded trials stay out of both buckets.                         |

| `regressed-lane`   | A regression raises cost per accepted outcome and trips the gate. |

| `timed-out-lane`   | A killed session leaves no trajectory; the model pin survives it. |

The suite manifests beside them cover the pin and the smoke rule:

`fixture-suite` pins the four tasks the priced and regressed jobs ran,

{

  "dataset": "terminal-bench@2.0"

}

{

 "id": "job-timed-out-lane",

 "started_at": "2026-08-25T10:00:00.000000",

 "finished_at": "2026-08-25T10:30:00.000000",

 "n_total_trials": 1

}

{

 "task": {

  "path": "timed-out"

 },

 "trial_name": "timed-out__c0c0c0c0",

 "agent": {

  "import_path": "adapters.openagents_coder:OpenAgentsCoder",

  "model_name": "ollama/qwen3.8:27b-mtp-q8_0"

 }

}

{

 "id": "trial-timed-out",

 "task_name": "timed-out",

 "trial_name": "timed-out__c0c0c0c0",

 "exception_info": {

  "exception_type": "AgentTimeoutError"

 },

 "verifier_result": {

  "rewards": {

   "reward": 0.0

  }

 },

 "agent_execution": {

  "started_at": "2026-08-25T10:00:00.000000",

  "finished_at": "2026-08-25T10:30:00.000000"

 }

}

    expect(after.successRate!).toBeLessThan(before.successRate!);

  });

});

/**

 * A trial that hit the agent timeout, which is what a degraded lane's run is

 * mostly made of.

 *

 * The coder writes its ATIF export at the end of a session, so a killed session

 * leaves none — and every figure this suite reads from a trajectory goes with

 * it. What must not go with it is the model, because a run whose lane failed is

 * the run you most want to know the lane of.

 */

describe("a trial with no trajectory", () => {

  test("recovers the model from Harbor's own trial config", () => {

    const result = report("timed-out-lane", "local");

    expect(result.models).toEqual(["ollama:qwen3.8:27b-mtp-q8_0"]);

    // Harbor spells it `ollama/…`; the catalog id the adapter sends is

    // `ollama:…`, and a recovered id has to price like a read one.

    expect(result.perTrial[0]!.disposition).toBe("unmetered_local_lane");

    expect(result.perTrial[0]!.disposition).not.toBe("unknown_model");

  });

  test("still reports the verifier's decision and leaves the token counts unknown", () => {

    const result = report("timed-out-lane", "local");

    expect(result.rejected).toBe(1);

    expect(result.accepted).toBe(0);

    expect(result.promptTokens).toBeNull();

    expect(result.toolCalls).toBeNull();

    expect(result.wallClockSeconds).toBe(1800);

  });

  test("leaves the CLI version unknown, because nothing on disk records it", () => {

    // Recoverable and unrecoverable are different, and inventing the second

    // would be worse than reporting it.

    expect(report("timed-out-lane", "local").agentVersions).toEqual([]);

  });

});

  return {

    task: dirName.includes("__") ? dirName.slice(0, dirName.lastIndexOf("__")) : dirName,

    outcome: outcomeOf(trialResult),

    modelId: readString(readField(agent, "model_name")),

    modelId:

      readString(readField(agent, "model_name")) ??

      modelFromTrialConfig(readJson(join(trialDir, "config.json"))),

    agentVersion: readString(readField(agent, "version")),

    promptTokens: usage.promptTokens,

    completionTokens: usage.completionTokens,

  };

};

/**

 * The model, recovered from Harbor's own trial config when the trajectory is

 * missing.

 *

 * The coder writes its ATIF export at the end of a session, so a trial that hit

 * the agent timeout or crashed leaves no trajectory and no model id — exactly

 * the trials a regression run is full of. Losing the model pin there is the

 * wrong way round: a run whose lane failed is the run you most want to know the

 * lane of, and a whole run of timeouts would otherwise report `model unknown`

 * and price as `unknown_model` for a reason that has nothing to do with pricing.

 *

 * Harbor records the model on every trial before the agent starts, spelled the

 * way its `--model` flag takes it. The adapter maps that spelling onto the

 * coder's catalog id, and this repeats that mapping so a recovered id prices

 * the same as one read from a trajectory. It is a second copy of a two-line

 * rule; the alternative is a model pin that disappears precisely when it

 * matters. Keep it in step with `_catalog_model` in

 * `bench/adapters/openagents_coder.py`.

 */

const modelFromTrialConfig = (trialConfig: unknown): string | null => {

  // The trial's own `config.json` holds the agent block at the top level; the

  // same block appears one level down inside a trial `result.json`. Both are

  // read so a caller does not have to know which file it handed over.

  const spelled =

    readString(readField(readField(trialConfig, "agent"), "model_name")) ??

    readString(readField(readField(readField(trialConfig, "config"), "agent"), "model_name"));

  if (spelled === null) return null;

  const separator = spelled.indexOf("/");

  if (separator === -1) return spelled;

  const provider = spelled.slice(0, separator);

  const name = spelled.slice(separator + 1);

  if (provider === "ollama") return `ollama:${name}`;

  return name === "" ? provider : name;

};

/**

 * A verifier that never ran leaves no `verifier_result`. That is `ungraded`.

 * Where one ran, any positive reward is an accepted outcome; Harbor writes the