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

    "filesScanned": 2430,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:51b6ad8b75a35b806924320c7d4d9f762f729c7e744412cb96ca5b6b9d81907a",

  "sourceDigest": "sha256:30573ab546f371af545bfe2cfedba47c5ec547e2acc61c8d9ce115761d3f7d4a",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { fleetPlainLines } from "./coder-fleet.js";

import { runCoderPlain } from "./coder-plain.js";

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

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

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

import { CoderTaskRegistry } from "./coder-tasks.js";

import { runCoderUi } from "./coder-ui.js";

      // so the CLI still holds no provider key and nothing typed here reaches

      // the account's conversation. Without a credential it falls back to the

      // stand-in and says so rather than failing.

      // An Ollama session reads the credential too, though it opens no thread of

      // its own. The parent answers locally; children still spend a server

      // grant, so a local session delegates exactly as a thread session does.

      const stored =

        offline || wantsOllama

        offline

          ? Option.none()

          : yield* findToken(endpoint.origin).pipe(

              Effect.catchTag("OpenAgentsCli.CredentialPersistenceUnavailable", () =>

      // A `--model ollama:<name>` session answers from the local Ollama server,

      // so it takes neither a thread nor the stand-in.

      const source =

      const source: ReplySource =

        wantsOllama && ollamaName !== undefined

          ? new OllamaReplySource({ model: ollamaName })

          : (thread ?? new DummyReplySource());

      // stays on the model it opened with, and a fan-out spends a budget the

      // reader's next question does not share.

      const childThread =

        thread !== undefined && Option.isSome(stored)

        Option.isSome(stored)

          ? yield* Effect.promise(() =>

              openChildThread({

                origin: endpoint.origin,

      // remember a slash command. A turn that needs three agents asks for them

      // mid-sentence, and `/delegate` stays as the way to launch a fan-out

      // without spending a turn to ask for one.

      if (thread !== undefined && setup !== undefined) {

        thread.useTools([delegateTool(setup.delegation)]);

      if (setup !== undefined) {

        source.useTools?.([delegateTool(setup.delegation)]);

      }

      // Delegation is off rather than quietly running children on the

 */

import { Ollama } from "ollama";

import type { Message as OllamaMessage, Tool as OllamaTool, ToolCall as OllamaToolCall } from "ollama";

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

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

const DEFAULT_HOST = "http://127.0.0.1:11434";

/**

 * How many times one turn may call tools before it has to answer.

 *

 * The same ceiling the thread lane uses, for the same reason: a model that

 * keeps delegating never reports to the reader. A local model spends no metered

 * budget, but it does spend the reader's wall clock and the children's.

 */

const MAX_TOOL_STEPS = 6;

export interface OllamaOptions {

  /** The Ollama model name, without the `ollama:` prefix. */

  readonly model: string;

  return match?.[1]?.trim();

};

interface WireMessage {

  readonly role: "user" | "assistant";

  readonly content: string;

}

/**

 * The transcript this source keeps, in Ollama's own message shape.

 *

 * A tool exchange is kept as the assistant turn that asked and a `tool` turn

 * carrying the output, which is what Ollama's chat API takes back. A model that

 * cannot see what its own call returned calls it again.

 */

type WireMessage = OllamaMessage;

export class OllamaReplySource implements ReplySource {

  private readonly client: Ollama;

  private readonly modelName: string;

  private readonly transcript: WireMessage[] = [];

  private tools: ReadonlyArray<CoderTool> = [];

  private callCount = 0;

  get model(): string {

    return `Ollama ${this.modelName}`;

    this.modelName = options.model;

  }

  /**

   * Declare the tools the model may call.

   *

   * Set after construction for the same reason the thread lane sets them then:

   * the tools need things built after the source exists, such as the fleet a

   * `delegate` call submits to.

   */

  useTools(tools: ReadonlyArray<CoderTool>): void {

    this.tools = tools;

  }

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

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

    let assistant = "";

    const stream = await this.client.chat({

      model: this.modelName,

      messages: this.transcript,

      stream: true,

    });

    const onAbort = () => stream.abort();

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

    // A turn is a loop, not a single call: the model may answer, or it may ask

    // for tools and then answer once it has seen what they returned. The

    // ceiling is what stops a model that only ever delegates.

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

      if (signal.aborted) return;

      const calls: OllamaToolCall[] = [];

      let assistant = "";

      const stream = await this.client.chat({

        model: this.modelName,

        // A snapshot, not the live array: the transcript grows while the round

        // streams, and a request that keeps growing after it was sent is a

        // request nobody can reason about.

        messages: [...this.transcript],

        stream: true,

        ...(this.tools.length === 0

          ? {}

          : {

              tools: this.tools.map((tool) => ({

                type: "function",

                function: {

                  name: tool.name,

                  description: tool.description,

                  // The client's type for a schema is narrower than JSON

                  // Schema. The server takes the schema as written.

                  parameters: tool.parameters as NonNullable<OllamaTool["function"]["parameters"]>,

                },

              })),

            }),

      });

      const onAbort = () => stream.abort();

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

      try {

        for await (const chunk of stream) {

          if (signal.aborted) break;

          const thinking = chunk.message.thinking;

          if (typeof thinking === "string" && thinking.length > 0) {

            yield { type: "reasoning", value: thinking };

          }

          const content = chunk.message.content;

          if (typeof content === "string" && content.length > 0) {

            assistant += content;

            yield { type: "text", value: content };

          }

          // Ollama sends whole calls rather than the fragments the chat lane

          // folds together, so they are collected as they arrive.

          const toolCalls = chunk.message.tool_calls;

          if (Array.isArray(toolCalls)) calls.push(...toolCalls);

          if (chunk.done) break;

        }

      } finally {

        signal.removeEventListener("abort", onAbort);

      }

    try {

      for await (const chunk of stream) {

        if (signal.aborted) break;

      if (signal.aborted) return;

        const thinking = chunk.message.thinking;

        if (typeof thinking === "string" && thinking.length > 0) {

          yield { type: "reasoning", value: thinking };

        }

      // Whatever the model said before asking is kept with the calls, so the

      // next round sees its own turn as it happened.

      this.transcript.push({

        role: "assistant",

        content: assistant,

        ...(calls.length === 0 ? {} : { tool_calls: calls }),

      });

        const content = chunk.message.content;

        if (typeof content === "string" && content.length > 0) {

          assistant += content;

          yield { type: "text", value: content };

        }

      if (calls.length === 0) return;

        if (chunk.done) break;

      for (const call of calls) {

        if (signal.aborted) return;

        yield* this.invoke(call, signal);

      }

    } finally {

      signal.removeEventListener("abort", onAbort);

      if (assistant.length > 0) {

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

    }

    // The ceiling was reached. Say so rather than ending on a tool result the

    // reader has to interpret as an answer.

    yield {

      type: "text",

      value: `\n\nStopped after ${String(MAX_TOOL_STEPS)} rounds of tool calls without an answer.`,

    };

  }

  /**

   * Run one call, report it, and put the result on the transcript.

   *

   * A tool that throws is reported as a failed call rather than ending the

   * turn: the model can act on "that needs a prompt" and cannot act on a turn

   * that died.

   */

  private async *invoke(call: OllamaToolCall, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    const name = call.function.name;

    // Ollama hands back parsed arguments where the chat lane sends JSON source.

    // The chunk carries the source because that is what the renderer shows.

    const args = (call.function.arguments ?? {}) as Record<string, unknown>;

    // Ollama numbers no calls, so the id is this session's own. It only has to

    // be stable between the `tool_call` chunk and its `tool_result`.

    this.callCount += 1;

    const callId = `${name}-${String(this.callCount)}`;

    yield { type: "tool_call", callId, name, arguments: JSON.stringify(args, undefined, 2) };

    const tool = this.tools.find((candidate) => candidate.name === name);

    let output: string;

    let failure: string | undefined;

    if (tool === undefined) {

      failure = `This session has no \`${name}\` tool.`;

      output = failure;

    } else {

      try {

        output = await tool.run(args, signal);

      } catch (cause) {

        failure = cause instanceof Error ? cause.message : String(cause);

        output = failure;

      }

    }

    yield { type: "tool_result", callId, output, error: failure };

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

  }

}

import type { DelegationOutcome, DelegationRequest } from "./coder-delegate.js";

import { parseDelegateCommand } from "./coder-delegate.js";

import type { CoderTask, CoderTaskId, CoderTaskRegistry } from "./coder-tasks.js";

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

/** What a reply source produces. One entry kind per member. */

export type ReplyChunk =

   * only where pressing it would do something.

   */

  cycleBackend?(): string;

  /**

   * Declare the tools the model may call.

   *

   * Optional because the tool runtime is the client's, not the transport's: a

   * source reaches it by running the calls a model asks for and reporting them

   * as chunks. A source that cannot do that leaves this undefined, and the

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

   */

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

  /**

   * Yield the reply to `prompt` in chunks. Rendering appends each chunk as it

   * arrives, so a slow source shows partial text rather than nothing.

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

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

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

import {

  isOllamaModelFlag,

  OllamaReplySource,

  parseOllamaModelFlag,

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

const MODEL = "qwen3.8:27b-mtp-q8_0";

/** One streamed Ollama chunk, in the shape the client yields. */

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

/**

 * Stand in for the Ollama client's `chat`, one scripted stream per round.

 *

 * The source drives a turn as a loop, so a tool test needs a second round to

 * answer with. Each call also records the request, which is how the assertions

 * about the declared tools and the transcript are made.

 */

const client = (rounds: ReadonlyArray<ReadonlyArray<ReturnType<typeof chunk>>>) => {

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

  let round = 0;

  const chat = vi.fn(async (request: Record<string, unknown>) => {

    requests.push(request);

    const scripted = rounds[round] ?? [];

    round += 1;

    return Object.assign(

      (async function* () {

        for (const piece of scripted) yield piece;

      })(),

      { abort: () => {} },

    );

  });

  return { chat, requests };

};

const sourceWith = (rounds: ReadonlyArray<ReadonlyArray<ReturnType<typeof chunk>>>) => {

  const stub = client(rounds);

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

  // The client is constructed in the constructor, so the stub replaces it.

  (source as unknown as { client: unknown }).client = { chat: stub.chat };

  return { source, stub };

};

const collect = async (source: OllamaReplySource, prompt: string): Promise<ReplyChunk[]> => {

  const chunks: ReplyChunk[] = [];

  for await (const piece of source.reply(prompt, new AbortController().signal)) {

    chunks.push(piece);

  }

  return chunks;

};

describe("the ollama model flag", () => {

  it("recognizes an ollama model and takes its name", () => {

    expect(isOllamaModelFlag("ollama:qwen3")).toBe(true);

    expect(isOllamaModelFlag("ox-alpha")).toBe(false);

    expect(parseOllamaModelFlag("ollama:qwen3")).toBe("qwen3");

  });

});

describe("an ollama reply", () => {

  it("streams text and reasoning without declaring tools it does not have", async () => {

    const { source, stub } = sourceWith([

      [chunk({ thinking: "weighing it" }), chunk({ content: "Hello" }), chunk({}, true)],

    ]);

    const chunks = await collect(source, "hi");

    expect(chunks).toEqual([

      { type: "reasoning", value: "weighing it" },

      { type: "text", value: "Hello" },

    ]);

    expect(stub.requests[0]).not.toHaveProperty("tools");

  });

});

/** A `delegate` stand-in that records the arguments the model sent. */

const delegate = (calls: Record<string, unknown>[]): CoderTool => ({

  name: "delegate",

  description: "Run a prompt on child agents.",

  parameters: { type: "object", properties: { prompt: { type: "string" } } },

  run: async (args) => {

    calls.push(args);

    return "child 1 said PONG";

  },

});

describe("an ollama turn that calls a tool", () => {

  const CALLING = [

    chunk({

      content: "",

      tool_calls: [{ function: { name: "delegate", arguments: { prompt: "say PONG" } } }],

    }),

    chunk({}, true),

  ];

  it("declares the tools, runs the call, and answers from its result", async () => {

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

    const { source, stub } = sourceWith([CALLING, [chunk({ content: "They said PONG." }, true)]]);

    source.useTools([delegate(calls)]);

    const chunks = await collect(source, "delegate this");

    // The tool ran with the arguments the model sent, parsed.

    expect(calls).toEqual([{ prompt: "say PONG" }]);

    const call = chunks.find((piece) => piece.type === "tool_call");

    const result = chunks.find((piece) => piece.type === "tool_result");

    expect(call).toMatchObject({ name: "delegate" });

    expect(result).toMatchObject({ output: "child 1 said PONG", error: undefined });

    // The call and its result share an id, which is how a renderer pairs them.

    expect(result).toMatchObject({ callId: (call as { callId: string }).callId });

    // The turn continued rather than ending on the tool result.

    expect(chunks.at(-1)).toEqual({ type: "text", value: "They said PONG." });

    // The tool was declared, and the second round carried the exchange back.

    expect(stub.requests[0]).toHaveProperty("tools");

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

    expect(messages.map((message) => message["role"])).toEqual(["user", "assistant", "tool"]);

    expect(messages.at(-1)).toMatchObject({ content: "child 1 said PONG", tool_name: "delegate" });

  });

  it("reports a tool that throws instead of ending the turn", async () => {

    const { source } = sourceWith([CALLING, [chunk({ content: "It failed." }, true)]]);

    source.useTools([

      {

        name: "delegate",

        description: "Run a prompt on child agents.",

        parameters: { type: "object" },

        run: () => Promise.reject(new Error("the fleet is full")),

      },

    ]);

    const chunks = await collect(source, "delegate this");

    expect(chunks.find((piece) => piece.type === "tool_result")).toMatchObject({

      error: "the fleet is full",

      output: "the fleet is full",

    });

    expect(chunks.at(-1)).toEqual({ type: "text", value: "It failed." });

  });

  it("tells the model when it asks for a tool the session does not have", async () => {

    const { source } = sourceWith([

      [

        chunk({ content: "", tool_calls: [{ function: { name: "nope", arguments: {} } }] }),

        chunk({}, true),

      ],

      [chunk({ content: "Understood." }, true)],

    ]);

    source.useTools([]);

    const chunks = await collect(source, "call nope");

    expect(chunks.find((piece) => piece.type === "tool_result")).toMatchObject({

      error: "This session has no `nope` tool.",

    });

  });

  it("stops after the tool-call ceiling rather than looping forever", async () => {

    const rounds = Array.from({ length: 8 }, () => CALLING);

    const { source, stub } = sourceWith(rounds);

    source.useTools([delegate([])]);

    const chunks = await collect(source, "keep going");

    // Six rounds, then a sentence saying why it stopped.

    expect(stub.chat).toHaveBeenCalledTimes(6);

    expect(chunks.at(-1)).toMatchObject({ type: "text" });

    expect((chunks.at(-1) as { value: string }).value).toContain("Stopped after 6 rounds");

  });

});