"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": 2436,

    "filesScanned": 2437,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:213d97f4fd62f412e9feabce849ebb61ba854f8faad1fd31941e0f8ec982cc63",

  "sourceDigest": "sha256:8b8a0cd69a97c37f05aad3a00b188183c4aaf167865ab050878a3ea987f5da5d",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

  private readonly modelName: string;

  private readonly transcript: WireMessage[] = [];

  private tools: ReadonlyArray<CoderTool> = [];

  /**

   * Messages that arrived mid-turn, waiting for the next step of it.

   *

   * Read between two model calls rather than at the end of the turn, which is

   * the difference between steering a model and waiting one out.

   */

  private steered: string[] = [];

  private callCount = 0;

  get model(): string {

   * which model is the part a reader needs, and so is knowing the transcript

   * survives.

   */

  /** Take a message for the next step of the running turn. */

  steer(text: string): boolean {

    this.steered.push(text);

    return true;

  }

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    try {

      yield* this.turn(prompt, signal);

    for (let step = 0; step < MAX_TOOL_STEPS; step += 1) {

      if (signal.aborted) return;

      // Anything the reader said since the last step joins here, before the

      // model is asked again. It reads as an ordinary turn in the conversation,

      // because that is what it is.

      for (const said of this.steered.splice(0)) {

        this.transcript.push({ role: "user", content: said });

      }

      const calls: OllamaToolCall[] = [];

      let assistant = "";

   * session then declares no tools rather than declaring tools nothing runs.

   */

  useTools?(tools: ReadonlyArray<CoderTool>): void;

  /**

   * Take a message mid-turn, to be read at the next step of the running turn.

   *

   * A turn is a loop of model calls, and between two of them is a place where

   * another message can join without stopping anything. That is what steering

   * is: not interrupting the model, and not waiting for it to finish, but

   * putting a sentence where it will be read next.

   *

   * Returns false when the source cannot take one, and the caller then holds it

   * until the turn ends rather than dropping it.

   */

  steer?(text: string): boolean;

  /**

   * The standing context this source sends with every turn, as text.

   *

    // that silently ignores the key is one that cannot be steered at all.

    if (this.controller !== undefined) {

      this.entries.push({ role: "you", text: prompt, settled: true, at: Date.now() });

      // Steering first: a source that runs a loop of model calls can read this

      // at its next step, so the model sees it while it is still working. A

      // source that cannot holds it until the turn ends instead of dropping it.

      if (this.source.steer?.(prompt) === true) {

        this.notice("Steering: the model reads this at its next step.");

        this.emit();

        return;

      }

      this.pending.push(prompt);

      this.notice(

        this.pending.length === 1

  private tools: ReadonlyArray<CoderTool> = [];

  /** Set for the one round that must answer rather than call another tool. */

  private mustAnswer = false;

  /**

   * Messages that arrived mid-turn, waiting for the next step of it.

   *

   * Read between two model calls rather than at the end of the turn, which is

   * the difference between steering a model and waiting one out.

   */

  private steered: string[] = [];

  constructor(private readonly state: SourceState) {

    this.threadId = state.threadId;

    };

  }

  /** Take a message for the next step of the running turn. */

  steer(text: string): boolean {

    this.steered.push(text);

    return true;

  }

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    // Per turn, not per session: a turn that had to answer without tools must

    // not leave the next one without them.

    try {

      for (let step = 0; ; step += 1) {

        // Anything the reader said since the last step joins here, before the

        // model is asked again.

        for (const said of this.steered.splice(0)) {

          this.transcript.push({ role: "user", content: said });

        }

        const calls: WireCall[] = [];

        let assistant = "";

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

import { CoderSession } from "../src/coder-session.js";

import { OllamaReplySource } from "../src/coder-ollama.js";

const chunk = (message: Record<string, unknown>, done = false) => ({ message, done });

describe("steering a running turn", () => {

  it("puts the message in front of the model at its next step", async () => {

    const requests: Record<string, unknown>[] = [];

    let round = 0;

    const gate: Array<() => void> = [];

    const source = new OllamaReplySource({ model: "m" });

    (source as unknown as { client: unknown }).client = {

      chat: async (request: Record<string, unknown>) => {

        requests.push(JSON.parse(JSON.stringify(request)) as Record<string, unknown>);

        const mine = round++;

        // Round 0 asks for a tool and waits, so a steer can arrive mid-turn.

        const pieces =

          mine === 0

            ? [chunk({ content: "", tool_calls: [{ function: { name: "t", arguments: {} } }] }), chunk({}, true)]

            : [chunk({ content: "done" }, true)];

        return Object.assign(

          (async function* () {

            if (mine === 0) await new Promise<void>((r) => gate.push(r));

            for (const p of pieces) yield p;

          })(),

          { abort: () => {} },

        );

      },

    };

    source.useTools([

      { name: "t", description: "d", parameters: {}, run: () => Promise.resolve("ok") },

    ]);

    const session = new CoderSession(source, "repo", "main");

    const turn = session.submit("original question");

    await new Promise((r) => setTimeout(r, 10));

    await session.submit("actually, do it the other way");

    // Not stopped: the turn is still running.

    expect(session.snapshot().running).toBe(true);

    gate.shift()?.();

    await turn;

    await new Promise((r) => setTimeout(r, 20));

    const later = requests.at(-1)?.["messages"] as ReadonlyArray<Record<string, unknown>>;

    const said = later.map((m) => m["content"]);

    expect(said).toContain("actually, do it the other way");

    // It arrived at a later step, not at the start.

    const first = requests[0]?.["messages"] as ReadonlyArray<Record<string, unknown>>;

    expect(first.map((m) => m["content"])).not.toContain("actually, do it the other way");

    expect(session.snapshot().entries.filter((e) => e.role === "notice").map((e) => e.text))

      .toContainEqual(expect.stringContaining("Steering"));

  });

});