"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2473,

    "filesScanned": 2474,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:d9d93b65d7614d382ef47b625cf1b305e5f4a907d8103d09dd0951d49b3d9ff0",

  "sourceDigest": "sha256:9c762fe37db50019a875a89c30c5bcb2a21ebc1d5e3d8ab94ea8eaa538bc7b0f",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (68 tracked test files)"

          "ref": "packages/openagents-cli (69 tracked test files)"

        },

        {

          "type": "behavior-contract",

  resumableThreads,

  type ThreadSummary,

} from "./coder-resume.js";

import { toolFamilyOf } from "./coder-tool-families.js";

import { openLocalThread, threadAnnouncement, threadSyncWanted } from "./coder-local-thread.js";

import { ThreadTranscriptWriter } from "./coder-transcript.js";

import { delegateTool, openagentsTool, shellTool, skillTool } from "./coder-tools.js";

              // The replayed history reaches the model transcript and the

              // interface, never the transcript writer: the server already

              // holds these events, and a resume must not post them twice.

              source.preload(replayWire(events));

              source.preload(replayWire(events, toolFamilyOf(source.model)));

              return { source, entries: replayEntries(events) };

            },

            catch: (cause) => coderRefusal(endpoint.origin, cause, "coder.thread.resume"),

  ToolCall as OllamaToolCall,

} from "ollama";

import { budgetedResult } from "./coder-tool-budget.js";

import { declaredDescription } from "./coder-tool-families.js";

import { merge } from "./coder-merge.js";

import type { ReplyChunk, ReplySource } from "./coder-session.js";

 */

const MAX_TOOL_STEPS = 100;

/**

 * How much of one tool's output is kept on the transcript.

 *

 * The reader sees all of it; this is only what goes back to the model on every

 * round after. A session that read the issue boards accumulated 82 KB of tool

 * output and re-sent it 25 times, which is where its wall clock went: 91% of

 * everything sent each round was output the model had already read.

 *

 * Generous enough that a normal command survives whole, and the head and the

 * tail are what a long one is read for anyway.

 */

const TOOL_RESULT_KEPT = 4_000;

/**

 * How much of one tool's output reaches the durable `tool.ran` event.

 *

 * The same figure the thread lane uses, for the same reason: the 4,000 above

 * is a context-budget decision re-spent on every round, and this bounds a

 * record written once, so it is set where every result a real session has

 * produced fits whole.

 * What the model is fed is bounded elsewhere and differently: this lane's

 * results are budgeted for the `local` family in `coder-tool-budget.ts`,

 * because they are re-sent on every round and a local model's window is a

 * fraction of a hosted one. This figure bounds a record written once, so it is

 * set where every result a real session has produced fits whole.

 */

const EVENT_RESULT_KEPT = 64_000;

/** A long tool result, kept at both ends. */

const bounded = (output: string, keep = TOOL_RESULT_KEPT): string => {

const bounded = (output: string, keep: number): string => {

  if (output.length <= keep) return output;

  const half = Math.floor(keep / 2);

  const cut = output.length - keep;

  return `${output.slice(0, half)}\n\n[${String(cut)} characters omitted from the middle; run it again more narrowly if you need them]\n\n${output.slice(-half)}`;

  return `${output.slice(0, half)}\n\n[${String(cut)} of ${String(output.length)} characters omitted from the middle; run it again more narrowly if you need them]\n\n${output.slice(-half)}`;

};

/**

        : { error: bounded(failure, EVENT_RESULT_KEPT) }),

    });

    this.transcript.push({ role: "tool", content: bounded(output), tool_name: name });

    // Budgeted for the local family: a small window and slow generation make

    // every re-sent character expensive in wall clock (coder-tool-budget.ts).

    this.transcript.push({

      role: "tool",

      content: budgetedResult(output, "local"),

      tool_name: name,

    });

  }

}

import { createInterface } from "node:readline";

import type { CoderEntry } from "./coder-session.js";

import { boundedResult, ThreadUnavailable, type WireMessage } from "./coder-thread.js";

import { budgetedResult } from "./coder-tool-budget.js";

import type { ToolFamily } from "./coder-tool-families.js";

import { ThreadUnavailable, type WireMessage } from "./coder-thread.js";

import { THREADS_PATH } from "./constants.js";

/** The server's listing cap. Pages are read at exactly this size. */

 * what reached the wire. `tool.ran` becomes the standard chat exchange: an

 * assistant message carrying the call in `tool_calls`, with the arguments as

 * the raw JSON string the record kept, then a `tool` message named by

 * `tool_call_id` with the result bounded by the same figure the live loop

 * uses, because this transcript is re-sent on every round and the bound is a

 * context-budget decision, not a property of the record. `turn.assistant` is

 * the turn's whole answer. `turn.reasoning` is deliberately absent: the live

 * `tool_call_id` with the result budgeted by the same allowance the live loop

 * uses, which is why the resumed session's model family has to be passed in:

 * this transcript is re-sent on every round and the bound is a context-budget

 * decision against that family's window, not a property of the record.

 * `turn.assistant` is the turn's whole answer. `turn.reasoning` is deliberately absent: the live

 * loop never puts a thought on the wire.

 *

 * One call per assistant message, not one per round: the record does not

 * `tool_calls` message is answered before the next assistant message, and

 * this shape keeps that invariant per call.

 */

export function replayWire(events: ReadonlyArray<ThreadEvent>): ReadonlyArray<WireMessage> {

export function replayWire(

  events: ReadonlyArray<ThreadEvent>,

  family: ToolFamily,

): ReadonlyArray<WireMessage> {

  const messages: WireMessage[] = [];

  for (const event of events) {

      messages.push({

        role: "tool",

        tool_call_id: callId,

        content: boundedResult(outcome),

        content: budgetedResult(outcome, family),

      });

    } else if (event.eventType === "turn.assistant") {

      const said = text(payload["text"]);

import { accumulate, frames, parse, parseArguments } from "./coder-thread.js";

import type { ChildGrant } from "./coder-child-gateway.js";

import type { DelegateEvent, DelegateHarness } from "./coder-delegate.js";

import { boundedResult } from "./coder-thread.js";

import { budgetedResult } from "./coder-tool-budget.js";

import { toolFamilyOf } from "./coder-tool-families.js";

import type { CoderTool } from "./coder-tools.js";

import { shellTool } from "./coder-tools.js";

import { Redacted } from "effect";

        transcript.push({

          role: "tool",

          tool_call_id: call.id,

          content: boundedResult(output),

          content: budgetedResult(output, toolFamilyOf(this.model)),

        });

        record({ type: "tool_result", callId: call.id, output });

      }

  readonly output: string;

  readonly code: number | undefined;

  readonly timedOut: boolean;

  /**

   * Characters the collector refused to hold, once the output passed the cap.

   *

   * Counted rather than discarded unrecorded: the reader of this result is a

   * model, and a `git log` it was handed half of reads exactly like a whole

   * one. The count is what lets the notice say how much is missing.

   */

  readonly dropped: number;

}

/**

    });

    let output = "";

    let dropped = 0;

    let settled = false;

    const finish = (result: ShellResult) => {

      if (settled) return;

    const timer = setTimeout(() => {

      child.kill("SIGKILL");

      finish({ output, code: undefined, timedOut: true });

      finish({ output, code: undefined, timedOut: true, dropped });

    }, timeoutMs);

    const onAbort = () => {

      child.kill("SIGKILL");

      finish({ output, code: undefined, timedOut: false });

      finish({ output, code: undefined, timedOut: false, dropped });

    };

    options.signal.addEventListener("abort", onAbort, { once: true });

    const collect = (chunk: Buffer) => {

      if (output.length < OUTPUT_LIMIT) output += chunk.toString("utf8");

      const text = chunk.toString("utf8");

      // Past the cap the text is counted rather than kept. Counting it is the

      // whole difference between a result that says what is missing and one

      // that quietly ends mid-file.

      if (output.length < OUTPUT_LIMIT) output += text;

      else dropped += text.length;

    };

    child.stdout.on("data", collect);

    child.stderr.on("data", collect);

        output: `The command could not be started: ${cause.message}`,

        code: undefined,

        timedOut: false,

        dropped: 0,

      });

    });

    child.on("close", (code) => {

      finish({ output, code: code ?? undefined, timedOut: false });

      finish({ output, code: code ?? undefined, timedOut: false, dropped });

    });

  });

}

/** What the model is shown for one run. */

export const renderShell = (result: ShellResult, timeoutMs: number): string => {

  const kept = Math.min(result.output.length, OUTPUT_LIMIT);

  const cut = result.output.length - kept + result.dropped;

  const bounded =

    result.output.length > OUTPUT_LIMIT

      ? `${result.output.slice(0, OUTPUT_LIMIT)}\n\n[truncated; narrow the command or write to a file and read part of it]`

    cut > 0

      ? `${result.output.slice(0, OUTPUT_LIMIT)}\n\n[The command printed ${String(kept + cut)} characters and this tool holds ${String(OUTPUT_LIMIT)}, so ${String(cut)} were cut from the end. What you have stops mid-output and must not be read as the whole of it: narrow the command, or write it to a file and read the part you need.]`

      : result.output;

  const body = bounded.trim();

import { Redacted } from "effect";

import type { ChildGrant } from "./coder-child-gateway.js";

import { budgetedResult, describeBudget, toolResultBudget } from "./coder-tool-budget.js";

import { declaredDescription, toolFamilyOf } from "./coder-tool-families.js";

import { merge } from "./coder-merge.js";

import type { ReplyChunk, ReplySource } from "./coder-session.js";

 */

const MAX_TOOL_STEPS = 100;

/** How much of one tool's output is kept on the transcript. */

const TOOL_RESULT_KEPT = 4_000;

/**

 * How much of one tool's output reaches the durable `tool.ran` event.

 *

 * A separate figure from `TOOL_RESULT_KEPT`, because they answer different

 * questions. The 4,000 above is a context-budget decision made against a

 * model's window: it is re-sent on every round of the turn. This one bounds a

 * record written once, so it is set where every result a real session has

 * produced fits whole — the largest measured was 8.4 KB — and only a

 * pathological dump is cut, kept at both ends the same way.

 * A separate figure from the model-facing budget in `coder-tool-budget.ts`,

 * because they answer different questions. That one is a context-budget

 * decision made against a model's window, per family: it is re-sent on every

 * round of the turn. This one bounds a record written once, so it is set where

 * every result a real session has produced fits whole — the largest measured

 * was 8.4 KB — and only a pathological dump is cut, kept at both ends the same

 * way.

 */

const EVENT_RESULT_KEPT = 64_000;

  if (output.length <= keep) return output;

  const half = Math.floor(keep / 2);

  const cut = output.length - keep;

  return `${output.slice(0, half)}\n\n[${String(cut)} characters omitted from the middle; run it again more narrowly if you need them]\n\n${output.slice(-half)}`;

  return `${output.slice(0, half)}\n\n[${String(cut)} of ${String(output.length)} characters omitted from the middle; run it again more narrowly if you need them]\n\n${output.slice(-half)}`;

};

/**

 * A tool result as the model transcript carries it. Exported for the replay in

 * `coder-resume.ts`, which must feed a resumed model exactly what the live

 * loop would have.

 */

export const boundedResult = (output: string): string => bounded(output, TOOL_RESULT_KEPT);

/** What the thread may still spend, as the server last reported it. */

export interface ThreadBudget {

  /** `undefined` where the server set no ceiling: there is nothing counting down. */

      `System message sent with every turn:\n\n${systemPrompt(this.tools, THREAD_LANE, this.standing)}`,

      "",

      declarations,

      "",

      describeBudget(toolResultBudget(toolFamilyOf(this.model))),

    ].join("\n");

  }

        : { error: bounded(failure, EVENT_RESULT_KEPT) }),

    });

    // Bounded on the way toward the model, not on the way to the reader or the

    // Budgeted on the way toward the model, not on the way to the reader or the

    // record: this is what goes back on every round after, and a session that

    // re-sends everything it has already read spends its wall clock on reading

    // it again. The `tool.ran` event above kept the fuller copy.

    results.set(call.id, boundedResult(output));

    // it again. The allowance is this model family's, and a cut result says so.

    // The `tool.ran` event above kept the fuller copy.

    results.set(call.id, budgetedResult(output, toolFamilyOf(this.model)));

  }

  /**

/**

 * What one tool result may cost, per model family.

 *

 * A tool result is not paid for once. Every later round of the turn re-sends

 * the whole transcript, so the result a command printed on round two is bought

 * again on rounds three through fifteen. The measured bill for that is in the

 * first graded Gym runs: a session that read the issue boards accumulated 82 KB

 * of tool output and re-sent it 25 times, and 91% of everything it sent each

 * round was output the model had already read

 * (`openagents.com` docs/terminalbench/2026-08-24-fix-git-run-analysis.md).

 *

 * The bound on that used to be one number — 4,000 characters — written twice,

 * once in the thread lane and once in the local lane, and applied to a 32k

 * local model and to a million-token hosted one alike. A single number cannot

 * be right for both: it is either most of a small model's window or a rounding

 * error in a large one, and in neither case does it reflect what the family's

 * tokenizer charges for those characters. So the budget is per family, it is

 * stated in tokens, and it is converted to characters through that family's own

 * density.

 *

 * ## The density figures are approximations, and say so

 *

 * Nothing here tokenizes. A real tokenizer per family is a dependency and a

 * download for a decision that is a ceiling, not an accounting entry — the

 * result is cut at a character count either way. What each family's figure is

 * for is that tokenizers differ enough to matter: byte-pair vocabularies

 * trained mostly on English prose land near four characters a token on prose

 * and lower on the shell output, paths, and diffs a coding session actually

 * reads. The numbers below are documented approximations, held low rather than

 * high, so an error spends less of the window than the budget says rather than

 * more. Replace one when a family is measured; do not read it as a measurement.

 *

 * ## Cutting is reported, never silent

 *

 * The caller of a tool is a model, and a model handed a quietly shortened

 * `git log` will summarize it as though it were the whole log. So a cut result

 * says it was cut, by how much, out of what, and against which family's budget

 * — the fail-closed limit discipline in `INVARIANTS.md`: a cap may drop

 * coverage, but it may never let an incomplete result read as complete.

 */

import type { ToolFamily } from "./coder-tool-families.js";

/** The figures a family's budget is derived from. */

interface FamilyBudget {

  /** The family's context window, in tokens, as the lane advertises it. */

  readonly contextWindowTokens: number;

  /** What one tool result may take of that window, in tokens. */

  readonly resultTokens: number;

  /** Approximate characters per token for this family's tokenizer. */

  readonly charactersPerToken: number;

  /** Why this family's result allowance is what it is. */

  readonly because: string;

}

/**

 * The budgets, as data.

 *

 * Exhaustive over `ToolFamily` on purpose: adding a family to that union

 * without deciding what it may spend does not compile. Each row carries the

 * reason it holds the figure it does, because a number nobody can argue with

 * is a number nobody will ever correct.

 */

const BUDGETS: Record<ToolFamily, FamilyBudget> = {

  default: {

    contextWindowTokens: 200_000,

    resultTokens: 1_100,

    // Byte-pair vocabularies of the o200k shape run near four characters a

    // token on prose and lower on the command output a session reads. Held at

    // 3.6 so the estimate errs toward spending less.

    charactersPerToken: 3.6,

    because:

      "the hosted general lanes carry a large window, and 1,100 tokens is the " +

      "measured allowance the shipped 4,000-character bound already amounted to",

  },

  gemini: {

    contextWindowTokens: 1_000_000,

    resultTokens: 700,

    // Google documents roughly four characters a token for English on the

    // SentencePiece vocabulary these lanes use.

    charactersPerToken: 4,

    because:

      "the window is the largest of any lane and the round count is what costs: " +

      "this family issued fifteen tool rounds where another issued six and spent " +

      "three times the input tokens replaying whole-file dumps, so its results " +

      "are cut sooner to make a narrower second read the cheaper move",

  },

  local: {

    contextWindowTokens: 32_768,

    resultTokens: 500,

    // Qwen-shaped byte-pair vocabularies, again held low for code and paths.

    charactersPerToken: 3.5,

    because:

      "the window is a fraction of a hosted one and generation is slow on one " +

      "machine, so every re-sent character is paid in wall clock rather than in " +

      "money",

  },

};

/** The smallest budget on the table: what an unrecognized family is given. */

const mostConservative = (): ToolFamily => {

  const families = Object.keys(BUDGETS) as ReadonlyArray<ToolFamily>;

  let smallest: ToolFamily = "local";

  for (const family of families) {

    if (charactersOf(BUDGETS[family]) < charactersOf(BUDGETS[smallest])) smallest = family;

  }

  return smallest;

};

const charactersOf = (budget: FamilyBudget): number =>

  Math.floor(budget.resultTokens * budget.charactersPerToken);

/** What one tool result may spend, resolved for one family. */

export interface ToolResultBudget {

  /** The family the budget was asked for. */

  readonly family: ToolFamily;

  /** The ceiling the result is cut to. */

  readonly characters: number;

  /** What those characters are believed to cost. */

  readonly tokens: number;

  /** The approximation the two are related by. */

  readonly charactersPerToken: number;

  readonly contextWindowTokens: number;

  /**

   * True when the family had no row and the smallest budget was substituted.

   *

   * Carried rather than hidden: the notice on a cut result says so, because a

   * budget that is a guess and a budget that is a decision are not the same

   * claim.

   */

  readonly substituted: boolean;

}

/**

 * The budget for a family.

 *

 * A family with no row falls back to the smallest budget on the table rather

 * than to a generous default. A family name reaches this from data — a lane

 * name derived from a server catalog, a resumed session's record — so the case

 * is reachable at runtime even though the union is exhaustive at compile time,

 * and guessing high is the failure that is expensive.

 */

export const toolResultBudget = (family: ToolFamily): ToolResultBudget => {

  const held = BUDGETS[family] as FamilyBudget | undefined;

  const substituted = held === undefined;

  const budget = held ?? BUDGETS[mostConservative()];

  return {

    family,

    characters: charactersOf(budget),

    tokens: budget.resultTokens,

    charactersPerToken: budget.charactersPerToken,

    contextWindowTokens: budget.contextWindowTokens,

    substituted,

  };

};

/** One line naming a family's allowance, for a reader asking what it is. */

export const describeBudget = (budget: ToolResultBudget): string =>

  `Tool results are cut to ${String(budget.characters)} characters for the ` +

  `${budget.family} model family: about ${String(budget.tokens)} tokens at an ` +

  `approximate ${String(budget.charactersPerToken)} characters per token, against a ` +

  `${String(budget.contextWindowTokens)}-token window` +

  (budget.substituted

    ? " — the smallest budget on the table, substituted because that family has none of its own."

    : ".");

/**

 * One tool result as the model transcript carries it.

 *

 * Kept at both ends, which is what a long output is read for: a command's

 * first lines say what it did and its last lines say how it ended, and the

 * middle is the part a second, narrower run can recover. The notice in place of

 * the middle is written for the model that has to decide what to do next, so it

 * carries the arithmetic rather than the word "truncated".

 */

export const budgetedResult = (output: string, family: ToolFamily): string => {

  const budget = toolResultBudget(family);

  if (output.length <= budget.characters) return output;

  const half = Math.floor(budget.characters / 2);

  const omitted = output.length - budget.characters;

  const notice =

    `[${String(omitted)} of ${String(output.length)} characters omitted from the middle. ` +

    `${describeBudget(budget)} ` +

    "Every later round of this turn re-sends what you are reading, which is why the " +

    "budget exists. What you have is incomplete and must not be summarized as if it " +

    "were the whole answer: run it again more narrowly — a range, a filter, a count — " +

    "if you need what is missing.]";

  return `${output.slice(0, half)}\n\n${notice}\n\n${output.slice(-half)}`;

};

  return [header, "", ...lines].join("\n");

}

/**

 * A child's answer, cut to what the parent is shown.

 *

 * The cut says its own size. A child that reported ten findings and was shown

 * as three reads, to the model holding the report, exactly like a child that

 * found three.

 */

function clip(text: string, limit: number): string {

  return text.length <= limit ? text : `${text.slice(0, limit)}\n…[truncated]`;

  if (text.length <= limit) return text;

  const cut = text.length - limit;

  return (

    `${text.slice(0, limit)}\n` +

    `…[${String(cut)} of ${String(text.length)} characters cut from the end of this child's ` +

    "answer; ask the child again for the part you need, or give it a narrower task]"

  );

}

/**

          stdio: ["ignore", "pipe", "pipe"],

        });

        let output = "";

        let dropped = 0;

        let done = false;

        const finish = (text: string) => {

        signal.addEventListener("abort", onAbort, { once: true });

        const collect = (chunk: Buffer) => {

          if (output.length < CLI_OUTPUT_LIMIT) output += chunk.toString("utf8");

          const text = chunk.toString("utf8");

          // Past the cap the text is counted, not dropped unrecorded: a listing

          // the model was handed half of reads like a whole listing.

          if (output.length < CLI_OUTPUT_LIMIT) output += text;

          else dropped += text.length;

        };

        child.stdout.on("data", collect);

        child.stderr.on("data", collect);

          const advice = args.includes("--json")

            ? "drop --json and read the plain output, or ask for one record"

            : "narrow it with a flag such as --limit, --label, or --state";

          const kept = Math.min(output.length, CLI_OUTPUT_LIMIT);

          const cut = output.length - kept + dropped;

          const bounded =

            output.length > CLI_OUTPUT_LIMIT

              ? `${output.slice(0, CLI_OUTPUT_LIMIT)}\n\n[The output was cut off here. Run it again and ${advice}; what you have above is incomplete and must not be summarized as if it were the whole answer.]`

            cut > 0

              ? `${output.slice(0, CLI_OUTPUT_LIMIT)}\n\n[The command printed ${String(kept + cut)} characters and this tool holds ${String(CLI_OUTPUT_LIMIT)}, so ${String(cut)} were cut off here. Run it again and ${advice}; what you have above is incomplete and must not be summarized as if it were the whole answer.]`

              : output;

          const body = bounded.trim();

          // The exit code is reported on failure because it is what the CLI

import type { ReplyChunk, ReplySource } from "./coder-session.js";

import { systemPrompt } from "./coder-system.js";

import { accumulate, boundedResult, frames, parse, parseArguments } from "./coder-thread.js";

import { budgetedResult } from "./coder-tool-budget.js";

import { toolFamilyOf } from "./coder-tool-families.js";

import { accumulate, frames, parse, parseArguments } from "./coder-thread.js";

import type { CoderTool } from "./coder-tools.js";

/**

        this.transcript.push({

          role: "tool",

          tool_call_id: call.id,

          content: boundedResult(output),

          content: budgetedResult(output, toolFamilyOf(this.model)),

        });

        yield { type: "tool_result", callId: call.id, output, error: undefined };

      }

describe("replayWire", () => {

  it("rebuilds the messages in the shape the live loop holds", () => {

    expect(replayWire(FIXTURE)).toEqual([

    expect(replayWire(FIXTURE, "default")).toEqual([

      { role: "user", content: "standing context\n\n---\n\nwhat is in mix.exs?" },

      {

        role: "assistant",

  });

  it("keeps the recorded arguments as the raw JSON string", () => {

    const wire = replayWire(FIXTURE);

    const wire = replayWire(FIXTURE, "default");

    const call = wire[1];

    expect(call?.role === "assistant" && call.tool_calls?.[0]?.function.arguments).toBe(

      `{"command":"cat mix.exs"}`,

  });

  it("keeps reasoning off the wire, as the live loop does", () => {

    const wire = replayWire(FIXTURE);

    const wire = replayWire(FIXTURE, "default");

    expect(wire.some((message) => message.content.includes("before answering"))).toBe(false);

  });

  it("bounds a stored tool result to the live loop's wire figure", () => {

    const wire = replayWire([

      {

        id: 1,

        eventType: "tool.ran",

        payload: {

          call_id: "call-1",

          tool: "shell",

          arguments: "{}",

          status: "succeeded",

          output: "x".repeat(10_000),

  it("budgets a stored tool result by the resumed session's model family", () => {

    const wire = replayWire(

      [

        {

          id: 1,

          eventType: "tool.ran",

          payload: {

            call_id: "call-1",

            tool: "shell",

            arguments: "{}",

            status: "succeeded",

            output: "x".repeat(10_000),

          },

          emittedAt: undefined,

        },

        emittedAt: undefined,

      },

    ]);

      ],

      "gemini",

    );

    const result = wire[1];

    expect(result?.role).toBe("tool");

    expect(result?.content).toContain("characters omitted from the middle");

    expect(result?.content.length ?? 0).toBeLessThan(5_000);

    expect(result?.content).toContain("for the gemini model family");

    // The same event replayed for a hosted lane keeps more of it, because the

    // budget is the family's and not the record's.

    const hosted = replayWire(

      [

        {

          id: 1,

          eventType: "tool.ran",

          payload: {

            call_id: "call-1",

            tool: "shell",

            arguments: "{}",

            status: "succeeded",

            output: "x".repeat(10_000),

          },

          emittedAt: undefined,

        },

      ],

      "default",

    );

    expect((hosted[1]?.content.length ?? 0) > (result?.content.length ?? 0)).toBe(true);

  });

});

    };

    const source = await remintThread({ origin: ORIGIN, token: TOKEN, threadId: THREAD_ID });

    const replayed = replayWire(FIXTURE);

    const replayed = replayWire(FIXTURE, "default");

    source.preload(replayed);

    source.useTranscript(sink);

  it("asks for a command rather than running nothing", async () => {

    await expect(run("   ")).resolves.toContain("`command` is required");

  });

  it("says how much of an oversized output was cut, rather than ending mid-line", async () => {

    // 100,000 characters against a 30,000-character hold. What the collector

    // refuses is counted, so the notice can name the whole size: a result that

    // stops without saying so is read as the whole of it.

    const output = await run("yes wwwwwwwwwwwwwwwwwww | head -n 5000", 30);

    expect(output).toContain("The command printed 100000 characters");

    expect(output).toContain("this tool holds 30000");

    expect(output).toContain("70000 were cut from the end");

    expect(output).toContain("must not be read as the whole of it");

  });

});

  ThreadUnavailable,

} from "../src/coder-thread.js";

import { Redacted } from "effect";

import { toolResultBudget } from "../src/coder-tool-budget.js";

import { shellTool } from "../src/coder-tools.js";

import { ThreadTranscriptWriter } from "../src/coder-transcript.js";

    expect(messages[1]?.["tool_calls"]).toHaveLength(1);

  });

  it("bounds a tool result on the wire while the record keeps the fuller copy", async () => {

  /** One turn that calls a tool returning 10,000 characters, on one model. */

  const dumped = async (model: string) => {

    const round = [

      `data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call-1","type":"function","function":{"name":"shell","arguments":"{}"}}]}}]}`,

      `data: {"choices":[{"index":0,"delta":{},"finish_reason":"tool_calls"}]}`,

      `data: [DONE]`,

      "",

    ].join("\n\n");

    const calls = stub({ proxy: [sse([round]), sse([LIVE_SSE])] });

    const calls = stub({

      create: json(201, { ...CREATED, grant: { ...CREATED.grant, model } }),

      proxy: [sse([round]), sse([LIVE_SSE])],

    });

    const source = await open();

    const sink = recorder();

    source.useTranscript(sink);

    const spends = calls.filter((call) => call.url.endsWith("/api/inference/proxy"));

    const messages = spends[1]?.body["messages"] as Array<Record<string, unknown>>;

    const result = messages.find((message) => message["role"] === "tool");

    const wire = result?.["content"] as string;

    // The 4,000-char context budget still holds on the way to the model...

    expect(wire.length).toBeLessThan(4_200);

    expect(wire).toContain("characters omitted");

    return { wire: result?.["content"] as string, sink };

  };

  it("budgets a tool result on the wire while the record keeps the fuller copy", async () => {

    const { wire, sink } = await dumped("gpt-5.6-luna");

    // The context budget for this model's family holds on the way to the

    // model, and the notice for what it cut is part of what is sent...

    const budget = toolResultBudget("default");

    expect(wire.length).toBeLessThan(budget.characters + 800);

    expect(wire).toContain(`${String(10_000 - budget.characters)} of 10000 characters omitted`);

    // ...while the durable event keeps the result whole, as before.

    const ran = sink.events.find((event) => event.eventType === "tool.ran");

    expect(ran?.payload["output"]).toBe("x".repeat(10_000));

  });

  it("budgets the same result differently on a model of another family", async () => {

    const hosted = await dumped("gpt-5.6-luna");

    const gemini = await dumped("gemini-3.7-flash");

    // Same tool, same output, two allowances — and each result says which

    // family's budget cut it and by how much.

    expect(gemini.wire.length).toBeLessThan(hosted.wire.length);

    expect(hosted.wire).toContain("for the default model family");

    expect(gemini.wire).toContain("for the gemini model family");

    expect(gemini.wire).toContain(

      `${String(10_000 - toolResultBudget("gemini").characters)} of 10000 characters omitted`,

    );

  });

  it("drops the calls past the step limit and asks for an answer without tools", async () => {

    const round = [

      `data: {"choices":[{"index":0,"delta":{"tool_calls":[{"index":0,"id":"call-1","type":"function","function":{"name":"shell","arguments":"{}"}}]}}]}`,

import { describe, expect, it } from "vitest";

import { budgetedResult, describeBudget, toolResultBudget } from "../src/coder-tool-budget.js";

import type { ToolFamily } from "../src/coder-tool-families.js";

import { toolFamilyOf } from "../src/coder-tool-families.js";

/** One oversized result, the same one for every family. */

const oversized = "x".repeat(20_000);

/** The characters a family keeps of that result, notice excluded. */

const kept = (family: ToolFamily): number =>

  budgetedResult(oversized, family).replaceAll(/\n\n\[[\s\S]*?\]\n\n/g, "").length;

describe("toolResultBudget", () => {

  it("gives each family its own allowance, in tokens and in characters", () => {

    const hosted = toolResultBudget("default");

    const gemini = toolResultBudget("gemini");

    const local = toolResultBudget("local");

    expect(hosted.characters).not.toBe(gemini.characters);

    expect(gemini.characters).not.toBe(local.characters);

    // Every budget is a token allowance converted through that family's own

    // approximate density, not a character count someone picked.

    for (const budget of [hosted, gemini, local]) {

      expect(budget.characters).toBe(Math.floor(budget.tokens * budget.charactersPerToken));

      expect(budget.substituted).toBe(false);

    }

    expect(gemini.contextWindowTokens).toBeGreaterThan(local.contextWindowTokens);

  });

  it("substitutes the smallest budget for a family it does not know, and says so", () => {

    const unknown = toolResultBudget("mystery-lane" as ToolFamily);

    expect(unknown.substituted).toBe(true);

    expect(unknown.characters).toBe(

      Math.min(

        toolResultBudget("default").characters,

        toolResultBudget("gemini").characters,

        toolResultBudget("local").characters,

      ),

    );

    expect(describeBudget(unknown)).toContain("substituted");

  });

  it("states the approximation rather than implying a token count was measured", () => {

    expect(describeBudget(toolResultBudget("gemini"))).toContain("approximate");

  });

});

describe("budgetedResult", () => {

  it("budgets one oversized result differently for two model families", () => {

    const forGemini = kept("gemini");

    const forHosted = kept("default");

    expect(forGemini).not.toBe(forHosted);

    expect(forGemini).toBeLessThan(oversized.length);

    expect(forHosted).toBeLessThan(oversized.length);

    expect(forGemini).toBeLessThanOrEqual(toolResultBudget("gemini").characters);

    expect(forHosted).toBeLessThanOrEqual(toolResultBudget("default").characters);

  });

  it("reports the cut to both families, with how much went and out of what", () => {

    for (const family of ["gemini", "default", "local"] as const) {

      const budget = toolResultBudget(family);

      const result = budgetedResult(oversized, family);

      const omitted = oversized.length - budget.characters;

      expect(result).toContain(`${String(omitted)} of ${String(oversized.length)} characters`);

      expect(result).toContain(`${String(budget.characters)} characters for the ${family}`);

      expect(result).toContain("must not be summarized as if it were the whole answer");

    }

  });

  it("keeps both ends of what it does show", () => {

    const output = `${"head".padEnd(4_000, "h")}${"tail".padStart(4_000, "t")}`;

    const result = budgetedResult(output, "default");

    expect(result.startsWith("head")).toBe(true);

    expect(result.endsWith("tail")).toBe(true);

  });

  it("leaves a result inside the budget exactly as the tool produced it", () => {

    const small = "the command succeeded";

    expect(budgetedResult(small, "local")).toBe(small);

    expect(budgetedResult(small, "gemini")).toBe(small);

  });

  it("budgets the lanes the catalog actually runs, through their families", () => {

    // The catalog names lanes, not families, so the two steps compose: a lane

    // resolves to a family and the family carries the allowance.

    const gemini = budgetedResult(oversized, toolFamilyOf("gemini-3.7-flash"));

    const luna = budgetedResult(oversized, toolFamilyOf("gpt-5.6-luna"));

    const ox = budgetedResult(oversized, toolFamilyOf("ox-alpha"));

    expect(gemini.length).not.toBe(luna.length);

    expect(luna.length).toBe(ox.length);

  });

});

    expect(delegation.registry.list()).toHaveLength(3);

  });

  it("says how much of a long child answer was cut, rather than ending it silently", async () => {

    const answer = "finding. ".repeat(1_000);

    const output = await delegateTool(delegationOf(harness(answer))).run(

      { prompt: "report everything" },

      new AbortController().signal,

    );

    // A child shown as three findings, having reported ten, reads to the model

    // holding the report exactly like a child that found three.

    expect(output).toContain(`of ${String(answer.trim().length)} characters cut from the end`);

    expect(output).toContain("ask the child again for the part you need");

  });

  it("tells each child of a fan-out which one it is", async () => {

    const prompts: string[] = [];

    const delegation = delegationOf({