autohand-cli 0.8.2 → 0.9.0

package/dist/rpc-NPS3PU4O.cjs

@@ -0,0 +1,3730 @@
+"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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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 _class2;
+
+var _chunk7JLT2VNWcjs = require('./chunk-7JLT2VNW.cjs');
+
+
+var _chunk5K3CDSWZcjs = require('./chunk-5K3CDSWZ.cjs');
+require('./chunk-QMAKTSZB.cjs');
+require('./chunk-HQWQZML5.cjs');
+
+
+var _chunkVGEV44V2cjs = require('./chunk-VGEV44V2.cjs');
+require('./chunk-Q6AC3PHY.cjs');
+require('./chunk-5CMYEM3R.cjs');
+
+
+var _chunkDI57A4BXcjs = 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');
+
+
+
+
+var _chunkJ5HE6CUMcjs = 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');
+
+
+var _chunkHSCUPEA4cjs = require('./chunk-HSCUPEA4.cjs');
+require('./chunk-WBU4Q4GS.cjs');
+
+
+var _chunkLFDPTJYFcjs = 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 _chunk7LWQCE4Ycjs = require('./chunk-7LWQCE4Y.cjs');
+
+
+var _chunk3LJJG5YYcjs = require('./chunk-3LJJG5YY.cjs');
+require('./chunk-XDLH4EDL.cjs');
+
+
+
+
+var _chunkMPULXVC4cjs = require('./chunk-MPULXVC4.cjs');
+
+
+var _chunkQ2IL4DDIcjs = require('./chunk-Q2IL4DDI.cjs');
+require('./chunk-FMB3TSWP.cjs');
+require('./chunk-IKUMVBCW.cjs');
+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/rpc/index.ts
+var _fsextra = require('fs-extra'); var _fsextra2 = _interopRequireDefault(_fsextra);
+var _path = require('path'); var _path2 = _interopRequireDefault(_path);
+
+// src/modes/rpc/types.ts
+var JSON_RPC_ERROR_CODES = {
+  // Standard JSON-RPC 2.0 errors
+  PARSE_ERROR: -32700,
+  INVALID_REQUEST: -32600,
+  METHOD_NOT_FOUND: -32601,
+  INVALID_PARAMS: -32602,
+  INTERNAL_ERROR: -32603,
+  // Server errors (reserved for implementation-defined errors: -32000 to -32099)
+  EXECUTION_ERROR: -32e3,
+  PERMISSION_DENIED: -32001,
+  TIMEOUT: -32002,
+  AGENT_BUSY: -32003,
+  ABORTED: -32004
+};
+var RPC_METHODS = {
+  // Client -> Server requests
+  PROMPT: "autohand.prompt",
+  ABORT: "autohand.abort",
+  RESET: "autohand.reset",
+  GET_STATE: "autohand.getState",
+  GET_MESSAGES: "autohand.getMessages",
+  BROWSER_HANDOFF_CREATE: "autohand.browserHandoff.create",
+  BROWSER_HANDOFF_ATTACH: "autohand.browserHandoff.attach",
+  BROWSER_HANDOFF_ATTACH_LATEST: "autohand.browserHandoff.attachLatest",
+  PERMISSION_RESPONSE: "autohand.permissionResponse",
+  PERMISSION_ACKNOWLEDGED: "autohand.permissionAcknowledged",
+  DIRECTORY_ACCESS_RESPONSE: "autohand.directoryAccessResponse",
+  DIRECTORY_ACCESS_ACKNOWLEDGED: "autohand.directoryAccessAcknowledged",
+  // Multi-file change preview
+  CHANGES_DECISION: "autohand.changesDecision",
+  // Skills management (non-interactive for RPC mode)
+  GET_SKILLS_REGISTRY: "autohand.getSkillsRegistry",
+  INSTALL_SKILL: "autohand.installSkill",
+  // Auto-mode control
+  AUTOMODE_START: "autohand.automode.start",
+  AUTOMODE_STATUS: "autohand.automode.status",
+  AUTOMODE_PAUSE: "autohand.automode.pause",
+  AUTOMODE_RESUME: "autohand.automode.resume",
+  AUTOMODE_CANCEL: "autohand.automode.cancel",
+  AUTOMODE_GET_LOG: "autohand.automode.getLog",
+  // Plan mode control
+  PLAN_MODE_SET: "autohand.planModeSet",
+  // Session history
+  GET_HISTORY: "autohand.getHistory",
+  GET_SESSION: "autohand.getSession",
+  // YOLO mode control
+  YOLO_SET: "autohand.yoloSet",
+  // MCP (Model Context Protocol) management
+  MCP_LIST_SERVERS: "autohand.mcp.listServers",
+  MCP_LIST_TOOLS: "autohand.mcp.listTools",
+  MCP_SET_VSCODE_TOOLS: "autohand.mcp.setVscodeTools",
+  MCP_INVOKE_RESPONSE: "autohand.mcp.invokeResponse",
+  MCP_GET_SERVER_CONFIGS: "autohand.mcp.getServerConfigs",
+  LEARN_RECOMMEND: "autohand.learn.recommend",
+  LEARN_UPDATE: "autohand.learn.update",
+  LEARN_GENERATE: "autohand.learn.generate",
+  SKILLS_SEARCH: "autohand.skills.search",
+  SKILLS_TRENDING: "autohand.skills.trending",
+  SKILLS_REMOVE: "autohand.skills.remove",
+  SKILLS_INSTALL: "autohand.skills.install",
+  // SDK control methods
+  SET_PERMISSION_MODE: "autohand.permissionModeSet",
+  SET_MODEL: "autohand.modelSet",
+  SET_MAX_THINKING_TOKENS: "autohand.maxThinkingTokensSet",
+  APPLY_FLAG_SETTINGS: "autohand.applyFlagSettings",
+  GET_SUPPORTED_MODELS: "autohand.getSupportedModels",
+  GET_SUPPORTED_COMMANDS: "autohand.getSupportedCommands",
+  GET_TOOLS_REGISTRY: "autohand.getToolsRegistry",
+  GET_CONTEXT_USAGE: "autohand.getContextUsage",
+  RELOAD_PLUGINS: "autohand.reloadPlugins",
+  GET_ACCOUNT_INFO: "autohand.getAccountInfo",
+  MCP_TOGGLE_SERVER: "autohand.mcp.toggleServer",
+  MCP_RECONNECT_SERVER: "autohand.mcp.reconnectServer",
+  MCP_SET_SERVERS: "autohand.mcp.setServers",
+  // Context compaction control
+  SET_CONTEXT_COMPACT: "autohand.setContextCompact",
+  // Setup wizard
+  SETUP: "autohand.setup"
+};
+var RPC_NOTIFICATIONS = {
+  AGENT_START: "autohand.agentStart",
+  AGENT_END: "autohand.agentEnd",
+  PING: "autohand.ping",
+  TURN_START: "autohand.turnStart",
+  TURN_END: "autohand.turnEnd",
+  MESSAGE_START: "autohand.messageStart",
+  MESSAGE_UPDATE: "autohand.messageUpdate",
+  MESSAGE_END: "autohand.messageEnd",
+  TOOL_START: "autohand.toolStart",
+  TOOL_UPDATE: "autohand.toolUpdate",
+  TOOL_END: "autohand.toolEnd",
+  PERMISSION_REQUEST: "autohand.permissionRequest",
+  DIRECTORY_ACCESS_REQUEST: "autohand.directoryAccessRequest",
+  ERROR: "autohand.error",
+  // Multi-file change preview notifications
+  CHANGES_BATCH_START: "autohand.changesBatchStart",
+  CHANGES_BATCH_UPDATE: "autohand.changesBatchUpdate",
+  CHANGES_BATCH_END: "autohand.changesBatchEnd",
+  // Hook lifecycle 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",
+  // Auto-mode lifecycle notifications
+  AUTOMODE_START: "autohand.automode.start",
+  AUTOMODE_ITERATION: "autohand.automode.iteration",
+  AUTOMODE_CHECKPOINT: "autohand.automode.checkpoint",
+  AUTOMODE_PAUSE: "autohand.automode.pause",
+  AUTOMODE_RESUME: "autohand.automode.resume",
+  AUTOMODE_CANCEL: "autohand.automode.cancel",
+  AUTOMODE_COMPLETE: "autohand.automode.complete",
+  AUTOMODE_ERROR: "autohand.automode.error",
+  // Mode change notifications
+  MODE_CHANGE: "autohand.modeChange",
+  // Pipe mode notifications
+  PIPE_OUTPUT: "autohand.pipe.output",
+  PIPE_COMPLETE: "autohand.pipe.complete",
+  PIPE_ERROR: "autohand.pipe.error",
+  // MCP bridge notifications (Server -> Client)
+  MCP_INVOKE_REQUEST: "autohand.mcp.invokeRequest",
+  MCP_TOOLS_CHANGED: "autohand.mcp.toolsChanged",
+  LEARN_INSTALL_COMPLETE: "autohand.learn.installComplete",
+  LEARN_SECURITY_WARNING: "autohand.learn.securityWarning",
+  LEARN_PROGRESS: "autohand.learn.progress",
+  SCHEDULE_TRIGGERED: "autohand.schedule.triggered",
+  // 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",
+  // Context lifecycle notifications
+  HOOK_CONTEXT_COMPACTED: "autohand.hook.contextCompacted",
+  HOOK_CONTEXT_OVERFLOW: "autohand.hook.contextOverflow",
+  HOOK_CONTEXT_WARNING: "autohand.hook.contextWarning",
+  HOOK_CONTEXT_CRITICAL: "autohand.hook.contextCritical"
+};
+var MAX_IMAGE_SIZE = 10 * 1024 * 1024;
+var VALID_IMAGE_MIME_TYPES = [
+  "image/png",
+  "image/jpeg",
+  "image/gif",
+  "image/webp"
+];
+function isValidImageMimeType(mimeType) {
+  return VALID_IMAGE_MIME_TYPES.includes(mimeType);
+}
+function isJsonRpcRequest(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const req = obj;
+  return req.jsonrpc === "2.0" && typeof req.method === "string";
+}
+function isJsonRpcResponse(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  const res = obj;
+  return res.jsonrpc === "2.0" && ("result" in res || "error" in res);
+}
+function isJsonRpcBatch(obj) {
+  return Array.isArray(obj) && obj.length > 0;
+}
+function isNotification(request) {
+  return request.id === void 0;
+}
+function createRequest(method, params, id) {
+  const request = {
+    jsonrpc: "2.0",
+    method
+  };
+  if (params !== void 0) {
+    request.params = params;
+  }
+  if (id !== void 0) {
+    request.id = id;
+  }
+  return request;
+}
+function createResponse(id, result) {
+  return {
+    jsonrpc: "2.0",
+    result,
+    id
+  };
+}
+function createErrorResponse(id, code, message, data) {
+  const response = {
+    jsonrpc: "2.0",
+    error: { code, message },
+    id
+  };
+  if (data !== void 0) {
+    response.error.data = data;
+  }
+  return response;
+}
+function createNotification(method, params) {
+  const notification = {
+    jsonrpc: "2.0",
+    method
+  };
+  if (params !== void 0) {
+    notification.params = params;
+  }
+  return notification;
+}
+
+// src/modes/rpc/adapter.ts
+var _crypto = require('crypto'); var _crypto2 = _interopRequireDefault(_crypto);
+
+// src/modes/rpc/protocol.ts
+function parseRequest(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return {
+      type: "error",
+      code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+      message: "Empty request"
+    };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (e2) {
+    return {
+      type: "error",
+      code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+      message: "Parse error: Invalid JSON"
+    };
+  }
+  if (isJsonRpcBatch(parsed)) {
+    const validRequests = [];
+    for (const item of parsed) {
+      if (isJsonRpcRequest(item)) {
+        validRequests.push(item);
+      }
+    }
+    if (validRequests.length === 0) {
+      return {
+        type: "error",
+        code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+        message: "Invalid batch: No valid requests"
+      };
+    }
+    return { type: "batch", requests: validRequests };
+  }
+  if (isJsonRpcRequest(parsed)) {
+    return { type: "single", request: parsed };
+  }
+  return {
+    type: "error",
+    code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+    message: "Invalid request: Missing jsonrpc version or method"
+  };
+}
+function serialize(obj) {
+  try {
+    return JSON.stringify(obj);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown serialization error";
+    process.stderr.write(`[RPC] Serialization error: ${message}
+`);
+    return JSON.stringify({
+      jsonrpc: "2.0",
+      error: {
+        code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        message: `Serialization failed: ${message}`
+      },
+      id: null
+    });
+  }
+}
+function serializeBatch(responses) {
+  try {
+    return JSON.stringify(responses);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown serialization error";
+    process.stderr.write(`[RPC] Batch serialization error: ${message}
+`);
+    return JSON.stringify([{
+      jsonrpc: "2.0",
+      error: {
+        code: JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        message: `Batch serialization failed: ${message}`
+      },
+      id: null
+    }]);
+  }
+}
+function createTimestamp() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+var idCounter = 0;
+function generateId(prefix = "id") {
+  return `${prefix}_${++idCounter}_${Date.now()}`;
+}
+var LineReader = (_class = class {
+  constructor(stream) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);_class.prototype.__init3.call(this);_class.prototype.__init4.call(this);
+    this.stream = stream;
+    this.stream.setEncoding("utf8");
+    this.stream.on("data", (chunk) => this.handleData(chunk));
+    this.stream.on("end", () => this.handleEnd());
+    this.stream.on("close", () => this.handleClose());
+  }
+  
+  __init() {this.buffer = ""}
+  __init2() {this.lineQueue = []}
+  __init3() {this.resolvers = []}
+  __init4() {this.closed = false}
+  handleData(chunk) {
+    this.buffer += chunk;
+    let newlineIndex;
+    while ((newlineIndex = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIndex);
+      this.buffer = this.buffer.slice(newlineIndex + 1);
+      if (line.trim()) {
+        this.deliverLine(line);
+      }
+    }
+  }
+  handleEnd() {
+    if (this.buffer.trim()) {
+      this.deliverLine(this.buffer);
+    }
+    this.buffer = "";
+    this.closed = true;
+  }
+  handleClose() {
+    this.closed = true;
+  }
+  deliverLine(line) {
+    if (this.resolvers.length > 0) {
+      const resolver = this.resolvers.shift();
+      resolver(line);
+    } else {
+      this.lineQueue.push(line);
+    }
+  }
+  /**
+   * Read the next line (async)
+   */
+  async readLine() {
+    if (this.lineQueue.length > 0) {
+      return this.lineQueue.shift();
+    }
+    if (this.closed) {
+      throw new Error("Stream closed");
+    }
+    return new Promise((resolve) => {
+      this.resolvers.push(resolve);
+    });
+  }
+  /**
+   * Check if there are pending lines
+   */
+  hasPendingLines() {
+    return this.lineQueue.length > 0;
+  }
+  /**
+   * Check if the stream is closed
+   */
+  isClosed() {
+    return this.closed;
+  }
+}, _class);
+function writeResponse(id, result) {
+  try {
+    const response = createResponse(id, result);
+    const serialized = serialize(response) + "\n";
+    process.stderr.write(`[RPC DEBUG] writeResponse id=${id} size=${serialized.length}b
+`);
+    process.stdout.write(serialized);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown write error";
+    process.stderr.write(`[RPC] Failed to write response for id '${id}': ${message}
+`);
+  }
+}
+function writeErrorResponse(id, code, message, data) {
+  try {
+    const response = createErrorResponse(id, code, message, data);
+    const serialized = serialize(response) + "\n";
+    process.stderr.write(`[RPC DEBUG] writeErrorResponse id=${id} size=${serialized.length}b
+`);
+    process.stdout.write(serialized);
+  } catch (error) {
+    const errMsg = error instanceof Error ? error.message : "Unknown write error";
+    process.stderr.write(`[RPC] Failed to write error response: ${errMsg}
+`);
+  }
+}
+function writeBatchResponse(responses) {
+  if (responses.length > 0) {
+    try {
+      const serialized = serializeBatch(responses) + "\n";
+      process.stderr.write(`[RPC DEBUG] writeBatchResponse count=${responses.length} size=${serialized.length}b
+`);
+      process.stdout.write(serialized);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown write error";
+      process.stderr.write(`[RPC] Failed to write batch response: ${message}
+`);
+    }
+  }
+}
+function writeNotification(method, params) {
+  try {
+    const notification = createNotification(method, params);
+    const serialized = serialize(notification) + "\n";
+    if (method !== "autohand.ping") {
+      process.stderr.write(`[RPC DEBUG] writeNotification method=${method} size=${serialized.length}b
+`);
+    }
+    process.stdout.write(serialized);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown write error";
+    process.stderr.write(`[RPC] Failed to write notification '${method}': ${message}
+`);
+  }
+}
+function writeParseError(message = "Parse error") {
+  writeErrorResponse(null, JSON_RPC_ERROR_CODES.PARSE_ERROR, message);
+}
+function writeInvalidRequestError(id, message = "Invalid request") {
+  writeErrorResponse(id, JSON_RPC_ERROR_CODES.INVALID_REQUEST, message);
+}
+function writeMethodNotFoundError(id, method) {
+  writeErrorResponse(
+    id,
+    JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+    `Method not found: ${method}`
+  );
+}
+function writeInternalError(id, message, data) {
+  writeErrorResponse(id, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message, data);
+}
+
+// src/modes/rpc/adapter.ts
+var RPC_ERROR_TYPE_MAP = {
+  context_overflow: "context",
+  model_not_found: "model",
+  invalid_request: "context",
+  auth_failed: "auth",
+  payment_required: "payment",
+  access_denied: "model",
+  rate_limited: "rate_limit",
+  server_error: "server",
+  network_error: "network",
+  timeout: "network",
+  cancelled: "unknown",
+  unknown: "unknown"
+};
+var RPC_ERROR_CODE_MAP = {
+  context_overflow: 400,
+  model_not_found: 404,
+  invalid_request: 400,
+  auth_failed: 401,
+  payment_required: 402,
+  access_denied: 403,
+  rate_limited: 429,
+  server_error: 500,
+  network_error: 504,
+  timeout: 504,
+  cancelled: -32e3,
+  unknown: -32e3
+};
+var RPC_ERROR_ICON_MAP = {
+  context_overflow: "\u{1F4E6}",
+  // 📦
+  model_not_found: "\u{1F916}",
+  // 🤖
+  invalid_request: "\u{1F4E6}",
+  // 📦
+  auth_failed: "\u{1F510}",
+  // 🔐
+  payment_required: "\u{1F4B3}",
+  // 💳
+  access_denied: "\u{1F916}",
+  // 🤖
+  rate_limited: "\u23F1\uFE0F",
+  // ⏱️
+  server_error: "\u{1F527}",
+  // 🔧
+  network_error: "\u{1F310}",
+  // 🌐
+  timeout: "\u{1F310}",
+  // 🌐
+  cancelled: "\u26A0\uFE0F",
+  // ⚠️
+  unknown: "\u26A0\uFE0F"
+  // ⚠️
+};
+var RPCAdapter = (_class2 = class {constructor() { _class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this);_class2.prototype.__init8.call(this);_class2.prototype.__init9.call(this);_class2.prototype.__init10.call(this);_class2.prototype.__init11.call(this);_class2.prototype.__init12.call(this);_class2.prototype.__init13.call(this);_class2.prototype.__init14.call(this);_class2.prototype.__init15.call(this);_class2.prototype.__init16.call(this);_class2.prototype.__init17.call(this);_class2.prototype.__init18.call(this);_class2.prototype.__init19.call(this);_class2.prototype.__init20.call(this);_class2.prototype.__init21.call(this);_class2.prototype.__init22.call(this);_class2.prototype.__init23.call(this);_class2.prototype.__init24.call(this);_class2.prototype.__init25.call(this);_class2.prototype.__init26.call(this);_class2.prototype.__init27.call(this);_class2.prototype.__init28.call(this); }
+  __init5() {this.agent = null}
+  __init6() {this.conversation = null}
+  __init7() {this.imageManager = null}
+  __init8() {this.sessionId = null}
+  __init9() {this.currentTurnId = null}
+  __init10() {this.turnStartTime = null}
+  __init11() {this.currentMessageId = null}
+  __init12() {this.currentMessageContent = ""}
+  __init13() {this.pendingPermissions = /* @__PURE__ */ new Map()}
+  __init14() {this.pendingDirectoryAccess = /* @__PURE__ */ new Map()}
+  __init15() {this.abortController = null}
+  __init16() {this.status = "idle"}
+  __init17() {this.model = ""}
+  __init18() {this.workspace = ""}
+  __init19() {this.contextPercent = 0}
+  __init20() {this.currentChangesBatchId = null}
+  // Enable preview mode for multi-file change batching (future: make configurable)
+  __init21() {this.previewModeEnabled = true}
+  // MCP bridge: VS Code tools registered by the extension
+  __init22() {this.vscodeTools = /* @__PURE__ */ new Map()}
+  // MCP bridge: pending tool invocations waiting for extension response
+  __init23() {this.pendingVscodeInvocations = /* @__PURE__ */ new Map()}
+  // MCP server configurations from CLI config (set during initialization)
+  __init24() {this.mcpServerConfigs = []}
+  // Cached vision support result (null = not yet checked)
+  __init25() {this.visionSupported = null}
+  // Keepalive interval to prevent Chrome from killing the MV3 service worker
+  // during long turns with no traffic.
+  __init26() {this.keepaliveInterval = null}
+  __init27() {this.KEEPALIVE_MS = 15e3}
+  // Config reference for runtime settings changes
+  __init28() {this.config = {}}
+  /**
+   * Check if the current model supports vision/image inputs.
+   * Uses async OpenRouter API with pattern-matching fallback, cached for the session.
+   */
+  async checkVisionSupport() {
+    if (this.visionSupported !== null) {
+      return this.visionSupported;
+    }
+    this.visionSupported = await _chunkWRTXCQ3Vcjs.modelSupportsImages.call(void 0, this.model);
+    return this.visionSupported;
+  }
+  /**
+   * Initialize the adapter with an agent instance
+   */
+  initialize(agent, conversation, model, workspace, mcpServerConfigs) {
+    this.agent = agent;
+    this.conversation = conversation;
+    this.model = model;
+    this.workspace = workspace;
+    this.sessionId = generateId("session");
+    this.mcpServerConfigs = _nullishCoalesce(mcpServerConfigs, () => ( []));
+    this.imageManager = _nullishCoalesce(_optionalChain([agent, 'access', _ => _.getImageManager, 'optionalCall', _2 => _2()]), () => ( new (0, _chunkHSCUPEA4cjs.ImageManager)()));
+    agent.setStatusListener((snapshot) => {
+      this.contextPercent = snapshot.contextPercent;
+      this.model = snapshot.model;
+    });
+    agent.setOutputListener((event) => {
+      this.handleAgentOutput(event);
+    });
+    writeNotification(RPC_NOTIFICATIONS.AGENT_START, {
+      sessionId: this.sessionId,
+      model: this.model,
+      workspace: this.workspace,
+      timestamp: createTimestamp(),
+      contextPercent: this.contextPercent
+    });
+  }
+  /**
+   * Get current agent state
+   */
+  getState() {
+    return {
+      status: this.status,
+      sessionId: this.sessionId,
+      model: this.model,
+      workspace: this.workspace,
+      contextPercent: this.contextPercent,
+      messageCount: _nullishCoalesce(_optionalChain([this, 'access', _3 => _3.conversation, 'optionalAccess', _4 => _4.history, 'call', _5 => _5(), 'access', _6 => _6.length]), () => ( 0))
+    };
+  }
+  /**
+   * Get message history
+   */
+  getMessages(limit) {
+    if (!this.conversation) {
+      return [];
+    }
+    let messages = this.conversation.history();
+    if (limit && limit > 0) {
+      messages = messages.slice(-limit);
+    }
+    return messages.map((msg, index) => this.convertMessage(msg, index));
+  }
+  /**
+   * Handle a prompt request
+   * Returns result for JSON-RPC response
+   */
+  async handlePrompt(requestId, params) {
+    if (!this.agent) {
+      throw new Error("Agent not initialized");
+    }
+    if (this.status === "processing") {
+      throw new Error("Agent is already processing");
+    }
+    this.status = "processing";
+    this.abortController = new AbortController();
+    this.startKeepalive();
+    this.currentTurnId = generateId("turn");
+    this.turnStartTime = Date.now();
+    writeNotification(RPC_NOTIFICATIONS.TURN_START, {
+      turnId: this.currentTurnId,
+      timestamp: createTimestamp()
+    });
+    try {
+      const imagePlaceholders = [];
+      process.stderr.write(`[RPC] handlePrompt: images=${_optionalChain([params, 'access', _7 => _7.images, 'optionalAccess', _8 => _8.length]) || 0}, hasImageManager=${!!this.imageManager}, model=${this.model}
+`);
+      if (params.images && params.images.length > 0) {
+        const supportsVisionResult = await this.checkVisionSupport();
+        if (!supportsVisionResult) {
+          process.stderr.write(`[RPC] WARNING: Model '${this.model}' does not support vision. Images will not be processed.
+`);
+          writeNotification(RPC_NOTIFICATIONS.ERROR, {
+            code: -32e3,
+            message: `Model '${this.model}' does not support image inputs. Please use a vision-capable model like claude-3.5-sonnet, gpt-4o, or gemini-1.5-pro.`,
+            recoverable: true,
+            timestamp: createTimestamp()
+          });
+        }
+      }
+      if (params.images && params.images.length > 0 && this.imageManager && await this.checkVisionSupport()) {
+        process.stderr.write(`[RPC] Processing ${params.images.length} images
+`);
+        for (const img of params.images) {
+          try {
+            process.stderr.write(`[RPC] Image: mimeType=${img.mimeType}, dataLength=${_optionalChain([img, 'access', _9 => _9.data, 'optionalAccess', _10 => _10.length]) || 0}
+`);
+            if (!isValidImageMimeType(img.mimeType)) {
+              process.stderr.write(`[RPC] Invalid MIME type: ${img.mimeType}
+`);
+              writeNotification(RPC_NOTIFICATIONS.ERROR, {
+                code: -32602,
+                // Invalid params
+                message: `Invalid image MIME type: ${img.mimeType}`,
+                recoverable: true,
+                timestamp: createTimestamp()
+              });
+              continue;
+            }
+            const data = Buffer.from(img.data, "base64");
+            process.stderr.write(`[RPC] Image decoded: ${data.length} bytes
+`);
+            if (data.length > MAX_IMAGE_SIZE) {
+              writeNotification(RPC_NOTIFICATIONS.ERROR, {
+                code: -32602,
+                message: `Image too large: ${Math.round(data.length / 1024 / 1024)}MB (max: ${Math.round(MAX_IMAGE_SIZE / 1024 / 1024)}MB)`,
+                recoverable: true,
+                timestamp: createTimestamp()
+              });
+              continue;
+            }
+            const id = this.imageManager.add(data, img.mimeType, img.filename);
+            const placeholder = this.imageManager.formatPlaceholder(id);
+            imagePlaceholders.push(placeholder);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : "Unknown error";
+            writeNotification(RPC_NOTIFICATIONS.ERROR, {
+              code: -32e3,
+              message: `Failed to process image: ${message}`,
+              recoverable: true,
+              timestamp: createTimestamp()
+            });
+          }
+        }
+      }
+      let instruction = params.message;
+      const isSlashCmd = this.agent.isSlashCommand(instruction);
+      if (!isSlashCmd) {
+        if (imagePlaceholders.length > 0) {
+          process.stderr.write(`[RPC] Image placeholders: ${imagePlaceholders.join(", ")}
+`);
+          instruction = `${imagePlaceholders.join(" ")}
+
+${instruction}`;
+        } else if (params.images && params.images.length > 0) {
+          process.stderr.write(`[RPC] WARNING: Images provided but no placeholders generated!
+`);
+        }
+        if (_optionalChain([params, 'access', _11 => _11.context, 'optionalAccess', _12 => _12.selection])) {
+          const sel = params.context.selection;
+          instruction = `${instruction}
+
+Context from ${sel.file} (lines ${sel.startLine}-${sel.endLine}):
+\`\`\`
+${sel.text}
+\`\`\``;
+        }
+      }
+      this.currentMessageId = generateId("msg");
+      this.currentMessageContent = "";
+      writeNotification(RPC_NOTIFICATIONS.MESSAGE_START, {
+        messageId: this.currentMessageId,
+        role: "assistant",
+        timestamp: createTimestamp()
+      });
+      let success = false;
+      try {
+        process.stderr.write(`[RPC DEBUG] Executing instruction: ${instruction.substring(0, 100)}
+`);
+        if (isSlashCmd) {
+          const { command, args } = this.agent.parseSlashCommand(instruction);
+          process.stderr.write(`[RPC DEBUG] Handling slash command: ${command}, args: ${JSON.stringify(args)}
+`);
+          if (this.agent.isSlashCommandSupported(command)) {
+            const result = await this.agent.handleSlashCommand(command, args);
+            if (result !== null) {
+              this.currentMessageContent = result;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: result,
+                timestamp: createTimestamp()
+              });
+            } else {
+              this.currentMessageContent = `Command ${command} executed.`;
+              writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+                messageId: this.currentMessageId,
+                delta: this.currentMessageContent,
+                timestamp: createTimestamp()
+              });
+            }
+            success = true;
+          } else {
+            this.currentMessageContent = `Unknown command: ${command}. Type /help for available commands.`;
+            writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+              messageId: this.currentMessageId,
+              delta: this.currentMessageContent,
+              timestamp: createTimestamp()
+            });
+            success = false;
+          }
+        } else {
+          const fileManager = this.agent.getFileManager();
+          process.stderr.write(`[RPC DEBUG] previewModeEnabled=${this.previewModeEnabled}, hasFileManager=${!!fileManager}
+`);
+          if (this.previewModeEnabled && fileManager) {
+            this.currentChangesBatchId = generateId("changes");
+            process.stderr.write(`[RPC DEBUG] Entering preview mode with batchId=${this.currentChangesBatchId}
+`);
+            this.emitChangesBatchStart(this.currentChangesBatchId);
+            fileManager.enterPreviewMode(this.currentChangesBatchId, (change) => {
+              this.emitChangesBatchUpdate(this.currentChangesBatchId, {
+                id: change.id,
+                filePath: change.filePath,
+                changeType: change.changeType,
+                originalContent: change.originalContent,
+                proposedContent: change.proposedContent,
+                description: change.description,
+                toolId: change.toolId,
+                toolName: change.toolName
+              });
+            });
+          }
+          try {
+            success = await this.agent.runInstruction(instruction);
+          } finally {
+            if (this.previewModeEnabled && fileManager && this.currentChangesBatchId) {
+              const pendingChanges = fileManager.getPendingChanges();
+              process.stderr.write(`[RPC DEBUG] Turn finished, pendingChanges=${pendingChanges.length}, files=${pendingChanges.map((c) => c.filePath).join(", ")}
+`);
+              this.emitChangesBatchEnd(this.currentChangesBatchId, pendingChanges.length);
+              if (pendingChanges.length === 0) {
+                fileManager.exitPreviewMode();
+              }
+              this.currentChangesBatchId = null;
+            }
+          }
+        }
+        process.stderr.write(`[RPC DEBUG] Instruction completed, success=${success}, content length=${this.currentMessageContent.length}
+`);
+        const turnDuration = this.turnStartTime ? Date.now() - this.turnStartTime : 0;
+        try {
+          const hookManager = _optionalChain([this, 'access', _13 => _13.agent, 'optionalAccess', _14 => _14.getHookManager, 'optionalCall', _15 => _15()]);
+          process.stderr.write(`[RPC DEBUG] Hook execution: hookManager=${!!hookManager}
+`);
+          if (hookManager) {
+            const snapshot2 = _optionalChain([this, 'access', _16 => _16.agent, 'optionalAccess', _17 => _17.getStatusSnapshot, 'call', _18 => _18()]);
+            process.stderr.write(`[RPC DEBUG] Executing stop hooks...
+`);
+            await hookManager.executeHooks("stop", {
+              sessionId: this.sessionId || void 0,
+              turnDuration,
+              tokensUsed: _nullishCoalesce(_optionalChain([snapshot2, 'optionalAccess', _19 => _19.tokensUsed]), () => ( 0))
+            });
+            process.stderr.write(`[RPC DEBUG] Stop hooks completed
+`);
+            this.emitHookStop(
+              _nullishCoalesce(_optionalChain([snapshot2, 'optionalAccess', _20 => _20.tokensUsed]), () => ( 0)),
+              0,
+              // toolCallsCount - not tracked per turn currently
+              turnDuration
+            );
+            process.stderr.write(`[RPC DEBUG] HOOK_STOP emitted
+`);
+          }
+        } catch (hookErr) {
+          const hookErrMsg = hookErr instanceof Error ? hookErr.message : String(hookErr);
+          process.stderr.write(`[RPC DEBUG] Hook execution error (non-blocking): ${hookErrMsg}
+`);
+        }
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : String(err);
+        const errorStack = err instanceof Error ? err.stack : "";
+        process.stderr.write(`[RPC DEBUG] Error during runInstruction: ${errorMessage}
+`);
+        process.stderr.write(`[RPC DEBUG] Stack: ${errorStack}
+`);
+        writeNotification(RPC_NOTIFICATIONS.ERROR, {
+          code: -32e3,
+          message: errorMessage,
+          recoverable: true,
+          timestamp: createTimestamp()
+        });
+        success = false;
+      }
+      process.stderr.write(`[RPC DEBUG] Emitting MESSAGE_END, messageId=${this.currentMessageId}
+`);
+      writeNotification(RPC_NOTIFICATIONS.MESSAGE_END, {
+        messageId: this.currentMessageId,
+        content: this.currentMessageContent,
+        timestamp: createTimestamp()
+      });
+      process.stderr.write(`[RPC DEBUG] MESSAGE_END emitted successfully
+`);
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+      const snapshot = _optionalChain([this, 'access', _21 => _21.agent, 'optionalAccess', _22 => _22.getStatusSnapshot, 'call', _23 => _23()]);
+      process.stderr.write(`[RPC DEBUG] Emitting TURN_END, turnId=${this.currentTurnId}
+`);
+      writeNotification(RPC_NOTIFICATIONS.TURN_END, {
+        turnId: this.currentTurnId,
+        timestamp: createTimestamp(),
+        contextPercent: this.contextPercent,
+        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _24 => _24.tokensUsed]),
+        durationMs
+      });
+      process.stderr.write(`[RPC DEBUG] TURN_END emitted successfully
+`);
+      this.stopKeepalive();
+      this.status = "idle";
+      this.currentTurnId = null;
+      this.turnStartTime = null;
+      this.currentMessageId = null;
+      this.abortController = null;
+      return { success };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[RPC DEBUG] Outer catch - error: ${errorMsg}
+`);
+      if (this.currentMessageId) {
+        process.stderr.write(`[RPC DEBUG] Emitting MESSAGE_END from outer catch, messageId=${this.currentMessageId}
+`);
+        writeNotification(RPC_NOTIFICATIONS.MESSAGE_END, {
+          messageId: this.currentMessageId,
+          content: this.currentMessageContent,
+          timestamp: createTimestamp()
+        });
+      }
+      const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+      const snapshot = _optionalChain([this, 'access', _25 => _25.agent, 'optionalAccess', _26 => _26.getStatusSnapshot, 'call', _27 => _27()]);
+      process.stderr.write(`[RPC DEBUG] Emitting TURN_END from outer catch, turnId=${this.currentTurnId}
+`);
+      writeNotification(RPC_NOTIFICATIONS.TURN_END, {
+        turnId: this.currentTurnId,
+        timestamp: createTimestamp(),
+        contextPercent: this.contextPercent,
+        tokensUsed: _optionalChain([snapshot, 'optionalAccess', _28 => _28.tokensUsed]),
+        durationMs
+      });
+      this.stopKeepalive();
+      this.status = "idle";
+      this.currentTurnId = null;
+      this.turnStartTime = null;
+      this.currentMessageId = null;
+      this.abortController = null;
+      throw error;
+    }
+  }
+  /**
+   * Handle abort request (can be notification with null id for instant abort)
+   */
+  handleAbort(_requestId) {
+    process.stderr.write(`[RPC] handleAbort called, abortController=${!!this.abortController}
+`);
+    for (const [permId, pending] of this.pendingPermissions) {
+      process.stderr.write(`[RPC] Clearing pending permission ${permId} due to abort
+`);
+      if (pending.ackTimeout) clearTimeout(pending.ackTimeout);
+      if (pending.responseTimeout) clearTimeout(pending.responseTimeout);
+      pending.resolve({ decision: "deny_once" });
+    }
+    this.pendingPermissions.clear();
+    if (this.abortController) {
+      this.abortController.abort();
+      this.stopKeepalive();
+      this.status = "idle";
+      if (this.currentMessageId) {
+        writeNotification(RPC_NOTIFICATIONS.MESSAGE_END, {
+          messageId: this.currentMessageId,
+          content: this.currentMessageContent,
+          // No marker - UI handles display
+          aborted: true,
+          timestamp: createTimestamp()
+        });
+      }
+      if (this.currentTurnId) {
+        const durationMs = this.turnStartTime ? Date.now() - this.turnStartTime : void 0;
+        const snapshot = _optionalChain([this, 'access', _29 => _29.agent, 'optionalAccess', _30 => _30.getStatusSnapshot, 'call', _31 => _31()]);
+        writeNotification(RPC_NOTIFICATIONS.TURN_END, {
+          turnId: this.currentTurnId,
+          timestamp: createTimestamp(),
+          contextPercent: this.contextPercent,
+          tokensUsed: _optionalChain([snapshot, 'optionalAccess', _32 => _32.tokensUsed]),
+          durationMs
+        });
+      }
+      this.currentTurnId = null;
+      this.turnStartTime = null;
+      this.currentMessageId = null;
+      this.currentMessageContent = "";
+      this.abortController = null;
+      return { success: true };
+    }
+    return { success: false };
+  }
+  /**
+   * Handle reset request
+   */
+  async handleReset(_requestId) {
+    if (this.agent && this.conversation) {
+      try {
+        const { extractAndSaveSessionMemories } = await Promise.resolve().then(() => _interopRequireWildcard(require("./extractSessionMemories-XL3MS37F.cjs")));
+        await extractAndSaveSessionMemories({
+          llm: this.agent.getLlmProvider(),
+          memoryManager: this.agent.getMemoryManager(),
+          conversationHistory: this.conversation.history(),
+          workspaceRoot: this.workspace
+        });
+      } catch (e3) {
+      }
+    }
+    if (this.conversation) {
+      const history = this.conversation.history();
+      const systemPrompt = _nullishCoalesce(_optionalChain([history, 'access', _33 => _33.find, 'call', _34 => _34((m) => m.role === "system"), 'optionalAccess', _35 => _35.content]), () => ( ""));
+      this.conversation.reset(systemPrompt);
+    }
+    _optionalChain([this, 'access', _36 => _36.imageManager, 'optionalAccess', _37 => _37.clear, 'call', _38 => _38()]);
+    this.stopKeepalive();
+    this.sessionId = generateId("session");
+    this.status = "idle";
+    this.currentTurnId = null;
+    this.currentMessageId = null;
+    this.currentMessageContent = "";
+    writeNotification(RPC_NOTIFICATIONS.AGENT_START, {
+      sessionId: this.sessionId,
+      model: this.model,
+      workspace: this.workspace,
+      timestamp: createTimestamp()
+    });
+    return { sessionId: this.sessionId };
+  }
+  /**
+   * Handle get_state request
+   */
+  handleGetState(_requestId) {
+    return this.getState();
+  }
+  /**
+   * Handle get_messages request
+   */
+  handleGetMessages(requestId, limit) {
+    const messages = this.getMessages(limit);
+    return { messages };
+  }
+  async handleBrowserHandoffCreate(_requestId, params) {
+    const session = _optionalChain([this, 'access', _39 => _39.agent, 'optionalAccess', _40 => _40.getSessionManager, 'optionalCall', _41 => _41(), 'access', _42 => _42.getCurrentSession, 'optionalCall', _43 => _43()]);
+    if (!session) {
+      throw new Error("No active session available for browser handoff.");
+    }
+    return _chunkMPULXVC4cjs.createBrowserHandoff.call(void 0, {
+      sessionId: session.metadata.sessionId,
+      workspaceRoot: session.metadata.projectPath,
+      extensionId: _optionalChain([params, 'optionalAccess', _44 => _44.extensionId]),
+      installUrl: _optionalChain([params, 'optionalAccess', _45 => _45.installUrl])
+    });
+  }
+  async handleBrowserHandoffAttach(_requestId, params) {
+    const handoff = await _chunkMPULXVC4cjs.attachBrowserHandoff.call(void 0, params.token);
+    if (!handoff) {
+      return { success: false };
+    }
+    if (!this.agent) {
+      throw new Error("Agent not initialized");
+    }
+    const attached = await this.agent.attachSession(handoff.sessionId);
+    this.sessionId = attached.sessionId;
+    this.stopKeepalive();
+    this.stopKeepalive();
+    this.workspace = attached.workspaceRoot;
+    this.model = attached.model;
+    this.status = "idle";
+    return {
+      success: true,
+      sessionId: attached.sessionId,
+      workspaceRoot: attached.workspaceRoot,
+      messageCount: attached.messageCount
+    };
+  }
+  async handleBrowserHandoffAttachLatest(_requestId, _params) {
+    const handoff = await _chunkMPULXVC4cjs.attachLatestBrowserHandoff.call(void 0, );
+    if (!handoff) {
+      return { success: false };
+    }
+    if (!this.agent) {
+      throw new Error("Agent not initialized");
+    }
+    const attached = await this.agent.attachSession(handoff.sessionId);
+    this.stopKeepalive();
+    this.sessionId = attached.sessionId;
+    this.workspace = attached.workspaceRoot;
+    this.model = attached.model;
+    this.status = "idle";
+    return {
+      success: true,
+      sessionId: attached.sessionId,
+      workspaceRoot: attached.workspaceRoot,
+      messageCount: attached.messageCount
+    };
+  }
+  /**
+   * Handle permission response from client
+   */
+  handlePermissionResponse(requestId, permRequestId, decision) {
+    process.stderr.write(`[RPC] handlePermissionResponse called: permRequestId=${permRequestId}, allowed=${decision}, pending keys=${Array.from(this.pendingPermissions.keys()).join(",")}
+`);
+    const pending = this.pendingPermissions.get(permRequestId);
+    if (pending) {
+      const normalized = _chunkVGEV44V2cjs.normalizePermissionPromptResponse.call(void 0, decision);
+      process.stderr.write(`[RPC] Found pending permission, resolving with allowed=${normalized.decision}
+`);
+      if (pending.ackTimeout) {
+        clearTimeout(pending.ackTimeout);
+      }
+      if (pending.responseTimeout) {
+        clearTimeout(pending.responseTimeout);
+      }
+      this.pendingPermissions.delete(permRequestId);
+      pending.resolve(normalized);
+      this.status = "processing";
+      process.stderr.write(`[RPC] Permission resolved, status set to processing
+`);
+      return { success: true };
+    }
+    process.stderr.write(`[RPC] Permission response for unknown request ${permRequestId}
+`);
+    return { success: false };
+  }
+  /**
+   * Request permission from client (called from agent's confirmDangerousAction)
+   * Uses two-phase timeout:
+   * - Phase 1: 30s to receive acknowledgment from extension
+   * - Phase 2: 1 hour for user to respond after ack received
+   */
+  async requestPermission(tool, description, context) {
+    const permRequestId = generateId("perm");
+    this.status = "waiting_permission";
+    process.stderr.write(`[RPC] requestPermission: tool=${tool}, permRequestId=${permRequestId}
+`);
+    writeNotification(RPC_NOTIFICATIONS.PERMISSION_REQUEST, {
+      requestId: permRequestId,
+      tool,
+      description,
+      context,
+      options: [
+        "allow_once",
+        "deny_once",
+        "allow_session",
+        "deny_session",
+        "allow_always_project",
+        "allow_always_user",
+        "deny_always_project",
+        "deny_always_user",
+        "alternative"
+      ],
+      timestamp: createTimestamp()
+    });
+    return new Promise((resolve, reject) => {
+      const ackTimeout = setTimeout(() => {
+        this.pendingPermissions.delete(permRequestId);
+        this.status = "processing";
+        process.stderr.write(`[RPC] Permission ack timeout for ${permRequestId}
+`);
+        resolve({ decision: "deny_once" });
+      }, 3e4);
+      this.pendingPermissions.set(permRequestId, {
+        requestId: permRequestId,
+        resolve,
+        reject,
+        ackTimeout,
+        responseTimeout: null,
+        acknowledged: false
+      });
+    });
+  }
+  /**
+   * Handle acknowledgment from client that permission UI is shown
+   * Extends timeout since we know extension is alive and user is deciding
+   */
+  handlePermissionAcknowledged(permRequestId) {
+    const pending = this.pendingPermissions.get(permRequestId);
+    if (!pending) {
+      process.stderr.write(`[RPC] Permission ack for unknown request ${permRequestId}
+`);
+      return { success: false };
+    }
+    if (pending.acknowledged) {
+      return { success: true };
+    }
+    if (pending.ackTimeout) {
+      clearTimeout(pending.ackTimeout);
+      pending.ackTimeout = null;
+    }
+    pending.acknowledged = true;
+    pending.responseTimeout = setTimeout(() => {
+      this.pendingPermissions.delete(permRequestId);
+      this.status = "processing";
+      process.stderr.write(`[RPC] Permission response timeout for ${permRequestId} (1 hour)
+`);
+      pending.resolve({ decision: "deny_once" });
+    }, 36e5);
+    process.stderr.write(`[RPC] Permission acknowledged for ${permRequestId}
+`);
+    return { success: true };
+  }
+  /**
+   * Request directory access from client (called from agent's requestDirectoryAccess)
+   * Uses two-phase timeout similar to permission requests:
+   * - Phase 1: 30s to receive acknowledgment from extension
+   * - Phase 2: 1 hour for user to respond after ack received
+   */
+  async requestDirectoryAccess(dirPath, reason) {
+    const requestId = generateId("dir");
+    this.status = "waiting_permission";
+    process.stderr.write(`[RPC] requestDirectoryAccess: path=${dirPath}, requestId=${requestId}
+`);
+    writeNotification(RPC_NOTIFICATIONS.DIRECTORY_ACCESS_REQUEST, {
+      requestId,
+      path: dirPath,
+      reason,
+      timestamp: createTimestamp()
+    });
+    return new Promise((resolve, reject) => {
+      const ackTimeout = setTimeout(() => {
+        this.pendingDirectoryAccess.delete(requestId);
+        this.status = "processing";
+        process.stderr.write(`[RPC] Directory access ack timeout for ${requestId}
+`);
+        resolve(void 0);
+      }, 3e4);
+      this.pendingDirectoryAccess.set(requestId, {
+        requestId,
+        path: dirPath,
+        resolve,
+        reject,
+        ackTimeout,
+        responseTimeout: null,
+        acknowledged: false
+      });
+    });
+  }
+  /**
+   * Handle acknowledgment from client that directory access UI is shown
+   */
+  handleDirectoryAccessAcknowledged(requestId) {
+    const pending = this.pendingDirectoryAccess.get(requestId);
+    if (!pending) {
+      process.stderr.write(`[RPC] Directory access ack for unknown request ${requestId}
+`);
+      return { success: false };
+    }
+    if (pending.acknowledged) {
+      return { success: true };
+    }
+    if (pending.ackTimeout) {
+      clearTimeout(pending.ackTimeout);
+      pending.ackTimeout = null;
+    }
+    pending.acknowledged = true;
+    pending.responseTimeout = setTimeout(() => {
+      this.pendingDirectoryAccess.delete(requestId);
+      this.status = "processing";
+      process.stderr.write(`[RPC] Directory access response timeout for ${requestId} (1 hour)
+`);
+      pending.resolve(void 0);
+    }, 36e5);
+    process.stderr.write(`[RPC] Directory access acknowledged for ${requestId}
+`);
+    return { success: true };
+  }
+  /**
+   * Handle directory access response from client
+   */
+  handleDirectoryAccessResponse(requestId, granted) {
+    process.stderr.write(`[RPC] handleDirectoryAccessResponse: requestId=${requestId}, granted=${granted}
+`);
+    const pending = this.pendingDirectoryAccess.get(requestId);
+    if (pending) {
+      if (pending.ackTimeout) {
+        clearTimeout(pending.ackTimeout);
+      }
+      if (pending.responseTimeout) {
+        clearTimeout(pending.responseTimeout);
+      }
+      this.pendingDirectoryAccess.delete(requestId);
+      pending.resolve(granted ? pending.path : void 0);
+      this.status = "processing";
+      process.stderr.write(`[RPC] Directory access resolved, status set to processing
+`);
+      return { success: true };
+    }
+    process.stderr.write(`[RPC] Directory access response for unknown request ${requestId}
+`);
+    return { success: false };
+  }
+  /**
+   * Emit tool execution start notification
+   */
+  emitToolStart(toolName, args) {
+    const toolId = generateId("tool");
+    writeNotification(RPC_NOTIFICATIONS.TOOL_START, {
+      toolId,
+      toolName,
+      args,
+      timestamp: createTimestamp()
+    });
+    return toolId;
+  }
+  /**
+   * Emit tool execution update notification (streaming output)
+   */
+  emitToolUpdate(toolId, chunk) {
+    writeNotification(RPC_NOTIFICATIONS.TOOL_UPDATE, {
+      toolId,
+      output: chunk.data,
+      stream: chunk.stream,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit tool execution end notification
+   */
+  emitToolEnd(toolId, toolName, success, output, error) {
+    writeNotification(RPC_NOTIFICATIONS.TOOL_END, {
+      toolId,
+      toolName,
+      success,
+      output,
+      error,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit message update notification (streaming content)
+   */
+  emitMessageUpdate(delta, thought) {
+    this.currentMessageContent += delta;
+    writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+      messageId: this.currentMessageId,
+      delta,
+      thought,
+      timestamp: createTimestamp()
+    });
+  }
+  // ============================================================================
+  // Multi-File Change Preview Methods
+  // ============================================================================
+  /**
+   * Emit changes batch start notification
+   */
+  emitChangesBatchStart(batchId) {
+    process.stderr.write(`[RPC DEBUG] emitChangesBatchStart: batchId=${batchId}
+`);
+    writeNotification(RPC_NOTIFICATIONS.CHANGES_BATCH_START, {
+      batchId,
+      turnId: _nullishCoalesce(this.currentTurnId, () => ( "")),
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit changes batch update notification (individual file change)
+   */
+  emitChangesBatchUpdate(batchId, change) {
+    process.stderr.write(`[RPC DEBUG] emitChangesBatchUpdate: batchId=${batchId}, changeId=${change.id}, file=${change.filePath}
+`);
+    writeNotification(RPC_NOTIFICATIONS.CHANGES_BATCH_UPDATE, {
+      batchId,
+      change,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit changes batch end notification
+   */
+  emitChangesBatchEnd(batchId, changeCount) {
+    process.stderr.write(`[RPC DEBUG] emitChangesBatchEnd: batchId=${batchId}, changeCount=${changeCount}
+`);
+    writeNotification(RPC_NOTIFICATIONS.CHANGES_BATCH_END, {
+      batchId,
+      changeCount,
+      timestamp: createTimestamp()
+    });
+  }
+  // ============================================================================
+  // Hook Lifecycle Notification Methods
+  // ============================================================================
+  /**
+   * Emit hook pre-tool notification
+   * Called before a tool begins execution
+   */
+  emitHookPreTool(toolId, toolName, args) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_PRE_TOOL, {
+      toolId,
+      toolName,
+      args,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook post-tool notification
+   * Called after a tool completes execution
+   */
+  emitHookPostTool(toolId, toolName, success, duration, output) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_POST_TOOL, {
+      toolId,
+      toolName,
+      success,
+      duration,
+      output,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook file-modified notification
+   * Called when a file is created, modified, or deleted
+   */
+  emitHookFileModified(filePath, changeType, toolId) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_FILE_MODIFIED, {
+      filePath,
+      changeType,
+      toolId,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook pre-prompt notification
+   * Called before sending a prompt to the LLM
+   */
+  emitHookPrePrompt(instruction, mentionedFiles) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_PRE_PROMPT, {
+      instruction,
+      mentionedFiles,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook post-response notification
+   * Called after receiving a response from the LLM
+   */
+  emitHookPostResponse(tokensUsed, toolCallsCount, duration) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_POST_RESPONSE, {
+      tokensUsed,
+      toolCallsCount,
+      duration,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook session-error notification
+   * Called when an error occurs during agent execution
+   */
+  emitHookSessionError(error, code, context) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_SESSION_ERROR, {
+      error,
+      code,
+      context,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook stop notification
+   * Called when agent finishes responding to a turn
+   */
+  emitHookStop(tokensUsed, toolCallsCount, duration) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_STOP, {
+      tokensUsed,
+      toolCallsCount,
+      duration,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook session-start notification
+   * Called when a session begins
+   */
+  emitHookSessionStart(sessionType) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_SESSION_START, {
+      sessionType,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook session-end notification
+   * Called when a session ends
+   */
+  emitHookSessionEnd(reason, duration) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_SESSION_END, {
+      reason,
+      duration,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook subagent-stop notification
+   * Called when a subagent finishes execution
+   */
+  emitHookSubagentStop(subagentId, subagentName, subagentType, success, duration, error) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_SUBAGENT_STOP, {
+      subagentId,
+      subagentName,
+      subagentType,
+      success,
+      duration,
+      error,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook permission-request notification
+   * Called when a permission dialog is about to be shown
+   */
+  emitHookPermissionRequest(tool, path2, command, args) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_PERMISSION_REQUEST, {
+      tool,
+      path: path2,
+      command,
+      args,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Emit hook notification
+   * Called when a notification is sent to the user
+   */
+  emitHookNotification(notificationType, message) {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_NOTIFICATION, {
+      notificationType,
+      message,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Handle changes decision from client (accept/reject)
+   */
+  async handleChangesDecision(requestId, params) {
+    const fileManager = _optionalChain([this, 'access', _46 => _46.agent, 'optionalAccess', _47 => _47.getFileManager, 'optionalCall', _48 => _48()]);
+    if (!fileManager) {
+      return {
+        success: false,
+        appliedCount: 0,
+        skippedCount: 0,
+        errors: [{ changeId: "unknown", error: "FileActionManager not available" }]
+      };
+    }
+    const { action, selectedChangeIds, batchId } = params;
+    if (fileManager.getBatchId() !== batchId) {
+      return {
+        success: false,
+        appliedCount: 0,
+        skippedCount: 0,
+        errors: [{ changeId: "unknown", error: `Batch ${batchId} not found or expired` }]
+      };
+    }
+    const pendingChanges = fileManager.getPendingChanges();
+    const totalCount = pendingChanges.length;
+    if (action === "reject_all") {
+      fileManager.clearPendingChanges();
+      fileManager.exitPreviewMode();
+      return {
+        success: true,
+        appliedCount: 0,
+        skippedCount: totalCount
+      };
+    }
+    const changeIds = action === "accept_selected" ? selectedChangeIds : void 0;
+    const result = await fileManager.applyPendingChanges(changeIds);
+    fileManager.exitPreviewMode();
+    return {
+      success: result.errors.length === 0,
+      appliedCount: result.applied.length,
+      skippedCount: totalCount - result.applied.length,
+      errors: result.errors.length > 0 ? result.errors.map((e) => ({ changeId: e.id, error: e.error })) : void 0
+    };
+  }
+  // ============================================================================
+  // Skills Management Methods (Non-Interactive for RPC Mode)
+  // ============================================================================
+  /**
+   * Get community skills registry
+   */
+  async handleGetSkillsRegistry(requestId, params) {
+    try {
+      const { CommunitySkillsCache } = await Promise.resolve().then(() => _interopRequireWildcard(require("./CommunitySkillsCache-2OIUV227.cjs")));
+      const { GitHubRegistryFetcher } = await Promise.resolve().then(() => _interopRequireWildcard(require("./GitHubRegistryFetcher-CYJLF2XL.cjs")));
+      const cache = new CommunitySkillsCache();
+      const fetcher = new GitHubRegistryFetcher();
+      let registry;
+      if (_optionalChain([params, 'optionalAccess', _49 => _49.forceRefresh])) {
+        process.stderr.write("[RPC] Force refreshing skills registry from GitHub\n");
+        registry = await fetcher.fetchRegistry();
+        await cache.setRegistry(registry);
+      } else {
+        const cached = await cache.getRegistry();
+        if (cached) {
+          registry = cached;
+        } else {
+          process.stderr.write("[RPC] Fetching skills registry from GitHub\n");
+          registry = await fetcher.fetchRegistry();
+          await cache.setRegistry(registry);
+        }
+      }
+      const skills = registry.skills.map((skill) => ({
+        id: skill.id,
+        name: skill.name,
+        description: skill.description,
+        category: skill.category,
+        tags: skill.tags,
+        rating: skill.rating,
+        downloadCount: skill.downloadCount,
+        isFeatured: skill.isFeatured,
+        isCurated: skill.isCurated
+      }));
+      return {
+        success: true,
+        skills,
+        categories: registry.categories
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`[RPC] Failed to get skills registry: ${message}
+`);
+      return {
+        success: false,
+        skills: [],
+        categories: [],
+        error: message
+      };
+    }
+  }
+  /**
+   * Install a skill by name (non-interactive)
+   */
+  async handleInstallSkill(requestId, params) {
+    try {
+      const skillsRegistry = _optionalChain([this, 'access', _50 => _50.agent, 'optionalAccess', _51 => _51.getSkillsRegistry, 'optionalCall', _52 => _52()]);
+      if (!skillsRegistry) {
+        return {
+          success: false,
+          error: "Skills registry not available"
+        };
+      }
+      const workspaceRoot = this.workspace;
+      const { CommunitySkillsCache } = await Promise.resolve().then(() => _interopRequireWildcard(require("./CommunitySkillsCache-2OIUV227.cjs")));
+      const { GitHubRegistryFetcher } = await Promise.resolve().then(() => _interopRequireWildcard(require("./GitHubRegistryFetcher-CYJLF2XL.cjs")));
+      const { AUTOHAND_PATHS, PROJECT_DIR_NAME } = await Promise.resolve().then(() => _interopRequireWildcard(require("./constants-RLMJ5D5P.cjs")));
+      const path2 = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+      const cache = new CommunitySkillsCache();
+      const fetcher = new GitHubRegistryFetcher();
+      let registry = await cache.getRegistry();
+      if (!registry) {
+        process.stderr.write("[RPC] Fetching skills registry for install\n");
+        registry = await fetcher.fetchRegistry();
+        await cache.setRegistry(registry);
+      }
+      const skill = fetcher.findSkill(registry.skills, params.skillName);
+      if (!skill) {
+        const similar = fetcher.findSimilarSkills(registry.skills, params.skillName, 3);
+        const suggestions = similar.map((s) => s.name).join(", ");
+        return {
+          success: false,
+          error: `Skill not found: ${params.skillName}${suggestions ? `. Did you mean: ${suggestions}?` : ""}`
+        };
+      }
+      const targetDir = params.scope === "project" ? path2.join(workspaceRoot, PROJECT_DIR_NAME, "skills") : AUTOHAND_PATHS.skills;
+      const isInstalled = await skillsRegistry.isSkillInstalled(skill.name, targetDir);
+      if (isInstalled && !params.force) {
+        return {
+          success: false,
+          error: `Skill "${skill.name}" already exists. Use force=true to overwrite.`
+        };
+      }
+      process.stderr.write(`[RPC] Installing skill ${skill.name} to ${params.scope}
+`);
+      let files = await cache.getSkillDirectory(skill.id);
+      if (!files) {
+        process.stderr.write(`[RPC] Fetching skill files from GitHub
+`);
+        files = await fetcher.fetchSkillDirectory(skill);
+        await cache.setSkillDirectory(skill.id, files);
+      }
+      const result = await skillsRegistry.importCommunitySkillDirectory(
+        skill.name,
+        files,
+        targetDir,
+        isInstalled
+        // force if overwriting
+      );
+      if (result.success) {
+        process.stderr.write(`[RPC] Successfully installed ${skill.name}
+`);
+        return {
+          success: true,
+          skillName: skill.name,
+          path: result.path
+        };
+      } else {
+        return {
+          success: false,
+          error: result.error || "Installation failed"
+        };
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`[RPC] Failed to install skill: ${message}
+`);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  // ============================================================================
+  // Learn Command Methods (RPC Mode)
+  // ============================================================================
+  /**
+   * Handle /learn recommend - analyze project and recommend skills
+   */
+  async handleLearnRecommend(requestId, params) {
+    try {
+      const { ProjectAnalyzer } = await Promise.resolve().then(() => _interopRequireWildcard(require("./autoSkill-YOLLFTP2.cjs")));
+      const { CommunitySkillsCache } = await Promise.resolve().then(() => _interopRequireWildcard(require("./CommunitySkillsCache-2OIUV227.cjs")));
+      const { GitHubRegistryFetcher } = await Promise.resolve().then(() => _interopRequireWildcard(require("./GitHubRegistryFetcher-CYJLF2XL.cjs")));
+      const { fetchRegistryWithFallback } = await Promise.resolve().then(() => _interopRequireWildcard(require("./communityInstaller-TWMGPSYM.cjs")));
+      const { LearnAdvisor } = await Promise.resolve().then(() => _interopRequireWildcard(require("./LearnAdvisor-XBRDNAGH.cjs")));
+      const workspace = this.workspace || process.cwd();
+      const deep = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _53 => _53.deep]), () => ( false));
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "analyzing",
+        timestamp: createTimestamp()
+      });
+      process.stderr.write(`[RPC] Learn recommend: analyzing project (deep=${deep})
+`);
+      const analyzer = new ProjectAnalyzer(workspace);
+      const analysis = await analyzer.analyze();
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "loading-registry",
+        timestamp: createTimestamp()
+      });
+      const cache = new CommunitySkillsCache();
+      const fetcher = new GitHubRegistryFetcher();
+      let registry;
+      try {
+        registry = await fetchRegistryWithFallback(cache, fetcher);
+      } catch (e4) {
+      }
+      const skillsRegistry = _optionalChain([this, 'access', _54 => _54.agent, 'optionalAccess', _55 => _55.getSkillsRegistry, 'optionalCall', _56 => _56()]);
+      const installedSkills = _nullishCoalesce(_optionalChain([skillsRegistry, 'optionalAccess', _57 => _57.listSkills, 'call', _58 => _58()]), () => ( []));
+      const registrySkills = _nullishCoalesce(_optionalChain([registry, 'optionalAccess', _59 => _59.skills]), () => ( []));
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "evaluating",
+        timestamp: createTimestamp()
+      });
+      const llm = _optionalChain([this, 'access', _60 => _60.agent, 'optionalAccess', _61 => _61.getLlmProvider, 'optionalCall', _62 => _62()]);
+      if (!llm) {
+        return {
+          success: false,
+          projectSummary: "",
+          audit: [],
+          recommendations: [],
+          gapAnalysis: null,
+          error: "LLM provider not available"
+        };
+      }
+      const advisor = new LearnAdvisor(llm);
+      const result = await advisor.analyze(analysis, installedSkills, registrySkills);
+      return {
+        success: true,
+        projectSummary: result.projectSummary,
+        audit: result.audit,
+        recommendations: result.recommendations,
+        gapAnalysis: result.gapAnalysis
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`[RPC] Learn recommend failed: ${message}
+`);
+      return {
+        success: false,
+        projectSummary: "",
+        audit: [],
+        recommendations: [],
+        gapAnalysis: null,
+        error: message
+      };
+    }
+  }
+  /**
+   * Handle /learn update - regenerate stale LLM-generated skills
+   */
+  async handleLearnUpdate(_requestId, _params) {
+    try {
+      const { ProjectAnalyzer } = await Promise.resolve().then(() => _interopRequireWildcard(require("./autoSkill-YOLLFTP2.cjs")));
+      const { computeProjectHash, injectGeneratedMetadata } = await Promise.resolve().then(() => _interopRequireWildcard(require("./communityInstaller-TWMGPSYM.cjs")));
+      const { LearnAdvisor } = await Promise.resolve().then(() => _interopRequireWildcard(require("./LearnAdvisor-XBRDNAGH.cjs")));
+      const fse = await Promise.resolve().then(() => _interopRequireWildcard(require("fs-extra")));
+      const workspace = this.workspace || process.cwd();
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "updating",
+        timestamp: createTimestamp()
+      });
+      process.stderr.write("[RPC] Learn update: checking for stale skills\n");
+      const analyzer = new ProjectAnalyzer(workspace);
+      const analysis = await analyzer.analyze();
+      const currentHash = computeProjectHash(analysis);
+      const skillsRegistry = _optionalChain([this, 'access', _63 => _63.agent, 'optionalAccess', _64 => _64.getSkillsRegistry, 'optionalCall', _65 => _65()]);
+      if (!skillsRegistry) {
+        return { success: false, updated: 0, unchanged: 0, results: [], error: "Skills registry not available" };
+      }
+      const allSkills = skillsRegistry.listSkills();
+      const generatedSkills = allSkills.filter(
+        (s) => _optionalChain([s, 'access', _66 => _66.metadata, 'optionalAccess', _67 => _67["agentskill-source"]]) === "llm-generated"
+      );
+      if (generatedSkills.length === 0) {
+        return { success: true, updated: 0, unchanged: 0, results: [] };
+      }
+      const llm = _optionalChain([this, 'access', _68 => _68.agent, 'optionalAccess', _69 => _69.getLlmProvider, 'optionalCall', _70 => _70()]);
+      if (!llm) {
+        return { success: false, updated: 0, unchanged: 0, results: [], error: "LLM provider not available" };
+      }
+      const advisor = new LearnAdvisor(llm);
+      let updated = 0;
+      let unchanged = 0;
+      const results = [];
+      for (const skill of generatedSkills) {
+        const storedHash = _optionalChain([skill, 'access', _71 => _71.metadata, 'optionalAccess', _72 => _72["agentskill-project-hash"]]);
+        if (storedHash === currentHash) {
+          unchanged++;
+          results.push({ name: skill.name, status: "unchanged" });
+          continue;
+        }
+        const generated = await advisor.generateSkill(analysis, null, []);
+        if (!generated) {
+          results.push({ name: skill.name, status: "failed" });
+          continue;
+        }
+        let frontmatter = `---
+name: ${generated.name}
+description: ${generated.description}
+`;
+        if (generated.allowedTools.length > 0) {
+          frontmatter += `allowed-tools: ${generated.allowedTools.join(" ")}
+`;
+        }
+        frontmatter += `---
+
+`;
+        let content = frontmatter + generated.body + "\n";
+        content = injectGeneratedMetadata(content, skill.name, currentHash);
+        try {
+          await fse.writeFile(skill.path, content, "utf-8");
+          updated++;
+          results.push({ name: skill.name, status: "updated" });
+        } catch (e5) {
+          results.push({ name: skill.name, status: "failed" });
+        }
+      }
+      return { success: true, updated, unchanged, results };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`[RPC] Learn update failed: ${message}
+`);
+      return { success: false, updated: 0, unchanged: 0, results: [], error: message };
+    }
+  }
+  /**
+   * Handle /learn generate - generate a custom skill for the project
+   */
+  async handleLearnGenerate(requestId, params) {
+    try {
+      const { ProjectAnalyzer } = await Promise.resolve().then(() => _interopRequireWildcard(require("./autoSkill-YOLLFTP2.cjs")));
+      const { computeProjectHash, injectGeneratedMetadata } = await Promise.resolve().then(() => _interopRequireWildcard(require("./communityInstaller-TWMGPSYM.cjs")));
+      const { LearnAdvisor } = await Promise.resolve().then(() => _interopRequireWildcard(require("./LearnAdvisor-XBRDNAGH.cjs")));
+      const { AUTOHAND_PATHS, PROJECT_DIR_NAME } = await Promise.resolve().then(() => _interopRequireWildcard(require("./constants-RLMJ5D5P.cjs")));
+      const fse = await Promise.resolve().then(() => _interopRequireWildcard(require("fs-extra")));
+      const path2 = await Promise.resolve().then(() => _interopRequireWildcard(require("path")));
+      const workspace = this.workspace || process.cwd();
+      const scope = params.scope;
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "generating",
+        timestamp: createTimestamp()
+      });
+      process.stderr.write(`[RPC] Learn generate: scope=${scope}
+`);
+      const llm = _optionalChain([this, 'access', _73 => _73.agent, 'optionalAccess', _74 => _74.getLlmProvider, 'optionalCall', _75 => _75()]);
+      if (!llm) {
+        return { success: false, error: "LLM provider not available" };
+      }
+      const analyzer = new ProjectAnalyzer(workspace);
+      const analysis = await analyzer.analyze();
+      const projectHash = computeProjectHash(analysis);
+      const advisor = new LearnAdvisor(llm);
+      const generated = await advisor.generateSkill(analysis, null, []);
+      if (!generated) {
+        return { success: false, error: "Failed to generate a custom skill" };
+      }
+      let frontmatter = `---
+name: ${generated.name}
+description: ${generated.description}
+`;
+      if (generated.allowedTools.length > 0) {
+        frontmatter += `allowed-tools: ${generated.allowedTools.join(" ")}
+`;
+      }
+      frontmatter += `---
+
+`;
+      let skillContent = frontmatter + generated.body + "\n";
+      skillContent = injectGeneratedMetadata(skillContent, generated.name, projectHash);
+      const targetDir = scope === "project" ? path2.join(workspace, PROJECT_DIR_NAME, "skills") : AUTOHAND_PATHS.skills;
+      const skillDir = path2.join(targetDir, generated.name);
+      await fse.ensureDir(skillDir);
+      const skillPath = path2.join(skillDir, "SKILL.md");
+      await fse.writeFile(skillPath, skillContent, "utf-8");
+      return { success: true, skillName: generated.name, skillPath };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      process.stderr.write(`[RPC] Learn generate failed: ${message}
+`);
+      return { success: false, error: message };
+    }
+  }
+  // ============================================================================
+  // Session History, YOLO, and MCP Handlers
+  // ============================================================================
+  /**
+   * Get paginated session history
+   */
+  async handleGetHistory(_requestId, params) {
+    const sessionManager = _optionalChain([this, 'access', _76 => _76.agent, 'optionalAccess', _77 => _77.getSessionManager, 'optionalCall', _78 => _78()]);
+    if (!sessionManager) {
+      return { sessions: [], currentPage: 1, totalPages: 0, totalItems: 0 };
+    }
+    try {
+      const allSessions = await sessionManager.listSessions();
+      const page = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _79 => _79.page]), () => ( 1));
+      const pageSize = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _80 => _80.pageSize]), () => ( 20));
+      const totalItems = allSessions.length;
+      const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+      const startIndex = (page - 1) * pageSize;
+      const pageSessions = allSessions.slice(startIndex, startIndex + pageSize);
+      return {
+        sessions: pageSessions.map((s) => ({
+          sessionId: s.sessionId,
+          createdAt: s.createdAt,
+          lastActiveAt: _nullishCoalesce(s.lastActiveAt, () => ( s.createdAt)),
+          projectName: _nullishCoalesce(s.projectName, () => ( "")),
+          model: _nullishCoalesce(s.model, () => ( "")),
+          messageCount: _nullishCoalesce(s.messageCount, () => ( 0)),
+          status: _nullishCoalesce(s.status, () => ( "completed"))
+        })),
+        currentPage: page,
+        totalPages,
+        totalItems
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[RPC] Failed to get history: ${message}
+`);
+      return { sessions: [], currentPage: 1, totalPages: 0, totalItems: 0 };
+    }
+  }
+  /**
+   * Get a specific session's metadata and messages
+   */
+  async handleGetSession(_requestId, params) {
+    const sessionManager = _optionalChain([this, 'access', _81 => _81.agent, 'optionalAccess', _82 => _82.getSessionManager, 'optionalCall', _83 => _83()]);
+    if (!sessionManager) {
+      return { success: false, error: "Session manager not available" };
+    }
+    try {
+      const session = await sessionManager.loadSession(params.sessionId);
+      const m = session.metadata;
+      const messages = session.getMessages().map((msg) => ({
+        id: msg.role === "user" ? `user-${_crypto2.default.randomUUID()}` : `msg-${_crypto2.default.randomUUID()}`,
+        role: msg.role,
+        content: msg.content,
+        timestamp: new Date(m.createdAt).toISOString(),
+        toolCalls: (_nullishCoalesce(msg.toolCalls, () => ( []))).map((tc) => ({
+          id: _nullishCoalesce(tc.callId, () => ( "")),
+          name: _nullishCoalesce(tc.name, () => ( "")),
+          args: _nullishCoalesce(tc.arguments, () => ( {}))
+        }))
+      }));
+      return {
+        success: true,
+        sessionId: m.sessionId,
+        projectName: _nullishCoalesce(m.projectName, () => ( "")),
+        model: _nullishCoalesce(m.model, () => ( "")),
+        messageCount: _nullishCoalesce(m.messageCount, () => ( 0)),
+        status: _nullishCoalesce(m.status, () => ( "completed")),
+        createdAt: m.createdAt,
+        lastActiveAt: _nullishCoalesce(m.lastActiveAt, () => ( m.createdAt)),
+        summary: m.summary,
+        messages,
+        workspaceRoot: _nullishCoalesce(m.projectPath, () => ( ""))
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[RPC] Failed to get session: ${message}
+`);
+      return {
+        success: false,
+        error: message,
+        sessionId: params.sessionId,
+        projectName: "",
+        model: "",
+        messageCount: 0,
+        status: "completed",
+        createdAt: "",
+        lastActiveAt: "",
+        messages: [],
+        workspaceRoot: ""
+      };
+    }
+  }
+  /**
+   * Set YOLO (unrestricted) mode with pattern and optional timeout
+   */
+  handleYoloSet(_requestId, params) {
+    const permissionManager = _optionalChain([this, 'access', _84 => _84.agent, 'optionalAccess', _85 => _85.getPermissionManager, 'optionalCall', _86 => _86()]);
+    if (!permissionManager) {
+      return { success: false };
+    }
+    try {
+      permissionManager.setMode("unrestricted");
+      process.stderr.write(`[RPC] YOLO mode enabled with pattern: ${params.pattern}
+`);
+      let expiresIn;
+      if (params.timeoutSeconds && params.timeoutSeconds > 0) {
+        expiresIn = params.timeoutSeconds;
+        setTimeout(() => {
+          permissionManager.setMode("interactive");
+          process.stderr.write(`[RPC] YOLO mode expired, reverted to interactive
+`);
+        }, params.timeoutSeconds * 1e3);
+      }
+      return { success: true, expiresIn };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`[RPC] Failed to set YOLO mode: ${message}
+`);
+      return { success: false };
+    }
+  }
+  /**
+   * List all MCP servers and their connection status
+   */
+  handleMcpListServers(_requestId) {
+    const mcpManager = _optionalChain([this, 'access', _87 => _87.agent, 'optionalAccess', _88 => _88.getMcpManager, 'optionalCall', _89 => _89()]);
+    if (!mcpManager) {
+      return { servers: [] };
+    }
+    return { servers: mcpManager.getServers() };
+  }
+  /**
+   * List all MCP tools, optionally filtered by server name
+   */
+  handleMcpListTools(_requestId, params) {
+    const mcpManager = _optionalChain([this, 'access', _90 => _90.agent, 'optionalAccess', _91 => _91.getMcpManager, 'optionalCall', _92 => _92()]);
+    if (!mcpManager) {
+      return { tools: [] };
+    }
+    const allTools = _optionalChain([params, 'optionalAccess', _93 => _93.serverName]) ? mcpManager.getToolsForServer(params.serverName) : mcpManager.getAllTools();
+    return {
+      tools: allTools.map((t) => {
+        const parsed = _chunkDI57A4BXcjs.McpClientManager.parseMcpToolName(t.name);
+        return {
+          name: t.name,
+          description: t.description,
+          serverName: _nullishCoalesce(_optionalChain([parsed, 'optionalAccess', _94 => _94.serverName]), () => ( "unknown"))
+        };
+      })
+    };
+  }
+  /**
+   * List persisted meta-tools and registry diagnostics for non-interactive clients.
+   */
+  handleGetToolsRegistry() {
+    const registry = _optionalChain([this, 'access', _95 => _95.agent, 'optionalAccess', _96 => _96.getToolsRegistry, 'optionalCall', _97 => _97()]);
+    if (!registry) {
+      return { tools: [], diagnostics: [] };
+    }
+    return {
+      tools: registry.listMetaTools({ includeDisabled: true }).map((tool) => ({
+        name: tool.name,
+        description: tool.description,
+        source: "meta",
+        scope: tool.scope,
+        disabled: tool.disabled,
+        createdAt: tool.createdAt,
+        schemaVersion: tool.schemaVersion,
+        handlerPreview: tool.handler.length > 140 ? `${tool.handler.slice(0, 137)}...` : tool.handler,
+        reuseHint: `Use ${tool.name} instead of creating another tool for: ${tool.description}`
+      })),
+      diagnostics: registry.getDiagnostics()
+    };
+  }
+  // ============================================================================
+  // MCP Bridge Methods (VS Code <-> CLI bidirectional tool bridging)
+  // ============================================================================
+  /**
+   * Receive VS Code MCP tool descriptors from the extension.
+   * These tools become available for the agent to invoke via the extension.
+   * Tool names are stored with a 'vscode__' prefix to distinguish them.
+   */
+  handleMcpSetVscodeTools(_requestId, params) {
+    this.vscodeTools.clear();
+    for (const tool of params.tools) {
+      const prefixedName = `vscode__${tool.serverName}__${tool.name}`;
+      this.vscodeTools.set(prefixedName, {
+        name: tool.name,
+        description: tool.description,
+        serverName: tool.serverName,
+        inputSchema: tool.inputSchema
+      });
+    }
+    process.stderr.write(
+      `[RPC] MCP bridge: registered ${this.vscodeTools.size} VS Code tools
+`
+    );
+    const allTools = this.getVscodeToolsList();
+    writeNotification(RPC_NOTIFICATIONS.MCP_TOOLS_CHANGED, {
+      tools: allTools,
+      timestamp: createTimestamp()
+    });
+    return { success: true };
+  }
+  /**
+   * Get the list of registered VS Code tools for notifications
+   */
+  getVscodeToolsList() {
+    const tools = [];
+    for (const [prefixedName, tool] of this.vscodeTools) {
+      tools.push({
+        name: prefixedName,
+        description: tool.description,
+        serverName: tool.serverName
+      });
+    }
+    return tools;
+  }
+  /**
+   * Invoke a VS Code MCP tool by sending a notification to the extension
+   * and waiting for the response. Called internally when the agent uses
+   * a tool with the 'vscode__' prefix.
+   */
+  async invokeVscodeTool(toolName, args) {
+    const tool = this.vscodeTools.get(toolName);
+    if (!tool) {
+      throw new Error(`VS Code tool not found: ${toolName}`);
+    }
+    const requestId = generateId("mcp-invoke");
+    writeNotification(RPC_NOTIFICATIONS.MCP_INVOKE_REQUEST, {
+      requestId,
+      toolName,
+      args,
+      timestamp: createTimestamp()
+    });
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingVscodeInvocations.delete(requestId);
+        reject(new Error(`VS Code tool invocation timed out: ${toolName}`));
+      }, 3e5);
+      this.pendingVscodeInvocations.set(requestId, {
+        resolve: (result) => {
+          clearTimeout(timeout);
+          resolve(result);
+        },
+        reject: (error) => {
+          clearTimeout(timeout);
+          reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Handle the invoke response from the extension for a pending VS Code tool call.
+   * Resolves or rejects the promise created in invokeVscodeTool.
+   */
+  handleMcpInvokeResponse(_requestId, params) {
+    const pending = this.pendingVscodeInvocations.get(params.requestId);
+    if (!pending) {
+      process.stderr.write(
+        `[RPC] MCP bridge: invoke response for unknown request ${params.requestId}
+`
+      );
+      return { success: false };
+    }
+    this.pendingVscodeInvocations.delete(params.requestId);
+    if (params.success) {
+      pending.resolve(_nullishCoalesce(params.result, () => ( "")));
+    } else {
+      pending.reject(new Error(_nullishCoalesce(params.error, () => ( "VS Code tool invocation failed"))));
+    }
+    return { success: true };
+  }
+  /**
+   * Return MCP server configurations from the CLI config.
+   * Sensitive environment variables (keys, tokens, secrets) are sanitized.
+   */
+  handleMcpGetServerConfigs(_requestId) {
+    const configs = this.mcpServerConfigs.map((server) => ({
+      name: server.name,
+      transport: server.transport,
+      command: server.command,
+      args: server.args,
+      url: server.url,
+      env: server.env ? this.sanitizeEnv(server.env) : void 0,
+      headers: server.headers ? this.sanitizeHeaders(server.headers) : void 0,
+      autoConnect: server.autoConnect
+    }));
+    return { configs };
+  }
+  /**
+   * Check if a tool name is a registered VS Code MCP tool
+   */
+  isVscodeTool(toolName) {
+    return this.vscodeTools.has(toolName);
+  }
+  /**
+   * Sanitize environment variables by redacting values that look like secrets.
+   * Keeps the key names but replaces sensitive values with '***'.
+   */
+  sanitizeEnv(env) {
+    const sensitivePatterns = /key|token|secret|password|credential|auth/i;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(env)) {
+      if (sensitivePatterns.test(key)) {
+        sanitized[key] = "***";
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+  /**
+   * Sanitize HTTP headers by redacting values that look like auth tokens.
+   */
+  sanitizeHeaders(headers) {
+    const sensitivePatterns = /authorization|token|key|secret|bearer/i;
+    const sanitized = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (sensitivePatterns.test(key)) {
+        sanitized[key] = "***";
+      } else {
+        sanitized[key] = value;
+      }
+    }
+    return sanitized;
+  }
+  /**
+   * Shutdown the adapter
+   */
+  startKeepalive() {
+    this.stopKeepalive();
+    this.keepaliveInterval = setInterval(() => {
+      writeNotification(RPC_NOTIFICATIONS.PING, {
+        timestamp: createTimestamp(),
+        status: this.status,
+        turnId: this.currentTurnId
+      });
+    }, this.KEEPALIVE_MS);
+  }
+  stopKeepalive() {
+    if (this.keepaliveInterval) {
+      clearInterval(this.keepaliveInterval);
+      this.keepaliveInterval = null;
+    }
+  }
+  shutdown(reason = "completed") {
+    this.stopKeepalive();
+    for (const [, pending] of this.pendingPermissions) {
+      if (pending.ackTimeout) {
+        clearTimeout(pending.ackTimeout);
+      }
+      if (pending.responseTimeout) {
+        clearTimeout(pending.responseTimeout);
+      }
+      pending.reject(new Error("Adapter shutdown"));
+    }
+    this.pendingPermissions.clear();
+    for (const [, pending] of this.pendingVscodeInvocations) {
+      pending.reject(new Error("Adapter shutdown"));
+    }
+    this.pendingVscodeInvocations.clear();
+    if (this.abortController) {
+      this.abortController.abort();
+    }
+    writeNotification(RPC_NOTIFICATIONS.AGENT_END, {
+      sessionId: this.sessionId,
+      reason,
+      timestamp: createTimestamp()
+    });
+  }
+  /**
+   * Handle output events from the agent
+   */
+  handleAgentOutput(event) {
+    process.stderr.write(`[RPC DEBUG] handleAgentOutput: type=${event.type}, content length=${_nullishCoalesce(_optionalChain([event, 'access', _98 => _98.content, 'optionalAccess', _99 => _99.length]), () => ( 0))}
+`);
+    switch (event.type) {
+      case "thinking":
+        if (event.thought) {
+          process.stderr.write(`[RPC DEBUG] Emitting thinking: ${event.thought.substring(0, 50)}...
+`);
+          writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+            messageId: this.currentMessageId,
+            delta: "",
+            thought: event.thought,
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "message":
+        if (event.content) {
+          process.stderr.write(`[RPC DEBUG] Emitting message content: ${event.content.substring(0, 100)}...
+`);
+          this.currentMessageContent = event.content;
+          writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+            messageId: this.currentMessageId,
+            delta: event.content,
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "tool_start":
+        if (event.toolName) {
+          writeNotification(RPC_NOTIFICATIONS.TOOL_START, {
+            toolId: _nullishCoalesce(event.toolId, () => ( generateId("tool"))),
+            toolName: event.toolName,
+            args: _nullishCoalesce(event.toolArgs, () => ( {})),
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "tool_end":
+        if (event.toolName) {
+          writeNotification(RPC_NOTIFICATIONS.TOOL_END, {
+            toolId: _nullishCoalesce(event.toolId, () => ( "unknown")),
+            toolName: event.toolName,
+            success: _nullishCoalesce(event.toolSuccess, () => ( true)),
+            output: event.toolOutput,
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "schedule_triggered":
+        writeNotification(RPC_NOTIFICATIONS.SCHEDULE_TRIGGERED, {
+          prompt: event.content,
+          scheduleId: event.scheduleId,
+          timestamp: createTimestamp()
+        });
+        break;
+      case "file_modified":
+        if (event.filePath) {
+          writeNotification(RPC_NOTIFICATIONS.HOOK_FILE_MODIFIED, {
+            filePath: event.filePath,
+            changeType: _nullishCoalesce(event.changeType, () => ( "modify")),
+            toolId: _nullishCoalesce(event.toolId, () => ( "")),
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "error":
+        if (event.content) {
+          process.stderr.write(`[RPC DEBUG] Emitting error: ${event.content.substring(0, 100)}...
+`);
+          const errorType = this.classifyError(event.content);
+          const icon = errorType.icon;
+          this.currentMessageContent = `${icon} ${event.content}`;
+          writeNotification(RPC_NOTIFICATIONS.MESSAGE_UPDATE, {
+            messageId: this.currentMessageId,
+            delta: this.currentMessageContent,
+            timestamp: createTimestamp()
+          });
+          writeNotification(RPC_NOTIFICATIONS.ERROR, {
+            code: errorType.code,
+            message: event.content,
+            errorType: errorType.type,
+            recoverable: errorType.recoverable,
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+    }
+  }
+  /**
+   * Classify error messages for appropriate UI treatment.
+   * Delegates to the shared classifyApiError() and maps the result
+   * to the RPC-specific shape (type, code, icon, recoverable).
+   */
+  classifyError(message) {
+    const classified = _chunk3OF56EMAcjs.classifyApiError.call(void 0, 0, message);
+    return {
+      type: _nullishCoalesce(RPC_ERROR_TYPE_MAP[classified.code], () => ( "unknown")),
+      code: _nullishCoalesce(RPC_ERROR_CODE_MAP[classified.code], () => ( -32e3)),
+      icon: _nullishCoalesce(RPC_ERROR_ICON_MAP[classified.code], () => ( "\u26A0\uFE0F")),
+      recoverable: classified.retryable
+    };
+  }
+  /**
+   * Convert LLMMessage to RpcMessage
+   */
+  convertMessage(msg, index) {
+    let toolCalls;
+    if (msg.tool_calls && msg.tool_calls.length > 0) {
+      toolCalls = msg.tool_calls.map((tc) => {
+        let args = {};
+        try {
+          if (_optionalChain([tc, 'access', _100 => _100.function, 'optionalAccess', _101 => _101.arguments])) {
+            args = JSON.parse(tc.function.arguments);
+          }
+        } catch (e6) {
+        }
+        return {
+          id: tc.id,
+          name: _nullishCoalesce(_optionalChain([tc, 'access', _102 => _102.function, 'optionalAccess', _103 => _103.name]), () => ( "unknown")),
+          args
+        };
+      });
+    }
+    return {
+      id: `msg_${index}`,
+      role: msg.role,
+      content: msg.content,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      toolCalls
+    };
+  }
+  // ============================================================================
+  // Auto-Mode RPC Handlers
+  // ============================================================================
+  /**
+   * Start auto-mode loop
+   */
+  async handleAutomodeStart(requestId, params) {
+    try {
+      const automodeManager = _optionalChain([this, 'access', _104 => _104.agent, 'optionalAccess', _105 => _105.getAutomodeManager, 'optionalCall', _106 => _106()]);
+      if (!automodeManager) {
+        return {
+          success: false,
+          error: "Auto-mode manager not available"
+        };
+      }
+      if (automodeManager.isActive()) {
+        return {
+          success: false,
+          error: "Auto-mode is already running"
+        };
+      }
+      process.stderr.write(`[RPC] Auto-mode start requested: ${params.prompt}
+`);
+      return {
+        success: true,
+        sessionId: `automode-${Date.now()}`
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  /**
+   * Get auto-mode status
+   */
+  handleAutomodeStatus(_requestId) {
+    const automodeManager = _optionalChain([this, 'access', _107 => _107.agent, 'optionalAccess', _108 => _108.getAutomodeManager, 'optionalCall', _109 => _109()]);
+    if (!automodeManager) {
+      return {
+        active: false,
+        paused: false
+      };
+    }
+    const state = automodeManager.getState();
+    return {
+      active: automodeManager.isActive(),
+      paused: automodeManager.isPausedState(),
+      state: state ? {
+        sessionId: state.sessionId,
+        status: state.status,
+        currentIteration: state.currentIteration,
+        maxIterations: state.maxIterations,
+        filesCreated: state.filesCreated,
+        filesModified: state.filesModified,
+        branch: state.branch,
+        lastCheckpoint: state.lastCheckpoint
+      } : void 0
+    };
+  }
+  /**
+   * Pause auto-mode loop
+   */
+  async handleAutomodePause(_requestId) {
+    try {
+      const automodeManager = _optionalChain([this, 'access', _110 => _110.agent, 'optionalAccess', _111 => _111.getAutomodeManager, 'optionalCall', _112 => _112()]);
+      if (!automodeManager) {
+        return {
+          success: false,
+          error: "Auto-mode manager not available"
+        };
+      }
+      if (!automodeManager.isActive()) {
+        return {
+          success: false,
+          error: "No auto-mode session is running"
+        };
+      }
+      if (automodeManager.isPausedState()) {
+        return {
+          success: false,
+          error: "Auto-mode is already paused"
+        };
+      }
+      await automodeManager.pause();
+      return { success: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  /**
+   * Resume auto-mode loop
+   */
+  async handleAutomodeResume(_requestId) {
+    try {
+      const automodeManager = _optionalChain([this, 'access', _113 => _113.agent, 'optionalAccess', _114 => _114.getAutomodeManager, 'optionalCall', _115 => _115()]);
+      if (!automodeManager) {
+        return {
+          success: false,
+          error: "Auto-mode manager not available"
+        };
+      }
+      if (!automodeManager.isActive()) {
+        return {
+          success: false,
+          error: "No auto-mode session to resume"
+        };
+      }
+      if (!automodeManager.isPausedState()) {
+        return {
+          success: false,
+          error: "Auto-mode is not paused"
+        };
+      }
+      await automodeManager.resume();
+      return { success: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  /**
+   * Cancel auto-mode loop
+   */
+  async handleAutomodeCancel(requestId, reason) {
+    try {
+      const automodeManager = _optionalChain([this, 'access', _116 => _116.agent, 'optionalAccess', _117 => _117.getAutomodeManager, 'optionalCall', _118 => _118()]);
+      if (!automodeManager) {
+        return {
+          success: false,
+          error: "Auto-mode manager not available"
+        };
+      }
+      if (!automodeManager.isActive()) {
+        return {
+          success: false,
+          error: "No auto-mode session to cancel"
+        };
+      }
+      await automodeManager.cancel(reason || "rpc_cancel");
+      return { success: true };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        error: message
+      };
+    }
+  }
+  /**
+   * Get auto-mode iteration log
+   */
+  handleAutomodeGetLog(requestId, limit) {
+    try {
+      const automodeManager = _optionalChain([this, 'access', _119 => _119.agent, 'optionalAccess', _120 => _120.getAutomodeManager, 'optionalCall', _121 => _121()]);
+      if (!automodeManager) {
+        return {
+          success: false,
+          iterations: [],
+          error: "Auto-mode manager not available"
+        };
+      }
+      const state = automodeManager.getState();
+      if (!state) {
+        return {
+          success: true,
+          iterations: []
+        };
+      }
+      const iterations = [];
+      return {
+        success: true,
+        iterations: limit ? iterations.slice(-limit) : iterations
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        iterations: [],
+        error: message
+      };
+    }
+  }
+  // ============================================================================
+  // SDK Control RPC Methods
+  // ============================================================================
+  /**
+   * Set permission mode
+   */
+  async handleSetPermissionMode(params) {
+    try {
+      const previousMode = _optionalChain([this, 'access', _122 => _122.config, 'optionalAccess', _123 => _123.permissionMode]) || "default";
+      this.config.permissionMode = params.mode;
+      return {
+        success: true,
+        currentMode: params.mode,
+        previousMode
+      };
+    } catch (e7) {
+      return {
+        success: false,
+        currentMode: _optionalChain([this, 'access', _124 => _124.config, 'optionalAccess', _125 => _125.permissionMode]) || "default",
+        previousMode: _optionalChain([this, 'access', _126 => _126.config, 'optionalAccess', _127 => _127.permissionMode]) || "default"
+      };
+    }
+  }
+  /**
+   * Set model
+   */
+  async handleSetModel(params) {
+    try {
+      this.config.model = params.model;
+      return {
+        success: true,
+        currentModel: params.model
+      };
+    } catch (e8) {
+      return {
+        success: false,
+        currentModel: _optionalChain([this, 'access', _128 => _128.config, 'optionalAccess', _129 => _129.model])
+      };
+    }
+  }
+  /**
+   * Set max thinking tokens
+   */
+  async handleSetMaxThinkingTokens(params) {
+    try {
+      this.config.maxThinkingTokens = _nullishCoalesce(params.maxThinkingTokens, () => ( void 0));
+      return {
+        success: true,
+        currentMaxThinkingTokens: _nullishCoalesce(params.maxThinkingTokens, () => ( null))
+      };
+    } catch (e9) {
+      return {
+        success: false,
+        currentMaxThinkingTokens: _optionalChain([this, 'access', _130 => _130.config, 'optionalAccess', _131 => _131.maxThinkingTokens]) || null
+      };
+    }
+  }
+  /**
+   * Apply flag settings — now propagates contextCompact to the agent.
+   */
+  async handleApplyFlagSettings(params) {
+    try {
+      const appliedSettings = [];
+      for (const [key, value] of Object.entries(params.settings)) {
+        if (value !== void 0) {
+          this.config[key] = value;
+          appliedSettings.push(key);
+          if (key === "contextCompact" && typeof value === "boolean") {
+            _optionalChain([this, 'access', _132 => _132.agent, 'optionalAccess', _133 => _133.setContextCompaction, 'call', _134 => _134(value)]);
+          }
+        }
+      }
+      return {
+        success: true,
+        appliedSettings
+      };
+    } catch (e10) {
+      return {
+        success: false,
+        appliedSettings: []
+      };
+    }
+  }
+  /**
+   * Get supported models
+   */
+  async handleGetSupportedModels() {
+    try {
+      const models = [
+        { id: "anthropic/claude-sonnet-4", displayName: "Claude Sonnet 4" },
+        { id: "anthropic/claude-3-5-sonnet-20241022", displayName: "Claude 3.5 Sonnet" },
+        { id: "openai/gpt-4o", displayName: "GPT-4o" },
+        { id: "openai/gpt-4o-mini", displayName: "GPT-4o Mini" }
+      ];
+      return {
+        models
+      };
+    } catch (e11) {
+      return {
+        models: []
+      };
+    }
+  }
+  /**
+   * Get supported commands
+   */
+  async handleGetSupportedCommands() {
+    try {
+      const commands = [
+        "help",
+        "model",
+        "auto",
+        "plan",
+        "skills",
+        "learn",
+        "mcp",
+        "chrome"
+      ];
+      return {
+        commands
+      };
+    } catch (e12) {
+      return {
+        commands: []
+      };
+    }
+  }
+  /**
+   * Get context usage — returns real data from the agent's orchestrator.
+   */
+  async handleGetContextUsage() {
+    try {
+      if (_optionalChain([this, 'access', _135 => _135.agent, 'optionalAccess', _136 => _136.getContextOrchestrator])) {
+        const orchestrator = this.agent.getContextOrchestrator();
+        const tools = _nullishCoalesce(_optionalChain([this, 'access', _137 => _137.agent, 'access', _138 => _138.getToolDefinitions, 'optionalCall', _139 => _139()]), () => ( []));
+        const usage = orchestrator.getExtendedUsage(tools);
+        return {
+          systemPrompt: usage.systemPrompt,
+          tools: usage.tools,
+          messages: usage.messages,
+          mcpTools: usage.mcpTools,
+          memoryFiles: usage.memoryFiles,
+          total: usage.total,
+          contextWindow: usage.contextWindow,
+          usagePercent: usage.usagePercent,
+          isWarning: usage.isWarning,
+          isCritical: usage.isCritical
+        };
+      }
+      return {
+        systemPrompt: 0,
+        tools: 0,
+        messages: 0,
+        mcpTools: 0,
+        memoryFiles: 0,
+        total: 0
+      };
+    } catch (e13) {
+      return {
+        systemPrompt: 0,
+        tools: 0,
+        messages: 0,
+        mcpTools: 0,
+        memoryFiles: 0,
+        total: 0
+      };
+    }
+  }
+  /**
+   * Set context compaction enabled/disabled
+   */
+  async handleSetContextCompact(params) {
+    try {
+      _optionalChain([this, 'access', _140 => _140.agent, 'optionalAccess', _141 => _141.setContextCompaction, 'call', _142 => _142(params.enabled)]);
+      return { enabled: params.enabled };
+    } catch (e14) {
+      return { enabled: _nullishCoalesce(_optionalChain([this, 'access', _143 => _143.agent, 'optionalAccess', _144 => _144.isContextCompactionEnabled, 'optionalCall', _145 => _145()]), () => ( false)) };
+    }
+  }
+  /**
+   * Reload plugins
+   */
+  async handleReloadPlugins() {
+    try {
+      const reloadedPlugins = ["skills"];
+      return {
+        success: true,
+        reloadedPlugins
+      };
+    } catch (e15) {
+      return {
+        success: false,
+        reloadedPlugins: []
+      };
+    }
+  }
+  /**
+   * Get account info
+   */
+  async handleGetAccountInfo() {
+    try {
+      return {
+        email: "user@example.com"
+      };
+    } catch (e16) {
+      return {
+        email: ""
+      };
+    }
+  }
+  /**
+   * Toggle MCP server
+   */
+  async handleMcpToggleServer(params) {
+    try {
+      return {
+        success: true,
+        serverName: params.serverName,
+        status: params.enabled ? "enabled" : "disabled"
+      };
+    } catch (e17) {
+      return {
+        success: false,
+        serverName: params.serverName,
+        status: "disabled"
+      };
+    }
+  }
+  /**
+   * Reconnect MCP server
+   */
+  async handleMcpReconnectServer(params) {
+    try {
+      return {
+        success: true,
+        serverName: params.serverName,
+        status: "connected"
+      };
+    } catch (e18) {
+      return {
+        success: false,
+        serverName: params.serverName,
+        status: "disconnected"
+      };
+    }
+  }
+  /**
+   * Set MCP servers
+   */
+  async handleMcpSetServers(params) {
+    try {
+      const configuredServers = Object.keys(params.servers);
+      return {
+        success: true,
+        configuredServers
+      };
+    } catch (e19) {
+      return {
+        success: false,
+        configuredServers: []
+      };
+    }
+  }
+}, _class2);
+
+// src/modes/rpc/index.ts
+var originalConsole = {
+  log: console.log,
+  warn: console.warn,
+  error: console.error,
+  info: console.info,
+  debug: console.debug
+};
+function suppressConsole() {
+  console.log = () => {
+  };
+  console.warn = () => {
+  };
+  console.error = () => {
+  };
+  console.info = () => {
+  };
+  console.debug = () => {
+  };
+}
+function restoreConsole() {
+  console.log = originalConsole.log;
+  console.warn = originalConsole.warn;
+  console.error = originalConsole.error;
+  console.info = originalConsole.info;
+  console.debug = originalConsole.debug;
+}
+async function runRpcMode(options) {
+  suppressConsole();
+  const { setBrowserBridgeOutput } = await Promise.resolve().then(() => _interopRequireWildcard(require("./browserToolBridge-BXRQB4B4.cjs")));
+  setBrowserBridgeOutput(process.stdout);
+  process.stdout.on("error", (err) => {
+    process.stderr.write(`[RPC] stdout error: ${err.message}
+`);
+  });
+  process.stdin.on("error", (err) => {
+    process.stderr.write(`[RPC] stdin error: ${err.message}
+`);
+  });
+  process.stdin.on("end", () => {
+    process.stderr.write("[RPC] stdin end (extension disconnected)\n");
+  });
+  let adapter = null;
+  let agent = null;
+  try {
+    const config = await _chunk46C73ZKKcjs.loadConfig.call(void 0, options.config, process.cwd());
+    const normalizedYolo = _chunkJ5HE6CUMcjs.normalizeYoloInput.call(void 0, options.yolo);
+    if (normalizedYolo) {
+      try {
+        const yoloPattern = _chunkJ5HE6CUMcjs.parseYoloPattern.call(void 0, normalizedYolo);
+        options.yolo = normalizedYolo;
+        config.permissions = {
+          ...config.permissions,
+          ..._chunkJ5HE6CUMcjs.buildPermissionSettingsFromYolo.call(void 0, yoloPattern)
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        writeErrorResponse(null, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, message);
+        process.exit(1);
+      }
+    }
+    const originalWorkspaceRoot = _nullishCoalesce(options.path, () => ( process.cwd()));
+    let workspaceRoot = originalWorkspaceRoot;
+    const workspacePathValidation = await _chunk3LJJG5YYcjs.validateWorkspacePath.call(void 0, originalWorkspaceRoot);
+    if (!workspacePathValidation.valid) {
+      writeErrorResponse(
+        null,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        workspacePathValidation.error || "Invalid workspace path"
+      );
+      process.exit(1);
+    }
+    const safetyCheck = _chunkWGNMOVMTcjs.checkWorkspaceSafety.call(void 0, originalWorkspaceRoot);
+    if (!safetyCheck.safe) {
+      writeErrorResponse(
+        null,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        `Unsafe workspace: ${safetyCheck.reason || originalWorkspaceRoot}`
+      );
+      process.exit(1);
+    }
+    const isAuthed = await _chunkQ2IL4DDIcjs.checkAuthenticated.call(void 0, config);
+    if (!isAuthed) {
+      writeErrorResponse(
+        null,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        "Authentication required. Run `autohand login` first."
+      );
+      process.exit(1);
+    }
+    if (!config.ui) {
+      config.ui = {};
+    }
+    config.ui.useInkRenderer = false;
+    if (_chunk7LWQCE4Ycjs.isSessionWorktreeEnabled.call(void 0, options.worktree)) {
+      const sessionWorktree = _chunk7LWQCE4Ycjs.prepareSessionWorktree.call(void 0, {
+        cwd: originalWorkspaceRoot,
+        worktree: options.worktree,
+        mode: "rpc"
+      });
+      workspaceRoot = sessionWorktree.worktreePath;
+      process.stderr.write(`[RPC] Using git worktree ${sessionWorktree.worktreePath} (${sessionWorktree.branchName})
+`);
+    }
+    const additionalDirs = [];
+    if (options.addDir && options.addDir.length > 0) {
+      for (const dir of options.addDir) {
+        const resolvedDir = _path2.default.resolve(dir);
+        if (!await _fsextra2.default.pathExists(resolvedDir)) {
+          throw new Error(`Additional directory does not exist: ${dir}`);
+        }
+        const stats = await _fsextra2.default.stat(resolvedDir);
+        if (!stats.isDirectory()) {
+          throw new Error(`Additional path is not a directory: ${dir}`);
+        }
+        const addDirSafetyCheck = _chunkWGNMOVMTcjs.checkWorkspaceSafety.call(void 0, resolvedDir);
+        if (!addDirSafetyCheck.safe) {
+          throw new Error(`Unsafe additional directory: ${dir} - ${addDirSafetyCheck.reason}`);
+        }
+        additionalDirs.push(resolvedDir);
+      }
+    }
+    const runtime = {
+      config,
+      workspaceRoot,
+      options: {
+        ...options,
+        clientContext: "chrome"
+        // Do NOT set yes: true - permissions are handled via RPC
+      },
+      additionalDirs: additionalDirs.length > 0 ? additionalDirs : void 0,
+      isRpcMode: true
+    };
+    const provider = _chunkWRTXCQ3Vcjs.ProviderFactory.create(config);
+    if (options.model) {
+      provider.setModel(options.model);
+    }
+    const files = new (0, _chunk5K3CDSWZcjs.FileActionManager)(workspaceRoot, additionalDirs);
+    agent = new (0, _chunk7JLT2VNWcjs.AutohandAgent)(provider, files, runtime);
+    await agent.initializeForRPC();
+    const conversation = _chunkDA7NBAJKcjs.ConversationManager.getInstance();
+    try {
+      const { CHROME_AUTOMATION_SYSTEM_PROMPT } = await Promise.resolve().then(() => _interopRequireWildcard(require("./chromeSkill-THW7N4IY.cjs")));
+      conversation.addSystemNote(CHROME_AUTOMATION_SYSTEM_PROMPT);
+    } catch (e20) {
+    }
+    adapter = new RPCAdapter();
+    adapter.initialize(
+      agent,
+      conversation,
+      _nullishCoalesce(_nullishCoalesce(options.model, () => ( _optionalChain([config, 'access', _146 => _146.openrouter, 'optionalAccess', _147 => _147.model]))), () => ( "unknown")),
+      workspaceRoot,
+      _optionalChain([config, 'access', _148 => _148.mcp, 'optionalAccess', _149 => _149.servers])
+    );
+    agent.setConfirmationCallback(async (message, context) => {
+      if (!adapter) {
+        throw new Error("RPC adapter not initialized");
+      }
+      const tool = _nullishCoalesce(_optionalChain([context, 'optionalAccess', _150 => _150.tool]), () => ( "action"));
+      const description = message;
+      const permContext = {};
+      if (_optionalChain([context, 'optionalAccess', _151 => _151.command])) permContext.command = context.command;
+      if (_optionalChain([context, 'optionalAccess', _152 => _152.path])) permContext.path = context.path;
+      return adapter.requestPermission(tool, description, permContext);
+    });
+    agent.setDirectoryAccessCallback(async (path2, reason) => {
+      if (!adapter) {
+        throw new Error("RPC adapter not initialized");
+      }
+      return adapter.requestDirectoryAccess(path2, reason);
+    });
+    const reader = new LineReader(process.stdin);
+    while (true) {
+      try {
+        const line = await reader.readLine();
+        process.stderr.write(`[RPC DEBUG] stdin read line size=${line.length}b
+`);
+        await handleLine(line, adapter);
+      } catch (error) {
+        if (error instanceof Error && error.message === "Stream closed") {
+          process.stderr.write("[RPC] Extension disconnected (stdin closed). Shutting down gracefully.\n");
+          break;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[RPC] Fatal error in request loop: ${message}
+`);
+        writeInternalError(null, message);
+      }
+    }
+    _optionalChain([adapter, 'optionalAccess', _153 => _153.shutdown, 'call', _154 => _154("disconnected")]);
+    process.exit(0);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeErrorResponse(null, JSON_RPC_ERROR_CODES.INTERNAL_ERROR, `Initialization error: ${message}`);
+    _optionalChain([adapter, 'optionalAccess', _155 => _155.shutdown, 'call', _156 => _156("error")]);
+    process.exit(1);
+  }
+}
+async function handleLine(line, adapter) {
+  process.stderr.write(`[RPC DEBUG] handleLine received: ${line.slice(0, 100)}
+`);
+  const parseResult = parseRequest(line);
+  if (parseResult.type === "error") {
+    writeErrorResponse(null, parseResult.code, parseResult.message);
+    return;
+  }
+  if (parseResult.type === "batch") {
+    const responses = await Promise.all(
+      parseResult.requests.map((req) => handleSingleRequest(req, adapter))
+    );
+    const validResponses = responses.filter((r) => r !== null);
+    writeBatchResponse(validResponses);
+    return;
+  }
+  const response = await handleSingleRequest(parseResult.request, adapter);
+  if (response !== null) {
+    process.stdout.write(JSON.stringify(response) + "\n");
+  }
+}
+async function handleSingleRequest(request, adapter) {
+  const { method, params, id } = request;
+  const shouldRespond = !isNotification(request);
+  try {
+    let result;
+    switch (method) {
+      case RPC_METHODS.PROMPT: {
+        const promptParams = params;
+        if (!_optionalChain([promptParams, 'optionalAccess', _157 => _157.message])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: message"
+            );
+          }
+          return null;
+        }
+        adapter.handlePrompt(id, promptParams).then((promptResult) => {
+          if (shouldRespond) {
+            process.stdout.write(JSON.stringify(createResponse(id, promptResult)) + "\n");
+          }
+        }).catch((error) => {
+          const message = error instanceof Error ? error.message : String(error);
+          if (shouldRespond) {
+            process.stdout.write(JSON.stringify(createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+              message
+            )) + "\n");
+          }
+        });
+        return null;
+      }
+      case RPC_METHODS.ABORT: {
+        process.stderr.write(`[RPC DEBUG] ABORT received! id=${id}, isNotification=${!shouldRespond}
+`);
+        result = adapter.handleAbort(_nullishCoalesce(id, () => ( null)));
+        break;
+      }
+      case RPC_METHODS.RESET: {
+        result = await adapter.handleReset(id);
+        break;
+      }
+      case RPC_METHODS.GET_STATE: {
+        result = adapter.handleGetState(id);
+        break;
+      }
+      case RPC_METHODS.GET_MESSAGES: {
+        const messagesParams = params;
+        result = adapter.handleGetMessages(id, _optionalChain([messagesParams, 'optionalAccess', _158 => _158.limit]));
+        break;
+      }
+      case RPC_METHODS.BROWSER_HANDOFF_CREATE: {
+        const handoffCreateParams = params;
+        result = await adapter.handleBrowserHandoffCreate(id, handoffCreateParams);
+        break;
+      }
+      case RPC_METHODS.BROWSER_HANDOFF_ATTACH: {
+        const handoffAttachParams = params;
+        if (!_optionalChain([handoffAttachParams, 'optionalAccess', _159 => _159.token])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: token"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleBrowserHandoffAttach(id, handoffAttachParams);
+        break;
+      }
+      case RPC_METHODS.BROWSER_HANDOFF_ATTACH_LATEST: {
+        const handoffAttachLatestParams = params;
+        result = await adapter.handleBrowserHandoffAttachLatest(id, handoffAttachLatestParams);
+        break;
+      }
+      case RPC_METHODS.PERMISSION_RESPONSE: {
+        const permParams = params;
+        if (!_optionalChain([permParams, 'optionalAccess', _160 => _160.requestId]) || _optionalChain([permParams, 'optionalAccess', _161 => _161.decision]) === void 0 && _optionalChain([permParams, 'optionalAccess', _162 => _162.allowed]) === void 0) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: requestId and a permission decision"
+            );
+          }
+          return null;
+        }
+        result = adapter.handlePermissionResponse(
+          id,
+          permParams.requestId,
+          permParams.decision ? { decision: permParams.decision, alternative: permParams.alternative } : Boolean(permParams.allowed)
+        );
+        break;
+      }
+      case RPC_METHODS.PERMISSION_ACKNOWLEDGED: {
+        const ackParams = params;
+        if (!_optionalChain([ackParams, 'optionalAccess', _163 => _163.requestId])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: requestId"
+            );
+          }
+          return null;
+        }
+        result = adapter.handlePermissionAcknowledged(ackParams.requestId);
+        break;
+      }
+      case RPC_METHODS.DIRECTORY_ACCESS_RESPONSE: {
+        const dirParams = params;
+        if (!_optionalChain([dirParams, 'optionalAccess', _164 => _164.requestId]) || typeof dirParams.granted !== "boolean") {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: requestId, granted"
+            );
+          }
+          return null;
+        }
+        result = adapter.handleDirectoryAccessResponse(dirParams.requestId, dirParams.granted);
+        break;
+      }
+      case RPC_METHODS.DIRECTORY_ACCESS_ACKNOWLEDGED: {
+        const dirAckParams = params;
+        if (!_optionalChain([dirAckParams, 'optionalAccess', _165 => _165.requestId])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: requestId"
+            );
+          }
+          return null;
+        }
+        result = adapter.handleDirectoryAccessAcknowledged(dirAckParams.requestId);
+        break;
+      }
+      case RPC_METHODS.CHANGES_DECISION: {
+        const decisionParams = params;
+        if (!_optionalChain([decisionParams, 'optionalAccess', _166 => _166.batchId]) || !_optionalChain([decisionParams, 'optionalAccess', _167 => _167.action])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: batchId, action"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleChangesDecision(id, decisionParams);
+        break;
+      }
+      case RPC_METHODS.GET_SKILLS_REGISTRY: {
+        const registryParams = params;
+        result = await adapter.handleGetSkillsRegistry(id, registryParams);
+        break;
+      }
+      case RPC_METHODS.INSTALL_SKILL: {
+        const installParams = params;
+        if (!_optionalChain([installParams, 'optionalAccess', _168 => _168.skillName]) || !_optionalChain([installParams, 'optionalAccess', _169 => _169.scope])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: skillName, scope"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleInstallSkill(id, installParams);
+        break;
+      }
+      // Auto-mode RPC methods
+      case RPC_METHODS.AUTOMODE_START: {
+        const startParams = params;
+        if (!_optionalChain([startParams, 'optionalAccess', _170 => _170.prompt])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: prompt"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleAutomodeStart(id, startParams);
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_STATUS: {
+        result = adapter.handleAutomodeStatus(id);
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_PAUSE: {
+        result = await adapter.handleAutomodePause(id);
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_RESUME: {
+        result = await adapter.handleAutomodeResume(id);
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_CANCEL: {
+        const cancelParams = params;
+        result = await adapter.handleAutomodeCancel(id, _optionalChain([cancelParams, 'optionalAccess', _171 => _171.reason]));
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_GET_LOG: {
+        const logParams = params;
+        result = adapter.handleAutomodeGetLog(id, _optionalChain([logParams, 'optionalAccess', _172 => _172.limit]));
+        break;
+      }
+      case RPC_METHODS.PLAN_MODE_SET: {
+        const planParams = params;
+        if (_optionalChain([planParams, 'optionalAccess', _173 => _173.enabled]) === void 0) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: enabled"
+            );
+          }
+          return null;
+        }
+        const planModeManager = _chunkLFDPTJYFcjs.getPlanModeManager.call(void 0, );
+        if (planParams.enabled) {
+          planModeManager.enable();
+        } else {
+          planModeManager.disable();
+        }
+        process.stderr.write(`[RPC DEBUG] Plan mode set to: ${planParams.enabled}
+`);
+        result = { success: true };
+        break;
+      }
+      case RPC_METHODS.GET_HISTORY: {
+        const historyParams = params;
+        result = await adapter.handleGetHistory(id, historyParams);
+        break;
+      }
+      case RPC_METHODS.GET_SESSION: {
+        result = await adapter.handleGetSession(id, params);
+        break;
+      }
+      case RPC_METHODS.YOLO_SET: {
+        const yoloParams = params;
+        if (!_optionalChain([yoloParams, 'optionalAccess', _174 => _174.pattern])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: pattern"
+            );
+          }
+          return null;
+        }
+        result = adapter.handleYoloSet(id, yoloParams);
+        break;
+      }
+      case RPC_METHODS.MCP_LIST_SERVERS: {
+        result = adapter.handleMcpListServers(id);
+        break;
+      }
+      case RPC_METHODS.MCP_LIST_TOOLS: {
+        const mcpToolsParams = params;
+        result = adapter.handleMcpListTools(id, mcpToolsParams);
+        break;
+      }
+      case RPC_METHODS.MCP_SET_VSCODE_TOOLS: {
+        const setToolsParams = params;
+        if (!_optionalChain([setToolsParams, 'optionalAccess', _175 => _175.tools])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: tools"
+            );
+          }
+          return null;
+        }
+        result = adapter.handleMcpSetVscodeTools(id, setToolsParams);
+        break;
+      }
+      case RPC_METHODS.MCP_INVOKE_RESPONSE: {
+        const invokeParams = params;
+        if (!_optionalChain([invokeParams, 'optionalAccess', _176 => _176.requestId]) || _optionalChain([invokeParams, 'optionalAccess', _177 => _177.success]) === void 0) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: requestId, success"
+            );
+          }
+          return null;
+        }
+        if (invokeParams.requestId.startsWith("browser_")) {
+          const { resolveBrowserToolResponse } = await Promise.resolve().then(() => _interopRequireWildcard(require("./browserToolBridge-BXRQB4B4.cjs")));
+          const handled = resolveBrowserToolResponse(
+            invokeParams.requestId,
+            invokeParams.success,
+            typeof invokeParams.result === "string" ? invokeParams.result : JSON.stringify(invokeParams.result),
+            invokeParams.error
+          );
+          if (handled) {
+            result = { success: true };
+            break;
+          }
+        }
+        result = adapter.handleMcpInvokeResponse(id, invokeParams);
+        break;
+      }
+      case RPC_METHODS.MCP_GET_SERVER_CONFIGS: {
+        result = adapter.handleMcpGetServerConfigs(id);
+        break;
+      }
+      // Learn command methods
+      case RPC_METHODS.LEARN_RECOMMEND: {
+        const learnParams = params;
+        result = await adapter.handleLearnRecommend(id, learnParams);
+        break;
+      }
+      case RPC_METHODS.LEARN_UPDATE: {
+        result = await adapter.handleLearnUpdate(id);
+        break;
+      }
+      case RPC_METHODS.LEARN_GENERATE: {
+        const generateParams = params;
+        if (!_optionalChain([generateParams, 'optionalAccess', _178 => _178.scope])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: scope"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleLearnGenerate(id, generateParams);
+        break;
+      }
+      // SDK control methods
+      case RPC_METHODS.SET_PERMISSION_MODE: {
+        const setPermParams = params;
+        if (!_optionalChain([setPermParams, 'optionalAccess', _179 => _179.mode])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: mode"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleSetPermissionMode(setPermParams);
+        break;
+      }
+      case RPC_METHODS.SET_MODEL: {
+        const setModelParams = params;
+        result = await adapter.handleSetModel(setModelParams);
+        break;
+      }
+      case RPC_METHODS.SET_MAX_THINKING_TOKENS: {
+        const setThinkingParams = params;
+        result = await adapter.handleSetMaxThinkingTokens(setThinkingParams);
+        break;
+      }
+      case RPC_METHODS.APPLY_FLAG_SETTINGS: {
+        const applyFlagsParams = params;
+        if (!_optionalChain([applyFlagsParams, 'optionalAccess', _180 => _180.settings])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: settings"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleApplyFlagSettings(applyFlagsParams);
+        break;
+      }
+      case RPC_METHODS.GET_SUPPORTED_MODELS: {
+        result = await adapter.handleGetSupportedModels();
+        break;
+      }
+      case RPC_METHODS.GET_SUPPORTED_COMMANDS: {
+        result = await adapter.handleGetSupportedCommands();
+        break;
+      }
+      case RPC_METHODS.GET_TOOLS_REGISTRY: {
+        result = adapter.handleGetToolsRegistry();
+        break;
+      }
+      case RPC_METHODS.GET_CONTEXT_USAGE: {
+        result = await adapter.handleGetContextUsage();
+        break;
+      }
+      case RPC_METHODS.SET_CONTEXT_COMPACT: {
+        const compactParams = params;
+        if (_optionalChain([compactParams, 'optionalAccess', _181 => _181.enabled]) === void 0) {
+          if (shouldRespond) {
+            return {
+              jsonrpc: "2.0",
+              error: { code: -32602, message: "Missing enabled parameter" },
+              id: _nullishCoalesce(id, () => ( null))
+            };
+          }
+          return null;
+        }
+        result = await adapter.handleSetContextCompact({ enabled: compactParams.enabled });
+        break;
+      }
+      case RPC_METHODS.RELOAD_PLUGINS: {
+        result = await adapter.handleReloadPlugins();
+        break;
+      }
+      case RPC_METHODS.GET_ACCOUNT_INFO: {
+        result = await adapter.handleGetAccountInfo();
+        break;
+      }
+      case RPC_METHODS.MCP_TOGGLE_SERVER: {
+        const toggleParams = params;
+        if (!_optionalChain([toggleParams, 'optionalAccess', _182 => _182.serverName]) || _optionalChain([toggleParams, 'optionalAccess', _183 => _183.enabled]) === void 0) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameters: serverName, enabled"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleMcpToggleServer(toggleParams);
+        break;
+      }
+      case RPC_METHODS.MCP_RECONNECT_SERVER: {
+        const reconnectParams = params;
+        if (!_optionalChain([reconnectParams, 'optionalAccess', _184 => _184.serverName])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: serverName"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleMcpReconnectServer(reconnectParams);
+        break;
+      }
+      case RPC_METHODS.MCP_SET_SERVERS: {
+        const setServersParams = params;
+        if (!_optionalChain([setServersParams, 'optionalAccess', _185 => _185.servers])) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: servers"
+            );
+          }
+          return null;
+        }
+        result = await adapter.handleMcpSetServers(setServersParams);
+        break;
+      }
+      default: {
+        if (shouldRespond) {
+          return createErrorResponse(
+            id,
+            JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+            `Method not found: ${method}`
+          );
+        }
+        return null;
+      }
+    }
+    if (shouldRespond) {
+      return createResponse(id, result);
+    }
+    return null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (shouldRespond) {
+      return createErrorResponse(
+        id,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        message
+      );
+    }
+    return null;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.JSON_RPC_ERROR_CODES = JSON_RPC_ERROR_CODES; exports.LineReader = LineReader; exports.MAX_IMAGE_SIZE = MAX_IMAGE_SIZE; exports.RPCAdapter = RPCAdapter; exports.RPC_METHODS = RPC_METHODS; exports.RPC_NOTIFICATIONS = RPC_NOTIFICATIONS; exports.VALID_IMAGE_MIME_TYPES = VALID_IMAGE_MIME_TYPES; exports.createErrorResponse = createErrorResponse; exports.createNotification = createNotification; exports.createRequest = createRequest; exports.createResponse = createResponse; exports.createTimestamp = createTimestamp; exports.generateId = generateId; exports.isJsonRpcBatch = isJsonRpcBatch; exports.isJsonRpcRequest = isJsonRpcRequest; exports.isJsonRpcResponse = isJsonRpcResponse; exports.isNotification = isNotification; exports.isValidImageMimeType = isValidImageMimeType; exports.parseRequest = parseRequest; exports.restoreConsole = restoreConsole; exports.runRpcMode = runRpcMode; exports.serialize = serialize; exports.serializeBatch = serializeBatch; exports.writeBatchResponse = writeBatchResponse; exports.writeErrorResponse = writeErrorResponse; exports.writeInternalError = writeInternalError; exports.writeInvalidRequestError = writeInvalidRequestError; exports.writeMethodNotFoundError = writeMethodNotFoundError; exports.writeNotification = writeNotification; exports.writeParseError = writeParseError; exports.writeResponse = writeResponse;