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

    "filesScanned": 2455,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:3fdcfedaf7211556caf02d4b9566d017ffbe1b92e761595b065e85d47b5576e2",

  "sourceDigest": "sha256:e3bf4b2c23dae0ee9b20eb8a0ce09bae4d32b9b57aa8d94ababaa57716efa9fd",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { ApiTransport } from "./api-transport.js";

import { BrowserLauncher } from "./browser-launcher.js";

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

import { SelfHarness } from "./coder-self-harness.js";

/**

 * The grant, where the caller has already established there is one.

 *

 * `laneFor` is only reached for the self lane through `fleetFor`, which refuses

 * that lane without a grant, so this cannot be nothing — but the type does not

 * know that, and inventing an empty grant to satisfy it would send a child at

 * the proxy with no authority.

 */

const nonNullGrant = (grant: ChildGrant | undefined): ChildGrant => {

  if (grant === undefined) throw new Error("The self lane needs the children's grant.");

  return grant;

};

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

import { writeChildHarnessConfig } from "./coder-child-config.js";

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

  firstAvailableChildModel,

  OpencodeHarness,

  resolveChildLane,

  selfChildLane,

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

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

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

  // or silently fell back, and one that was asked exactly this said so rather

  // than guess.

  const laneFor = (choice: string) => {

    const harness = /^devin(:.+)?$/.test(choice)

      ? new DevinHarness(choice.startsWith("devin:") ? { permissionMode: choice.slice(6) } : {})

      : new OpencodeHarness({

          model: choice,

          ...(command === undefined ? {} : { command }),

          ...(namedConfig === undefined ? {} : { configPath: namedConfig }),

          autoApprove: options.autoApprove,

        });

    const harness = selfChildLane(choice)

      ? // The self lane needs the grant, and a session without one cannot take

        // it. `fleetFor` refuses the lane rather than falling through to a

        // different agent under the name the caller asked for.

        new SelfHarness({ grant: nonNullGrant(options.grant) })

      : /^devin(:.+)?$/.test(choice)

        ? new DevinHarness(choice.startsWith("devin:") ? { permissionMode: choice.slice(6) } : {})

        : new OpencodeHarness({

            model: choice,

            ...(command === undefined ? {} : { command }),

            ...(namedConfig === undefined ? {} : { configPath: namedConfig }),

            autoApprove: options.autoApprove,

          });

    return {

      fleet: new DelegateFleet(registry, harness, {

  const fleetFor = (choice: string) => {

    const lane = resolveChildLane(choice);

    if (lane === undefined) return undefined;

    // The self lane spends the children's grant. Without one there is nothing

    // to spend, and answering with a different agent under the name the caller

    // asked for would be worse than saying no.

    if (selfChildLane(lane) && options.grant === undefined) return undefined;

    const existing = lanes.get(lane);

    if (existing !== undefined) return existing;

    const built = laneFor(lane);

  // and expires under a console that outlives it; the harness's own catalog

  // costs nothing and needs no credential from us. The grant stays as the

  // fallback for a machine whose harness lists none of them.

  // Self first. A child run by this process is the same loop the parent runs,

  // on the grant the server minted for children and pinned to Ox Alpha — no

  // second agent to install, no second credential, and the model is the one the

  // conversation asked for rather than whichever one that install happened to

  // have. `opencode` is the fallback for a session with no grant to spend, and

  // for a reader who names a lane.

  if ((named === undefined || named.trim().length === 0) && options.grant !== undefined) {

    const harness = new SelfHarness({ grant: options.grant });

    const fleet = new DelegateFleet(registry, harness, {

      maxConcurrent: Math.max(1, options.concurrency),

      cwd: options.cwd,

    });

    return {

      delegation: {

        registry,

        fleet,

        label: `${harness.agent} (${childLaneName(harness.model)})`,

        models: CHILD_MODELS,

        fleetFor,

      },

      close: () => Promise.resolve(),

    };

  }

  const free =

    named === undefined || named.trim().length === 0

      ? await firstAvailableChildModel(command ?? "opencode")

        );

      }

      // 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 && !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.",

        );

      }

      // With --resume the positional argument named the thread, not a prompt.

      const oneShot = resume ? undefined : Option.getOrUndefined(prompt);

}

export const CODER_BACKENDS: readonly CoderBackend[] = [

  { id: "ox-alpha", label: "Ox Alpha" },

  { id: "gemini-3.7-flash", label: "Gemini 3.7 Flash" },

  { id: "ox-alpha", label: "Ox Alpha" },

  { id: "gpt-5.6-luna", label: "Luna" },

];

/**

 * The backend a coder session leads with when nobody names one.

 *

 * A *preference*, not an answer. A coder turn is a long one with tools in it,

 * and this build leads with the fast model for that — but only where the server

 * actually serves it. Where it does not, `chooseBackend` falls to the server's

 * own default rather than opening a thread on a name the catalog will refuse.

 * Gemini 3.7 Flash: fast, a million tokens of context, and steady enough to

 * hold a conversation. Delegated children run on Ox Alpha instead — it is

 * built for sustained agentic coding, which is what a child is given, and

 * where it stalls the cost is one child rather than the conversation.

 *

 * A *preference*, not an answer. Where a deployment does not serve it,

 * `chooseBackend` falls to the server's own default rather than opening a

 * thread on a name the catalog will refuse.

 */

export const DEFAULT_CODER_BACKEND = "gemini-3.7-flash";

 *

 * A slug still resolves to itself, so nothing that already worked stops.

 */

/**

 * The lane run by this process, on the account's own thread grant.

 *

 * Named rather than aliased to a harness slug, because it is not a model this

 * or any harness offers — it is the parent's own loop, smaller, on the grant

 * the server minted for children.

 */

export const SELF_CHILD_LANE = "openagents";

export const CHILD_LANE_ALIASES: Readonly<Record<string, string>> = {

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

  // `ox-alpha` means the self-hosted lane now. It is the same model either

  // way — the server routes the child's grant to OpenRouter's

  // `stealth/ox-alpha` — and running it here costs no second agent, no second

  // credential, and no second idea of what a coding agent is. The opencode

  // route to the same model is still reachable, by its own slug.

  "ox-alpha": SELF_CHILD_LANE,

  [SELF_CHILD_LANE]: SELF_CHILD_LANE,

  gemini: "opencode/gemini-3.7-flash",

};

 * than from what it remembers.

 */

export const CHILD_MODELS: ReadonlyArray<string> = [

  ...Object.keys(CHILD_LANE_ALIASES),

  // Deduplicated: `ox-alpha` and `openagents` are two names for one lane, and

  // offering both in the enum would read as two choices.

  ...new Set(Object.keys(CHILD_LANE_ALIASES)),

  ...FREE_CHILD_MODELS,

  "devin",

];

  return FREE_CHILD_MODELS.includes(asked) ? asked : undefined;

};

/** Whether this resolved lane is the one this process runs itself. */

export const selfChildLane = (lane: string): boolean => lane === SELF_CHILD_LANE;

/**

 * The first preferred model the harness offers, or undefined when it lists none.

 *

import { appendFileSync } from "node:fs";

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

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

import { Redacted } from "effect";

/**

 * Children run by this process, on the account's own thread grant.

 *

 * The lane this replaces is `opencode`: a second coding agent, installed

 * separately, with its own credentials, its own model catalog, its own tool

 * loop, and its own idea of what a coding agent is. It worked, and it cost a

 * process per child and an unbounded amount of behaviour nobody here chose —

 * a child answering from whichever model that install happened to have, with

 * whichever tools that version happened to ship.

 *

 * A self-hosted child is the same loop the parent session already runs,

 * smaller: the grant the server minted for children, pinned to Ox Alpha, a

 * short and deliberate toolset, and this process's own turn loop. No second

 * agent to install, no second credential, and the model is the one the

 * conversation asked for rather than the one the harness had.

 *

 * The proxy is the only thing it talks to, so no provider key reaches this

 * process (RELEASE-002). `ox-alpha` is what the child thread's grant pins, and

 * the server routes that to OpenRouter's `stealth/ox-alpha`.

 *

 * `opencode` stays as the fallback for a session with no grant to spend, and

 * for a reader who names it.

 */

/** How many rounds of tool calls one child may take. */

const MAX_ROUNDS = 60;

/** What a child is told it is, and what it may do. */

const SYSTEM = (cwd: string, tools: ReadonlyArray<CoderTool>) =>

  [

    "You are a delegated child agent of `openagents coder`, working in a terminal.",

    "",

    "You were given one task by a parent agent, and you cannot ask it anything: it is not",

    "waiting on you and there is nobody to answer. Everything you need is in the task, or is",

    "on this machine, or is not available — say so plainly rather than guessing.",

    "",

    `The working directory is ${cwd}.`,

    "",

    `You have ${String(tools.length)} tool${tools.length === 1 ? "" : "s"}, and no others:`,

    ...tools.map((tool) => `- \`${tool.name}\``),

    "",

    // The parent counts on this: a child's answer is read by an agent, not a

    // person, and a child that stops mid-task without saying so is reported as

    // having succeeded.

    "That list is complete. You cannot delegate further — you are the child. When you are",

    "done, your final message is the whole of what the parent receives, so it has to carry",

    "the answer rather than point at work you did. If you could not finish, say what you did,",

    "what stopped you, and what remains.",

  ].join("\n");

export interface SelfHarnessOptions {

  readonly grant: ChildGrant;

  /** Overrides the tools a child gets. For tests. */

  readonly tools?: (cwd: string) => ReadonlyArray<CoderTool>;

}

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 SelfHarness implements DelegateHarness {

  readonly agent = "openagents";

  readonly model: string;

  /**

   * Live children's transcripts, by session.

   *

   * What makes a retry resume rather than restart. A child whose provider

   * dropped after twenty tool calls carries on from its own transcript instead

   * of re-reading and re-editing everything.

   */

  private readonly sessions = new Map<string, WireMessage[]>();

  private sequence = 0;

  constructor(private readonly options: SelfHarnessOptions) {

    this.model = options.grant.model;

  }

  /**

   * The toolset a child gets, which is deliberately shorter than the parent's.

   *

   * `shell` is the whole of it. It reads, writes, searches, lists, and runs

   * tests, which is the work a child is given; the parent's other tools are

   * either the parent's own business (`delegate` — a child that delegates is a

   * fan-out nobody asked for) or a way of reaching the account (`openagents`),

   * which is not a child's to spend.

   */

  private toolsFor(cwd: string): ReadonlyArray<CoderTool> {

    return this.options.tools?.(cwd) ?? [shellTool(cwd)];

  }

  async *run(

    input: {

      readonly prompt: string;

      readonly cwd: string;

      readonly transcriptPath: string;

      readonly resumeSessionId?: string | undefined;

    },

    signal: AbortSignal,

  ): AsyncIterable<DelegateEvent> {

    const tools = this.toolsFor(input.cwd);

    const resumed =

      input.resumeSessionId === undefined

        ? undefined

        : this.sessions.get(input.resumeSessionId);

    const sessionId = input.resumeSessionId ?? this.mintSession();

    const transcript: WireMessage[] = resumed ?? [

      { role: "system", content: SYSTEM(input.cwd, tools) },

      { role: "user", content: input.prompt },

    ];

    if (resumed !== undefined) {

      transcript.push({

        role: "user",

        content:

          "The previous attempt stopped when the model provider became unavailable. " +

          "Continue from where you left off and finish the task.",

      });

    }

    this.sessions.set(sessionId, transcript);

    yield { type: "session", sessionId };

    const record = (entry: Record<string, unknown>) => {

      // Written as it happens, not at the end, so a child that is killed still

      // leaves everything it had done behind.

      try {

        appendFileSync(input.transcriptPath, `${JSON.stringify(entry)}\n`);

      } catch {

        // A transcript that cannot be written must not end the child's work.

      }

    };

    record({ type: "session", sessionId, model: this.model, cwd: input.cwd });

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

      if (signal.aborted) return;

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

      let said = "";

      const body = await this.call(transcript, tools, signal);

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

      for await (const frame of frames(body, 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) {

          const counts = usage as Record<string, unknown>;

          const input_tokens = counts["prompt_tokens"];

          const output_tokens = counts["completion_tokens"];

          if (typeof input_tokens === "number" && typeof output_tokens === "number") {

            yield { type: "tokens", input: input_tokens, output: output_tokens };

          }

        }

        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 content = parts["content"];

          if (typeof content === "string") said += content;

          const asked = parts["tool_calls"];

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

        }

      }

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

      if (wanted.length === 0) {

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

        record({ type: "text", value: said });

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

        this.sessions.delete(sessionId);

        return;

      }

      transcript.push({

        role: "assistant",

        content: said,

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

          id: call.id,

          type: "function",

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

        })),

      });

      for (const call of wanted) {

        if (signal.aborted) return;

        const args = parseArguments(call.args);

        yield {

          type: "tool",

          callId: call.id,

          name: call.name,

          target: targetOf(args),

        };

        record({ type: "tool", callId: call.id, name: call.name, arguments: args });

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

        const output =

          tool === undefined

            ? `No tool called ${call.name} is available to a child agent.`

            : await tool

                .run(args, signal)

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

        transcript.push({

          role: "tool",

          tool_call_id: call.id,

          content: boundedResult(output),

        });

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

      }

    }

    yield {

      type: "error",

      message: `The child stopped after ${String(MAX_ROUNDS)} rounds of tool calls.`,

    };

  }

  /** One call to the proxy on the child's grant. */

  private async call(

    transcript: ReadonlyArray<WireMessage>,

    tools: ReadonlyArray<CoderTool>,

    signal: AbortSignal,

  ): Promise<ReadableStream<Uint8Array> | undefined> {

    const response = await fetch(this.options.grant.proxyUrl, {

      method: "POST",

      signal,

      headers: {

        authorization: `Bearer ${Redacted.value(this.options.grant.token)}`,

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

        accept: "text/event-stream, application/json",

      },

      body: JSON.stringify({

        model: this.options.grant.model,

        stream: true,

        messages: transcript,

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

          type: "function",

          function: {

            name: tool.name,

            description: tool.description,

            parameters: tool.parameters,

          },

        })),

      }),

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

      if (signal.aborted) return undefined;

      // Thrown rather than yielded, so the fleet's retry sees it: the words

      // matter, because that is what `transientProviderFailure` reads.

      throw new Error(`Upstream request failed: ${String(cause)}`);

    });

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

    if (!response.ok) {

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

      throw new Error(

        `The inference proxy refused the child's call (${String(response.status)})` +

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

      );

    }

    return response.body ?? undefined;

  }

  private mintSession(): string {

    this.sequence += 1;

    return `s${Date.now().toString(36)}${this.sequence.toString(36).padStart(2, "0")}`;

  }

}

/** The one argument worth showing in a fleet row, if there is one. */

function targetOf(args: Record<string, unknown>): string | undefined {

  for (const key of ["command", "path", "file", "pattern"]) {

    const value = args[key];

    if (typeof value === "string" && value.length > 0) return value;

  }

  return undefined;

}

  it("publishes ids the chat API's own enum lists", () => {

    // These are the values `POST /api/v3/chat/turns` accepts as `model`, so a

    // change here without the matching server change is a refusal at runtime.

    expect(backendIds()).toEqual(["ox-alpha", "gemini-3.7-flash"]);

    expect(backendIds()).toEqual(["gemini-3.7-flash", "ox-alpha", "gpt-5.6-luna"]);

  });

});

  });

  it("leads with the preferred backend where the server serves it", () => {

    const chosen = chooseBackend([

      model("gpt-5.6-luna", true, true),

      model("gemini-3.7-flash", true),

    ]);

    const chosen = chooseBackend([model("ox-alpha", true, true), model("gemini-3.7-flash", true)]);

    expect(chosen?.id).toBe("gemini-3.7-flash");

  });

  it("falls to the server's own default when the preference is not served", () => {

    // The case that sent every session into a 422: no deployment served a model

    // by that id, and the client named it anyway.

    const chosen = chooseBackend([model("gpt-5.6-luna", true, true), model("ox-alpha", false)]);

    expect(chosen?.id).toBe("gpt-5.6-luna");

    // Ox Alpha is what a session falls to when Gemini is not served here.

    const chosen = chooseBackend([model("ox-alpha", true, true), model("gemini-3.7-flash", false)]);

    expect(chosen?.id).toBe("ox-alpha");

  });

  it("falls past an unavailable default to something that can answer", () => {

    const chosen = chooseBackend([model("gpt-5.6-luna", false, true), model("ox-alpha", true)]);

    expect(chosen?.id).toBe("ox-alpha");

    const chosen = chooseBackend([model("gpt-5.6-luna", false, true), model("gemini-x", true)]);

    expect(chosen?.id).toBe("gemini-x");

  });

  it("honours an explicitly named model over the preference", () => {

    const chosen = chooseBackend(

      [model("gpt-5.6-luna", true, true), model("gemini-3.7-flash", true)],

      "gpt-5.6-luna",

      [model("gpt-5.6-luna", true, true), model("ox-alpha", true)],

      "ox-alpha",

    );

    expect(chosen?.id).toBe("gpt-5.6-luna");

    expect(chosen?.id).toBe("ox-alpha");

  });

  it("chooses nothing when no model has a configured credential", () => {

  CHILD_MODELS,

  childLaneName,

  resolveChildLane,

  SELF_CHILD_LANE,

  selfChildLane,

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

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

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

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

describe("naming a lane", () => {

  it("resolves the name a person uses to the slug the harness knows", () => {

    // Ox Alpha's slug says neither `ox` nor `alpha`, so a session offered only

    // the slug is one nobody can ask for Ox Alpha by name.

    expect(resolveChildLane("ox-alpha")).toBe("opencode/x-preview-f-free");

    expect(CHILD_LANE_ALIASES["ox-alpha"]).toBe("opencode/x-preview-f-free");

  it("resolves Ox Alpha to the lane this process runs itself", () => {

    // It is the same model whichever lane serves it — the child's grant is

    // routed to OpenRouter's `stealth/ox-alpha` — so asking for Ox Alpha means

    // the lane that costs no second agent and no second credential.

    expect(resolveChildLane("ox-alpha")).toBe(SELF_CHILD_LANE);

    expect(resolveChildLane("openagents")).toBe(SELF_CHILD_LANE);

    expect(selfChildLane(resolveChildLane("ox-alpha") ?? "")).toBe(true);

  });

  it("resolves a slug to itself, so nothing that worked stops", () => {

  it("still resolves opencode's own slug, so nothing that worked stops", () => {

    expect(resolveChildLane("opencode/x-preview-f-free")).toBe("opencode/x-preview-f-free");

    expect(selfChildLane("opencode/x-preview-f-free")).toBe(false);

  });

  it("carries a Devin permission mode through", () => {

  it("reports a lane by the name a reader would recognise", () => {

    // Reached by slug or by alias, it reports the same name, so a caller can

    // tell whether the lane they asked for is the lane that answered.

    expect(childLaneName("opencode/x-preview-f-free")).toBe("ox-alpha");

    expect(childLaneName(SELF_CHILD_LANE)).toBe("ox-alpha");

    expect(childLaneName("opencode/gemini-3.7-flash")).toBe("gemini");

  });

  it("offers the names first, since those are what a call would say", () => {

    expect(CHILD_MODELS.slice(0, 2)).toEqual(["ox-alpha", "gemini"]);

    expect(CHILD_MODELS.slice(0, 2)).toEqual(["ox-alpha", "openagents"]);

    expect(CHILD_MODELS).toContain("gemini");

    expect(CHILD_MODELS).toContain("devin");

    // One lane, two names for it, offered once each and not duplicated further.

    expect(CHILD_MODELS.filter((name) => name === "ox-alpha")).toHaveLength(1);

  });

});

    expect(defaultBackendId()).toBe("gemini-3.7-flash");

    // And the list still mirrors the server's enum in its own order: a

    // preference is named, not expressed by reordering an agreement.

    expect(CODER_BACKENDS.map((backend) => backend.id)).toEqual(["ox-alpha", "gemini-3.7-flash"]);

    expect(CODER_BACKENDS.map((backend) => backend.id)).toEqual([

      "gemini-3.7-flash",

      "ox-alpha",

      "gpt-5.6-luna",

    ]);

  });

});

import { readFileSync } from "node:fs";

import { mkdtempSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

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

import { Redacted } from "effect";

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

import { SelfHarness } from "../src/coder-self-harness.js";

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

const GRANT = {

  proxyUrl: "https://openagents.test/api/inference/proxy",

  token: Redacted.make("oa_grant_child"),

  model: "ox-alpha",

};

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 tool = (name: string, run: CoderTool["run"]): CoderTool => ({

  name,

  description: `the ${name} tool`,

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

  run,

});

const drain = async (harness: SelfHarness, prompt: string, transcriptPath: string) => {

  const events: DelegateEvent[] = [];

  for await (const event of harness.run(

    { prompt, cwd: "/repo", transcriptPath },

    new AbortController().signal,

  )) {

    events.push(event);

  }

  return events;

};

const scratch = () => join(mkdtempSync(join(tmpdir(), "oa-self-")), "child.jsonl");

afterEach(() => {

  vi.unstubAllGlobals();

});

describe("a child this process runs itself", () => {

  it("spends the children's grant against the proxy, on the model it pins", async () => {

    const sent = stub([sse([`data: {"choices":[{"delta":{"content":"done"}}]}`, `data: [DONE]`])]);

    const harness = new SelfHarness({ grant: GRANT, tools: () => [] });

    const events = await drain(harness, "do it", scratch());

    expect(sent[0]?.url).toBe(GRANT.proxyUrl);

    expect(sent[0]?.authorization).toBe("Bearer oa_grant_child");

    expect(sent[0]?.body["model"]).toBe("ox-alpha");

    expect(events.at(-1)).toEqual({ type: "text", value: "done" });

  });

  it("tells the child what it is and that it cannot delegate further", async () => {

    // A child that fans out is a fan-out nobody asked for, and a child that

    // stops without saying so is reported to the parent as having succeeded.

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

    const harness = new SelfHarness({ grant: GRANT, tools: (cwd) => [tool(`in-${cwd}`, async () => "")] });

    await drain(harness, "do it", scratch());

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

    const system = String(messages[0]?.["content"]);

    expect(messages[0]?.["role"]).toBe("system");

    expect(system).toContain("delegated child agent");

    expect(system).toContain("cannot delegate further");

    expect(system).toContain("/repo");

    // The tools it actually has, named as the whole list.

    expect(system).toContain("`in-/repo`");

    expect(messages[1]).toEqual({ role: "user", content: "do it" });

  });

  it("runs a 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\\":\\"git log\\"}"}}]}}]}`,

        `data: [DONE]`,

      ]),

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

    ]);

    const harness = new SelfHarness({

      grant: GRANT,

      tools: () => [

        tool("shell", async (args) => {

          ran.push(String(args["command"]));

          return "abc123 a commit";

        }),

      ],

    });

    const events = await drain(harness, "read the log", scratch());

    expect(ran).toEqual(["git log"]);

    expect(events.some((event) => event.type === "tool" && event.name === "shell")).toBe(true);

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

    expect(second.find((message) => message["role"] === "tool")).toMatchObject({

      tool_call_id: "c1",

      content: "abc123 a commit",

    });

    expect(events.at(-1)).toEqual({ type: "text", value: "the log" });

  });

  it("reports the tool it is running, so the fleet can show it", async () => {

    stub([

      sse([

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

        `data: [DONE]`,

      ]),

      sse([`data: [DONE]`]),

    ]);

    const harness = new SelfHarness({ grant: GRANT, tools: () => [tool("shell", async () => "")] });

    const events = await drain(harness, "look", scratch());

    const activity = events.find((event) => event.type === "tool");

    expect(activity).toMatchObject({ name: "shell", target: "ls -la" });

  });

  it("writes its transcript as it goes, not at the end", async () => {

    stub([

      sse([

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

        `data: [DONE]`,

      ]),

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

    ]);

    const path = scratch();

    const harness = new SelfHarness({ grant: GRANT, tools: () => [tool("shell", async () => "/repo")] });

    await drain(harness, "where", path);

    const lines = readFileSync(path, "utf8").trim().split("\n").map((line) => JSON.parse(line));

    expect(lines.map((line: { type: string }) => line.type)).toEqual([

      "session",

      "tool",

      "tool_result",

      "text",

    ]);

  });

  it("resumes a session rather than starting the task again", async () => {

    stub([

      sse([

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

        `data: [DONE]`,

      ]),

      // The provider drops. The fleet retries with the session it was given.

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

    ]);

    const harness = new SelfHarness({ grant: GRANT, tools: () => [tool("shell", async () => "ok")] });

    const path = scratch();

    const first = await drain(harness, "long task", path);

    const session = first.find((event) => event.type === "session");

    expect(session).toMatchObject({ type: "session" });

  });

  it("says so rather than pretending, when the proxy refuses", async () => {

    stub([new Response("no", { status: 403 })]);

    const harness = new SelfHarness({ grant: GRANT, tools: () => [] });

    await expect(drain(harness, "go", scratch())).rejects.toThrow(/refused the child's call \(403\)/);

  });

});