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

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.57",
   "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;
@@ -48,6 +49,8 @@ export interface AgentRequest {
   mcpTools?: string[];
   /** False when the agent's settings turn its auto-compaction off. */
   autoCompact?: boolean;
+  /** Tokens at which this agent compacts, when its settings set it. */
+  compactAt?: number;
   delegationQuota?: { used: number; consults?: number };
   /** See PiRunOptions.expert. */
   expert?: { model?: string; thinking: string };
@@ -75,6 +78,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. */
@@ -183,6 +188,7 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
       mcpTools: request.mcpTools,
       ...(request.skills ? { skills: request.skills } : {}),
       ...(request.autoCompact === false ? { autoCompact: false } : {}),
+      ...(request.compactAt ? { compactAt: request.compactAt } : {}),
       task: request.instruction,
       systemPrompt,
       tools: toolsFor(request),
@@ -190,6 +196,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/delegation.ts

@@ -16,6 +16,7 @@ import { runPiAgent, type PiRunOptions, type ProcessRunner } from "./pi-runner.t
 import { startDeskServer } from "../desk/ipc.ts";
 import { DESK_ENV, DeskSession, deskSessionAt, PEER_TOOLS } from "../desk/session.ts";
 import { BOARD_ENV } from "../desk/board.ts";
+import { mcpGrant } from "../pi/grants.ts";
 
 export const MAX_CHILDREN = 5;
 export const DELEGATE_TOOL = "delegate_subtasks";
@@ -95,7 +96,8 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   const quota = options.delegationQuota ?? { used: 0 };
   const consults = canConsult(agent, config.workflow.consultExpert);
   const tools = [...new Set([...baseTools, "codemode", "tool_search", ...(canDelegate(agent, quota.used) ? [DELEGATE_TOOL] : []), ...(consults ? [EXPERT_TOOL] : [])])];
-  const mcpTools = options.mcpTools ?? agentProfile(config, agent.domain, agent.role).mcpTools ?? [];
+  // A caller that passes its profile's grant (even an absent one, meaning every connected tool) wins over the role's.
+  const mcpTools = mcpGrant("mcpTools" in options ? options.mcpTools : agentProfile(config, agent.domain, agent.role).mcpTools, !editable);
   const policy: AgentPolicy = { tools, mcpTools, readOnly: !editable, depth };
   if (depth > 1) return { tools, mcpTools, env: { ...options.env, [AGENT_ENV]: JSON.stringify(policy), [DELEGATION_ENV]: "" }, note: options.env?.[EXPERT_ENV] ? "You are advising a worker: read what you need, answer its question, and change nothing." : "You are a child agent. Finish only your assigned brief and report evidence to your parent; you cannot delegate further.", close: async () => {}, onStart: options.onStart, children: [] as AgentRun[] };
 

package/src/execution/pi-runner.ts

@@ -1,7 +1,7 @@
 import type { AgentRun } from "../schemas/findings.ts";
 import type { Domain, Role } from "../schemas/agent.ts";
 import { delegationHost } from "./delegation.ts";
-import { AUTO_COMPACT_ENV } from "../pi/quiet.ts";
+import { AUTO_COMPACT_ENV, COMPACT_AT_ENV } from "../pi/quiet.ts";
 import { fileURLToPath } from "node:url";
 import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -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 {
@@ -51,6 +53,8 @@ export interface PiRunOptions {
   env?: Record<string, string>;
   /** False when the agent's settings turn its auto-compaction off. */
   autoCompact?: boolean;
+  /** Tokens at which the agent compacts its context; absent uses the built-in threshold. */
+  compactAt?: number;
   /** Kill the agent after this long without any output; 0 disables. */
   stallTimeoutMs?: number;
   /** Silence allowed while one tool call is in flight (tests, builds); 0 disables. */
@@ -59,6 +63,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 +408,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 +428,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 +471,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,7 +657,9 @@ 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> {
-  const options = given.autoCompact === false ? { ...given, env: { ...given.env, [AUTO_COMPACT_ENV]: "0" } } : given;
+  if (given.harness) return runHarnessAgent({ ...given, harness: given.harness });
+  const compactEnv = { ...(given.autoCompact === false ? { [AUTO_COMPACT_ENV]: "0" } : {}), ...(given.compactAt ? { [COMPACT_AT_ENV]: String(given.compactAt) } : {}) };
+  const options = Object.keys(compactEnv).length ? { ...given, env: { ...given.env, ...compactEnv } } : given;
   const host = await delegationHost(options, run);
   let prompt: ReturnType<typeof writePromptFile> | undefined;
   try {

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);
+      }
+    },
+  };
+}