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

    "filesScanned": 2439,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:154444d74279069de014797ee8c9943bc18f625702640bc4dbdb6bd1d5e82f18",

  "sourceDigest": "sha256:b66f940c59b2d89100cc77723ed92cd43247cc8b3b868330a5c2d39cdb6b33d9",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

child gets the same prompt and is told its own number separately — write for

whichever child is reading rather than naming one.

`--child-model devin` runs the children on the Devin CLI instead, and

`devin:<mode>` picks a permission mode other than the default `dangerous`. A

Devin child brings its own credentials and model rather than spending this

session's grant. Prefer this over running `devin` yourself through `shell`: a

fleet child renders, stops with `ctrl+x`, and does not block the turn, while a

shell child is one opaque call that freezes the session until it ends.

**The lane is chosen per call.** `delegate` takes a `model`, and its enum is

the lanes this session can reach: `ox-alpha`, `gemini`, `devin`, and the model

slugs behind them. The same names work on the CLI as `--child-model`. A fan-out

of straightforward fixes and a fan-out of design questions are different work

and want different models, and there is no need to restart a session to change

lanes.

`devin` runs the children on the Devin CLI, and `devin:<mode>` picks a

permission mode other than the default `dangerous`. A Devin child brings its own

credentials and model rather than spending this session's grant. Prefer it over

running `devin` yourself through `shell`: a fleet child renders, stops with

`ctrl+x`, and does not block the turn, while a shell child is one opaque call

that freezes the session until it ends.

## Burning through a backlog

- **Devin** for straightforward engineering: a named fix, a test to write, a

  migration, a rename, a documented change with a clear shape.

- **opencode on Ox Alpha** (`--child-model ox-alpha`) for high-concept and

  strategic work: design, architecture, anything where the shape of the answer

  is the question.

- **Ox Alpha** (`model: "ox-alpha"`) for high-concept and strategic work:

  design, architecture, anything where the shape of the answer is the question.

If you cannot tell which, it is the second kind.

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

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

import {

  CHILD_MODELS,

  childLaneName,

  DelegateFleet,

  DevinHarness,

  describePrompt,

  firstAvailableChildModel,

  OpencodeHarness,

  resolveChildLane,

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

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

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

  const command = options.command ?? process.env["OPENAGENTS_DELEGATE_COMMAND"];

  const namedConfig = options.configPath ?? process.env["OPENAGENTS_DELEGATE_CONFIG"];

  // One registry for the session, whatever a call chooses to run on, so the

  // children of two models still render as one fleet and stop together.

  const registry = new CoderTaskRegistry();

  // Labelled by the name that was asked for. A caller who names `ox-alpha` and

  // is answered `x-preview-f-free` cannot tell whether the request was honoured

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

        });

    return {

      fleet: new DelegateFleet(registry, harness, {

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

        cwd: options.cwd,

      }),

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

    };

  };

  // Cached, so a second call on the same model reuses its fleet rather than

  // starting a second one that competes with the first for the same cap.

  const lanes = new Map<string, { fleet: DelegateFleet; label: string }>();

  const fleetFor = (choice: string) => {

    const lane = resolveChildLane(choice);

    if (lane === undefined) return undefined;

    const existing = lanes.get(lane);

    if (existing !== undefined) return existing;

    const built = laneFor(lane);

    lanes.set(lane, built);

    return built;

  };

  // `--child-model devin` runs children on the Devin CLI instead. It brings its

  // own credentials and its own model, so it needs neither this session's grant

  // nor a gateway, and it is refused up front when it is not installed rather

  // than once per child.

  if (named !== undefined && /^devin(:(.+))?$/.test(named.trim())) {

    const mode = /^devin:(.+)$/.exec(named.trim())?.[1];

    const harness = new DevinHarness(mode === undefined ? {} : { permissionMode: mode });

    const registry = new CoderTaskRegistry();

    const fleet = new DelegateFleet(registry, harness, {

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

      cwd: options.cwd,

    });

  // An alias on the flag too, so `--child-model ox-alpha` means what it says

  // and the skill that documents it is not documenting a thing that fails.

  const askedFor = named === undefined ? undefined : resolveChildLane(named);

  if (askedFor !== undefined && /^devin(:(.+))?$/.test(askedFor)) {

    const mode = /^devin:(.+)$/.exec(askedFor)?.[1];

    const lane = laneFor(mode === undefined ? "devin" : `devin:${mode}`);

    return {

      delegation: { registry, fleet, label: `${harness.agent} (${harness.model})` },

      delegation: { registry, ...lane, models: CHILD_MODELS, fleetFor },

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

    };

  }

      : undefined;

  if (free !== undefined) {

    const harness = new OpencodeHarness({

      model: free,

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

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

      autoApprove: options.autoApprove,

    });

    const registry = new CoderTaskRegistry();

    const fleet = new DelegateFleet(registry, harness, {

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

      cwd: options.cwd,

    });

    const lane = fleetFor(free) ?? laneFor(free);

    return {

      delegation: { registry, fleet, label: `${harness.agent} (${free})` },

      delegation: { registry, ...lane, models: CHILD_MODELS, fleetFor },

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

    };

  }

  if (named !== undefined && named.trim().length > 0) {

    model = named;

    // `--child-model ox-alpha` means the lane, not a literal model name the

    // harness has never heard of. Resolved here so the flag and the tool's

    // `model` parameter accept the same words, and an unrecognised name is

    // still passed through for the harness to refuse by name.

    model = askedFor ?? named;

    configPath = namedConfig;

    close = () => Promise.resolve();

  } else if (options.grant !== undefined) {

    configPath,

    autoApprove: options.autoApprove,

  });

  const registry = new CoderTaskRegistry();

  const fleet = new DelegateFleet(registry, harness, {

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

    cwd: options.cwd,

  });

  return {

    delegation: { registry, fleet, label: `${harness.agent} (${model})` },

    delegation: {

      registry,

      fleet,

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

      models: CHILD_MODELS,

      fleetFor,

    },

    close,

  };

}

  "opencode/gemini-3.5-flash",

];

/**

 * What a lane is called, and what it resolves to.

 *

 * The names are the ones people use. Ox Alpha's slug is

 * `opencode/x-preview-f-free` — it says neither `ox` nor `alpha`, because

 * opencode's normalization maps `x-preview-f` to `ox-alpha` elsewhere — so a

 * session offered only the slug is a session nobody can ask for Ox Alpha by

 * name. Asked "can you delegate to ox alpha", one answered no while holding

 * exactly that lane under a name it could not connect to the question.

 *

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

 */

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

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

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

};

/**

 * Every lane a `delegate` call may name, by the name a caller would use.

 *

 * Devin is here because it brings its own credentials rather than spending this

 * session's grant. Offered as an enum so a call chooses from what exists rather

 * than from what it remembers.

 */

export const CHILD_MODELS: ReadonlyArray<string> = [

  ...Object.keys(CHILD_LANE_ALIASES),

  ...FREE_CHILD_MODELS,

  "devin",

];

/**

 * The name a lane is known by, given its slug.

 *

 * So a lane reached by its slug still reports the name a reader would recognise,

 * whichever way it was reached.

 */

export const childLaneName = (lane: string): string =>

  Object.entries(CHILD_LANE_ALIASES).find(([, slug]) => slug === lane)?.[0] ?? lane;

/** The lane a name means, whether it is an alias, a slug, or Devin. */

export const resolveChildLane = (name: string): string | undefined => {

  const asked = name.trim();

  if (asked.length === 0) return undefined;

  if (/^devin(:.+)?$/.test(asked)) return asked;

  const aliased = CHILD_LANE_ALIASES[asked];

  if (aliased !== undefined) return aliased;

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

};

/**

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

 *

}

/** What the session needs in order to delegate. Absent means it cannot. */

export interface CoderDelegation {

  readonly registry: CoderTaskRegistry;

export interface CoderDelegationFleet {

  /** Usually a `DelegateFleet`. Narrow on purpose, so tests can stand in. */

  readonly fleet: { submit(request: DelegationRequest): Promise<DelegationOutcome> };

  /** Shown when the reader asks for help, and in the launch notice. */

  readonly label: string;

}

export interface CoderDelegation extends CoderDelegationFleet {

  readonly registry: CoderTaskRegistry;

  /**

   * The models a call may name, for the tool to offer and to validate against.

   *

   * Empty when the session can only run children one way, and the tool then

   * offers no choice rather than one that goes nowhere.

   */

  readonly models?: ReadonlyArray<string>;

  /**

   * A fleet running children on `model`, or the default when none is named.

   *

   * Built here rather than at session start because the choice belongs to the

   * call: a fan-out of straightforward fixes and a fan-out of design questions

   * are different work and want different models, and a session that had to be

   * restarted to change lanes is a session that will not change them.

   *

   * Returns undefined for a model this session cannot reach, so the tool can

   * say which ones it can rather than failing a child at launch.

   */

  fleetFor?(model: string): CoderDelegationFleet | undefined;

}

/** Where reply chunks come from. One implementation today; ACP is the next. */

export interface ReplySource {

  /** The label the status line shows for the reply source. */

import { fileURLToPath } from "node:url";

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

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

import {

  DEFAULT_TIMEOUT_MS,

  MAXIMUM_TIMEOUT_MS,

 * the renderer reads the registry, not this call.

 */

export function delegateTool(delegation: CoderDelegation): CoderTool {

  const models = delegation.fleetFor === undefined ? [] : (delegation.models ?? []);

  return {

    name: "delegate",

    description:

      'for whichever child reads it: say "read the file at your own number" rather than naming ' +

      'one child ("you are child 1"), which gives every child the same work and wastes the ' +

      "fan-out. Prefer one call with a count over several calls. At most " +

      `${String(MAX_DELEGATE_COUNT)} children.`,

      `${String(MAX_DELEGATE_COUNT)} children.` +

      (models.length === 0

        ? ""

        : ` Children run on ${delegation.label} unless \`model\` names another: ${models.join(", ")}.`),

    parameters: {

      type: "object",

      properties: {

          type: "string",

          description: "Three to five words naming the task, shown in the fleet.",

        },

        ...(models.length === 0

          ? {}

          : {

              model: {

                type: "string",

                enum: [...models],

                description:

                  "Which model the children run on. Defaults to " +

                  `${delegation.label}. Straightforward engineering suits a fast model; ` +

                  "work whose shape is the question suits a stronger one.",

              },

            }),

      },

      required: ["prompt"],

      additionalProperties: false,

        return "No children were started: `prompt` is required and must say what the child does.";

      }

      // The lane is chosen per call. A session that had to be restarted to

      // change models is a session that will not change them.

      const named = typeof args["model"] === "string" ? args["model"].trim() : "";

      const lane =

        named.length === 0

          ? { fleet: delegation.fleet, label: delegation.label }

          : delegation.fleetFor?.(named);

      if (lane === undefined) {

        return models.length === 0

          ? `This session runs children one way only, on ${delegation.label}, so \`model\` cannot be chosen here.`

          : `There is no \`${named}\` lane. This session can run children on: ${models.join(", ")}.`;

      }

      const requested = typeof args["count"] === "number" ? Math.trunc(args["count"]) : 1;

      const count = Math.min(MAX_DELEGATE_COUNT, Math.max(1, requested));

      const described = typeof args["description"] === "string" ? args["description"].trim() : "";

      try {

        const outcomes = await Promise.all(

          Array.from({ length: count }, (_unused, index) =>

            delegation.fleet.submit({

            lane.fleet.submit({

              description,

              prompt: identify(prompt, index + 1, count),

              background: true,

            }),

          ),

        );

        return report(outcomes, delegation);

        return report(outcomes, delegation.registry, lane.label);

      } finally {

        signal.removeEventListener("abort", onAbort);

      }

}

/** Every child's outcome, in the order they were launched. */

function report(outcomes: ReadonlyArray<DelegationOutcome>, delegation: CoderDelegation): string {

// The registry is the session's and is shared by every lane, so the children of

// two models still render as one fleet. The label is the lane's own, because

// that is what answered.

function report(

  outcomes: ReadonlyArray<DelegationOutcome>,

  registry: CoderTaskRegistry,

  label: string,

): string {

  const lines: string[] = [];

  let completed = 0;

      continue;

    }

    const task = delegation.registry.get(outcome.taskId);

    const task = registry.get(outcome.taskId);

    const label = `${outcome.taskId}${task === undefined ? "" : ` ${task.description}`}`;

    if (outcome.status === "completed") {

      completed += 1;

    } else {

      lines.push(`${label} stopped before finishing.`);

    }

    delegation.registry.markRead(outcome.taskId);

    registry.markRead(outcome.taskId);

  }

  const header =

    `${String(completed)} of ${String(outcomes.length)} ` +

    `${outcomes.length === 1 ? "child" : "children"} completed on ${delegation.label}.`;

    `${outcomes.length === 1 ? "child" : "children"} completed on ${label}.`;

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

}

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

import {

  CHILD_LANE_ALIASES,

  CHILD_MODELS,

  childLaneName,

  resolveChildLane,

} 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 a slug to itself, so nothing that worked stops", () => {

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

  });

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

    expect(resolveChildLane("devin")).toBe("devin");

    expect(resolveChildLane("devin:auto")).toBe("devin:auto");

  });

  it("refuses a name no lane answers to", () => {

    expect(resolveChildLane("gpt-9")).toBeUndefined();

    expect(resolveChildLane("  ")).toBeUndefined();

  });

  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("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).toContain("devin");

  });

});

describe("choosing a lane in the tool call", () => {

  const delegation = (options: { lanes?: boolean } = {}): CoderDelegation => {

    const registry = new CoderTaskRegistry();

    const fleet = { submit: () => Promise.resolve({ taskId: "t", status: "completed" } as never) };

    const base = { registry, fleet, label: "opencode (ox-alpha)" };

    return options.lanes === false

      ? base

      : {

          ...base,

          models: CHILD_MODELS,

          fleetFor: (name: string) =>

            resolveChildLane(name) === undefined

              ? undefined

              : { fleet, label: `opencode (${name})` },

        };

  };

  it("offers the lanes as an enum, so a call names one that exists", () => {

    const { parameters, description } = delegateTool(delegation());

    const model = (parameters["properties"] as Record<string, { enum?: string[] }>)["model"];

    expect(model?.enum).toContain("ox-alpha");

    expect(model?.enum).toContain("devin");

    expect(description).toContain("ox-alpha");

  });

  it("offers no choice when the session runs children one way", () => {

    // A knob that goes nowhere is worse than no knob: one session answered

    // "no, I cannot delegate to ox alpha" while holding exactly that lane.

    const { parameters } = delegateTool(delegation({ lanes: false }));

    expect(parameters["properties"]).not.toHaveProperty("model");

  });

  it("says which lanes exist when a call names one that does not", async () => {

    const output = await delegateTool(delegation()).run(

      { prompt: "go", model: "gpt-9" },

      new AbortController().signal,

    );

    expect(output).toContain("no `gpt-9` lane");

    expect(output).toContain("ox-alpha");

  });

});