autohand-cli 0.8.2 → 0.9.0

package/dist/acp-EOETGAHC.cjs

@@ -0,0 +1,1517 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+var _chunk7JLT2VNWcjs = require('./chunk-7JLT2VNW.cjs');
+
+
+var _chunk5K3CDSWZcjs = require('./chunk-5K3CDSWZ.cjs');
+require('./chunk-QMAKTSZB.cjs');
+require('./chunk-HQWQZML5.cjs');
+require('./chunk-VGEV44V2.cjs');
+require('./chunk-Q6AC3PHY.cjs');
+require('./chunk-5CMYEM3R.cjs');
+require('./chunk-DI57A4BX.cjs');
+require('./chunk-LQBONA55.cjs');
+require('./chunk-AU6JAGZJ.cjs');
+require('./chunk-GBMDFWJX.cjs');
+require('./chunk-FFBDRUO5.cjs');
+require('./chunk-GWY26SUD.cjs');
+require('./chunk-ROLA6EFO.cjs');
+require('./chunk-PCM3N3CL.cjs');
+require('./chunk-BYE7RQFZ.cjs');
+require('./chunk-PHJO5YAL.cjs');
+require('./chunk-Z36XBUMX.cjs');
+require('./chunk-U3WDY42C.cjs');
+require('./chunk-FHK7UDOJ.cjs');
+require('./chunk-DRWDEHE5.cjs');
+require('./chunk-AUYSIEVV.cjs');
+require('./chunk-HDK2EHVH.cjs');
+require('./chunk-PDHT7LQS.cjs');
+require('./chunk-MQESBFBZ.cjs');
+require('./chunk-TXPSTCG7.cjs');
+require('./chunk-PUD76XQT.cjs');
+require('./chunk-IEXKKKOF.cjs');
+require('./chunk-CWINVFRI.cjs');
+require('./chunk-J2K57QM7.cjs');
+require('./chunk-J5ADZN6V.cjs');
+require('./chunk-3S563FNF.cjs');
+require('./chunk-DPSIGY6L.cjs');
+require('./chunk-JHGIWNHL.cjs');
+require('./chunk-ZASDSY7P.cjs');
+require('./chunk-6GUODJKM.cjs');
+require('./chunk-SOLBYSLY.cjs');
+require('./chunk-OPNI6O7F.cjs');
+require('./chunk-E6GFD7VR.cjs');
+require('./chunk-47PHDKNW.cjs');
+require('./chunk-QCLYBIMM.cjs');
+require('./chunk-M7RVTUWE.cjs');
+require('./chunk-AC7DZ6SK.cjs');
+require('./chunk-75EDROHL.cjs');
+require('./chunk-6XVVIY54.cjs');
+require('./chunk-WGLBC5AY.cjs');
+require('./chunk-LDJQ5QHG.cjs');
+require('./chunk-O6TQP7U7.cjs');
+require('./chunk-MFK6HE47.cjs');
+require('./chunk-TJNBASFD.cjs');
+require('./chunk-JP3YHTQ2.cjs');
+require('./chunk-3KLSNNRW.cjs');
+require('./chunk-6HH236FV.cjs');
+require('./chunk-HS4USDND.cjs');
+
+
+var _chunkDA7NBAJKcjs = require('./chunk-DA7NBAJK.cjs');
+require('./chunk-YFXTE422.cjs');
+require('./chunk-DIZTWFVR.cjs');
+require('./chunk-HXQREVTA.cjs');
+require('./chunk-4JNNTOGF.cjs');
+require('./chunk-RBZ7AFX7.cjs');
+require('./chunk-VXCMGBXY.cjs');
+require('./chunk-XGMI6IYB.cjs');
+require('./chunk-AOKCI722.cjs');
+require('./chunk-N6O3XUZ2.cjs');
+require('./chunk-UXLW45ZE.cjs');
+require('./chunk-OR67YXQK.cjs');
+require('./chunk-DEQVRSV5.cjs');
+require('./chunk-J5HE6CUM.cjs');
+require('./chunk-UGFVM77J.cjs');
+require('./chunk-QW2RW2GY.cjs');
+require('./chunk-ZHJ7JGME.cjs');
+require('./chunk-JJ4KA7HK.cjs');
+require('./chunk-WTB7AFL6.cjs');
+
+
+var _chunkWRTXCQ3Vcjs = require('./chunk-WRTXCQ3V.cjs');
+require('./chunk-HSCUPEA4.cjs');
+require('./chunk-WBU4Q4GS.cjs');
+require('./chunk-LFDPTJYF.cjs');
+require('./chunk-MUNUUFU7.cjs');
+require('./chunk-MOJ7ADW4.cjs');
+require('./chunk-WKRDBCP2.cjs');
+require('./chunk-B4HSNOIH.cjs');
+require('./chunk-BQ22N3TX.cjs');
+require('./chunk-IGMPWJ2I.cjs');
+require('./chunk-2CGE7ZV3.cjs');
+require('./chunk-3DDL2E55.cjs');
+require('./chunk-4256YRCO.cjs');
+require('./chunk-LJD7KR3L.cjs');
+require('./chunk-ZZ63NW7A.cjs');
+require('./chunk-7MU7LWF3.cjs');
+require('./chunk-UWFG2R2I.cjs');
+
+
+var _chunkMO4KP6XScjs = require('./chunk-MO4KP6XS.cjs');
+
+
+
+var _chunk7LWQCE4Ycjs = require('./chunk-7LWQCE4Y.cjs');
+
+
+var _chunk3LJJG5YYcjs = require('./chunk-3LJJG5YY.cjs');
+require('./chunk-XDLH4EDL.cjs');
+require('./chunk-MPULXVC4.cjs');
+require('./chunk-Q2IL4DDI.cjs');
+require('./chunk-FMB3TSWP.cjs');
+require('./chunk-IKUMVBCW.cjs');
+
+
+var _chunkREMGR23Vcjs = require('./chunk-REMGR23V.cjs');
+
+
+
+var _chunk3OF56EMAcjs = require('./chunk-3OF56EMA.cjs');
+require('./chunk-D2OSPLYC.cjs');
+require('./chunk-CH2J4PVE.cjs');
+require('./chunk-KNTUI4TZ.cjs');
+require('./chunk-TQ33WBY5.cjs');
+
+
+var _chunk46C73ZKKcjs = require('./chunk-46C73ZKK.cjs');
+require('./chunk-MXVIDIC6.cjs');
+require('./chunk-3EDDDZS2.cjs');
+require('./chunk-YWTIXHU6.cjs');
+require('./chunk-2VHB43IX.cjs');
+require('./chunk-E26KKI46.cjs');
+require('./chunk-XF2WIKHR.cjs');
+
+
+var _chunkWGNMOVMTcjs = require('./chunk-WGNMOVMT.cjs');
+require('./chunk-CHI52KFR.cjs');
+require('./chunk-VBOFPU5M.cjs');
+require('./chunk-3HT76LNN.cjs');
+
+// src/modes/acp/index.ts
+var _stream = require('stream');
+var _sdk = require('@agentclientprotocol/sdk');
+
+// src/modes/acp/adapter.ts
+
+
+// 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",
+  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",
+  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: "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 = _nullishCoalesce(config.provider, () => ( "openrouter"));
+  const providerConfig = config[providerName];
+  if (_optionalChain([providerConfig, 'optionalAccess', _ => _.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 (_optionalChain([config, 'optionalAccess', _2 => _2.permissions, 'optionalAccess', _3 => _3.mode]) === "unrestricted") return "unrestricted";
+  if (_optionalChain([config, 'optionalAccess', _4 => _4.permissions, 'optionalAccess', _5 => _5.mode]) === "restricted") return "restricted";
+  return "interactive";
+}
+function resolveDefaultModel(config) {
+  const providerName = _nullishCoalesce(config.provider, () => ( "openrouter"));
+  const providerConfig = config[providerName];
+  return _nullishCoalesce(_optionalChain([providerConfig, 'optionalAccess', _6 => _6.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 = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _7 => _7.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 (_optionalChain([context, 'optionalAccess', _8 => _8.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: _optionalChain([context, 'optionalAccess', _9 => _9.command]),
+            path: _optionalChain([context, 'optionalAccess', _10 => _10.path]),
+            args: _optionalChain([context, 'optionalAccess', _11 => _11.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 _optionalChain([meta, 'optionalAccess', _12 => _12.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 = class _AutohandAcpAdapter {
+  constructor(connection, cliOptions = {}) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);_class.prototype.__init5.call(this);_class.prototype.__init6.call(this);_class.prototype.__init7.call(this);
+    this.connection = connection;
+    this.cliOptions = cliOptions;
+  }
+  
+  
+  __init() {this.sessions = /* @__PURE__ */ new Map()}
+  __init2() {this.agents = /* @__PURE__ */ new Map()}
+  __init3() {this.permissionBridges = /* @__PURE__ */ new Map()}
+  __init4() {this.sessionConfigOptions = /* @__PURE__ */ new Map()}
+  __init5() {this.cancelledSessions = /* @__PURE__ */ new Set()}
+  __init6() {this.config = null}
+  
+  __init7() {this.toolStartTimes = /* @__PURE__ */ new Map()}
+  static __initStatic() {this.LIST_SESSIONS_PAGE_SIZE = 50}
+  async ensureConfig() {
+    if (!this.config) {
+      this.config = await _chunk46C73ZKKcjs.loadConfig.call(void 0, 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: _nullishCoalesce(m.split("/").pop(), () => ( m))
+      })),
+      currentModelId: modelId
+    };
+  }
+  cloneConfigOptions(options) {
+    return structuredClone(options);
+  }
+  getSessionConfigOptions(sessionId) {
+    const options = _nullishCoalesce(this.sessionConfigOptions.get(sessionId), () => ( []));
+    return this.cloneConfigOptions(options);
+  }
+  validateMode(modeId) {
+    if (!DEFAULT_ACP_MODES.some((mode) => mode.id === modeId)) {
+      throw _sdk.RequestError.invalidParams({ message: `Unsupported mode: ${modeId}` });
+    }
+  }
+  validateModel(config, modelId) {
+    const models = parseAvailableModels(config);
+    if (!models.includes(modelId)) {
+      throw _sdk.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 (_chunk7LWQCE4Ycjs.isSessionWorktreeEnabled.call(void 0, this.cliOptions.worktree)) {
+      const sessionWorktree = _chunk7LWQCE4Ycjs.prepareSessionWorktree.call(void 0, {
+        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 = _chunkWRTXCQ3Vcjs.ProviderFactory.create(config);
+    const files = new (0, _chunk5K3CDSWZcjs.FileActionManager)(workspaceRoot);
+    const agent = new (0, _chunk7JLT2VNWcjs.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 = _chunkDA7NBAJKcjs.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 || _optionalChain([tc, 'access', _13 => _13.function, 'optionalAccess', _14 => _14.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 (!_optionalChain([msg, 'access', _15 => _15.content, 'optionalAccess', _16 => _16.trim, 'call', _17 => _17()])) {
+        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 _chunk46C73ZKKcjs.loadConfig.call(void 0, void 0, process.cwd());
+    return {
+      protocolVersion: _sdk.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: _chunkREMGR23Vcjs.package_default.version
+      }
+    };
+  }
+  // ==========================================================================
+  // ACP Agent Interface: authenticate
+  // ==========================================================================
+  async authenticate(_params) {
+    if (_optionalChain([this, 'access', _18 => _18.config, 'optionalAccess', _19 => _19.auth, 'optionalAccess', _20 => _20.token])) {
+      return {};
+    }
+    const provider = _nullishCoalesce(_optionalChain([this, 'access', _21 => _21.config, 'optionalAccess', _22 => _22.provider]), () => ( "openrouter"));
+    const providerConfig = _optionalChain([this, 'access', _23 => _23.config, 'optionalAccess', _24 => _24[provider]]);
+    if (_optionalChain([providerConfig, 'optionalAccess', _25 => _25.apiKey])) {
+      return {};
+    }
+    throw _sdk.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: DEFAULT_ACP_COMMANDS.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 _sdk.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 = _nullishCoalesce(_optionalChain([block, 'access', _26 => _26.resource, 'optionalAccess', _27 => _27.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("/") && !_chunk7JLT2VNWcjs.isLikelyFilePathSlashInput.call(void 0, 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 _sdk.RequestError.invalidParams({ message: "Session not found" });
+    }
+    if (!agent) {
+      throw _sdk.RequestError.invalidParams({ message: "Session agent not found" });
+    }
+    this.validateMode(params.modeId);
+    session.modeId = params.modeId;
+    _optionalChain([this, 'access', _28 => _28.permissionBridges, 'access', _29 => _29.get, 'call', _30 => _30(params.sessionId), 'optionalAccess', _31 => _31.setMode, 'call', _32 => _32(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 _sdk.RequestError.invalidParams({ message: "Session not found" });
+    }
+    if (!agent) {
+      throw _sdk.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 _sdk.RequestError.invalidParams({ message: "Session not found" });
+    }
+    const option = options.find((entry) => entry.id === params.configId);
+    if (!option) {
+      throw _sdk.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 _sdk.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 Promise.resolve().then(() => _interopRequireWildcard(require("./SessionManager-WAPTFMDO.cjs")));
+      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 _sdk.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: _nullishCoalesce(s.projectPath, () => ( "")),
+          title: _nullishCoalesce(_nullishCoalesce(s.summary, () => ( s.projectName)), () => ( `Session ${s.sessionId.slice(0, 8)}`)),
+          updatedAt: _nullishCoalesce(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 _sdk.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 _sdk.RequestError.invalidParams({ message: "Source session not found" });
+    }
+    const sourceAgent = this.agents.get(params.sessionId);
+    if (sourceAgent) {
+      try {
+        const conversation = _chunkDA7NBAJKcjs.ConversationManager.getInstance();
+        const { extractAndSaveSessionMemories } = await Promise.resolve().then(() => _interopRequireWildcard(require("./extractSessionMemories-XL3MS37F.cjs")));
+        await extractAndSaveSessionMemories({
+          llm: sourceAgent.getLlmProvider(),
+          memoryManager: sourceAgent.getMemoryManager(),
+          conversationHistory: conversation.history(),
+          workspaceRoot: sourceSession.workspaceRoot
+        });
+      } catch (e) {
+      }
+    }
+    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 _sdk.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 = _nullishCoalesce(event.toolId, () => ( `tool_${Date.now()}`));
+            const kind = resolveToolKind(event.toolName);
+            const title = resolveToolDisplayName(event.toolName);
+            const locations = [];
+            if (_optionalChain([event, 'access', _33 => _33.toolArgs, 'optionalAccess', _34 => _34.path]) && typeof event.toolArgs.path === "string") {
+              locations.push({ path: event.toolArgs.path });
+            }
+            if (_optionalChain([event, 'access', _35 => _35.toolArgs, 'optionalAccess', _36 => _36.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: _nullishCoalesce(event.toolArgs, () => ( {}))
+              }
+            });
+            this.toolStartTimes.set(toolCallId, Date.now());
+            this.emitHookPreTool(sessionId, toolCallId, event.toolName, _nullishCoalesce(event.toolArgs, () => ( {})));
+          }
+          break;
+        case "tool_end":
+          if (event.toolName) {
+            const toolCallId = _nullishCoalesce(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,
+              _nullishCoalesce(event.changeType, () => ( "modify")),
+              _nullishCoalesce(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 _chunk3OF56EMAcjs.ApiError) {
+      return {
+        message: error.rawDetail || error.message,
+        code: error.code,
+        recoverable: error.retryable
+      };
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, message);
+    return {
+      message,
+      code: classified.code,
+      recoverable: classified.retryable
+    };
+  }
+}, _class.__initStatic(), _class);
+
+// 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 = _nullishCoalesce(options.path, () => ( process.cwd()));
+  const workspacePathValidation = await _chunk3LJJG5YYcjs.validateWorkspacePath.call(void 0, workspacePath);
+  if (!workspacePathValidation.valid) {
+    process.stderr.write(`[ACP] Error: ${workspacePathValidation.error}
+`);
+    process.exit(1);
+  }
+  const safetyCheck = _chunkWGNMOVMTcjs.checkWorkspaceSafety.call(void 0, 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");
+  _chunkMO4KP6XScjs.installProcessErrorHandlers.call(void 0, );
+  const input = _stream.Writable.toWeb(process.stdout);
+  const output = _stream.Readable.toWeb(process.stdin);
+  const stream = _sdk.ndJsonStream.call(void 0, input, output);
+  const _connection = new (0, _sdk.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");
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.ACP_HOOK_NOTIFICATIONS = ACP_HOOK_NOTIFICATIONS; exports.AutohandAcpAdapter = AutohandAcpAdapter; exports.DEFAULT_ACP_COMMANDS = DEFAULT_ACP_COMMANDS; exports.DEFAULT_ACP_MODES = DEFAULT_ACP_MODES; exports.TOOL_DISPLAY_NAMES = TOOL_DISPLAY_NAMES; exports.TOOL_KIND_MAP = TOOL_KIND_MAP; exports.buildConfigOptions = buildConfigOptions; exports.createPermissionBridge = createPermissionBridge; exports.parseAvailableModels = parseAvailableModels; exports.resolveDefaultMode = resolveDefaultMode; exports.resolveDefaultModel = resolveDefaultModel; exports.resolveToolDisplayName = resolveToolDisplayName; exports.resolveToolKind = resolveToolKind; exports.runAcpMode = runAcpMode;