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

    "filesScanned": 2454,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:ac35b91f0360afc7210b7c55d483e80298724af060859b7f702fba112d503937",

  "sourceDigest": "sha256:3fdcfedaf7211556caf02d4b9566d017ffbe1b92e761595b065e85d47b5576e2",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { rebuild, RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

import { loadSkillSelection, standingContext } from "./coder-skills.js";

import { startDevServer } from "./coder-dev-server.js";

import { ZenReplySource, zenCredential } from "./coder-zen.js";

import { describeWorkspace } from "./coder-workspace.js";

import { ComputerClient } from "./computer-client.js";

import { ComputerUp } from "./computer-up.js";

        });

      }

      // `--model opencode:<slug>` answers from OpenCode Zen on the credential

      // opencode already holds here. It is how a session runs on Ox Alpha,

      // which is free there and which no deployment serves.

      const wantsZen = named !== undefined && /^opencode:/.test(named);

      const zenAsked = wantsZen && named !== undefined ? named.slice("opencode:".length) : undefined;

      const wantsOllama = named === undefined ? localModel !== undefined : isOllamaModelFlag(named);

      const zenKey = wantsZen ? zenCredential() : undefined;

      if (wantsZen && (zenAsked === undefined || zenAsked.length === 0)) {

        return yield* new InputError({

          message:

            "`--model opencode:` is missing a model name. Use `opencode:<model>`, " +

            "for example `opencode:ox-alpha`.",

        });

      }

      if (wantsZen && zenKey === undefined) {

        return yield* new InputError({

          message:

            "No OpenCode Zen credential is available on this machine. Sign in with " +

            "`opencode providers`, or set OPENCODE_API_KEY.",

        });

      }

      const askedFor =

        named === undefined

          ? localModel

      // A dev server and production do not serve the same list, and a client

      // that assumes one of them is wrong against the other.

      const served =

        Option.isSome(stored) && !wantsOllama && !offline && resumed === undefined

        Option.isSome(stored) && !wantsOllama && !wantsZen && !offline && resumed === undefined

          ? yield* Effect.promise(() =>

              fetchServedCatalog({

                origin: endpoint.origin,

      // never overrules a server that has spoken. The flag takes a string

      // rather than an enum so an `ollama:` prefix can reach the local server,

      // which is why this is a check and not `Flag.choice`.

      if (named !== undefined && !wantsOllama) {

      if (named !== undefined && !wantsOllama && !wantsZen) {

        const refusal =

          served !== undefined

            ? refuseBackend(served, named)

      const thread =

        resumed !== undefined

          ? resumed.source

          : Option.isSome(stored) && !wantsOllama && !resume

          : Option.isSome(stored) && !wantsOllama && !wantsZen && !resume

            ? yield* Effect.tryPromise({

                try: () =>

                  openThread({

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

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

      const source: ReplySource =

        wantsOllama && ollamaName !== undefined

          ? new OllamaReplySource({

              model: ollamaName,

              ...(Option.isSome(reasoning) ? { reasoning: reasoning.value } : {}),

            })

          : (thread ?? new DummyReplySource());

        wantsZen && zenAsked !== undefined && zenKey !== undefined

          ? new ZenReplySource({ model: zenAsked, key: zenKey })

          : wantsOllama && ollamaName !== undefined

            ? new OllamaReplySource({

                model: ollamaName,

                ...(Option.isSome(reasoning) ? { reasoning: reasoning.value } : {}),

              })

            : (thread ?? new DummyReplySource());

      // Children get their own thread on their own model. The conversation

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

        return described;

      };

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

      // conversation's model, so the refusal that turned it off is what the

      // reader sees.

      if (childThread?.kind === "refused") {

      // Only when there is really no way to run a child. A refused child

      // thread is not that: `buildDelegation` prefers a free harness model over

      // the account's grant anyway, so the grant lane failing is the normal

      // path rather than a loss of capability. Reporting it as "this session

      // cannot delegate" was false — the `delegate` tool was declared, the

      // model correctly said it could delegate, and the notice above it said

      // the opposite.

      if (setup === undefined && childThread?.kind === "refused") {

        session.notice(`This session cannot delegate: ${childThread.reason}`);

      }

      if (Option.isNone(stored) && !offline && !wantsOllama) {

      if (Option.isNone(stored) && !offline && !wantsOllama && !wantsZen) {

        session.notice(

          "No stored credential, so replies come from the built-in stand-in. " +

            `Run \`${loginCommandFor(endpoint)}\` to reach a real model.`,

      // A grant pins the model the proxy will use, and the thread route takes

      // no model parameter, so a named backend cannot reach this turn. Saying

      // nothing would leave a reader with a flag that appeared to work.

      if (thread !== undefined && Option.isSome(model) && !wantsOllama) {

      if (thread !== undefined && Option.isSome(model) && !wantsOllama && !wantsZen) {

        session.notice(

          `This thread's grant pins ${thread.model}. \`--model\` names a chat API ` +

            "backend, which the inference proxy does not route to, so it had no effect.",

}

/** Frames of an SSE body, yielded as the body arrives rather than after it. */

async function* frames(

export async function* frames(

  body: ReadableStream<Uint8Array>,

  signal: AbortSignal,

): AsyncIterable<string> {

  return parts.length === 0 ? undefined : parts.join("\n");

}

function parse(frame: string): Record<string, unknown> | undefined {

export function parse(frame: string): Record<string, unknown> | undefined {

  try {

    const value: unknown = JSON.parse(frame);

    return typeof value === "object" && value !== null

 * Chat-completions splits one call across frames and identifies the pieces by

 * `index`, so a name and its arguments can arrive separately.

 */

function accumulate(

export function accumulate(

  calls: Map<number, { id: string; name: string; args: string }>,

  fragments: ReadonlyArray<unknown>,

): void {

 * refusal ("prompt is required") is a sentence the model can act on, and a

 * parse error thrown here would end the turn instead.

 */

function parseArguments(args: string): Record<string, unknown> {

export function parseArguments(args: string): Record<string, unknown> {

  return parse(args) ?? {};

}

import { existsSync, readFileSync } from "node:fs";

import { homedir } from "node:os";

import { join } from "node:path";

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 type { CoderTool } from "./coder-tools.js";

/**

 * A coder session answered by OpenCode Zen, on the credential opencode already

 * holds on this machine.

 *

 * The reason this lane exists: Ox Alpha is free and unlimited there, and no

 * OpenAgents deployment serves it — the model is in the server's catalog but

 * its provider credential is not configured, so a thread opened on it is

 * refused. Waiting for that credential to reach a deployment is a wait; the

 * machine already has one.

 *

 * Zen is an OpenAI-compatible endpoint that takes tool calls, so this is the

 * same wire shape the inference proxy speaks and the same turn loop. What it is

 * not is `opencode` the agent: opencode's own server runs its own loop with its

 * own tools, and a session driven through that would be running opencode's

 * tools rather than this session's. Only the endpoint and the key are borrowed.

 *

 * Nothing here spends an OpenAgents grant and nothing reaches a thread, so a

 * session on this lane keeps no server-side transcript.

 */

/** Where opencode keeps the credential this lane borrows. */

const AUTH_FILE = join(homedir(), ".local", "share", "opencode", "auth.json");

const ZEN_BASE = "https://opencode.ai/zen/v1";

/**

 * The names a reader uses for a Zen model, mapped to what the API takes.

 *

 * `ox-alpha` is the name it is known by and `x-preview-f-free` is the slug it

 * answers to; Zen itself calls it "Ox Alpha Free (Unlimited)". A reader who

 * types the name it is called should not have to know the other one.

 */

const ALIASES: Record<string, string> = {

  "ox-alpha": "x-preview-f-free",

  "ox-alpha-free": "x-preview-f-free",

};

export const zenModelId = (asked: string): string => ALIASES[asked] ?? asked;

/**

 * The credential, from the environment or from opencode's own store.

 *

 * Read rather than copied: this is opencode's key, it stays where opencode put

 * it, and a session that finds none says so instead of calling without one.

 */

export const zenCredential = (

  env: NodeJS.ProcessEnv = process.env,

  authFile: string = AUTH_FILE,

): string | undefined => {

  const named = env["OPENCODE_API_KEY"];

  if (named !== undefined && named.length > 0) return named;

  if (!existsSync(authFile)) return undefined;

  try {

    const store = JSON.parse(readFileSync(authFile, "utf8")) as Record<string, unknown>;

    const entry = store["opencode"];

    if (typeof entry !== "object" || entry === null) return undefined;

    const key = (entry as Record<string, unknown>)["key"];

    return typeof key === "string" && key.length > 0 ? key : undefined;

  } catch {

    return undefined;

  }

};

const LANE = "You answer from Ox Alpha through OpenCode Zen, on this machine's own credential.";

/** How many rounds of tool calls one turn may take before it is stopped. */

const MAX_ROUNDS = 100;

type WireMessage =

  | { readonly role: "system"; readonly content: string }

  | { readonly role: "user"; readonly content: string }

  | {

      readonly role: "assistant";

      readonly content: string;

      readonly tool_calls?: ReadonlyArray<Record<string, unknown>>;

    }

  | { readonly role: "tool"; readonly tool_call_id: string; readonly content: string };

export class ZenReplySource implements ReplySource {

  private readonly key: string;

  private readonly slug: string;

  private readonly transcript: WireMessage[] = [];

  private tools: ReadonlyArray<CoderTool> = [];

  private standing: string | undefined;

  private steered: string[] = [];

  private spentIn = 0;

  private spentOut = 0;

  private callCount = 0;

  constructor(options: { readonly model: string; readonly key: string }) {

    this.slug = zenModelId(options.model);

    this.key = options.key;

  }

  get model(): string {

    return this.slug === "x-preview-f-free" ? "ox-alpha" : this.slug;

  }

  get modelId(): string {

    return this.slug;

  }

  /** What the status line shows in place of a thread budget: this lane has none. */

  get budget(): string {

    return `${String(this.callCount)} calls · ${String(this.spentIn + this.spentOut)} tok · free`;

  }

  useContext(standing: string): void {

    this.standing = standing;

  }

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

    this.tools = tools;

  }

  toolDefinitions(): ReadonlyArray<Record<string, unknown>> {

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

      type: "function",

      function: { name: tool.name, description: tool.description, parameters: tool.parameters },

    }));

  }

  describeContext(): string {

    const declarations =

      this.tools.length === 0

        ? "No tools are declared to the model."

        : `${String(this.tools.length)} tool${this.tools.length === 1 ? "" : "s"} declared to the model:\n\n${this.tools

            .map(

              (tool) =>

                `- \`${tool.name}\`\n  ${tool.description}\n  parameters: ${JSON.stringify(tool.parameters)}`,

            )

            .join("\n\n")}`;

    return [

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

      "",

      declarations,

    ].join("\n");

  }

  steer(text: string): boolean {

    this.steered.push(text);

    return true;

  }

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

    if (!this.transcript.some((message) => message.role === "system")) {

      this.transcript.unshift({

        role: "system",

        content: systemPrompt(this.tools, LANE, this.standing),

      });

    }

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

    for (let round = 0; round < MAX_ROUNDS; round += 1) {

      if (signal.aborted) return;

      // 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.

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

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

      }

      const calls: Map<number, { id: string; name: string; args: string }> = new Map();

      let assistant = "";

      const response = await this.call(signal);

      if (response === undefined || signal.aborted) return;

      for await (const frame of frames(response, signal)) {

        if (signal.aborted) return;

        if (frame === "[DONE]") break;

        const payload = parse(frame);

        if (payload === undefined) continue;

        const usage = payload["usage"];

        if (typeof usage === "object" && usage !== null) this.spend(usage as Record<string, unknown>);

        const choices = payload["choices"];

        if (!Array.isArray(choices)) continue;

        for (const choice of choices) {

          const delta = (choice as Record<string, unknown>)["delta"];

          if (typeof delta !== "object" || delta === null) continue;

          const parts = delta as Record<string, unknown>;

          const thought = parts["reasoning"] ?? parts["reasoning_content"];

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

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

          }

          const content = parts["content"];

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

            assistant += content;

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

          }

          const toolCalls = parts["tool_calls"];

          if (Array.isArray(toolCalls)) accumulate(calls, toolCalls);

        }

      }

      const asked = [...calls.values()];

      if (asked.length === 0) {

        if (assistant.length > 0) this.transcript.push({ role: "assistant", content: assistant });

        yield {

          type: "usage",

          promptTokens: this.spentIn,

          completionTokens: this.spentOut,

          calls: round + 1,

        };

        return;

      }

      // The assistant turn carries the calls it made, and every one of them is

      // answered before the next round: a call whose result never follows is a

      // transcript the provider refuses.

      this.transcript.push({

        role: "assistant",

        content: assistant,

        tool_calls: asked.map((call) => ({

          id: call.id,

          type: "function",

          function: { name: call.name, arguments: call.args },

        })),

      });

      for (const call of asked) {

        yield { type: "tool_call", callId: call.id, name: call.name, arguments: call.args };

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

        const output =

          tool === undefined

            ? `No tool called ${call.name} is declared in this session.`

            : await tool

                .run(parseArguments(call.args), signal)

                .catch((cause: unknown) => `The tool failed: ${String(cause)}`);

        this.transcript.push({

          role: "tool",

          tool_call_id: call.id,

          content: boundedResult(output),

        });

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

      }

    }

    yield {

      type: "text",

      value: `\n\nThe turn stopped after ${String(MAX_ROUNDS)} rounds of tool calls.`,

    };

  }

  private async call(signal: AbortSignal): Promise<ReadableStream<Uint8Array> | undefined> {

    this.callCount += 1;

    const response = await fetch(`${ZEN_BASE}/chat/completions`, {

      method: "POST",

      signal,

      headers: {

        authorization: `Bearer ${this.key}`,

        "content-type": "application/json",

        accept: "text/event-stream",

      },

      body: JSON.stringify({

        model: this.slug,

        stream: true,

        stream_options: { include_usage: true },

        messages: this.transcript,

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

          ? {}

          : {

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

                type: "function",

                function: {

                  name: tool.name,

                  description: tool.description,

                  parameters: tool.parameters,

                },

              })),

            }),

      }),

    }).catch((cause: unknown) => {

      if (signal.aborted) return undefined;

      throw new Error(`OpenCode Zen could not be reached: ${String(cause)}`);

    });

    if (response === undefined || signal.aborted) return undefined;

    if (!response.ok) {

      const detail = (await response.text().catch(() => "")).slice(0, 300);

      throw new Error(

        `OpenCode Zen refused the call (${String(response.status)})` +

          (detail.length === 0 ? "." : `: ${detail}`),

      );

    }

    return response.body ?? undefined;

  }

  private spend(usage: Record<string, unknown>): void {

    const input = usage["prompt_tokens"];

    const output = usage["completion_tokens"];

    if (typeof input === "number") this.spentIn = input;

    if (typeof output === "number") this.spentOut = output;

  }

}

import { mkdtempSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

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

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

import { ZenReplySource, zenCredential, zenModelId } from "../src/coder-zen.js";

const authFile = (contents: unknown) => {

  const path = join(mkdtempSync(join(tmpdir(), "oa-zen-")), "auth.json");

  writeFileSync(path, JSON.stringify(contents));

  return path;

};

const sse = (lines: ReadonlyArray<string>) =>

  new Response(

    new ReadableStream<Uint8Array>({

      start(controller) {

        controller.enqueue(new TextEncoder().encode(lines.join("\n\n") + "\n\n"));

        controller.close();

      },

    }),

    { status: 200, headers: { "content-type": "text/event-stream" } },

  );

interface Sent {

  readonly url: string;

  readonly authorization: string;

  readonly body: Record<string, unknown>;

}

const stub = (responses: ReadonlyArray<Response>) => {

  const sent: Sent[] = [];

  const queue = [...responses];

  vi.stubGlobal(

    "fetch",

    vi.fn(async (target: URL | string, init?: RequestInit) => {

      const headers = (init?.headers ?? {}) as Record<string, string>;

      sent.push({

        url: String(target),

        authorization: headers["authorization"] ?? "",

        body: JSON.parse(typeof init?.body === "string" ? init.body : "{}") as Record<

          string,

          unknown

        >,

      });

      return queue.shift() ?? sse([`data: [DONE]`]);

    }),

  );

  return sent;

};

const chunks = async (source: ZenReplySource, prompt: string) => {

  const out: ReplyChunk[] = [];

  for await (const chunk of source.reply(prompt, new AbortController().signal)) out.push(chunk);

  return out;

};

const textOf = (out: ReadonlyArray<ReplyChunk>) =>

  out.map((chunk) => (chunk.type === "text" ? chunk.value : "")).join("");

afterEach(() => {

  vi.unstubAllGlobals();

});

describe("naming the model", () => {

  it("takes the name Ox Alpha is known by and sends the slug it answers to", () => {

    expect(zenModelId("ox-alpha")).toBe("x-preview-f-free");

  });

  it("passes an unrecognised name through for the API to refuse by name", () => {

    expect(zenModelId("some-other-model")).toBe("some-other-model");

  });

  it("reports the readable name back, whichever was asked for", () => {

    expect(new ZenReplySource({ model: "x-preview-f-free", key: "k" }).model).toBe("ox-alpha");

    expect(new ZenReplySource({ model: "ox-alpha", key: "k" }).model).toBe("ox-alpha");

  });

});

describe("finding the credential", () => {

  it("prefers the environment", () => {

    expect(zenCredential({ OPENCODE_API_KEY: "from-env" }, authFile({}))).toBe("from-env");

  });

  it("reads opencode's own store when the environment names none", () => {

    const path = authFile({ opencode: { type: "api", key: "from-store" } });

    expect(zenCredential({}, path)).toBe("from-store");

  });

  it("takes only opencode's entry, not another provider's key", () => {

    const path = authFile({ google: { type: "api", key: "not-this-one" } });

    expect(zenCredential({}, path)).toBe(undefined);

  });

  it("reports none rather than calling without one", () => {

    expect(zenCredential({}, join(tmpdir(), "oa-zen-absent", "auth.json"))).toBe(undefined);

    expect(zenCredential({}, authFile("not an object"))).toBe(undefined);

  });

});

describe("answering a turn", () => {

  it("calls Zen with the slug and the borrowed key", async () => {

    const sent = stub([

      sse([`data: {"choices":[{"delta":{"content":"Hi"}}]}`, `data: [DONE]`]),

    ]);

    const source = new ZenReplySource({ model: "ox-alpha", key: "secret-key" });

    expect(textOf(await chunks(source, "hello"))).toBe("Hi");

    expect(sent[0]?.url).toBe("https://opencode.ai/zen/v1/chat/completions");

    expect(sent[0]?.authorization).toBe("Bearer secret-key");

    expect(sent[0]?.body["model"]).toBe("x-preview-f-free");

  });

  it("opens with the session's anchor, once", async () => {

    const sent = stub([

      sse([`data: {"choices":[{"delta":{"content":"a"}}]}`, `data: [DONE]`]),

      sse([`data: {"choices":[{"delta":{"content":"b"}}]}`, `data: [DONE]`]),

    ]);

    const source = new ZenReplySource({ model: "ox-alpha", key: "k" });

    source.useContext("Workspace facts.");

    await chunks(source, "first");

    await chunks(source, "second");

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

    const anchors = messages.filter((message) => message["role"] === "system");

    expect(anchors).toHaveLength(1);

    expect(String(anchors[0]?.["content"])).toContain("Ox Alpha through OpenCode Zen");

    expect(String(anchors[0]?.["content"])).toContain("Workspace facts.");

  });

  it("runs a declared tool and answers the model with its result", async () => {

    const ran: string[] = [];

    const sent = stub([

      sse([

        `data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"c1","function":{"name":"shell","arguments":"{\\"command\\":\\"ls\\"}"}}]}}]}`,

        `data: [DONE]`,

      ]),

      sse([`data: {"choices":[{"delta":{"content":"two files"}}]}`, `data: [DONE]`]),

    ]);

    const source = new ZenReplySource({ model: "ox-alpha", key: "k" });

    source.useTools([

      {

        name: "shell",

        description: "run a command",

        parameters: { type: "object" },

        run: async (args) => {

          ran.push(String((args as Record<string, unknown>)["command"]));

          return "a.txt b.txt";

        },

      },

    ]);

    expect(textOf(await chunks(source, "list them"))).toBe("two files");

    expect(ran).toEqual(["ls"]);

    // The result is answered back on the transcript, keyed to the call. A call

    // whose result never follows is a transcript the provider refuses.

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

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

    expect(result).toMatchObject({ tool_call_id: "c1", content: "a.txt b.txt" });

  });

  it("declares the session's tools to the model", async () => {

    const sent = stub([sse([`data: [DONE]`])]);

    const source = new ZenReplySource({ model: "ox-alpha", key: "k" });

    source.useTools([

      { name: "shell", description: "run", parameters: { type: "object" }, run: async () => "" },

    ]);

    await chunks(source, "hello");

    const tools = sent[0]?.body["tools"] as Array<Record<string, unknown>>;

    expect(tools).toHaveLength(1);

    expect((tools[0]?.["function"] as Record<string, unknown>)["name"]).toBe("shell");

  });

  it("says which call was refused rather than falling silent", async () => {

    stub([new Response("no such model", { status: 404 })]);

    const source = new ZenReplySource({ model: "nonsense", key: "k" });

    await expect(chunks(source, "hello")).rejects.toThrow(/404.*no such model/s);

  });

});