/**

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

 * The enum is the names; `CHILD_LANES` is what each one is. Offered as an enum

 * so a call chooses from what exists rather than from what it remembers.

 */

/**

 * What each lane actually is: who runs the child, and what answers it.

 *

 * The two are independent and the enum reads as one list, which is how a

 * session came to describe `opencode/x-preview-f-free` as a "fast preview /

 * experimental" model. It is not. It is **the same model as `ox-alpha`** —

 * opencode's own normalization maps `x-preview-f` to `ox-alpha` — reached

 * through a different harness on a different credential. A caller choosing

 * between them is choosing who runs the child, not which model thinks.

 *

 * So each lane says both, and says who pays.

 */

export interface ChildLane {

  /** The name a `delegate` call passes as `model`. */

  readonly name: string;

  /** What runs the child and gives it its tools. */

  readonly harness: string;

  /** What answers. */

  readonly model: string;

  /** Where that model is served from, and whose credential pays for it. */

  readonly served: string;

  readonly bestFor: string;

}

export const CHILD_LANES: ReadonlyArray<ChildLane> = [

  {

    name: "ox-alpha",

    harness: "openagents (this process, one `shell` tool)",

    model: "Ox Alpha",

    served: "the OpenAgents inference proxy, routed to OpenRouter `stealth/ox-alpha`, on this session's thread grant",

    bestFor: "work whose shape is the question: design, architecture, an open-ended refactor",

  },

  {

    name: "opencode/x-preview-f-free",

    harness: "opencode (a separate CLI on this machine, its own tools)",

    // Named as the same model on purpose. The difference between this lane and

    // the one above is the harness and the credential, and a description that

    // implies two models sends a caller here for the wrong reason.

    model: "Ox Alpha — the same model as `ox-alpha`, under opencode's name for it",

    served: "OpenCode Zen, on this machine's opencode credential",

    bestFor: "the same work as `ox-alpha`, when you want opencode's harness and tools instead of ours",

  },

  {

    name: "gemini",

    harness: "opencode (a separate CLI on this machine, its own tools)",

    model: "Gemini 3.7 Flash",

    served: "OpenCode Zen, on this machine's opencode credential",

    bestFor: "fast, straightforward coding and analysis",

  },

  {

    name: "devin",

    harness: "devin (the Devin CLI, its own tools)",

    // Devin picks its own model from its own configuration and print mode does

    // not report which, so naming one here would be inventing it.

    model: "Devin's own, not reported",

    served: "Devin, on its own credentials — it spends nothing of this account's",

    bestFor: "straightforward engineering with a clear shape: a named fix, a test, a migration",

  },

];

/** One lane as a line a model can read. */

export const describeChildLane = (lane: ChildLane): string =>

  `\`${lane.name}\` — harness: ${lane.harness}; model: ${lane.model}; served by ${lane.served}. ` +

  `Best for ${lane.bestFor}.`;

export const CHILD_MODELS: ReadonlyArray<string> = [

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

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

  renderShell,

  runShell,

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

import { CHILD_LANES, describeChildLane } from "./coder-delegate.js";

import { catalogEntry, renderSkill, type CoderSkill } from "./coder-skills.js";

import { describePrompt, MAX_DELEGATE_COUNT } from "./coder-delegate.js";

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

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

      (models.length === 0

        ? ""

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

        : ` Children run on ${delegation.label} unless \`model\` names another lane.\n\n` +

          // Named in full, because the enum alone reads as a list of models and

          // it is not one: two of these lanes are the same model under

          // different harnesses, and a session that could not tell described

          // one of them as a "fast preview / experimental" model it is not.

          "A lane is a harness and a model together. The harness runs the child and gives it " +

          "its tools; the model is what answers. Choosing a lane chooses both:\n" +

          CHILD_LANES.filter((lane) => models.includes(lane.name))

            .map((lane) => `- ${describeChildLane(lane)}`)

            .join("\n")),

    parameters: {

      type: "object",

      properties: {

                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.",

                  "Which lane the children run on — a harness and a model together, not a " +

                  `model on its own. Defaults to ${delegation.label}. The tool's own ` +

                  "description says what each lane is; two of them are the same model under " +

                  "different harnesses, so pick by what the work needs and whose credential " +

                  "should pay.",

              },

            }),

      },

import {

  CHILD_MODELS,

  CHILD_LANES,

  type ChildLane,

  childLaneName,

  describeChildLane,

  resolveChildLane,

  SELF_CHILD_LANE,

  selfChildLane,

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

  });

});

describe("saying what a lane is", () => {

  const lane = (name: string) => CHILD_LANES.find((entry) => entry.name === name);

  it("names a harness and a model for every lane a call can pick", () => {

    // The enum reads as a list of models and is not one. A session that could

    // not tell described `opencode/x-preview-f-free` as a "fast preview /

    // experimental" model, which it is not: it is Ox Alpha.

    for (const name of CHILD_MODELS) {

      const resolved = resolveChildLane(name);

      expect(resolved).toBeDefined();

      // `openagents` and `ox-alpha` are two names for one lane, described once.

      const described = lane(name) ?? lane("ox-alpha");

      expect(described?.harness).toBeTruthy();

      expect(described?.model).toBeTruthy();

      expect(described?.served).toBeTruthy();

    }

  });

  it("says the two Ox Alpha lanes are the same model, differing in harness", () => {

    const ours = lane("ox-alpha");

    const theirs = lane("opencode/x-preview-f-free");

    expect(ours?.model).toContain("Ox Alpha");

    expect(theirs?.model).toContain("Ox Alpha");

    expect(theirs?.model).toContain("same model");

    // What actually differs.

    expect(ours?.harness).toContain("openagents");

    expect(theirs?.harness).toContain("opencode");

    expect(ours?.served).toContain("OpenRouter");

    expect(theirs?.served).toContain("OpenCode Zen");

  });

  it("does not call the opencode lane fast or experimental", () => {

    const theirs = describeChildLane(lane("opencode/x-preview-f-free") as ChildLane);

    expect(theirs).not.toMatch(/experimental|preview tier|lightweight/i);

  });

  it("says which harness the Gemini lane runs on, since the name does not", () => {

    const gemini = lane("gemini");

    expect(gemini?.harness).toContain("opencode");

    expect(gemini?.model).toContain("Gemini 3.7 Flash");

  });

  it("says Devin is a harness that brings its own model and credential", () => {

    const devin = lane("devin");

    expect(devin?.harness).toContain("Devin CLI");

    expect(devin?.served).toContain("its own credentials");

  });

  it("puts every offered lane's description in front of the model", () => {

    const registry = new CoderTaskRegistry();

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

    const { description } = delegateTool({

      registry,

      fleet,

      label: "openagents (ox-alpha)",

      models: CHILD_MODELS,

      fleetFor: () => ({ fleet, label: "x" }),

    } as unknown as CoderDelegation);

    for (const entry of CHILD_LANES) {

      if (!CHILD_MODELS.includes(entry.name)) continue;

      expect(description).toContain(entry.harness);

      expect(description).toContain(entry.model);

    }

    expect(description).toContain("A lane is a harness and a model together");

  });

});

      cwd: "/tmp",

        background: true,

      },

      Date.now(),

      // A fixed start, because the completion below is a fixed instant too and

      // the pair is what makes the duration deterministic. Started at

      // `Date.now()` and completed at epoch 4000, the child finished

      // fifty-six years before it began and the duration clamped to zero.

      1_000,

    );

  registry.start(task.id, new AbortController());

  registry.recordToolUse(task.id, { toolName: "bash", target: "pnpm test" });