autohand-cli 0.8.3 → 0.9.1

package/dist/acp-5Y2W6OZP.js

@@ -0,0 +1,1556 @@
+import {
+  FileActionManager
+} from "./chunk-ZQAT5VT5.js";
+import {
+  AutohandAgent,
+  isLikelyFilePathSlashInput
+} from "./chunk-CCIDL4SA.js";
+import "./chunk-XAV24VYN.js";
+import "./chunk-ZPLCAXJW.js";
+import "./chunk-7IRQ7JEH.js";
+import "./chunk-U2QUMKCB.js";
+import "./chunk-GNBBIAMD.js";
+import "./chunk-ZNGRLCFQ.js";
+import "./chunk-SNDDZG5H.js";
+import "./chunk-ES2HJQ4N.js";
+import "./chunk-6R25D2H5.js";
+import "./chunk-26G7YGOW.js";
+import "./chunk-KWXGDSYT.js";
+import "./chunk-S5QKRA2V.js";
+import "./chunk-PGFLPURU.js";
+import "./chunk-QEGOB6QV.js";
+import "./chunk-M5DK524Z.js";
+import "./chunk-JMN3GZU6.js";
+import "./chunk-7PJKTSRN.js";
+import "./chunk-5JTTM5SC.js";
+import "./chunk-2H5O745H.js";
+import "./chunk-BP37FVBM.js";
+import "./chunk-FFHSCM5M.js";
+import "./chunk-3ZOOH44N.js";
+import "./chunk-WPE2XHVX.js";
+import "./chunk-2IW5YFJ4.js";
+import "./chunk-HBXAA3XB.js";
+import "./chunk-3OEDGIFW.js";
+import "./chunk-WNUVPKBW.js";
+import "./chunk-RAKO7UN7.js";
+import "./chunk-CECH6QQP.js";
+import "./chunk-FBQJZKFX.js";
+import "./chunk-NB6M6ESM.js";
+import "./chunk-Q3BS6FPM.js";
+import "./chunk-4XVLNOFA.js";
+import "./chunk-DNSD7DVJ.js";
+import "./chunk-SPQ7QIQ6.js";
+import "./chunk-QBYGMMDD.js";
+import "./chunk-O5GI6SR3.js";
+import "./chunk-C5QIQQ37.js";
+import "./chunk-44ZWOBTI.js";
+import "./chunk-4E7SHPNQ.js";
+import "./chunk-QHPFA6OE.js";
+import "./chunk-H426KOGY.js";
+import "./chunk-WNJXIACY.js";
+import "./chunk-XZVDYC5U.js";
+import "./chunk-DGBPWODD.js";
+import {
+  ConversationManager
+} from "./chunk-HQUSEWT4.js";
+import "./chunk-TR6NECEZ.js";
+import "./chunk-24QIWILL.js";
+import "./chunk-2NUX2RAI.js";
+import "./chunk-OIGYWOL6.js";
+import "./chunk-SDLY4X3G.js";
+import "./chunk-HXHE2KAO.js";
+import "./chunk-65LRPW5W.js";
+import "./chunk-YXM6SA7P.js";
+import "./chunk-RS2E32YB.js";
+import "./chunk-SRMGWMQO.js";
+import "./chunk-SVLBJMYO.js";
+import "./chunk-PZZMIYII.js";
+import "./chunk-6HF6XSCC.js";
+import "./chunk-EYHKL4QC.js";
+import "./chunk-ZK6HOR62.js";
+import "./chunk-P4FUTSVK.js";
+import "./chunk-YC5OBZQU.js";
+import "./chunk-H4D2Q2AL.js";
+import "./chunk-SZD45IDG.js";
+import "./chunk-W3X6PAC7.js";
+import "./chunk-JMJRFSNJ.js";
+import "./chunk-TSV4LVHK.js";
+import "./chunk-SFFEKZGC.js";
+import "./chunk-TYBPTKFT.js";
+import "./chunk-UR27UDTB.js";
+import "./chunk-CFAWTLSC.js";
+import "./chunk-I2ZK3AOD.js";
+import "./chunk-4LMUDS2K.js";
+import "./chunk-HTU4W3GB.js";
+import "./chunk-KMP6Y3LJ.js";
+import "./chunk-YVQI26H4.js";
+import "./chunk-HSWWM6AM.js";
+import "./chunk-TH26BQJG.js";
+import {
+  ProviderFactory
+} from "./chunk-JPFRI4L4.js";
+import "./chunk-MANJ67D3.js";
+import "./chunk-VUGOOGHB.js";
+import "./chunk-LUMV3DB2.js";
+import "./chunk-BQU3HAE7.js";
+import "./chunk-575PXZX7.js";
+import {
+  isGoalFeatureEnabled
+} from "./chunk-7MY4JHER.js";
+import "./chunk-FP46B4X3.js";
+import "./chunk-QRQF3556.js";
+import "./chunk-V5ELP2XE.js";
+import "./chunk-EEHWALXA.js";
+import "./chunk-PTTZI4QZ.js";
+import "./chunk-UWZ4G3SQ.js";
+import "./chunk-ZUYYHKQA.js";
+import "./chunk-46MTALKD.js";
+import "./chunk-YQDI753V.js";
+import "./chunk-MMKZSJUN.js";
+import "./chunk-4567QNRB.js";
+import {
+  installProcessErrorHandlers
+} from "./chunk-7WAUCLLQ.js";
+import {
+  validateWorkspacePath
+} from "./chunk-KA2U6MY2.js";
+import {
+  isSessionWorktreeEnabled,
+  prepareSessionWorktree
+} from "./chunk-C46B72VK.js";
+import "./chunk-WQ3VJXZB.js";
+import "./chunk-GSDV75A5.js";
+import "./chunk-6AYJCDTA.js";
+import "./chunk-GLBAF54O.js";
+import "./chunk-7DJJGKM6.js";
+import {
+  package_default
+} from "./chunk-JB3JCYBJ.js";
+import {
+  ApiError,
+  classifyApiError
+} from "./chunk-FQVG6ZHF.js";
+import "./chunk-X3TI5TJJ.js";
+import "./chunk-NZ3ZWLUW.js";
+import "./chunk-HZWU6IO3.js";
+import "./chunk-CSTUTDTH.js";
+import {
+  loadConfig
+} from "./chunk-IEPLQ47J.js";
+import "./chunk-5A7ZL64N.js";
+import "./chunk-YZWE7XSM.js";
+import "./chunk-LANGD5CO.js";
+import "./chunk-NBGOIFKP.js";
+import "./chunk-JAQO6XDB.js";
+import "./chunk-SHRLFX6F.js";
+import "./chunk-UOQECODR.js";
+import {
+  checkWorkspaceSafety
+} from "./chunk-PB7W7R72.js";
+import "./chunk-LEZEWKPA.js";
+import "./chunk-L6OH44HL.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/modes/acp/index.ts
+import { Readable, Writable } from "stream";
+import { AgentSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
+
+// src/modes/acp/adapter.ts
+import { PROTOCOL_VERSION, RequestError } from "@agentclientprotocol/sdk";
+
+// src/modes/acp/types.ts
+var ACP_HOOK_NOTIFICATIONS = {
+  HOOK_PRE_TOOL: "autohand.hook.preTool",
+  HOOK_POST_TOOL: "autohand.hook.postTool",
+  HOOK_FILE_MODIFIED: "autohand.hook.fileModified",
+  HOOK_PRE_PROMPT: "autohand.hook.prePrompt",
+  HOOK_POST_RESPONSE: "autohand.hook.postResponse",
+  HOOK_SESSION_ERROR: "autohand.hook.sessionError",
+  HOOK_STOP: "autohand.hook.stop",
+  HOOK_SESSION_START: "autohand.hook.sessionStart",
+  HOOK_SESSION_END: "autohand.hook.sessionEnd",
+  HOOK_SUBAGENT_STOP: "autohand.hook.subagentStop",
+  HOOK_PERMISSION_REQUEST: "autohand.hook.permissionRequest",
+  HOOK_NOTIFICATION: "autohand.hook.notification",
+  // Setup wizard notifications
+  SETUP_STARTED: "autohand.setup.started",
+  SETUP_STEP_START: "autohand.setup.stepStart",
+  SETUP_STEP_COMPLETE: "autohand.setup.stepComplete",
+  SETUP_CANCELLED: "autohand.setup.cancelled",
+  SETUP_ERROR: "autohand.setup.error",
+  SETUP_COMPLETE: "autohand.setup.complete"
+};
+var TOOL_KIND_MAP = {
+  // Read operations
+  read_file: "read",
+  list_tree: "read",
+  list_directory: "read",
+  file_stats: "read",
+  file_info: "read",
+  // Search operations
+  fff_grep: "search",
+  fff_find: "search",
+  find: "search",
+  web_search: "fetch",
+  web_repo: "fetch",
+  // Edit operations
+  write_file: "edit",
+  append_file: "edit",
+  apply_patch: "edit",
+  format_file: "edit",
+  replace_in_file: "edit",
+  search_replace: "edit",
+  create_directory: "edit",
+  copy_path: "edit",
+  // Move/delete operations
+  rename_path: "move",
+  delete_path: "delete",
+  // Execute operations
+  run_command: "execute",
+  custom_command: "execute",
+  git_status: "execute",
+  git_diff: "execute",
+  git_commit: "execute",
+  git_add: "execute",
+  git_init: "execute",
+  git_log: "execute",
+  git_list_untracked: "execute",
+  git_checkout: "execute",
+  git_branch: "execute",
+  // Dependencies
+  dependency_add: "execute",
+  dependency_remove: "execute",
+  dependency_update: "execute",
+  dependency_list: "read",
+  // Think/plan operations
+  todo_write: "think",
+  plan: "think",
+  smart_context_cropper: "think",
+  thinking: "think",
+  // Memory/other operations
+  save_memory: "other",
+  recall_memory: "other",
+  tools_registry: "other",
+  tool_search: "other",
+  get_goal: "think",
+  create_goal: "think",
+  create_goal_from_template: "think",
+  update_goal: "think",
+  clear_goal: "think",
+  list_goal_templates: "read",
+  enqueue_goal: "think",
+  list_goal_queue: "read",
+  start_queued_goal: "think",
+  dequeue_goal: "think",
+  remove_queued_goal: "think",
+  skill: "other",
+  sleep: "other",
+  project_info: "read",
+  workspace_info: "read"
+  // MCP tools (prefixed with mcp__)
+  // These are dynamically matched via resolveToolKind()
+};
+var TOOL_DISPLAY_NAMES = {
+  // Read operations
+  read_file: "Read",
+  list_tree: "List",
+  tool_search: "Search tools",
+  skill: "Skill",
+  sleep: "Wait",
+  list_directory: "List",
+  file_stats: "Stats",
+  file_info: "Info",
+  // Search operations
+  fff_grep: "Search",
+  fff_find: "Find files",
+  find: "Search",
+  search: "Search",
+  search_files: "Search",
+  search_with_context: "Search",
+  semantic_search: "Search",
+  web_search: "Web Search",
+  web_repo: "Web Repo",
+  // Edit operations
+  write_file: "Write",
+  append_file: "Append",
+  apply_patch: "Patch",
+  notebook_edit: "Notebook",
+  format_file: "Format",
+  replace_in_file: "Replace",
+  search_replace: "Replace",
+  create_directory: "Create",
+  copy_path: "Copy",
+  // Move/delete operations
+  rename_path: "Rename",
+  delete_path: "Delete",
+  // Execute operations
+  run_command: "Run",
+  custom_command: "Custom",
+  git_status: "Git Status",
+  git_diff: "Git Diff",
+  git_commit: "Git Commit",
+  git_add: "Git Add",
+  git_init: "Git Init",
+  git_log: "Git Log",
+  git_list_untracked: "Git Untracked",
+  git_checkout: "Git Checkout",
+  git_branch: "Git Branch",
+  // Dependencies
+  dependency_add: "Add Dep",
+  dependency_remove: "Remove Dep",
+  dependency_update: "Update Dep",
+  dependency_list: "List Deps",
+  // Think/plan operations
+  todo_write: "Todo",
+  plan: "Plan",
+  smart_context_cropper: "Thinking",
+  thinking: "Thinking",
+  // Memory/other
+  save_memory: "Save Memory",
+  recall_memory: "Recall Memory",
+  tools_registry: "Tools",
+  get_goal: "Get Goal",
+  create_goal: "Create Goal",
+  create_goal_from_template: "Goal Template",
+  update_goal: "Update Goal",
+  clear_goal: "Clear Goal",
+  list_goal_templates: "Goal Templates",
+  enqueue_goal: "Queue Goal",
+  list_goal_queue: "Goal Queue",
+  start_queued_goal: "Start Queued Goal",
+  dequeue_goal: "Dequeue Goal",
+  remove_queued_goal: "Remove Queued Goal",
+  project_info: "Project Info",
+  workspace_info: "Workspace Info"
+};
+function resolveToolKind(toolName) {
+  if (toolName in TOOL_KIND_MAP) {
+    return TOOL_KIND_MAP[toolName];
+  }
+  if (toolName.startsWith("mcp__")) {
+    return "execute";
+  }
+  return "other";
+}
+function resolveToolDisplayName(toolName) {
+  if (toolName in TOOL_DISPLAY_NAMES) {
+    return TOOL_DISPLAY_NAMES[toolName];
+  }
+  if (toolName.startsWith("mcp__")) {
+    const parts = toolName.split("__");
+    if (parts.length >= 3) {
+      return `MCP: ${parts[1]}/${parts.slice(2).join("/")}`;
+    }
+  }
+  return toolName.split("_").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+var DEFAULT_ACP_COMMANDS = [
+  { name: "help", description: "Show available commands" },
+  { name: "new", description: "Start a new conversation" },
+  { name: "model", description: "Select or change the model" },
+  { name: "resume", description: "Resume a previous session" },
+  { name: "sessions", description: "List recent sessions" },
+  { name: "session", description: "Show current session info" },
+  { name: "status", description: "Show Autohand status" },
+  { name: "undo", description: "Undo the last file change" },
+  { name: "init", description: "Create AGENTS.md file" },
+  { name: "memory", description: "Manage conversation memory" },
+  { name: "skills", description: "List available skills" },
+  { name: "export", description: "Export conversation" },
+  { name: "permissions", description: "Manage tool permissions" },
+  { name: "feedback", description: "Send feedback to Autohand" },
+  { name: "agents", description: "List available agents" },
+  { name: "hooks", description: "Manage lifecycle hooks" },
+  { name: "automode", description: "Toggle autonomous agent loop" },
+  { name: "add-dir", description: "Add additional working directory" },
+  { name: "share", description: "Share session transcript" },
+  { name: "formatters", description: "Manage code formatters" },
+  { name: "lint", description: "Run code linting" },
+  { name: "mcp", description: "Manage MCP servers" },
+  {
+    name: "mcp install",
+    description: "Browse and install community MCP servers"
+  },
+  { name: "sync", description: "Sync settings with cloud" },
+  { name: "history", description: "Show conversation history" },
+  { name: "about", description: "Show Autohand version and links" },
+  { name: "plan", description: "Toggle plan mode" },
+  { name: "goal", description: "Manage persistent goals and queued goal work" },
+  { name: "ide", description: "IDE integration settings" },
+  { name: "search", description: "Configure web search" },
+  { name: "login", description: "Sign in to Autohand account" },
+  { name: "logout", description: "Sign out of Autohand account" },
+  { name: "learn", description: "Analyze project and recommend skills" },
+  { name: "skills search", description: "Search community skills" },
+  { name: "skills trending", description: "Show trending community skills" },
+  { name: "skills remove", description: "Remove an installed skill" }
+];
+var DEFAULT_ACP_MODES = [
+  {
+    id: "interactive",
+    name: "Interactive",
+    description: "Default mode with approval prompts for risky actions"
+  },
+  {
+    id: "full-access",
+    name: "Full Access",
+    description: "Auto-approve all actions within the workspace"
+  },
+  {
+    id: "unrestricted",
+    name: "Unrestricted",
+    description: "Skip all approval prompts (use with caution)"
+  },
+  {
+    id: "auto-mode",
+    name: "Auto Mode",
+    description: "Autonomous multi-step execution loop"
+  },
+  {
+    id: "restricted",
+    name: "Restricted",
+    description: "Deny all dangerous operations automatically"
+  },
+  {
+    id: "dry-run",
+    name: "Dry Run",
+    description: "Preview actions without applying changes"
+  }
+];
+function buildConfigOptions(_config) {
+  const options = [];
+  options.push({
+    type: "select",
+    id: "thinking_level",
+    name: "Thinking Level",
+    description: "Control the depth of LLM reasoning",
+    options: [
+      { value: "none", name: "None" },
+      { value: "normal", name: "Normal" },
+      { value: "extended", name: "Extended" }
+    ],
+    currentValue: "normal"
+  });
+  options.push({
+    type: "select",
+    id: "auto_commit",
+    name: "Auto Commit",
+    description: "Automatically commit changes with LLM-generated messages",
+    options: [
+      { value: "off", name: "Off" },
+      { value: "on", name: "On" }
+    ],
+    currentValue: "off"
+  });
+  const contextCompactEnabled = true;
+  options.push({
+    type: "select",
+    id: "context_compact",
+    name: "Context Compaction",
+    description: "Automatically compact context when sessions grow long",
+    options: [
+      { value: "on", name: "On" },
+      { value: "off", name: "Off" }
+    ],
+    currentValue: contextCompactEnabled ? "on" : "off"
+  });
+  return options;
+}
+function parseAvailableModels(config) {
+  const models = [];
+  const providerName = config.provider ?? "openrouter";
+  const providerConfig = config[providerName];
+  if (providerConfig?.model) {
+    models.push(providerConfig.model);
+  }
+  const popularModels = [
+    "openrouter/auto",
+    "anthropic/claude-sonnet-4-20250514",
+    "openai/gpt-4o",
+    "openai/gpt-5",
+    "google/gemini-3.0-pro",
+    "deepseek/deepseek-v4",
+    "anthropic/claude-5-sonnet",
+    "anthropic/claude-5-opus"
+  ];
+  for (const m of popularModels) {
+    if (!models.includes(m)) {
+      models.push(m);
+    }
+  }
+  return models;
+}
+function resolveDefaultMode(config) {
+  if (config?.permissions?.mode === "unrestricted") return "unrestricted";
+  if (config?.permissions?.mode === "restricted") return "restricted";
+  return "interactive";
+}
+function resolveDefaultModel(config) {
+  const providerName = config.provider ?? "openrouter";
+  const providerConfig = config[providerName];
+  return providerConfig?.model ?? "anthropic/claude-5-sonnet";
+}
+
+// src/modes/acp/permissions.ts
+function createPermissionBridge(options) {
+  const { connection, sessionId } = options;
+  let { modeId } = options;
+  const setMode = (newModeId) => {
+    modeId = newModeId;
+  };
+  const confirmAction = async (message, context) => {
+    if (modeId === "unrestricted" || modeId === "full-access" || modeId === "auto-mode") {
+      return { decision: "allow_once" };
+    }
+    if (modeId === "restricted" || modeId === "dry-run") {
+      return { decision: "deny_once" };
+    }
+    const toolName = context?.tool ?? "action";
+    const kind = resolveToolKind(toolName);
+    const title = resolveToolDisplayName(toolName);
+    const toolCallId = `perm_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+    const locations = [];
+    if (context?.path) {
+      locations.push({ path: context.path });
+    }
+    try {
+      const response = await connection.requestPermission({
+        sessionId,
+        toolCall: {
+          toolCallId,
+          title: `${title}: ${message}`,
+          kind,
+          status: "pending",
+          locations,
+          rawInput: {
+            tool: toolName,
+            description: message,
+            command: context?.command,
+            path: context?.path,
+            args: context?.args
+          }
+        },
+        options: [
+          { kind: "allow_once", name: "Yes", optionId: "allow_once" },
+          { kind: "reject_once", name: "No", optionId: "deny_once" },
+          { kind: "allow_once", name: "Allow Once", optionId: "allow_session" },
+          { kind: "reject_once", name: "Deny Once", optionId: "deny_session" },
+          { kind: "allow_always", name: "Allow Always (Project)", optionId: "allow_always_project" },
+          { kind: "allow_always", name: "Allow Always (User)", optionId: "allow_always_user" },
+          { kind: "reject_always", name: "Deny Always (Project)", optionId: "deny_always_project" },
+          { kind: "reject_always", name: "Deny Always (User)", optionId: "deny_always_user" },
+          { kind: "reject_once", name: "Enter alternative...", optionId: "alternative" }
+        ]
+      });
+      if (response.outcome.outcome === "selected") {
+        const optionId = response.outcome.optionId;
+        if (optionId === "alternative") {
+          const meta = response.outcome._meta;
+          const alternative = typeof meta?.alternative === "string" ? meta.alternative.trim() : "";
+          return alternative ? { decision: "alternative", alternative } : { decision: "deny_once" };
+        }
+        return { decision: optionId };
+      }
+      return { decision: "deny_once" };
+    } catch (error) {
+      process.stderr.write(
+        `[ACP] Permission request failed: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+      return { decision: "deny_once" };
+    }
+  };
+  return { confirmAction, setMode };
+}
+
+// src/modes/acp/adapter.ts
+var AutohandAcpAdapter = class _AutohandAcpAdapter {
+  constructor(connection, cliOptions = {}) {
+    this.connection = connection;
+    this.cliOptions = cliOptions;
+  }
+  connection;
+  cliOptions;
+  sessions = /* @__PURE__ */ new Map();
+  agents = /* @__PURE__ */ new Map();
+  permissionBridges = /* @__PURE__ */ new Map();
+  sessionConfigOptions = /* @__PURE__ */ new Map();
+  cancelledSessions = /* @__PURE__ */ new Set();
+  config = null;
+  clientCapabilities;
+  toolStartTimes = /* @__PURE__ */ new Map();
+  static LIST_SESSIONS_PAGE_SIZE = 50;
+  async ensureConfig() {
+    if (!this.config) {
+      this.config = await loadConfig(void 0, process.cwd());
+    }
+    return this.config;
+  }
+  buildSessionModes(modeId) {
+    return {
+      availableModes: DEFAULT_ACP_MODES.map((m) => ({
+        id: m.id,
+        name: m.name,
+        description: m.description
+      })),
+      currentModeId: modeId
+    };
+  }
+  buildSessionModels(config, modelId) {
+    return {
+      availableModels: parseAvailableModels(config).map((m) => ({
+        modelId: m,
+        name: m.split("/").pop() ?? m
+      })),
+      currentModelId: modelId
+    };
+  }
+  getSessionCommands(config) {
+    if (isGoalFeatureEnabled(config)) return DEFAULT_ACP_COMMANDS;
+    return DEFAULT_ACP_COMMANDS.filter((cmd) => cmd.name !== "goal");
+  }
+  cloneConfigOptions(options) {
+    return structuredClone(options);
+  }
+  getSessionConfigOptions(sessionId) {
+    const options = this.sessionConfigOptions.get(sessionId) ?? [];
+    return this.cloneConfigOptions(options);
+  }
+  validateMode(modeId) {
+    if (!DEFAULT_ACP_MODES.some((mode) => mode.id === modeId)) {
+      throw RequestError.invalidParams({ message: `Unsupported mode: ${modeId}` });
+    }
+  }
+  validateModel(config, modelId) {
+    const models = parseAvailableModels(config);
+    if (!models.includes(modelId)) {
+      throw RequestError.invalidParams({ message: `Unsupported model: ${modelId}` });
+    }
+  }
+  convertAcpMcpServers(mcpServers) {
+    if (!mcpServers || mcpServers.length === 0) {
+      return [];
+    }
+    return mcpServers.map((server) => {
+      if ("command" in server) {
+        return {
+          name: server.name,
+          transport: "stdio",
+          command: server.command,
+          args: [...server.args],
+          env: Object.fromEntries(server.env.map((variable) => [variable.name, variable.value])),
+          autoConnect: true
+        };
+      }
+      return {
+        name: server.name,
+        transport: server.type,
+        url: server.url,
+        headers: Object.fromEntries(server.headers.map((header) => [header.name, header.value])),
+        autoConnect: true
+      };
+    });
+  }
+  async connectSessionMcpServers(agent, mcpServers) {
+    const converted = this.convertAcpMcpServers(mcpServers);
+    if (converted.length === 0) {
+      return;
+    }
+    await agent.connectAcpMcpServers(converted);
+  }
+  resolveWorkspaceRoot(sessionId, cwd) {
+    let workspaceRoot = cwd;
+    if (isSessionWorktreeEnabled(this.cliOptions.worktree)) {
+      const sessionWorktree = prepareSessionWorktree({
+        cwd,
+        worktree: this.cliOptions.worktree,
+        mode: "acp"
+      });
+      workspaceRoot = sessionWorktree.worktreePath;
+      process.stderr.write(
+        `[ACP] Session ${sessionId} using git worktree ${sessionWorktree.worktreePath} (${sessionWorktree.branchName})
+`
+      );
+    }
+    return workspaceRoot;
+  }
+  async createManagedSession(sessionId, workspaceRoot) {
+    const config = await this.ensureConfig();
+    if (!config.ui) {
+      config.ui = {};
+    }
+    config.ui.useInkRenderer = false;
+    const modeId = resolveDefaultMode(config);
+    const modelId = resolveDefaultModel(config);
+    const runtime = {
+      config,
+      workspaceRoot,
+      options: {
+        yes: modeId === "unrestricted" || modeId === "full-access",
+        unrestricted: modeId === "unrestricted",
+        restricted: modeId === "restricted",
+        dryRun: modeId === "dry-run",
+        contextCompact: true
+        // Default enabled; ACP config can toggle via applyAcpConfigOption
+      },
+      isRpcMode: true
+    };
+    const provider = ProviderFactory.create(config);
+    const files = new FileActionManager(workspaceRoot);
+    const agent = new AutohandAgent(provider, files, runtime);
+    await agent.initializeForRPC();
+    const state = {
+      sessionId,
+      modeId,
+      modelId,
+      workspaceRoot,
+      createdAt: Date.now(),
+      abortController: new AbortController(),
+      promptCount: 0
+    };
+    this.sessions.set(sessionId, state);
+    this.agents.set(sessionId, agent);
+    this.sessionConfigOptions.set(sessionId, buildConfigOptions(config));
+    agent.setOutputListener((event) => {
+      this.handleAgentOutput(sessionId, event);
+    });
+    const permBridge = createPermissionBridge({
+      connection: this.connection,
+      sessionId,
+      modeId
+    });
+    agent.setConfirmationCallback(async (message, context) => {
+      return permBridge.confirmAction(message, context);
+    });
+    this.permissionBridges.set(sessionId, permBridge);
+    return { config, state, agent };
+  }
+  restoreConversation(messages) {
+    const conversation = ConversationManager.getInstance();
+    if (!conversation.isInitialized()) {
+      throw new Error("Conversation manager is not initialized");
+    }
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        if (!msg.content.startsWith("You are Autohand")) {
+          conversation.addSystemNote(msg.content);
+        }
+        continue;
+      }
+      let convertedToolCalls;
+      if (msg.toolCalls && Array.isArray(msg.toolCalls)) {
+        convertedToolCalls = msg.toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.tool || tc.function?.name || "unknown",
+            arguments: typeof tc.args === "string" ? tc.args : JSON.stringify(tc.args || {})
+          }
+        }));
+      }
+      conversation.addMessage({
+        role: msg.role,
+        content: msg.content,
+        name: msg.name,
+        tool_calls: convertedToolCalls,
+        tool_call_id: msg.tool_call_id
+      });
+    }
+  }
+  async replayConversation(sessionId, messages) {
+    for (const msg of messages) {
+      if (!msg.content?.trim()) {
+        continue;
+      }
+      if (msg.role === "user") {
+        await this.connection.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "user_message_chunk",
+            content: { type: "text", text: msg.content }
+          }
+        });
+        continue;
+      }
+      if (msg.role === "assistant") {
+        await this.connection.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: msg.content }
+          }
+        });
+        continue;
+      }
+      if (msg.role === "tool") {
+        await this.connection.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `[tool] ${msg.content}` }
+          }
+        });
+        continue;
+      }
+      if (msg.role === "system" && !msg.content.startsWith("You are Autohand")) {
+        await this.connection.sessionUpdate({
+          sessionId,
+          update: {
+            sessionUpdate: "agent_message_chunk",
+            content: { type: "text", text: `[system] ${msg.content}` }
+          }
+        });
+      }
+    }
+  }
+  async restoreSession(sessionId, cwd, mcpServers) {
+    const workspaceRoot = this.resolveWorkspaceRoot(sessionId, cwd);
+    const { config, state, agent } = await this.createManagedSession(sessionId, workspaceRoot);
+    await this.connectSessionMcpServers(agent, mcpServers);
+    const sessionManager = agent.getSessionManager();
+    try {
+      const loadedSession = await sessionManager.loadSession(sessionId);
+      const messages = loadedSession.getMessages();
+      this.restoreConversation(messages);
+      if (loadedSession.metadata.model) {
+        state.modelId = loadedSession.metadata.model;
+      }
+      this.sessions.set(sessionId, state);
+      return { config, state, messages };
+    } catch (error) {
+      this.sessions.delete(sessionId);
+      this.agents.delete(sessionId);
+      this.permissionBridges.delete(sessionId);
+      this.sessionConfigOptions.delete(sessionId);
+      throw error;
+    }
+  }
+  // ==========================================================================
+  // ACP Agent Interface: initialize
+  // ==========================================================================
+  async initialize(params) {
+    this.clientCapabilities = params.clientCapabilities;
+    this.config = await loadConfig(void 0, process.cwd());
+    return {
+      protocolVersion: PROTOCOL_VERSION,
+      agentCapabilities: {
+        promptCapabilities: {
+          embeddedContext: true,
+          image: true
+        },
+        loadSession: true,
+        mcpCapabilities: {
+          http: true,
+          sse: true
+        },
+        sessionCapabilities: {
+          list: {},
+          resume: {},
+          fork: {}
+        }
+      },
+      agentInfo: {
+        name: "autohand-cli",
+        title: "Autohand Code",
+        version: package_default.version
+      }
+    };
+  }
+  // ==========================================================================
+  // ACP Agent Interface: authenticate
+  // ==========================================================================
+  async authenticate(_params) {
+    if (this.config?.auth?.token) {
+      return {};
+    }
+    const provider = this.config?.provider ?? "openrouter";
+    const providerConfig = this.config?.[provider];
+    if (providerConfig?.apiKey) {
+      return {};
+    }
+    throw RequestError.authRequired({
+      message: "Please run `autohand --setup` or `autohand login` in your terminal."
+    });
+  }
+  // ==========================================================================
+  // ACP Agent Interface: newSession
+  // ==========================================================================
+  async newSession(params) {
+    const sessionId = crypto.randomUUID();
+    const workspaceRoot = this.resolveWorkspaceRoot(sessionId, params.cwd);
+    const { config, state, agent } = await this.createManagedSession(sessionId, workspaceRoot);
+    await this.connectSessionMcpServers(agent, params.mcpServers);
+    this.emitHookSessionStart(sessionId, "startup");
+    const response = {
+      sessionId,
+      modes: this.buildSessionModes(state.modeId),
+      models: this.buildSessionModels(config, state.modelId),
+      configOptions: this.getSessionConfigOptions(sessionId),
+      _meta: {
+        commands: this.getSessionCommands(config).map((cmd) => ({
+          name: cmd.name,
+          description: cmd.description
+        }))
+      }
+    };
+    return response;
+  }
+  // ==========================================================================
+  // ACP Agent Interface: prompt
+  // ==========================================================================
+  async prompt(params) {
+    const session = this.sessions.get(params.sessionId);
+    const agent = this.agents.get(params.sessionId);
+    if (!session || !agent) {
+      throw RequestError.invalidParams({ message: "Session not found" });
+    }
+    session.abortController = new AbortController();
+    this.cancelledSessions.delete(params.sessionId);
+    let instruction = "";
+    if (params.prompt) {
+      for (const block of params.prompt) {
+        if (block.type === "text") {
+          instruction += block.text;
+        } else if (block.type === "resource") {
+          const resourceUri = block.resource?.uri ?? "";
+          instruction += `
+[Resource: ${resourceUri}]`;
+        }
+      }
+    }
+    if (!instruction.trim()) {
+      return { stopReason: "end_turn" };
+    }
+    session.promptCount++;
+    if (session.promptCount === 1) {
+      const title = instruction.trim().slice(0, 120);
+      this.connection.sessionUpdate({
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          title,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    } else {
+      this.connection.sessionUpdate({
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "session_info_update",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      });
+    }
+    const trimmed = instruction.trim();
+    if (trimmed.startsWith("/") && !isLikelyFilePathSlashInput(trimmed)) {
+      const { command, args } = agent.parseSlashCommand(trimmed);
+      if (agent.isSlashCommand(trimmed)) {
+        try {
+          if (agent.isSlashCommandSupported(command)) {
+            const result = await agent.handleSlashCommand(command, args);
+            if (result !== null) {
+              await this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "agent_message_chunk",
+                  content: { type: "text", text: result }
+                }
+              });
+            } else {
+              await this.connection.sessionUpdate({
+                sessionId: params.sessionId,
+                update: {
+                  sessionUpdate: "agent_message_chunk",
+                  content: { type: "text", text: `Command ${command} executed.` }
+                }
+              });
+            }
+          } else {
+            await this.connection.sessionUpdate({
+              sessionId: params.sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: { type: "text", text: `Unknown command: ${command}. Type /help for available commands.` }
+              }
+            });
+          }
+        } catch (err) {
+          const errMsg = err instanceof Error ? err.message : String(err);
+          await this.connection.sessionUpdate({
+            sessionId: params.sessionId,
+            update: {
+              sessionUpdate: "agent_message_chunk",
+              content: { type: "text", text: `Error: ${errMsg}` }
+            }
+          });
+        }
+        return { stopReason: "end_turn" };
+      }
+    }
+    const turnStart = Date.now();
+    this.emitHookPrePrompt(params.sessionId, instruction, []);
+    try {
+      const success = await agent.runInstruction(instruction);
+      const turnDuration = Date.now() - turnStart;
+      this.emitHookStop(params.sessionId, 0, 0, turnDuration);
+      if (!success && this.cancelledSessions.has(params.sessionId)) {
+        return { stopReason: "cancelled" };
+      }
+      return { stopReason: "end_turn" };
+    } catch (err) {
+      if (session.abortController.signal.aborted || this.cancelledSessions.has(params.sessionId)) {
+        return { stopReason: "cancelled" };
+      }
+      const classified = this.classifyAndFormatError(err);
+      process.stderr.write(`[ACP] Prompt error (${classified.code}): ${classified.message}
+`);
+      this.emitHookSessionError(params.sessionId, classified.message, classified.code);
+      await this.connection.sessionUpdate({
+        sessionId: params.sessionId,
+        update: {
+          sessionUpdate: "agent_message_chunk",
+          content: { type: "text", text: `Error (${classified.code}): ${classified.message}` }
+        }
+      });
+      return { stopReason: "end_turn" };
+    }
+  }
+  // ==========================================================================
+  // ACP Agent Interface: cancel
+  // ==========================================================================
+  async cancel(params) {
+    const session = this.sessions.get(params.sessionId);
+    const agent = this.agents.get(params.sessionId);
+    if (session) {
+      session.abortController.abort();
+      this.cancelledSessions.add(params.sessionId);
+    }
+    if (agent) {
+      agent.cancelCurrentInstruction();
+    }
+  }
+  // ==========================================================================
+  // ACP Agent Interface: setSessionMode
+  // ==========================================================================
+  async setSessionMode(params) {
+    const session = this.sessions.get(params.sessionId);
+    const agent = this.agents.get(params.sessionId);
+    if (!session) {
+      throw RequestError.invalidParams({ message: "Session not found" });
+    }
+    if (!agent) {
+      throw RequestError.invalidParams({ message: "Session agent not found" });
+    }
+    this.validateMode(params.modeId);
+    session.modeId = params.modeId;
+    this.permissionBridges.get(params.sessionId)?.setMode(params.modeId);
+    agent.applyAcpMode(params.modeId);
+    process.stderr.write(`[ACP] Session ${params.sessionId} mode set to: ${params.modeId}
+`);
+    await this.connection.sessionUpdate({
+      sessionId: params.sessionId,
+      update: {
+        sessionUpdate: "current_mode_update",
+        currentModeId: params.modeId
+      }
+    });
+    return {};
+  }
+  // ==========================================================================
+  // ACP Agent Interface: unstable_setSessionModel
+  // ==========================================================================
+  async unstable_setSessionModel(params) {
+    const session = this.sessions.get(params.sessionId);
+    const agent = this.agents.get(params.sessionId);
+    if (!session) {
+      throw RequestError.invalidParams({ message: "Session not found" });
+    }
+    if (!agent) {
+      throw RequestError.invalidParams({ message: "Session agent not found" });
+    }
+    const config = await this.ensureConfig();
+    this.validateModel(config, params.modelId);
+    session.modelId = params.modelId;
+    agent.applyAcpModel(params.modelId);
+    process.stderr.write(`[ACP] Session ${params.sessionId} model set to: ${params.modelId}
+`);
+    return {};
+  }
+  async unstable_setSessionConfigOption(params) {
+    const options = this.sessionConfigOptions.get(params.sessionId);
+    const agent = this.agents.get(params.sessionId);
+    if (!options || !agent) {
+      throw RequestError.invalidParams({ message: "Session not found" });
+    }
+    const option = options.find((entry) => entry.id === params.configId);
+    if (!option) {
+      throw RequestError.invalidParams({ message: `Unknown config option: ${params.configId}` });
+    }
+    const validValues = [];
+    if (option.type === "select" && "options" in option) {
+      for (const entry of option.options) {
+        if ("value" in entry) {
+          validValues.push(entry.value);
+        } else if ("options" in entry) {
+          for (const subEntry of entry.options) {
+            validValues.push(subEntry.value);
+          }
+        }
+      }
+    }
+    if (typeof params.value === "string" && !validValues.includes(params.value)) {
+      throw RequestError.invalidParams({
+        message: `Invalid value "${params.value}" for config option "${params.configId}"`
+      });
+    }
+    option.currentValue = params.value;
+    agent.applyAcpConfigOption(params.configId, String(params.value));
+    return {
+      configOptions: this.cloneConfigOptions(options)
+    };
+  }
+  // ==========================================================================
+  // ACP Agent Interface: unstable_listSessions (optional)
+  // ==========================================================================
+  async unstable_listSessions(params) {
+    try {
+      const { SessionManager } = await import("./SessionManager-554PHVPC.js");
+      const sessionManager = new SessionManager();
+      await sessionManager.initialize();
+      const sessions = await sessionManager.listSessions();
+      const filtered = params.cwd ? sessions.filter((session) => session.projectPath === params.cwd) : sessions;
+      const offset = params.cursor ? Number.parseInt(params.cursor, 10) : 0;
+      if (Number.isNaN(offset) || offset < 0) {
+        throw RequestError.invalidParams({ message: `Invalid cursor: ${params.cursor}` });
+      }
+      const paged = filtered.slice(offset, offset + _AutohandAcpAdapter.LIST_SESSIONS_PAGE_SIZE);
+      const nextOffset = offset + paged.length;
+      const nextCursor = nextOffset < filtered.length ? String(nextOffset) : void 0;
+      return {
+        sessions: paged.map((s) => ({
+          sessionId: s.sessionId,
+          cwd: s.projectPath ?? "",
+          title: s.summary ?? s.projectName ?? `Session ${s.sessionId.slice(0, 8)}`,
+          updatedAt: s.lastActiveAt ?? s.createdAt
+        })),
+        ...nextCursor ? { nextCursor } : {}
+      };
+    } catch (err) {
+      process.stderr.write(`[ACP] Failed to list sessions: ${err instanceof Error ? err.message : String(err)}
+`);
+      return { sessions: [] };
+    }
+  }
+  // ==========================================================================
+  // ACP Agent Interface: unstable_resumeSession (optional)
+  // ==========================================================================
+  async unstable_resumeSession(_params) {
+    try {
+      const params = _params;
+      const { config, state } = await this.restoreSession(params.sessionId, params.cwd, params.mcpServers);
+      this.emitHookSessionStart(params.sessionId, "resume");
+      process.stderr.write(`[ACP] Resumed session ${params.sessionId}
+`);
+      return {
+        modes: this.buildSessionModes(state.modeId),
+        models: this.buildSessionModels(config, state.modelId),
+        configOptions: this.getSessionConfigOptions(params.sessionId)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw RequestError.invalidParams({ message: `Failed to resume session: ${message}` });
+    }
+  }
+  // ==========================================================================
+  // ACP Agent Interface: unstable_forkSession (optional)
+  // ==========================================================================
+  async unstable_forkSession(params) {
+    const sourceSession = this.sessions.get(params.sessionId);
+    if (!sourceSession) {
+      throw RequestError.invalidParams({ message: "Source session not found" });
+    }
+    const sourceAgent = this.agents.get(params.sessionId);
+    if (sourceAgent) {
+      try {
+        const conversation = ConversationManager.getInstance();
+        const { extractAndSaveSessionMemories } = await import("./extractSessionMemories-A2JX5WJ2.js");
+        await extractAndSaveSessionMemories({
+          llm: sourceAgent.getLlmProvider(),
+          memoryManager: sourceAgent.getMemoryManager(),
+          conversationHistory: conversation.history(),
+          workspaceRoot: sourceSession.workspaceRoot
+        });
+      } catch {
+      }
+    }
+    const newSessionResponse = await this.newSession({
+      cwd: sourceSession.workspaceRoot,
+      mcpServers: []
+    });
+    return {
+      sessionId: newSessionResponse.sessionId
+    };
+  }
+  // ==========================================================================
+  // ACP Agent Interface: loadSession (optional)
+  // ==========================================================================
+  async loadSession(params) {
+    try {
+      const { config, state, messages } = await this.restoreSession(params.sessionId, params.cwd, params.mcpServers);
+      await this.replayConversation(params.sessionId, messages);
+      this.emitHookSessionStart(params.sessionId, "resume");
+      process.stderr.write(`[ACP] Loaded session ${params.sessionId} with ${messages.length} messages
+`);
+      return {
+        modes: this.buildSessionModes(state.modeId),
+        models: this.buildSessionModels(config, state.modelId),
+        configOptions: this.getSessionConfigOptions(params.sessionId)
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw RequestError.invalidParams({ message: `Failed to load session: ${message}` });
+    }
+  }
+  // ==========================================================================
+  // Hook Lifecycle Notifications
+  // ==========================================================================
+  /**
+   * Safely emit a hook notification via extNotification.
+   * Hook notifications must never crash the agent — errors are logged and swallowed.
+   */
+  async emitHookSafe(method, params) {
+    try {
+      await this.connection.extNotification(method, params);
+    } catch (err) {
+      process.stderr.write(
+        `[ACP] Failed to emit hook notification ${method}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  emitHookPreTool(sessionId, toolId, toolName, args) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_PRE_TOOL, {
+      sessionId,
+      toolId,
+      toolName,
+      args,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookPostTool(sessionId, toolId, toolName, success, duration, output) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_POST_TOOL, {
+      sessionId,
+      toolId,
+      toolName,
+      success,
+      duration,
+      output,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookFileModified(sessionId, filePath, changeType, toolId) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_FILE_MODIFIED, {
+      sessionId,
+      filePath,
+      changeType,
+      toolId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookPrePrompt(sessionId, instruction, mentionedFiles) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_PRE_PROMPT, {
+      sessionId,
+      instruction,
+      mentionedFiles,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookPostResponse(sessionId, tokensUsed, toolCallsCount, duration) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_POST_RESPONSE, {
+      sessionId,
+      tokensUsed,
+      toolCallsCount,
+      duration,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookSessionError(sessionId, error, code, context) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_SESSION_ERROR, {
+      sessionId,
+      error,
+      code,
+      context,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookStop(sessionId, tokensUsed, toolCallsCount, duration) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_STOP, {
+      sessionId,
+      tokensUsed,
+      toolCallsCount,
+      duration,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookSessionStart(sessionId, sessionType) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_SESSION_START, {
+      sessionId,
+      sessionType,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookSessionEnd(sessionId, reason, duration) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_SESSION_END, {
+      sessionId,
+      reason,
+      duration,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookSubagentStop(sessionId, subagentId, subagentName, subagentType, success, duration, error) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_SUBAGENT_STOP, {
+      sessionId,
+      subagentId,
+      subagentName,
+      subagentType,
+      success,
+      duration,
+      error,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookPermissionRequest(sessionId, tool, path, command, args) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_PERMISSION_REQUEST, {
+      sessionId,
+      tool,
+      path,
+      command,
+      args,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  emitHookNotification(sessionId, notificationType, message) {
+    void this.emitHookSafe(ACP_HOOK_NOTIFICATIONS.HOOK_NOTIFICATION, {
+      sessionId,
+      notificationType,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  // ==========================================================================
+  // Agent Output → ACP Session Updates
+  // ==========================================================================
+  /**
+   * Translates AutohandAgent output events into ACP session update notifications.
+   * This is the core bridge between the agent's internal event system and the ACP protocol.
+   */
+  async handleAgentOutput(sessionId, event) {
+    try {
+      switch (event.type) {
+        case "thinking":
+          if (event.thought) {
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: {
+                  type: "thinking",
+                  text: event.thought
+                }
+              }
+            });
+          }
+          break;
+        case "message":
+          if (event.content) {
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: {
+                  type: "text",
+                  text: event.content
+                }
+              }
+            });
+          }
+          break;
+        case "tool_start":
+          if (event.toolName) {
+            const toolCallId = event.toolId ?? `tool_${Date.now()}`;
+            const kind = resolveToolKind(event.toolName);
+            const title = resolveToolDisplayName(event.toolName);
+            const locations = [];
+            if (event.toolArgs?.path && typeof event.toolArgs.path === "string") {
+              locations.push({ path: event.toolArgs.path });
+            }
+            if (event.toolArgs?.file && typeof event.toolArgs.file === "string") {
+              locations.push({ path: event.toolArgs.file });
+            }
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "tool_call",
+                toolCallId,
+                title,
+                kind,
+                status: "in_progress",
+                locations,
+                rawInput: event.toolArgs ?? {}
+              }
+            });
+            this.toolStartTimes.set(toolCallId, Date.now());
+            this.emitHookPreTool(sessionId, toolCallId, event.toolName, event.toolArgs ?? {});
+          }
+          break;
+        case "tool_end":
+          if (event.toolName) {
+            const toolCallId = event.toolId ?? "unknown";
+            const status = event.toolSuccess !== false ? "completed" : "failed";
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "tool_call_update",
+                toolCallId,
+                status,
+                rawOutput: event.toolOutput ? { output: event.toolOutput } : void 0
+              }
+            });
+            const startTime = this.toolStartTimes.get(toolCallId);
+            const duration = startTime ? Date.now() - startTime : 0;
+            this.toolStartTimes.delete(toolCallId);
+            this.emitHookPostTool(
+              sessionId,
+              toolCallId,
+              event.toolName,
+              event.toolSuccess !== false,
+              duration,
+              event.toolOutput
+            );
+          }
+          break;
+        case "schedule_triggered":
+          if (event.content) {
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: { type: "text", text: `[Scheduled job triggered] ${event.content}` }
+              }
+            });
+          }
+          break;
+        case "file_modified":
+          if (event.filePath) {
+            this.emitHookFileModified(
+              sessionId,
+              event.filePath,
+              event.changeType ?? "modify",
+              event.toolId ?? ""
+            );
+          }
+          break;
+        case "error":
+          if (event.content) {
+            const classified = this.classifyAndFormatError(event.content);
+            await this.connection.sessionUpdate({
+              sessionId,
+              update: {
+                sessionUpdate: "agent_message_chunk",
+                content: {
+                  type: "text",
+                  text: `Error (${classified.code}): ${classified.message}`
+                }
+              }
+            });
+            this.emitHookSessionError(sessionId, classified.message, classified.code);
+          }
+          break;
+      }
+    } catch (err) {
+      process.stderr.write(
+        `[ACP] Failed to send session update: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  /**
+   * Classify an error and return a structured result for ACP consumers.
+   * Accepts either an Error instance (including ApiError), a string, or an unknown.
+   */
+  classifyAndFormatError(error) {
+    if (error instanceof ApiError) {
+      return {
+        message: error.rawDetail || error.message,
+        code: error.code,
+        recoverable: error.retryable
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const classified = classifyApiError(0, message);
+    return {
+      message,
+      code: classified.code,
+      recoverable: classified.retryable
+    };
+  }
+};
+
+// src/modes/acp/index.ts
+function redirectConsoleToStderr() {
+  const stderrWrite = (...args) => {
+    process.stderr.write(args.map(String).join(" ") + "\n");
+  };
+  console.log = stderrWrite;
+  console.info = stderrWrite;
+  console.warn = stderrWrite;
+  console.debug = stderrWrite;
+}
+async function runAcpMode(options) {
+  const workspacePath = options.path ?? process.cwd();
+  const workspacePathValidation = await validateWorkspacePath(workspacePath);
+  if (!workspacePathValidation.valid) {
+    process.stderr.write(`[ACP] Error: ${workspacePathValidation.error}
+`);
+    process.exit(1);
+  }
+  const safetyCheck = checkWorkspaceSafety(workspacePath);
+  if (!safetyCheck.safe) {
+    process.stderr.write(`[ACP] Error: Unsafe workspace \u2014 ${safetyCheck.reason}
+`);
+    process.exit(1);
+  }
+  redirectConsoleToStderr();
+  process.env.AUTOHAND_CLIENT_NAME = "acp";
+  process.stderr.write("[ACP] Starting native ACP mode...\n");
+  installProcessErrorHandlers();
+  const input = Writable.toWeb(process.stdout);
+  const output = Readable.toWeb(process.stdin);
+  const stream = ndJsonStream(input, output);
+  const _connection = new AgentSideConnection(
+    (conn) => new AutohandAcpAdapter(conn, options),
+    stream
+  );
+  process.stdin.resume();
+  _connection.signal.addEventListener("abort", () => {
+    process.stderr.write("[ACP] Connection closed.\n");
+    process.exit(0);
+  });
+  process.stderr.write("[ACP] Native ACP mode ready. Waiting for client...\n");
+}
+export {
+  ACP_HOOK_NOTIFICATIONS,
+  AutohandAcpAdapter,
+  DEFAULT_ACP_COMMANDS,
+  DEFAULT_ACP_MODES,
+  TOOL_DISPLAY_NAMES,
+  TOOL_KIND_MAP,
+  buildConfigOptions,
+  createPermissionBridge,
+  parseAvailableModels,
+  resolveDefaultMode,
+  resolveDefaultModel,
+  resolveToolDisplayName,
+  resolveToolKind,
+  runAcpMode
+};