@a-t-h-i/bot-lobby 0.6.55 → 0.6.56

package/THIRD_PARTY_NOTICES.md

@@ -5,7 +5,9 @@
 The web UI's look (colours, radii, shadows, control and dialog styles, the
 sidebar rail, the chat rows, the work log, the composer (its surface, footer controls and send button), the select
 fields and drop-down lists, the loading and status animations and the
-built-in colour themes) is adapted from T3 Code,
+built-in colour themes), and the third-party harness support (the model
+manifest, CLI flags, prompt injection and ACP handling behind Settings >
+Harnesses), is adapted from T3 Code,
 https://github.com/pingdotgg/t3code. No T3 Code package is a
 dependency; the styles and markup below were ported into this repository and
 rewired to bot-lobby's own data layer. Each adapted file starts with a comment
@@ -37,6 +39,15 @@ naming the file it came from.
 | `webui/src/app/TerminalDrawer.tsx` | `apps/web/src/components/ThreadTerminalDrawer.tsx` (the drawer, its floating toolbar and terminal list) |
 | `webui/src/tabs/lobby/InlineActivity.tsx` | `apps/web/src/components/chat/WorkLog.tsx` |
 | `src/webui/palette-core.ts` (the built-in themes) | `packages/shared/src/themePalettes.ts` (Blossom is their T3 Chat theme, renamed) |
+| `src/harness/model-manifest.json` (copied as is) | `apps/server/src/provider/model-manifest.json` |
+| `src/harness/catalog.ts` | `apps/server/src/provider/ClaudeModelCatalog.ts` (effort descriptors and maps), `CodexProvider.ts` (effort levels), `antigravityAuthSupport.ts` (`buildAntigravityAcpSpawnInput`) |
+| `src/harness/cli-args.ts` | `packages/shared/src/cliArgs.ts` (`tokenizeCliArgs`) |
+| `src/harness/instructions.ts` | `packages/provider-core/src/server/runtimeInstructions.ts`, `orchestrationInstructions.ts` (`t3AcpPromptWithInstructions`) |
+| `src/harness/codex.ts` | `apps/server/src/textGeneration/CodexTextGeneration.ts`, `apps/server/src/provider/codexLaunchArgs.ts` |
+| `src/harness/claude.ts` | `apps/server/src/textGeneration/ClaudeTextGeneration.ts`, `apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts` (auto-compact window) |
+| `src/harness/claude-sdk.ts` | `apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts` (Agent SDK query options) |
+| `src/harness/acp.ts` | `apps/server/src/provider/acp/AntigravityProtocol.ts` (permission answers), `packages/provider-acp/src/server/sessionConfig.ts` (session option categories) |
+| `src/schemas/harness.ts`, `webui/src/tabs/settings/HarnessesGroup.tsx` | `packages/contracts/src/settings.ts` (provider settings fields), `apps/web/src/components/settings/ProviderInstanceCard.tsx` |
 
 ```
 MIT License

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.55",
+  "version": "0.6.56",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -96,5 +96,8 @@
     "typebox": "1.3.27",
     "typescript": "^5.7.0",
     "vite": "8.3.2"
+  },
+  "optionalDependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.3.306"
   }
 }

package/src/execution/agent-runner.ts

@@ -9,6 +9,7 @@ import { runPiAgent, spawnPiProcess, type ProcessRunner, type RelayAsk } from ".
 import { ASK_ENV } from "../ask/relay.ts";
 import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
 import { ASK_TOOL } from "../ask/types.ts";
+import type { HarnessRun } from "../schemas/harness.ts";
 
 export interface AgentContext {
   task: string;
@@ -75,6 +76,8 @@ export interface AgentRequest {
   route?: string;
   /** Lets the agent ask the user (ask_user_question, relayed through the master). */
   onAsk?: RelayAsk;
+  /** Run on this third-party harness instead of pi. */
+  harness?: HarnessRun;
 }
 
 /** The watchdog fields of an AgentRequest, taken from the workflow config. */
@@ -190,6 +193,7 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       thinking: request.thinking,
       signal,
       ...(request.onAsk ? { onAsk: request.onAsk } : {}),
+      ...(request.harness ? { harness: request.harness } : {}),
       env: request.onAsk ? { ...request.env, [ASK_ENV]: "1" } : request.env,
       stallTimeoutMs: request.stallTimeoutMs,
       toolStallTimeoutMs: request.toolStallTimeoutMs,

package/src/execution/pi-runner.ts

@@ -13,6 +13,8 @@ import { shortDuration } from "../text.ts";
 import { readRelayRequest } from "../ask/relay.ts";
 import type { AskQuestion, AskResult } from "../ask/types.ts";
 import type { EffortRouter, RunProfileLike } from "../classifier/effort.ts";
+import type { HarnessRun } from "../schemas/harness.ts";
+import { runHarnessAgent } from "../harness/runner.ts";
 
 /** Live control over one running subagent: queue a steering message for its next turn. */
 export interface RunHandle {
@@ -59,6 +61,8 @@ export interface PiRunOptions {
   onStart?: (handle: RunHandle) => void;
   /** Answers the agent's relayed questions; without it they are cancelled like any other dialog. */
   onAsk?: RelayAsk;
+  /** Run on this third-party harness instead of pi (`model` is then ignored for the harness's own). */
+  harness?: HarnessRun;
 }
 
 export interface ProcessOutcome {
@@ -402,10 +406,10 @@ export function isPiLauncher(script: string): boolean {
   return base === "pi" || base === "pi.js" || script.includes("pi-coding-agent");
 }
 
-const POSIX = process.platform !== "win32";
+export const POSIX = process.platform !== "win32";
 
 /** Signal the child's whole process group (POSIX), so grandchildren go too. */
-function signalGroup(proc: ChildProcess, signal: NodeJS.Signals): void {
+export function signalGroup(proc: ChildProcess, signal: NodeJS.Signals): void {
   if (proc.pid === undefined) return;
   if (POSIX) {
     try {
@@ -422,7 +426,7 @@ function signalGroup(proc: ChildProcess, signal: NodeJS.Signals): void {
   }
 }
 
-function terminate(proc: ChildProcess, graceMs = 5000): void {
+export function terminate(proc: ChildProcess, graceMs = 5000): void {
   signalGroup(proc, "SIGTERM");
   const escalation = setTimeout(() => signalGroup(proc, "SIGKILL"), graceMs);
   escalation.unref();
@@ -465,7 +469,7 @@ interface RunState {
 }
 
 /** Smallest positive limit, used to pick a watchdog cadence that can see it. */
-function watchInterval(...limits: Array<number | undefined>): number {
+export function watchInterval(...limits: Array<number | undefined>): number {
   const positive = limits.filter((limit): limit is number => typeof limit === "number" && limit > 0);
   const smallest = positive.length > 0 ? Math.min(...positive) : 4000;
   return Math.max(25, Math.min(1000, Math.floor(smallest / 4)));
@@ -651,6 +655,7 @@ function writePromptFile(prompt: string): { file: string; cleanup: () => void }
 
 /** Run one isolated subagent and normalise its outcome. */
 export async function runPiAgent(given: PiRunOptions, run: ProcessRunner = spawnPiProcess): Promise<PiRunResult> {
+  if (given.harness) return runHarnessAgent({ ...given, harness: given.harness });
   const options = given.autoCompact === false ? { ...given, env: { ...given.env, [AUTO_COMPACT_ENV]: "0" } } : given;
   const host = await delegationHost(options, run);
   let prompt: ReturnType<typeof writePromptFile> | undefined;

package/src/harness/acp.ts

@@ -0,0 +1,272 @@
+/**
+ * Agent Client Protocol (JSON-RPC 2.0 over stdio) for Antigravity, Gemini
+ * CLI, OpenCode and any other ACP agent: initialize, open a session in the
+ * working folder, pick the model and effort through the session's options,
+ * send the task with Bot Lobby's instructions in front, and map the
+ * `session/update` notifications onto pi's stream events. The client offers
+ * no file system or terminal of its own, so the agent uses its own tools,
+ * and its permission requests are answered from the role's allowlist.
+ *
+ * Adapted from T3 Code: the prompt wrapping from
+ * `packages/provider-core/src/server/orchestrationInstructions.ts`, the
+ * permission answers from `apps/server/src/provider/acp/AntigravityProtocol.ts`
+ * (`selectAntigravityPermissionOptionId`, `isAntigravityUserInputRequest`) and
+ * the session option categories from `packages/provider-acp/src/server/sessionConfig.ts`.
+ */
+import { THINKING_LEVELS } from "../schemas/configuration.ts";
+import type { HarnessDriver, HarnessIO } from "./process.ts";
+import type { HarnessAccess, HarnessCollector, HarnessPlan } from "./runner.ts";
+
+export const ACP_PROTOCOL_VERSION = 1;
+
+interface RpcMessage {
+  jsonrpc?: string;
+  id?: number | string;
+  method?: string;
+  params?: Record<string, unknown>;
+  result?: Record<string, unknown> | null;
+  error?: { code?: number; message?: string };
+}
+
+interface PermissionOption {
+  optionId: string;
+  kind?: string;
+  name?: string;
+}
+
+interface ConfigOption {
+  id: string;
+  category?: string;
+  type?: string;
+  options?: Array<{ value?: string; name?: string; options?: Array<{ value?: string; name?: string }> }>;
+}
+
+/** pi's tool names for ACP tool kinds, for the activity line and the edit log. */
+const KIND_TOOLS: Record<string, string> = {
+  read: "read",
+  edit: "edit",
+  delete: "write",
+  move: "write",
+  search: "grep",
+  execute: "bash",
+  fetch: "fetch_content",
+  think: "think",
+};
+
+/** Whether a role may run a tool of this ACP kind. */
+export function acpKindAllowed(kind: string | undefined, access: HarnessAccess): boolean {
+  if (access.writes) return true;
+  switch (kind) {
+    case "read":
+    case "search":
+    case "think":
+      return true;
+    case "fetch":
+      return access.web;
+    case "execute":
+      return access.shell;
+    default:
+      return false;
+  }
+}
+
+/** The option to pick for a permission request, or undefined to cancel it (a question for the user, which nobody can answer here). */
+export function acpPermissionOption(request: { toolCall?: { toolCallId?: string; kind?: string }; options?: PermissionOption[] }, access: HarnessAccess): string | undefined {
+  if (request.toolCall?.toolCallId?.startsWith("interaction_")) return undefined;
+  const allow = acpKindAllowed(request.toolCall?.kind, access);
+  const kinds = allow ? ["allow_once", "allow_always"] : ["reject_once", "reject_always"];
+  for (const kind of kinds) {
+    const option = request.options?.find((entry) => entry.kind === kind && entry.optionId.trim());
+    if (option) return option.optionId;
+  }
+  return undefined;
+}
+
+function choices(option: ConfigOption): Array<{ value: string; name: string }> {
+  return (option.options ?? []).flatMap((entry) => ("options" in entry && Array.isArray(entry.options) ? entry.options : [entry]))
+    .filter((entry): entry is { value: string; name: string } => typeof entry.value === "string")
+    .map((entry) => ({ value: entry.value, name: entry.name ?? entry.value }));
+}
+
+/** The choice whose id or name is the effort level, or the nearest one below it. */
+export function acpEffortChoice(option: ConfigOption, level: string): string | undefined {
+  const list = choices(option);
+  const at = THINKING_LEVELS.indexOf(level as (typeof THINKING_LEVELS)[number]);
+  for (let index = at; index >= 0; index--) {
+    const name = THINKING_LEVELS[index]!;
+    const hit = list.find((choice) => choice.value.toLowerCase() === name || choice.name.toLowerCase() === name);
+    if (hit) return hit.value;
+  }
+  return undefined;
+}
+
+function blockText(content: unknown): string {
+  if (!content || typeof content !== "object") return "";
+  const block = content as { type?: string; text?: string };
+  return block.type === "text" && typeof block.text === "string" ? block.text : "";
+}
+
+function toolArgs(update: Record<string, unknown>): Record<string, unknown> {
+  const raw = (update.rawInput && typeof update.rawInput === "object" ? update.rawInput : {}) as Record<string, unknown>;
+  const locations = Array.isArray(update.locations) ? update.locations as Array<{ path?: string }> : [];
+  const path = locations.find((entry) => typeof entry.path === "string")?.path ?? raw.path ?? raw.file_path ?? raw.filePath;
+  return { ...raw, ...(typeof path === "string" ? { path } : {}), ...(typeof update.title === "string" ? { title: update.title } : {}) };
+}
+
+export function acpDriver(io: HarnessIO, plan: HarnessPlan, prompt: string, collector: HarnessCollector, access: HarnessAccess, cwd: string): HarnessDriver {
+  let nextId = 1;
+  const pending = new Map<number, (message: RpcMessage) => void>();
+  const tools = new Map<string, string>();
+  const steers: string[] = [];
+  let sessionId: string | undefined;
+  let message = "";
+  let thought = "";
+  let prompting = false;
+  let finished = false;
+
+  const request = (method: string, params: Record<string, unknown>, then: (message: RpcMessage) => void) => {
+    const id = nextId++;
+    pending.set(id, then);
+    io.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }));
+  };
+  const notify = (method: string, params: Record<string, unknown>) => io.write(JSON.stringify({ jsonrpc: "2.0", method, params }));
+  const respond = (id: number | string, result: unknown) => io.write(JSON.stringify({ jsonrpc: "2.0", id, result }));
+  const fail = (text: string) => {
+    if (finished) return;
+    finished = true;
+    collector.error = text;
+    io.done();
+  };
+  const flushThought = () => {
+    if (thought.trim()) io.emit({ type: "thought", text: thought.trim().slice(0, 1500) });
+    thought = "";
+  };
+  const send = (text: string) => {
+    prompting = true;
+    message = "";
+    io.emit({ type: "turn_start" });
+    request("session/prompt", { sessionId, prompt: [{ type: "text", text }] }, (reply) => {
+      prompting = false;
+      flushThought();
+      if (message.trim()) collector.text = message;
+      if (reply.error) return fail(reply.error.message ?? "the agent refused the prompt");
+      const usage = reply.result?.usage as { inputTokens?: number; outputTokens?: number } | undefined;
+      if (usage) {
+        collector.addUsage(usage.inputTokens ?? 0, usage.outputTokens ?? 0, 0, plan.model || undefined);
+        io.emit({ type: "usage", input: usage.inputTokens ?? 0, output: usage.outputTokens ?? 0, cost: 0, ...(plan.model ? { model: plan.model } : {}) });
+      }
+      const stop = String(reply.result?.stopReason ?? "end_turn");
+      if (stop === "cancelled") collector.stopReason = "aborted";
+      else if (stop === "refusal") collector.error = "the agent refused the task";
+      // A steering message sent mid-turn goes in as the next prompt.
+      if (stop !== "cancelled" && steers.length > 0) return send(steers.splice(0).join("\n\n"));
+      finished = true;
+      io.done();
+    });
+  };
+  const configure = (result: Record<string, unknown>, then: () => void) => {
+    const steps: Array<(next: () => void) => void> = [];
+    const options = Array.isArray(result.configOptions) ? result.configOptions as ConfigOption[] : [];
+    const modelOption = options.find((option) => option.category === "model");
+    const effortOption = options.find((option) => option.category === "thought_level");
+    if (plan.model && modelOption) steps.push((next) => request("session/set_config_option", { sessionId, configId: modelOption.id, value: plan.model }, next));
+    else if (plan.model && result.models) steps.push((next) => request("session/set_model", { sessionId, modelId: plan.model }, next));
+    const effort = effortOption ? acpEffortChoice(effortOption, plan.level) : undefined;
+    if (effortOption && effort) steps.push((next) => request("session/set_config_option", { sessionId, configId: effortOption.id, value: effort }, next));
+    const run = () => {
+      const step = steps.shift();
+      if (step) step(() => run());
+      else then();
+    };
+    run();
+  };
+  const onUpdate = (update: Record<string, unknown>) => {
+    switch (update.sessionUpdate) {
+      case "agent_message_chunk": {
+        const text = blockText(update.content);
+        if (!text) return;
+        flushThought();
+        if (!message) io.emit({ type: "writing" });
+        message += text;
+        return;
+      }
+      case "agent_thought_chunk": {
+        const text = blockText(update.content);
+        if (!text) return;
+        if (!thought) io.emit({ type: "thinking" });
+        thought += text;
+        return;
+      }
+      case "tool_call": {
+        flushThought();
+        if (message.trim()) collector.text = message;
+        message = "";
+        const id = String(update.toolCallId ?? "");
+        const name = KIND_TOOLS[String(update.kind ?? "")] ?? "tool";
+        if (id && !tools.has(id)) {
+          tools.set(id, name);
+          io.emit({ type: "tool_execution_start", toolName: name, args: toolArgs(update) });
+        }
+        if (update.status === "completed" || update.status === "failed") onUpdate({ ...update, sessionUpdate: "tool_call_update" });
+        return;
+      }
+      case "tool_call_update": {
+        const id = String(update.toolCallId ?? "");
+        const name = tools.get(id);
+        if (!name || (update.status !== "completed" && update.status !== "failed")) return;
+        tools.delete(id);
+        io.emit({ type: "tool_execution_end", toolName: name, isError: update.status === "failed" });
+        return;
+      }
+      case "usage_update": {
+        const cost = (update.cost as { amount?: number } | undefined)?.amount;
+        if (typeof cost === "number" && cost > collector.usage.cost) collector.usage.cost = cost;
+        return;
+      }
+    }
+  };
+  const onRequest = (message: RpcMessage) => {
+    if (message.id === undefined) return;
+    if (message.method === "session/request_permission") {
+      const optionId = acpPermissionOption((message.params ?? {}) as Parameters<typeof acpPermissionOption>[0], access);
+      respond(message.id, { outcome: optionId ? { outcome: "selected", optionId } : { outcome: "cancelled" } });
+      return;
+    }
+    // No file system or terminal was offered; anything else is unknown.
+    io.write(JSON.stringify({ jsonrpc: "2.0", id: message.id, error: { code: -32601, message: `Method not found: ${message.method}` } }));
+  };
+  return {
+    start() {
+      request("initialize", { protocolVersion: ACP_PROTOCOL_VERSION, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }, clientInfo: { name: "bot-lobby", version: "1" } }, (reply) => {
+        if (reply.error) return fail(`the agent did not start: ${reply.error.message ?? "initialize failed"}`);
+        request("session/new", { cwd, mcpServers: [] }, (created) => {
+          if (created.error || typeof created.result?.sessionId !== "string") return fail(`the agent did not open a session: ${created.error?.message ?? "no session id"}${/auth|key|sign|log ?in/i.test(created.error?.message ?? "") ? " (sign in to it once in a terminal)" : ""}`);
+          sessionId = created.result.sessionId;
+          collector.session = sessionId;
+          configure(created.result, () => send(prompt));
+        });
+      });
+    },
+    steer(text) {
+      if (prompting) steers.push(text);
+    },
+    abort() {
+      if (sessionId) notify("session/cancel", { sessionId });
+    },
+    line(text) {
+      let message: RpcMessage;
+      try {
+        message = JSON.parse(text) as RpcMessage;
+      } catch {
+        return;
+      }
+      if (message.method === "session/update") return onUpdate((message.params?.update ?? {}) as Record<string, unknown>);
+      if (message.method) return onRequest(message);
+      if (typeof message.id === "number") {
+        const then = pending.get(message.id);
+        pending.delete(message.id);
+        then?.(message);
+      }
+    },
+  };
+}

package/src/harness/catalog.ts

@@ -0,0 +1,257 @@
+/**
+ * What Bot Lobby knows about each third-party harness: how to start it, which
+ * models it serves and which effort levels each model takes.
+ *
+ * The model list is T3 Code's model manifest
+ * (`apps/server/src/provider/model-manifest.json`), copied as is into
+ * `model-manifest.json` next to this file; the effort descriptors and CLI
+ * effort maps are read the way T3 Code's `ClaudeModelCatalog.ts` reads them.
+ * The Antigravity launch details follow T3 Code's
+ * `antigravityAuthSupport.ts` (`buildAntigravityAcpSpawnInput`).
+ */
+import { readFileSync } from "node:fs";
+import { THINKING_LEVELS, type ThinkingLevelName } from "../schemas/configuration.ts";
+import type { HarnessId, HarnessProtocol, HarnessSettings } from "../schemas/harness.ts";
+import { tokenizeCliArgs } from "./cli-args.ts";
+
+export interface HarnessInfo {
+  id: HarnessId;
+  label: string;
+  protocol: HarnessProtocol;
+  /** The command when the settings name no binary; empty when the user must give one. */
+  command: string;
+  /** Arguments that put the command into the mode Bot Lobby speaks (ACP), before the user's launch arguments. */
+  args: readonly string[];
+  /** The environment variable the home path setting sets. */
+  homeEnv?: string;
+  /** Model providers the settings offer (`value` "" keeps the harness's own). */
+  providers: ReadonlyArray<{ value: string; label: string }>;
+  /** Where the effort level goes: a CLI flag, the model variant (Antigravity) or the agent's own session option (ACP). */
+  effort: "flag" | "variant" | "session";
+  /** One line for the settings page. */
+  blurb: string;
+}
+
+const WINDOWS = process.platform === "win32";
+
+export const HARNESSES: Record<HarnessId, HarnessInfo> = {
+  codex: {
+    id: "codex",
+    label: "Codex CLI",
+    protocol: "codex-exec",
+    command: "codex",
+    args: [],
+    homeEnv: "CODEX_HOME",
+    providers: [
+      { value: "", label: "Codex's own" },
+      { value: "openai", label: "OpenAI" },
+      { value: "ollama", label: "Ollama (local)" },
+      { value: "lmstudio", label: "LM Studio (local)" },
+    ],
+    effort: "flag",
+    blurb: "OpenAI's coding agent, run headless with codex exec.",
+  },
+  claude: {
+    id: "claude",
+    label: "Claude Code",
+    protocol: "claude-stream",
+    command: "claude",
+    args: [],
+    homeEnv: "CLAUDE_CONFIG_DIR",
+    providers: [
+      { value: "", label: "Anthropic" },
+      { value: "bedrock", label: "Amazon Bedrock" },
+      { value: "vertex", label: "Google Vertex AI" },
+    ],
+    effort: "flag",
+    blurb: "Anthropic's coding agent, driven through the Claude Agent SDK.",
+  },
+  antigravity: {
+    id: "antigravity",
+    label: "Antigravity",
+    protocol: "acp",
+    command: WINDOWS ? "agy_acp_server.exe" : "agy_acp_server.par",
+    args: process.platform === "linux" ? ["--uid="] : [],
+    providers: [],
+    effort: "variant",
+    blurb: "Google's Antigravity agent through its ACP server, signed in with your Antigravity account.",
+  },
+  gemini: {
+    id: "gemini",
+    label: "Gemini CLI",
+    protocol: "acp",
+    command: "gemini",
+    args: ["--acp"],
+    providers: [],
+    effort: "session",
+    blurb: "Google's Gemini CLI in ACP mode.",
+  },
+  opencode: {
+    id: "opencode",
+    label: "OpenCode",
+    protocol: "acp",
+    command: "opencode",
+    args: ["acp"],
+    providers: [],
+    effort: "session",
+    blurb: "OpenCode in ACP mode; models are named provider/model.",
+  },
+  acp: {
+    id: "acp",
+    label: "Custom ACP agent",
+    protocol: "acp",
+    command: "",
+    args: [],
+    providers: [],
+    effort: "session",
+    blurb: "Any agent that speaks the Agent Client Protocol: give its command and arguments.",
+  },
+};
+
+/** The command and arguments one run starts, with the user's launch arguments last. */
+export function harnessCommand(id: HarnessId, settings: HarnessSettings): { command: string; args: string[] } {
+  const info = HARNESSES[id];
+  return { command: settings.binaryPath || info.command, args: [...info.args, ...tokenizeCliArgs(settings.launchArgs)] };
+}
+
+export interface HarnessModel {
+  id: string;
+  label: string;
+  /** False for the manifest's older models, listed after the current ones. */
+  current: boolean;
+  /** Effort levels (pi's names) the model takes; empty when the harness picks its own. */
+  efforts: ThinkingLevelName[];
+  /** The level the harness uses when none is chosen. */
+  defaultEffort?: ThinkingLevelName;
+  custom?: boolean;
+}
+
+interface ManifestModel {
+  slug: string;
+  name: string;
+  status?: string;
+  profile?: string;
+}
+
+interface ManifestOption {
+  id: string;
+  type?: string;
+  options?: Array<{ id: string; isDefault?: boolean }>;
+}
+
+interface ManifestProfile {
+  capabilities?: { optionDescriptors?: ManifestOption[] };
+  adapter?: { claudeCode?: { effortMap?: Record<string, string | null> } };
+}
+
+interface Manifest {
+  providers: Record<string, { models: ManifestModel[]; profiles?: Record<string, ManifestProfile> }>;
+}
+
+let manifest: Manifest | undefined;
+
+function readManifest(): Manifest {
+  manifest ??= JSON.parse(readFileSync(new URL("./model-manifest.json", import.meta.url), "utf8")) as Manifest;
+  return manifest;
+}
+
+const MANIFEST_KEYS: Partial<Record<HarnessId, string>> = { codex: "codex", claude: "claudeAgent", antigravity: "antigravity" };
+
+/** Codex's reasoning efforts, as T3 Code's `CodexProvider.ts` labels them. */
+const CODEX_EFFORTS: ThinkingLevelName[] = ["minimal", "low", "medium", "high", "xhigh"];
+
+const isLevel = (value: string): value is ThinkingLevelName => (THINKING_LEVELS as readonly string[]).includes(value);
+
+function claudeEfforts(profile: ManifestProfile | undefined): { efforts: ThinkingLevelName[]; defaultEffort?: ThinkingLevelName } {
+  const option = profile?.capabilities?.optionDescriptors?.find((entry) => entry.id === "effort");
+  if (!option?.options) return { efforts: [] };
+  const map = profile?.adapter?.claudeCode?.effortMap ?? {};
+  const efforts = option.options.map((entry) => entry.id).filter((id): id is ThinkingLevelName => isLevel(id) && map[id] !== null);
+  const fallback = option.options.find((entry) => entry.isDefault)?.id;
+  return { efforts, ...(fallback && isLevel(fallback) ? { defaultEffort: fallback } : {}) };
+}
+
+/** Antigravity sells one model per effort (`…-flash-high`); the settings show one model with an effort slider. */
+const VARIANT = /^(.*)-(low|medium|high)$/;
+const VARIANT_LABEL = / \((Low|Medium|High)\)$/;
+
+function antigravityModels(models: ManifestModel[]): HarnessModel[] {
+  const families = new Map<string, HarnessModel>();
+  const out: HarnessModel[] = [];
+  for (const model of models) {
+    const match = VARIANT.exec(model.slug);
+    if (!match) {
+      out.push({ id: model.slug, label: model.name, current: model.status === "current", efforts: [] });
+      continue;
+    }
+    const [, base, level] = match as unknown as [string, string, ThinkingLevelName];
+    let family = families.get(base);
+    if (!family) {
+      family = { id: base, label: model.name.replace(VARIANT_LABEL, ""), current: model.status === "current", efforts: [], defaultEffort: "high" };
+      families.set(base, family);
+      out.push(family);
+    }
+    family.efforts.push(level);
+  }
+  for (const family of families.values()) family.efforts.sort((a, b) => THINKING_LEVELS.indexOf(a) - THINKING_LEVELS.indexOf(b));
+  return out;
+}
+
+/** The models a harness offers: the manifest's current ones, its older ones, then the ones typed into settings. */
+export function harnessModels(id: HarnessId, settings: HarnessSettings): HarnessModel[] {
+  const key = MANIFEST_KEYS[id];
+  const entry = key ? readManifest().providers[key] : undefined;
+  let models: HarnessModel[] = [];
+  if (entry && id === "antigravity") models = antigravityModels(entry.models);
+  else if (entry) {
+    models = entry.models.map((model) => {
+      const efforts = id === "codex" ? { efforts: CODEX_EFFORTS, defaultEffort: "medium" as const } : claudeEfforts(model.profile ? entry.profiles?.[model.profile] : undefined);
+      return { id: model.slug, label: model.name, current: model.status === "current", ...efforts };
+    });
+  }
+  models.sort((a, b) => Number(b.current) - Number(a.current));
+  const known = new Set(models.map((model) => model.id));
+  const fallbackEfforts = id === "codex" ? CODEX_EFFORTS : id === "claude" ? (["low", "medium", "high", "xhigh", "max"] as ThinkingLevelName[]) : [];
+  for (const custom of settings.customModels) {
+    if (!known.has(custom)) models.push({ id: custom, label: custom, current: true, efforts: fallbackEfforts, custom: true });
+  }
+  return models;
+}
+
+/** The nearest level at or below `level` that `efforts` holds, else the lowest one above it. */
+export function nearestEffort(efforts: readonly ThinkingLevelName[], level: string): ThinkingLevelName | undefined {
+  if (efforts.length === 0) return undefined;
+  const at = THINKING_LEVELS.indexOf(isLevel(level) ? level : "medium");
+  const below = efforts.filter((effort) => THINKING_LEVELS.indexOf(effort) <= at);
+  return below.length > 0 ? below[below.length - 1] : efforts[0];
+}
+
+/**
+ * What the harness is told for an agent's effort: Codex's `model_reasoning_effort`,
+ * Claude Code's `--effort` (through the model's effort map) or Antigravity's
+ * model variant. Undefined leaves it to the harness (and to ACP session options).
+ */
+export function harnessEffort(id: HarnessId, settings: HarnessSettings, model: string, level: string): string | undefined {
+  const info = HARNESSES[id];
+  if (info.effort === "session") return undefined;
+  const known = harnessModels(id, settings).find((entry) => entry.id === model);
+  if (id === "codex") return nearestEffort(known?.efforts.length ? known.efforts : CODEX_EFFORTS, level);
+  if (id === "claude") {
+    const efforts = known?.efforts.length ? known.efforts : (["low", "medium", "high", "xhigh", "max"] as ThinkingLevelName[]);
+    const chosen = nearestEffort(efforts, level);
+    if (!chosen) return undefined;
+    const key = MANIFEST_KEYS.claude!;
+    const manifestModel = readManifest().providers[key]?.models.find((entry) => entry.slug === model);
+    const profile = manifestModel?.profile ? readManifest().providers[key]?.profiles?.[manifestModel.profile] : undefined;
+    const mapped = profile?.adapter?.claudeCode?.effortMap?.[chosen];
+    return typeof mapped === "string" ? mapped : chosen;
+  }
+  return known?.efforts.length ? nearestEffort(known.efforts, level) : undefined;
+}
+
+/** The model id a run passes to the harness: Antigravity's variant slug carries the effort. */
+export function harnessModelId(id: HarnessId, settings: HarnessSettings, model: string, level: string): string {
+  if (!model || HARNESSES[id].effort !== "variant") return model;
+  const effort = harnessEffort(id, settings, model, level);
+  return effort ? `${model}-${effort}` : model;
+}