const comparison = compareRuns([proxy, local]).laneComparisons[0]!;

    expect(comparison.baselineLane).toBe("proxy");

    const lane = comparison.lanes.find((entry) => entry.lane === "local")!;

    expect(lane.costDelta?.direction).toBe("worse");

    expect(comparison.lanes.find((entry) => entry.lane === "proxy")!.costDelta).toBeNull();

    // Success rate compares across any two lanes; it is measured the same way

    // on both sides whatever either one costs.

    expect(

      comparison.lanes.find((entry) => entry.lane === "local")!.successRateDelta?.direction,

    ).toBe("worse");

  });

  test("refuses a cost delta against the local lane, which bills no metered tokens", () => {

    // This is the lane comparison #34 actually asks for — house models through

    // the proxy against a local model — and its cost delta is permanently

    // unstatable in one direction. Saying so is the point: a blank cell here

    // reads as "the same", and a zero would read as "free".

    const proxy = row("priced-lane", "proxy", "2026-08-25T10:00:00.000Z");

    const local = row("regressed-lane", "local", "2026-08-25T10:05:00.000Z");

    const lane = compareRuns([proxy, local]).laneComparisons[0]!.lanes.find(

      (entry) => entry.lane === "local",

    )!;

    expect(lane.costDelta?.direction).toBe("unpriced");

    expect(lane.costDelta?.absolute).toBeNull();

    expect(lane.costDelta?.reason).toContain("cost_unknown");

  });

  test("honours an explicit baseline lane", () => {

    const comparison = compareRuns([proxy, local], { baselineLane: "local" }).laneComparisons[0]!;

    expect(comparison.baselineLane).toBe("local");

    expect(comparison.lanes.find((entry) => entry.lane === "local")!.costDelta).toBeNull();

    expect(comparison.lanes.find((entry) => entry.lane === "proxy")!.costDelta?.direction).toBe(

      "better",

      "unpriced",

    );

  });

 * 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", () => {

  test("recovers the model spelled the way the coder's own export spells it", () => {

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

    // Harbor spells it `ollama/qwen3.8:…`; the coder's ATIF export writes the

    // bare name. A run that mixed a completed trial with a killed one would

    // otherwise report two models where there is one, and the run digest would

    // pin the pair.

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

  });

  test("prices a bare local-lane id off the lane, not off a prefix in the id", () => {

    // Nothing in `qwen3.8:27b-mtp-q8_0` says it ran locally. The run does.

    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");

  });

        cachedInputTokens: trial.cachedInputTokens,

      },

      catalog,

      run.lane,

    );

    if (cost.usd === null) {

      unpricedTrials += 1;

 * 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`.

 * way its `--model` flag takes it: `<provider>/<name>`. The id has to come back

 * spelled the way the CODER spells it, not the way Harbor does, because a run

 * mixing completed and killed trials would otherwise report two models where

 * there is one — and the report would list them, the digest would pin them, and

 * a lane comparison would treat the pair as a confounder. The coder's ATIF

 * export records the bare name (`qwen3.8:27b-mtp-q8_0`), so that is what a

 * recovered id is.

 *

 * Note that this deliberately does NOT reproduce the adapter's `ollama:` local

 * prefix. That prefix is how the adapter tells the CLI which lane to use; it

 * never reaches the trajectory, so adding it here would invent a spelling

 * nothing else in the run uses. Whether the lane bills metered tokens is a fact

 * about the lane, and the lane is on the run — see `priceUsage`.

 */

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

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

  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;

  return name === "" ? spelled.slice(0, separator) : name;

};

/**

  readonly reason: string;

}

/** The local lane runs on hardware you own; no per-token rate applies. */

const isLocalLaneModel = (modelId: string): boolean =>

  modelId.startsWith("ollama:") || modelId.startsWith("ollama/");

/**

 * Whether this trial ran on a lane that bills no metered tokens.

 *

 * The lane the run was executed on is the authority, and it is passed in

 * because it is a fact the run records rather than something to be guessed at.

 * The `ollama:` prefix is kept as a secondary signal for a caller pricing one

 * trial with no lane in hand, but it was never a good primary one: the coder's

 * own ATIF export writes the bare model name, so an id read from a trajectory

 * carries no prefix to spot and a whole local run priced as `unknown_model` —

 * which reads as a gap in the rate catalog rather than as a lane that has no

 * rates to be in it.

 */

const isUnmetered = (modelId: string, lane: string | null): boolean =>

  lane === "local" || modelId.startsWith("ollama:") || modelId.startsWith("ollama/");

/**

 * Price one trial's usage against a rate catalog.

 *

 * Unknown stays unknown. A model with no rate, a local lane with no per-token

 * rate at all, or usage missing either token dimension all return `usd: null`

 * with a disposition that names the reason. Nothing here falls back to a

 * conservative default rate: this function measures, it does not charge.

 * Unknown stays unknown. A model with no rate, a lane with no per-token rate at

 * all, or usage missing either token dimension all return `usd: null` with a

 * disposition that names the reason. Nothing here falls back to a conservative

 * default rate: this function measures, it does not charge.

 */

export const priceUsage = (

  modelId: string | null,

  usage: UsageForCost,

  catalog: Readonly<Record<string, ModelRateRow>> = CODER_RATE_CATALOG,

  lane: string | null = null,

): CostResult => {

  if (modelId === null || modelId === "") {

    return {

      reason: "the trial records no model id, so no rate can be selected",

    };

  }

  if (isLocalLaneModel(modelId)) {

  if (isUnmetered(modelId, lane)) {

    return {

      usd: null,

      disposition: "unmetered_local_lane",

      rateBasis: null,

      reason: `${modelId} runs on the local lane, which bills no metered tokens, so it has no per-token cost`,

      reason: `${modelId} ran on the local lane, which bills no metered tokens, so it has no per-token cost`,

    };

  }

  const row = catalog[modelId];