@vellumai/assistant 0.6.6 → 0.7.1

package/src/cli.ts

@@ -18,10 +18,7 @@ import {
   updateStatusText,
 } from "./cli/main-screen.jsx";
 import { renderHistoryContent } from "./daemon/handlers/shared.js";
-import type {
-  ConfirmationRequest,
-  ServerMessage,
-} from "./daemon/message-protocol.js";
+import type { ServerMessage } from "./daemon/message-protocol.js";
 import { getConversation, getMessages } from "./memory/conversation-crud.js";
 import {
   getConversationByKey,
@@ -59,63 +56,6 @@ export function sanitizeUrlForDisplay(rawUrl: unknown): string {
   }
 }
 
-function stringifyConfirmationInputValue(value: unknown): string {
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean")
-    return String(value);
-  if (value == null) return "null";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return String(value);
-  }
-}
-
-export function formatConfirmationInputLines(
-  input: Record<string, unknown>,
-): string[] {
-  const lines: string[] = [];
-  for (const key of Object.keys(input).sort()) {
-    const rawValue = input[key];
-    const value =
-      key.toLowerCase().includes("url") && typeof rawValue === "string"
-        ? sanitizeUrlForDisplay(rawValue)
-        : rawValue;
-    const rendered = stringifyConfirmationInputValue(value);
-    const renderedLines = rendered.split("\n");
-    if (renderedLines.length === 0) {
-      lines.push(`${key}:`);
-      continue;
-    }
-    lines.push(`${key}: ${renderedLines[0]}`);
-    for (const continuation of renderedLines.slice(1)) {
-      lines.push(`  ${continuation}`);
-    }
-  }
-  return lines;
-}
-
-export function formatConfirmationCommandPreview(
-  req: Pick<ConfirmationRequest, "toolName" | "input">,
-): string {
-  if (req.toolName === "bash" || req.toolName === "host_bash") {
-    return String(req.input.command ?? "");
-  }
-  if (req.toolName === "file_read" || req.toolName === "host_file_read") {
-    return `read ${req.input.path ?? ""}`;
-  }
-  if (req.toolName === "file_write" || req.toolName === "host_file_write") {
-    return `write ${req.input.path ?? ""}`;
-  }
-  if (req.toolName === "file_edit" || req.toolName === "host_file_edit") {
-    return `edit ${req.input.path ?? ""}`;
-  }
-  if (req.toolName === "web_fetch") {
-    return `fetch ${sanitizeUrlForDisplay(req.input.url ?? "")}`;
-  }
-  return req.toolName;
-}
-
 export async function startCli(): Promise<void> {
   let conversationKey = CLI_CONVERSATION_KEY;
   let conversationId = "";
@@ -558,27 +498,6 @@ export async function startCli(): Promise<void> {
         prompt();
         break;
 
-      case "secret_detected": {
-        const wasSpinning = spinner.isSpinning;
-        spinner.stop();
-        const types = msg.matches.map((m) => m.type).join(", ");
-        const actionLabel =
-          msg.action === "redact"
-            ? "redacted"
-            : msg.action === "block"
-              ? "blocked"
-              : "detected";
-        process.stdout.write(
-          `\n  ⚠ Secret ${actionLabel} in ${msg.toolName} output: ${types}\n`,
-        );
-        for (const match of msg.matches) {
-          process.stdout.write(`    • ${match.type}: ${match.redactedValue}\n`);
-        }
-        process.stdout.write("\n");
-        if (wasSpinning) spinner.start("Thinking...");
-        break;
-      }
-
       case "conversation_list_response":
         if (pendingSessionPick) {
           renderConversationPicker(msg.conversations);

package/src/config/__tests__/feature-flag-registry-guard.test.ts

@@ -31,7 +31,7 @@ function loadRegistry(): Record<string, unknown> {
   return JSON.parse(raw);
 }
 
-const VALID_SCOPES = new Set(["assistant", "macos"]);
+const VALID_SCOPES = new Set(["assistant", "client"]);
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -169,7 +169,7 @@ describe("unified feature flag registry guard", () => {
       const scope = flag.scope as string;
       if (!VALID_SCOPES.has(scope)) {
         violations.push(
-          `flag '${flag.id}' has invalid scope '${scope}' (expected 'assistant' or 'macos')`,
+          `flag '${flag.id}' has invalid scope '${scope}' (expected 'assistant' or 'client')`,
         );
       }
     }

package/src/config/acp-defaults.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_ACP_AGENT_PROFILES,
+  DEFAULT_AGENT_NPM_PACKAGES,
+} from "./acp-defaults.js";
+
+describe("DEFAULT_ACP_AGENT_PROFILES", () => {
+  test("ships exactly the expected agent ids", () => {
+    expect(Object.keys(DEFAULT_ACP_AGENT_PROFILES).sort()).toEqual([
+      "claude",
+      "codex",
+    ]);
+  });
+
+  test("claude profile uses the @agentclientprotocol adapter binary", () => {
+    expect(DEFAULT_ACP_AGENT_PROFILES.claude).toEqual({
+      command: "claude-agent-acp",
+      args: [],
+      description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
+    });
+  });
+
+  test("codex profile uses the @zed-industries adapter binary", () => {
+    expect(DEFAULT_ACP_AGENT_PROFILES.codex).toEqual({
+      command: "codex-acp",
+      args: [],
+      description: "OpenAI Codex CLI (via @zed-industries/codex-acp)",
+    });
+  });
+
+  test("is frozen at runtime so mutation throws in strict mode", () => {
+    expect(Object.isFrozen(DEFAULT_ACP_AGENT_PROFILES)).toBe(true);
+    for (const profile of Object.values(DEFAULT_ACP_AGENT_PROFILES)) {
+      expect(Object.isFrozen(profile)).toBe(true);
+    }
+  });
+});
+
+describe("DEFAULT_AGENT_NPM_PACKAGES", () => {
+  test("is keyed by command name with the canonical npm package", () => {
+    expect(DEFAULT_AGENT_NPM_PACKAGES).toEqual({
+      "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
+      "codex-acp": "@zed-industries/codex-acp",
+    });
+  });
+
+  test("every default profile's command has a matching npm package", () => {
+    for (const profile of Object.values(DEFAULT_ACP_AGENT_PROFILES)) {
+      expect(DEFAULT_AGENT_NPM_PACKAGES[profile.command]).toBeDefined();
+    }
+  });
+
+  test("is frozen at runtime so mutation throws in strict mode", () => {
+    expect(Object.isFrozen(DEFAULT_AGENT_NPM_PACKAGES)).toBe(true);
+  });
+});

package/src/config/acp-defaults.ts

@@ -0,0 +1,40 @@
+import type { AcpAgentConfig } from "./acp-schema.js";
+
+/**
+ * Default ACP agent profiles that ship with the assistant.
+ *
+ * When `acp.enabled: true` and the user has not provided a config entry for an
+ * agent id, the resolver falls back to this map so common agents like `claude`
+ * and `codex` Just Work without requiring per-user config.
+ *
+ * Keyed by agent id. Frozen so accidental runtime mutation throws in strict
+ * mode and the readonly type matches actual runtime behavior.
+ */
+export const DEFAULT_ACP_AGENT_PROFILES: Readonly<
+  Record<string, AcpAgentConfig>
+> = Object.freeze({
+  claude: Object.freeze({
+    command: "claude-agent-acp",
+    args: [],
+    description: "Claude Code (via @agentclientprotocol/claude-agent-acp)",
+  }),
+  codex: Object.freeze({
+    command: "codex-acp",
+    args: [],
+    description: "OpenAI Codex CLI (via @zed-industries/codex-acp)",
+  }),
+});
+
+/**
+ * Single source of truth for adapter binary → npm package name. Both the
+ * version-check probe in `acp_spawn` and the resolver's install-hint format
+ * key off this map, so a new adapter only needs one entry here.
+ *
+ * Keyed by command name (not agent id) so the mapping follows the binary
+ * regardless of how a user's config aliases an agent.
+ */
+export const DEFAULT_AGENT_NPM_PACKAGES: Readonly<Record<string, string>> =
+  Object.freeze({
+    "claude-agent-acp": "@agentclientprotocol/claude-agent-acp",
+    "codex-acp": "@zed-industries/codex-acp",
+  });

package/src/config/acp-schema.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 
-export const AcpAgentConfigSchema = z
+const AcpAgentConfigSchema = z
   .object({
     command: z.string().describe("Command to spawn the ACP agent process"),
     args: z

package/src/config/assistant-feature-flags.ts

@@ -5,12 +5,9 @@
  * `meta/feature-flags/feature-flag-registry.json` and resolves the effective
  * enabled/disabled state for each declared assistant-scope flag by consulting
  * (in priority order):
- *   1. Override values from the gateway IPC socket (or local file fallback)
- *   2. Remote values from `feature-flags-remote.json` (platform-pushed,
- *      cached locally; only used in local mode — containerized mode gets
- *      remote values via the gateway)
- *   3. defaults registry `defaultEnabled`         (for declared keys)
- *   4. `true`                                     (for undeclared keys)
+ *   1. Override values from the gateway IPC socket
+ *   2. defaults registry `defaultEnabled`         (for declared keys)
+ *   3. `true`                                     (for undeclared keys)
  *
  * Key format:
  *   Canonical:  simple kebab-case string (e.g., "browser", "ces-tools")
@@ -20,7 +17,6 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 import { ipcGetFeatureFlags } from "../ipc/gateway-client.js";
-import { getProtectedDir } from "../util/platform.js";
 import type { AssistantConfig } from "./schema.js";
 
 // ---------------------------------------------------------------------------
@@ -128,59 +124,6 @@ let cachedOverrides: Record<string, boolean> | null = null;
  */
 let cachedOverridesFromGateway = false;
 
-/**
- * File format for the local feature-flags.json override file, matching the
- * gateway's feature-flag-store.ts schema.
- */
-interface FeatureFlagFileData {
-  version: 1;
-  values: Record<string, boolean>;
-}
-
-/**
- * Resolve the path to the feature flag overrides file.
- *
- * Docker: `GATEWAY_SECURITY_DIR/feature-flags.json`
- * Local:  `<protectedDir>/feature-flags.json` — resolved via `getProtectedDir()`
- *         so it honors `BASE_DATA_DIR` for per-instance setups.
- */
-function getFeatureFlagOverridesPath(): string {
-  const securityDir = process.env.GATEWAY_SECURITY_DIR;
-  if (securityDir) {
-    return join(securityDir, "feature-flags.json");
-  }
-  return join(getProtectedDir(), "feature-flags.json");
-}
-
-/**
- * Load override values from the local feature-flags.json file.
- * Returns an empty record if the file doesn't exist or is malformed.
- */
-function loadOverridesFromFile(): Record<string, boolean> {
-  const path = getFeatureFlagOverridesPath();
-  if (!existsSync(path)) return {};
-
-  try {
-    const raw = readFileSync(path, "utf-8");
-    const data = JSON.parse(raw) as FeatureFlagFileData;
-    if (data.version !== 1) return {};
-    if (
-      data.values &&
-      typeof data.values === "object" &&
-      !Array.isArray(data.values)
-    ) {
-      const filtered: Record<string, boolean> = {};
-      for (const [k, v] of Object.entries(data.values)) {
-        if (typeof v === "boolean") filtered[k] = v;
-      }
-      return filtered;
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-
 /**
  * Fetch override values from the gateway via IPC (Unix domain socket).
  *
@@ -205,9 +148,8 @@ async function fetchOverridesFromGateway(): Promise<Record<string, boolean>> {
  * uses the gateway. In local mode, falls back to the local file when
  * the gateway is unreachable.
  *
- * On failure, the cache is left unset so subsequent sync calls fall
- * through to the file-based fallback rather than caching an empty map
- * that masks all overrides for the process lifetime.
+ * On failure, the cache is left unset so subsequent sync calls return an
+ * empty override map (registry defaults only).
  *
  * No-ops when the cache is already populated — callers that want to
  * refresh must call `clearFeatureFlagOverridesCache()` first. This lets
@@ -224,23 +166,18 @@ export async function initFeatureFlagOverrides(): Promise<void> {
     return;
   }
 
-  // Gateway returned empty or failed. If the cache was populated from the
-  // file fallback, leave it in place for the next sync read. Otherwise leave
-  // unset so `loadOverrides()` falls through to file on first sync read.
+  // Gateway returned empty or failed — leave cache unset so loadOverrides()
+  // returns an empty map on subsequent sync reads.
 }
 
 /**
  * Read cached overrides synchronously.
  *
- * If `initFeatureFlagOverrides()` was called at startup, this returns the
- * pre-populated cache. Otherwise falls back to the local file — this
- * ensures the resolver never blocks on a network call.
+ * Returns the gateway-populated cache if `initFeatureFlagOverrides()` was
+ * called at startup, or an empty record otherwise.
  */
 function loadOverrides(): Record<string, boolean> {
-  if (cachedOverrides != null) return cachedOverrides;
-
-  cachedOverrides = loadOverridesFromFile();
-  return cachedOverrides;
+  return cachedOverrides ?? {};
 }
 
 // ---------------------------------------------------------------------------
@@ -253,47 +190,15 @@ function loadOverrides(): Record<string, boolean> {
  */
 let cachedRemoteValues: Record<string, boolean> | null = null;
 
-/**
- * Load remote flag values from the `feature-flags-remote.json` file that
- * lives alongside the local overrides file. Returns an empty record if the
- * file doesn't exist or is malformed.
- *
- * In containerized mode, this file won't exist — the gateway already merges
- * remote values into its response — so we'll harmlessly return `{}`.
- */
-function loadRemoteValuesFromFile(): Record<string, boolean> {
-  const overridesPath = getFeatureFlagOverridesPath();
-  const remotePath = join(dirname(overridesPath), "feature-flags-remote.json");
-  if (!existsSync(remotePath)) return {};
-
-  try {
-    const raw = readFileSync(remotePath, "utf-8");
-    const data = JSON.parse(raw) as FeatureFlagFileData;
-    if (data.version !== 1) return {};
-    if (
-      data.values &&
-      typeof data.values === "object" &&
-      !Array.isArray(data.values)
-    ) {
-      const filtered: Record<string, boolean> = {};
-      for (const [k, v] of Object.entries(data.values)) {
-        if (typeof v === "boolean") filtered[k] = v;
-      }
-      return filtered;
-    }
-    return {};
-  } catch {
-    return {};
-  }
-}
-
 /**
  * Load remote values with module-level caching.
+ *
+ * Remote values are now always included in the gateway IPC response (merged
+ * server-side), so this only returns the injected test cache. In production,
+ * remote values flow through the overrides cache.
  */
 function loadRemoteValues(): Record<string, boolean> {
-  if (cachedRemoteValues != null) return cachedRemoteValues;
-  cachedRemoteValues = loadRemoteValuesFromFile();
-  return cachedRemoteValues;
+  return cachedRemoteValues ?? {};
 }
 
 /**
@@ -338,11 +243,9 @@ export function _setOverridesForTesting(
  * Resolve whether an assistant feature flag is enabled.
  *
  * Resolution order:
- *   1. Override from gateway IPC socket (or local file fallback)
- *   2. Remote value from `feature-flags-remote.json` (platform-pushed,
- *      cached locally)
- *   3. defaults registry `defaultEnabled`         (for declared assistant-scope keys)
- *   4. `true`                                     (for undeclared keys with no override)
+ *   1. Override from gateway IPC socket
+ *   2. defaults registry `defaultEnabled`         (for declared assistant-scope keys)
+ *   3. `true`                                     (for undeclared keys with no override)
  */
 export function isAssistantFeatureFlagEnabled(
   key: string,
@@ -367,30 +270,3 @@ export function isAssistantFeatureFlagEnabled(
   // 4. Undeclared keys with no persisted override default to enabled
   return true;
 }
-
-/**
- * Return the loaded defaults registry (for introspection/tooling).
- */
-export function getAssistantFeatureFlagDefaults(): FeatureFlagDefaultsRegistry {
-  return loadDefaultsRegistry();
-}
-
-// ---------------------------------------------------------------------------
-// Named flag helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Canonical key for the `home-feed` flag — gates the activity feed section on
- * the macOS Home page (nudges, digests, actions, threads). Requires the
- * `home-tab` flag to also be enabled. Declared in
- * `meta/feature-flags/feature-flag-registry.json` with scope `macos`.
- */
-export const HOME_FEED_FLAG = "home-feed";
-
-/**
- * Resolve whether the `home-feed` flag is enabled for the current assistant
- * config. Wraps `isAssistantFeatureFlagEnabled` with the canonical key.
- */
-export function isHomeFeedEnabled(config: AssistantConfig): boolean {
-  return isAssistantFeatureFlagEnabled(HOME_FEED_FLAG, config);
-}

package/src/config/bundled-skills/acp/SKILL.md

@@ -8,7 +8,7 @@ metadata:
     display-name: "ACP"
 ---
 
-ACP agent orchestration - spawn external coding agents (Claude Code, Codex, Gemini CLI, etc.) to work on tasks via the Agent Client Protocol.
+ACP agent orchestration - spawn external coding agents (Claude Code, Codex, etc.) to work on tasks via the Agent Client Protocol. Each agent runs as its own subprocess speaking ACP over stdio and streams results back into the conversation.
 
 ## Usage
 
@@ -20,22 +20,15 @@ When the user first tries to use ACP and it's not configured, set it up automati
 
 1. **Check if `claude-agent-acp` is installed** by running `which claude-agent-acp`. If not found, install it:
    ```bash
-   npm install -g @zed-industries/claude-agent-acp
+   npm i -g @agentclientprotocol/claude-agent-acp
    ```
 
-2. **Enable ACP in the workspace config** by editing the config file to add the `acp` section. The correct config is:
+2. **Enable ACP in the workspace config** by editing the config file to add the `acp` section. Default profiles for `claude` and `codex` ship out-of-box, so the minimal config is just:
    ```json
    {
      "acp": {
        "enabled": true,
-       "maxConcurrentSessions": 4,
-       "agents": {
-         "claude": {
-           "command": "claude-agent-acp",
-           "args": [],
-           "description": "Claude Code (via ACP adapter)"
-         }
-       }
+       "maxConcurrentSessions": 4
      }
    }
    ```
@@ -44,22 +37,57 @@ When the user first tries to use ACP and it's not configured, set it up automati
 
 4. Then retry the `acp_spawn` call. Do NOT run `vellum sleep && vellum wake` - that kills the conversation.
 
+## Codex setup
+
+To use Codex via ACP, both the `codex-acp` adapter and the underlying `codex` CLI must be on PATH:
+
+1. **Install the ACP adapter:**
+   ```bash
+   npm i -g @zed-industries/codex-acp
+   ```
+   This provides the `codex-acp` binary that the assistant spawns.
+
+2. **Install the Codex CLI** (version 0.111 or higher) via OpenAI's distribution channel of choice. The `codex-acp` adapter shells out to `codex` under the hood and will fail if it isn't on PATH.
+
+3. **Authenticate.** The `codex-acp` adapter inherits whatever auth the underlying `codex` CLI uses. Typical flows:
+   - `codex login` (OAuth)
+   - `CODEX_API_KEY` environment variable
+   - `OPENAI_API_KEY` environment variable
+
+If `codex-acp` isn't on PATH when the user asks for it, the assistant will surface the install hint via `acp_list_agents`.
+
 ## Critical: correct agent command
 
-- The command MUST be `claude-agent-acp` - this is the ACP adapter from `@zed-industries/claude-agent-acp`.
-- NEVER use `claude`, `claude -p`, `claude --acp`, or any other command. Only `claude-agent-acp` speaks the ACP JSON-RPC protocol.
-- NEVER change an existing ACP config to use a different command. If the config already has `claude-agent-acp`, leave it alone.
+- `claude-agent-acp` and `codex-acp` are the two supported adapter binaries today. They are what speak the ACP JSON-RPC protocol.
+- NEVER use `claude`, `claude -p`, `claude --acp`, the bare `codex` CLI, or any other command as the ACP `command`. Only the dedicated `*-acp` adapters speak the protocol.
+- Default profiles for `claude` and `codex` ship out-of-box. Users only need an `agents.<id>` entry in config if they want to override the defaults (e.g. point to a custom binary path or pass extra args).
+- NEVER change an existing ACP config to use a different command. If the config already has `claude-agent-acp` or `codex-acp`, leave it alone.
 
 ## Updating the adapter
 
-If `acp_spawn` reports that `claude-agent-acp` is outdated, ask the user before updating. To update:
+If `acp_spawn` reports that an adapter is outdated, ask the user before updating. To update:
 
 ```bash
-npm install -g @zed-industries/claude-agent-acp@latest
+npm i -g @agentclientprotocol/claude-agent-acp@latest
+# or
+npm i -g @zed-industries/codex-acp@latest
 ```
 
 Then retry the `acp_spawn` call.
 
+## When to use acp_steer vs acp_spawn
+
+- **`acp_steer` interrupts the in-flight prompt.** Use it to course-correct a running agent ("stop, do X instead"). It cancels whatever the agent is currently working on and replaces it with the new instruction.
+- **For follow-ups after the current task** ("also do Y when you're done"), do NOT use `acp_steer`. Wait for the `acp_session_completed` notification and call `acp_spawn` again with the new task. Queued follow-ups in the same session are not yet supported.
+
+## Discoverability
+
+Use `acp_list_agents` to see what's set up and what's missing. It returns each available agent profile, whether ACP is enabled, whether the agent's binary is on PATH, and an install hint if not. This is the right tool to call when deciding between `claude` and `codex`, or when the user asks "what coding agents do I have?"
+
+## Working directory
+
+Default to the conversation's current working directory when spawning an agent. For risky changes or parallel work where you don't want the agent touching the same checkout the user is editing, create a git worktree first via the shell tool and pass that worktree path as `cwd` to `acp_spawn`. That keeps the agent isolated from the user's in-progress work.
+
 ## Tips
 
 - The spawned agent runs autonomously with its own tools, file editing, and terminal access.

package/src/config/bundled-skills/acp/TOOLS.json

@@ -3,7 +3,7 @@
   "tools": [
     {
       "name": "acp_spawn",
-      "description": "Spawn an external coding agent (e.g. Claude Code, Codex, Gemini CLI) via ACP to work on a task. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If ACP is not enabled, follow the setup instructions in SKILL.md to install claude-agent-acp and configure it. The command MUST be 'claude-agent-acp' - NEVER use 'claude', 'claude -p', or 'claude --acp'.",
+      "description": "Spawn an external coding agent (e.g. Claude Code, Codex) via ACP to work on a task. Default profiles ship for `claude` (`claude-agent-acp`) and `codex` (`codex-acp`); the assistant resolves the agent id to the right adapter binary. The agent runs as a subprocess and streams results back. Use this when you want to delegate a coding task to an external agent that has its own tools, file editing, and terminal access. If a binary is missing, the call returns an actionable install hint — do NOT alter `agents.<id>.command` to swap binaries. If ACP is disabled, follow the setup instructions in SKILL.md.",
       "category": "orchestration",
       "risk": "high",
       "input_schema": {
@@ -74,6 +74,50 @@
       },
       "executor": "tools/acp-abort.ts",
       "execution_target": "host"
+    },
+    {
+      "name": "acp_steer",
+      "description": "**Interrupts** the in-flight prompt of a running ACP session and replaces it with `instruction`. Use to redirect the agent (e.g., 'stop, do X instead'). For follow-up work that should happen *after* the current task, do NOT use this — wait for `acp_session_completed` and `acp_spawn` again.",
+      "category": "orchestration",
+      "risk": "medium",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "acp_session_id": {
+            "type": "string",
+            "description": "The ID of the ACP session to steer."
+          },
+          "instruction": {
+            "type": "string",
+            "description": "The new instruction that replaces the in-flight prompt."
+          },
+          "activity": {
+            "type": "string",
+            "description": "Brief explanation of why this tool is being called"
+          }
+        },
+        "required": ["acp_session_id", "instruction"]
+      },
+      "executor": "tools/acp-steer.ts",
+      "execution_target": "host"
+    },
+    {
+      "name": "acp_list_agents",
+      "description": "Lists ACP coding agents available to spawn. Each entry includes whether ACP is enabled, whether the agent's binary is on PATH, and an install command if not. Use this to decide between 'claude' and 'codex' or to surface setup steps to the user.",
+      "category": "orchestration",
+      "risk": "low",
+      "input_schema": {
+        "type": "object",
+        "properties": {
+          "activity": {
+            "type": "string",
+            "description": "Brief explanation of why this tool is being called"
+          }
+        },
+        "required": []
+      },
+      "executor": "tools/acp-list-agents.ts",
+      "execution_target": "host"
     }
   ]
 }

package/src/config/bundled-skills/acp/tools/acp-list-agents.ts

@@ -0,0 +1,12 @@
+import { executeAcpListAgents } from "../../../../tools/acp/list-agents.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeAcpListAgents(input, context);
+}

package/src/config/bundled-skills/acp/tools/acp-steer.ts

@@ -0,0 +1,12 @@
+import { executeAcpSteer } from "../../../../tools/acp/steer.js";
+import type {
+  ToolContext,
+  ToolExecutionResult,
+} from "../../../../tools/types.js";
+
+export async function run(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  return executeAcpSteer(input, context);
+}