autohand-cli 0.8.3 → 0.9.1

package/dist/rpc-XH7QLN4H.js

@@ -0,0 +1,3874 @@
+import {
+  FileActionManager
+} from "./chunk-ZQAT5VT5.js";
+import {
+  AutohandAgent
+} from "./chunk-CCIDL4SA.js";
+import "./chunk-XAV24VYN.js";
+import {
+  normalizePermissionPromptResponse
+} from "./chunk-ZPLCAXJW.js";
+import "./chunk-7IRQ7JEH.js";
+import "./chunk-U2QUMKCB.js";
+import {
+  McpClientManager
+} from "./chunk-GNBBIAMD.js";
+import "./chunk-ZNGRLCFQ.js";
+import "./chunk-SNDDZG5H.js";
+import "./chunk-ES2HJQ4N.js";
+import "./chunk-6R25D2H5.js";
+import "./chunk-26G7YGOW.js";
+import "./chunk-KWXGDSYT.js";
+import "./chunk-S5QKRA2V.js";
+import "./chunk-PGFLPURU.js";
+import "./chunk-QEGOB6QV.js";
+import "./chunk-M5DK524Z.js";
+import "./chunk-JMN3GZU6.js";
+import "./chunk-7PJKTSRN.js";
+import "./chunk-5JTTM5SC.js";
+import "./chunk-2H5O745H.js";
+import "./chunk-BP37FVBM.js";
+import "./chunk-FFHSCM5M.js";
+import "./chunk-3ZOOH44N.js";
+import "./chunk-WPE2XHVX.js";
+import "./chunk-2IW5YFJ4.js";
+import "./chunk-HBXAA3XB.js";
+import "./chunk-3OEDGIFW.js";
+import "./chunk-WNUVPKBW.js";
+import "./chunk-RAKO7UN7.js";
+import "./chunk-CECH6QQP.js";
+import "./chunk-FBQJZKFX.js";
+import "./chunk-NB6M6ESM.js";
+import "./chunk-Q3BS6FPM.js";
+import "./chunk-4XVLNOFA.js";
+import "./chunk-DNSD7DVJ.js";
+import "./chunk-SPQ7QIQ6.js";
+import "./chunk-QBYGMMDD.js";
+import "./chunk-O5GI6SR3.js";
+import "./chunk-C5QIQQ37.js";
+import "./chunk-44ZWOBTI.js";
+import "./chunk-4E7SHPNQ.js";
+import "./chunk-QHPFA6OE.js";
+import "./chunk-H426KOGY.js";
+import "./chunk-WNJXIACY.js";
+import "./chunk-XZVDYC5U.js";
+import "./chunk-DGBPWODD.js";
+import {
+  ConversationManager
+} from "./chunk-HQUSEWT4.js";
+import "./chunk-TR6NECEZ.js";
+import "./chunk-24QIWILL.js";
+import "./chunk-2NUX2RAI.js";
+import "./chunk-OIGYWOL6.js";
+import "./chunk-SDLY4X3G.js";
+import "./chunk-HXHE2KAO.js";
+import "./chunk-65LRPW5W.js";
+import "./chunk-YXM6SA7P.js";
+import "./chunk-RS2E32YB.js";
+import "./chunk-SRMGWMQO.js";
+import "./chunk-SVLBJMYO.js";
+import "./chunk-PZZMIYII.js";
+import "./chunk-6HF6XSCC.js";
+import "./chunk-EYHKL4QC.js";
+import "./chunk-ZK6HOR62.js";
+import "./chunk-P4FUTSVK.js";
+import "./chunk-YC5OBZQU.js";
+import "./chunk-H4D2Q2AL.js";
+import {
+  GoalManager
+} from "./chunk-SZD45IDG.js";
+import "./chunk-W3X6PAC7.js";
+import "./chunk-JMJRFSNJ.js";
+import "./chunk-TSV4LVHK.js";
+import "./chunk-SFFEKZGC.js";
+import "./chunk-TYBPTKFT.js";
+import "./chunk-UR27UDTB.js";
+import "./chunk-CFAWTLSC.js";
+import "./chunk-I2ZK3AOD.js";
+import {
+  buildPermissionSettingsFromYolo,
+  normalizeYoloInput,
+  parseYoloPattern
+} from "./chunk-4LMUDS2K.js";
+import "./chunk-HTU4W3GB.js";
+import "./chunk-KMP6Y3LJ.js";
+import "./chunk-YVQI26H4.js";
+import "./chunk-HSWWM6AM.js";
+import "./chunk-TH26BQJG.js";
+import {
+  ProviderFactory,
+  modelSupportsImages
+} from "./chunk-JPFRI4L4.js";
+import {
+  ImageManager
+} from "./chunk-MANJ67D3.js";
+import "./chunk-VUGOOGHB.js";
+import {
+  getPlanModeManager
+} from "./chunk-LUMV3DB2.js";
+import "./chunk-BQU3HAE7.js";
+import "./chunk-575PXZX7.js";
+import {
+  GOAL_FEATURE_DISABLED_MESSAGE,
+  isGoalFeatureEnabled
+} from "./chunk-7MY4JHER.js";
+import "./chunk-FP46B4X3.js";
+import "./chunk-QRQF3556.js";
+import "./chunk-V5ELP2XE.js";
+import "./chunk-EEHWALXA.js";
+import "./chunk-PTTZI4QZ.js";
+import "./chunk-UWZ4G3SQ.js";
+import "./chunk-ZUYYHKQA.js";
+import "./chunk-46MTALKD.js";
+import "./chunk-YQDI753V.js";
+import "./chunk-MMKZSJUN.js";
+import "./chunk-4567QNRB.js";
+import {
+  validateWorkspacePath
+} from "./chunk-KA2U6MY2.js";
+import {
+  isSessionWorktreeEnabled,
+  prepareSessionWorktree
+} from "./chunk-C46B72VK.js";
+import "./chunk-WQ3VJXZB.js";
+import {
+  attachBrowserHandoff,
+  attachLatestBrowserHandoff,
+  createBrowserHandoff
+} from "./chunk-GSDV75A5.js";
+import {
+  checkAuthenticated
+} from "./chunk-6AYJCDTA.js";
+import "./chunk-GLBAF54O.js";
+import "./chunk-7DJJGKM6.js";
+import "./chunk-JB3JCYBJ.js";
+import {
+  classifyApiError
+} from "./chunk-FQVG6ZHF.js";
+import "./chunk-X3TI5TJJ.js";
+import "./chunk-NZ3ZWLUW.js";
+import "./chunk-HZWU6IO3.js";
+import "./chunk-CSTUTDTH.js";
+import {
+  loadConfig
+} from "./chunk-IEPLQ47J.js";
+import "./chunk-5A7ZL64N.js";
+import "./chunk-YZWE7XSM.js";
+import "./chunk-LANGD5CO.js";
+import "./chunk-NBGOIFKP.js";
+import "./chunk-JAQO6XDB.js";
+import "./chunk-SHRLFX6F.js";
+import "./chunk-UOQECODR.js";
+import {
+  checkWorkspaceSafety
+} from "./chunk-PB7W7R72.js";
+import "./chunk-LEZEWKPA.js";
+import "./chunk-L6OH44HL.js";
+import "./chunk-QGM4M3NI.js";
+
+// src/modes/rpc/index.ts
+import fs from "fs-extra";
+import path from "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",
+  GOAL_GET: "autohand.goal.get",
+  GOAL_CREATE: "autohand.goal.create",
+  GOAL_UPDATE: "autohand.goal.update",
+  GOAL_CLEAR: "autohand.goal.clear",
+  GOAL_QUEUE: "autohand.goal.queue",
+  GOAL_START_QUEUED: "autohand.goal.startQueued",
+  GOAL_LIST_TEMPLATES: "autohand.goal.listTemplates"
+};
+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
+import crypto from "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 {
+    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 {
+  constructor(stream) {
+    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());
+  }
+  stream;
+  buffer = "";
+  lineQueue = [];
+  resolvers = [];
+  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;
+  }
+};
+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 = class {
+  agent = null;
+  conversation = null;
+  imageManager = null;
+  sessionId = null;
+  currentTurnId = null;
+  turnStartTime = null;
+  currentMessageId = null;
+  currentMessageContent = "";
+  pendingPermissions = /* @__PURE__ */ new Map();
+  pendingDirectoryAccess = /* @__PURE__ */ new Map();
+  abortController = null;
+  status = "idle";
+  model = "";
+  workspace = "";
+  contextPercent = 0;
+  currentChangesBatchId = null;
+  // Enable preview mode for multi-file change batching (future: make configurable)
+  previewModeEnabled = true;
+  // MCP bridge: VS Code tools registered by the extension
+  vscodeTools = /* @__PURE__ */ new Map();
+  // MCP bridge: pending tool invocations waiting for extension response
+  pendingVscodeInvocations = /* @__PURE__ */ new Map();
+  // MCP server configurations from CLI config (set during initialization)
+  mcpServerConfigs = [];
+  // Cached vision support result (null = not yet checked)
+  visionSupported = null;
+  // Keepalive interval to prevent Chrome from killing the MV3 service worker
+  // during long turns with no traffic.
+  keepaliveInterval = null;
+  KEEPALIVE_MS = 15e3;
+  yoloRevertTimer = null;
+  yoloRevertGeneration = 0;
+  // Config reference for runtime settings changes
+  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 modelSupportsImages(this.model);
+    return this.visionSupported;
+  }
+  /**
+   * Initialize the adapter with an agent instance
+   */
+  initialize(agent, conversation, model, workspace, config, mcpServerConfigs) {
+    this.agent = agent;
+    this.conversation = conversation;
+    this.model = model;
+    this.workspace = workspace;
+    this.config = config ? { ...config } : {};
+    this.sessionId = generateId("session");
+    this.mcpServerConfigs = mcpServerConfigs ?? [];
+    this.imageManager = agent.getImageManager?.() ?? new 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: this.conversation?.history().length ?? 0
+    };
+  }
+  async handleGoalGet() {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).getSnapshot();
+  }
+  async handleGoalCreate(params) {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).createGoal({
+      objective: params.objective,
+      tokenBudget: params.token_budget,
+      timeBudgetSeconds: params.time_budget_seconds,
+      minTokensBeforeWrapUp: params.min_tokens_before_wrap_up,
+      minTimeSecondsBeforeWrapUp: params.min_time_seconds_before_wrap_up
+    });
+  }
+  async handleGoalUpdate(params) {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).updateGoal({
+      objective: params.objective,
+      status: parseRpcGoalStatus(params.status),
+      tokenBudget: params.token_budget,
+      timeBudgetSeconds: params.time_budget_seconds,
+      minTokensBeforeWrapUp: params.min_tokens_before_wrap_up,
+      minTimeSecondsBeforeWrapUp: params.min_time_seconds_before_wrap_up
+    });
+  }
+  async handleGoalClear() {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).clearGoal();
+  }
+  async handleGoalQueue(params) {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    const manager = new GoalManager(this.workspace);
+    return manager.enqueueGoal({
+      objective: params.objective,
+      source: "rpc",
+      tokenBudget: params.token_budget,
+      timeBudgetSeconds: params.time_budget_seconds,
+      minTokensBeforeWrapUp: params.min_tokens_before_wrap_up,
+      minTimeSecondsBeforeWrapUp: params.min_time_seconds_before_wrap_up
+    });
+  }
+  async handleGoalStartQueued() {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).startQueuedGoal();
+  }
+  async handleGoalListTemplates() {
+    if (!this.isGoalFeatureEnabled()) return this.goalFeatureDisabledResult();
+    return new GoalManager(this.workspace).listTemplates();
+  }
+  isGoalFeatureEnabled() {
+    return isGoalFeatureEnabled(this.config);
+  }
+  goalFeatureDisabledResult() {
+    return { ok: false, message: GOAL_FEATURE_DISABLED_MESSAGE };
+  }
+  /**
+   * 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=${params.images?.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=${img.data?.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 (params.context?.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 = this.agent?.getHookManager?.();
+          process.stderr.write(`[RPC DEBUG] Hook execution: hookManager=${!!hookManager}
+`);
+          if (hookManager) {
+            const snapshot2 = this.agent?.getStatusSnapshot();
+            process.stderr.write(`[RPC DEBUG] Executing stop hooks...
+`);
+            await hookManager.executeHooks("stop", {
+              sessionId: this.sessionId || void 0,
+              turnDuration,
+              tokensUsed: snapshot2?.tokensUsed ?? 0,
+              tokensUsageStatus: snapshot2?.tokensUsageStatus
+            });
+            process.stderr.write(`[RPC DEBUG] Stop hooks completed
+`);
+            this.emitHookStop(
+              snapshot2?.tokensUsed ?? 0,
+              0,
+              // toolCallsCount - not tracked per turn currently
+              turnDuration,
+              snapshot2?.tokensUsageStatus
+            );
+            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 = this.agent?.getStatusSnapshot();
+      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: snapshot?.tokensUsed,
+        tokensUsageStatus: snapshot?.tokensUsageStatus,
+        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 = this.agent?.getStatusSnapshot();
+      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: snapshot?.tokensUsed,
+        tokensUsageStatus: snapshot?.tokensUsageStatus,
+        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 = this.agent?.getStatusSnapshot();
+        writeNotification(RPC_NOTIFICATIONS.TURN_END, {
+          turnId: this.currentTurnId,
+          timestamp: createTimestamp(),
+          contextPercent: this.contextPercent,
+          tokensUsed: snapshot?.tokensUsed,
+          tokensUsageStatus: snapshot?.tokensUsageStatus,
+          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 import("./extractSessionMemories-A2JX5WJ2.js");
+        await extractAndSaveSessionMemories({
+          llm: this.agent.getLlmProvider(),
+          memoryManager: this.agent.getMemoryManager(),
+          conversationHistory: this.conversation.history(),
+          workspaceRoot: this.workspace
+        });
+      } catch {
+      }
+    }
+    if (this.conversation) {
+      const history = this.conversation.history();
+      const systemPrompt = history.find((m) => m.role === "system")?.content ?? "";
+      this.conversation.reset(systemPrompt);
+    }
+    this.imageManager?.clear();
+    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 = this.agent?.getSessionManager?.().getCurrentSession?.();
+    if (!session) {
+      throw new Error("No active session available for browser handoff.");
+    }
+    return createBrowserHandoff({
+      sessionId: session.metadata.sessionId,
+      workspaceRoot: session.metadata.projectPath,
+      extensionId: params?.extensionId,
+      installUrl: params?.installUrl
+    });
+  }
+  async handleBrowserHandoffAttach(_requestId, params) {
+    const handoff = await attachBrowserHandoff(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 attachLatestBrowserHandoff();
+    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 = normalizePermissionPromptResponse(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: 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, tokensUsageStatus = "actual") {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_POST_RESPONSE, {
+      tokensUsed,
+      tokensUsageStatus,
+      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, tokensUsageStatus = "actual") {
+    writeNotification(RPC_NOTIFICATIONS.HOOK_STOP, {
+      tokensUsed,
+      tokensUsageStatus,
+      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 = this.agent?.getFileManager?.();
+    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 import("./CommunitySkillsCache-ZACDPD4J.js");
+      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-J2BWPXJF.js");
+      const cache = new CommunitySkillsCache();
+      const fetcher = new GitHubRegistryFetcher();
+      let registry;
+      if (params?.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 = this.agent?.getSkillsRegistry?.();
+      if (!skillsRegistry) {
+        return {
+          success: false,
+          error: "Skills registry not available"
+        };
+      }
+      const workspaceRoot = this.workspace;
+      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-ZACDPD4J.js");
+      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-J2BWPXJF.js");
+      const { AUTOHAND_PATHS, PROJECT_DIR_NAME } = await import("./constants-EJFAWJQI.js");
+      const path2 = await import("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 import("./autoSkill-66PKCYTW.js");
+      const { CommunitySkillsCache } = await import("./CommunitySkillsCache-ZACDPD4J.js");
+      const { GitHubRegistryFetcher } = await import("./GitHubRegistryFetcher-J2BWPXJF.js");
+      const { fetchRegistryWithFallback } = await import("./communityInstaller-RVL4STPS.js");
+      const { LearnAdvisor } = await import("./LearnAdvisor-KKEQ5QCV.js");
+      const workspace = this.workspace || process.cwd();
+      const deep = params?.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 {
+      }
+      const skillsRegistry = this.agent?.getSkillsRegistry?.();
+      const installedSkills = skillsRegistry?.listSkills() ?? [];
+      const registrySkills = registry?.skills ?? [];
+      writeNotification(RPC_NOTIFICATIONS.LEARN_PROGRESS, {
+        status: "evaluating",
+        timestamp: createTimestamp()
+      });
+      const llm = this.agent?.getLlmProvider?.();
+      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 import("./autoSkill-66PKCYTW.js");
+      const { computeProjectHash, injectGeneratedMetadata } = await import("./communityInstaller-RVL4STPS.js");
+      const { LearnAdvisor } = await import("./LearnAdvisor-KKEQ5QCV.js");
+      const fse = await import("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 = this.agent?.getSkillsRegistry?.();
+      if (!skillsRegistry) {
+        return { success: false, updated: 0, unchanged: 0, results: [], error: "Skills registry not available" };
+      }
+      const allSkills = skillsRegistry.listSkills();
+      const generatedSkills = allSkills.filter(
+        (s) => s.metadata?.["agentskill-source"] === "llm-generated"
+      );
+      if (generatedSkills.length === 0) {
+        return { success: true, updated: 0, unchanged: 0, results: [] };
+      }
+      const llm = this.agent?.getLlmProvider?.();
+      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 = skill.metadata?.["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 {
+          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 import("./autoSkill-66PKCYTW.js");
+      const { computeProjectHash, injectGeneratedMetadata } = await import("./communityInstaller-RVL4STPS.js");
+      const { LearnAdvisor } = await import("./LearnAdvisor-KKEQ5QCV.js");
+      const { AUTOHAND_PATHS, PROJECT_DIR_NAME } = await import("./constants-EJFAWJQI.js");
+      const fse = await import("fs-extra");
+      const path2 = await import("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 = this.agent?.getLlmProvider?.();
+      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 = this.agent?.getSessionManager?.();
+    if (!sessionManager) {
+      return { sessions: [], currentPage: 1, totalPages: 0, totalItems: 0 };
+    }
+    try {
+      const allSessions = await sessionManager.listSessions();
+      const page = params?.page ?? 1;
+      const pageSize = params?.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: s.lastActiveAt ?? s.createdAt,
+          projectName: s.projectName ?? "",
+          model: s.model ?? "",
+          messageCount: s.messageCount ?? 0,
+          status: 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 = this.agent?.getSessionManager?.();
+    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-${crypto.randomUUID()}` : `msg-${crypto.randomUUID()}`,
+        role: msg.role,
+        content: msg.content,
+        timestamp: new Date(m.createdAt).toISOString(),
+        toolCalls: (msg.toolCalls ?? []).map((tc) => ({
+          id: tc.callId ?? "",
+          name: tc.name ?? "",
+          args: tc.arguments ?? {}
+        }))
+      }));
+      return {
+        success: true,
+        sessionId: m.sessionId,
+        projectName: m.projectName ?? "",
+        model: m.model ?? "",
+        messageCount: m.messageCount ?? 0,
+        status: m.status ?? "completed",
+        createdAt: m.createdAt,
+        lastActiveAt: m.lastActiveAt ?? m.createdAt,
+        summary: m.summary,
+        messages,
+        workspaceRoot: 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 = this.agent?.getPermissionManager?.();
+    if (!permissionManager) {
+      return { success: false };
+    }
+    try {
+      const revertGeneration = ++this.yoloRevertGeneration;
+      if (this.yoloRevertTimer) {
+        clearTimeout(this.yoloRevertTimer);
+        this.yoloRevertTimer = null;
+      }
+      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;
+        this.yoloRevertTimer = setTimeout(() => {
+          if (this.yoloRevertGeneration !== revertGeneration) {
+            return;
+          }
+          this.yoloRevertTimer = null;
+          permissionManager.setMode("interactive");
+          process.stderr.write(`[RPC] YOLO mode expired, reverted to interactive
+`);
+        }, params.timeoutSeconds * 1e3);
+        this.yoloRevertTimer.unref?.();
+      }
+      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 = this.agent?.getMcpManager?.();
+    if (!mcpManager) {
+      return { servers: [] };
+    }
+    return { servers: mcpManager.getServers() };
+  }
+  /**
+   * List all MCP tools, optionally filtered by server name
+   */
+  handleMcpListTools(_requestId, params) {
+    const mcpManager = this.agent?.getMcpManager?.();
+    if (!mcpManager) {
+      return { tools: [] };
+    }
+    const allTools = params?.serverName ? mcpManager.getToolsForServer(params.serverName) : mcpManager.getAllTools();
+    return {
+      tools: allTools.map((t) => {
+        const parsed = McpClientManager.parseMcpToolName(t.name);
+        return {
+          name: t.name,
+          description: t.description,
+          serverName: parsed?.serverName ?? "unknown"
+        };
+      })
+    };
+  }
+  /**
+   * List persisted meta-tools and registry diagnostics for non-interactive clients.
+   */
+  handleGetToolsRegistry() {
+    const registry = this.agent?.getToolsRegistry?.();
+    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(params.result ?? "");
+    } else {
+      pending.reject(new Error(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=${event.content?.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: event.toolId ?? generateId("tool"),
+            toolName: event.toolName,
+            args: event.toolArgs ?? {},
+            timestamp: createTimestamp()
+          });
+        }
+        break;
+      case "tool_end":
+        if (event.toolName) {
+          writeNotification(RPC_NOTIFICATIONS.TOOL_END, {
+            toolId: event.toolId ?? "unknown",
+            toolName: event.toolName,
+            success: 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: event.changeType ?? "modify",
+            toolId: 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 = classifyApiError(0, message);
+    return {
+      type: RPC_ERROR_TYPE_MAP[classified.code] ?? "unknown",
+      code: RPC_ERROR_CODE_MAP[classified.code] ?? -32e3,
+      icon: 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 (tc.function?.arguments) {
+            args = JSON.parse(tc.function.arguments);
+          }
+        } catch {
+        }
+        return {
+          id: tc.id,
+          name: tc.function?.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 = this.agent?.getAutomodeManager?.();
+      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 = this.agent?.getAutomodeManager?.();
+    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 = this.agent?.getAutomodeManager?.();
+      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 = this.agent?.getAutomodeManager?.();
+      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 = this.agent?.getAutomodeManager?.();
+      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 = this.agent?.getAutomodeManager?.();
+      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 = this.config?.permissionMode || "default";
+      this.config.permissionMode = params.mode;
+      return {
+        success: true,
+        currentMode: params.mode,
+        previousMode
+      };
+    } catch {
+      return {
+        success: false,
+        currentMode: this.config?.permissionMode || "default",
+        previousMode: this.config?.permissionMode || "default"
+      };
+    }
+  }
+  /**
+   * Set model
+   */
+  async handleSetModel(params) {
+    try {
+      this.config.model = params.model;
+      return {
+        success: true,
+        currentModel: params.model
+      };
+    } catch {
+      return {
+        success: false,
+        currentModel: this.config?.model
+      };
+    }
+  }
+  /**
+   * Set max thinking tokens
+   */
+  async handleSetMaxThinkingTokens(params) {
+    try {
+      this.config.maxThinkingTokens = params.maxThinkingTokens ?? void 0;
+      return {
+        success: true,
+        currentMaxThinkingTokens: params.maxThinkingTokens ?? null
+      };
+    } catch {
+      return {
+        success: false,
+        currentMaxThinkingTokens: this.config?.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") {
+            this.agent?.setContextCompaction(value);
+          }
+        }
+      }
+      return {
+        success: true,
+        appliedSettings
+      };
+    } catch {
+      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 {
+      return {
+        models: []
+      };
+    }
+  }
+  /**
+   * Get supported commands
+   */
+  async handleGetSupportedCommands() {
+    try {
+      const commands = [
+        "help",
+        "model",
+        "auto",
+        "plan",
+        "skills",
+        "learn",
+        "mcp",
+        "chrome"
+      ];
+      return {
+        commands
+      };
+    } catch {
+      return {
+        commands: []
+      };
+    }
+  }
+  /**
+   * Get context usage — returns real data from the agent's orchestrator.
+   */
+  async handleGetContextUsage() {
+    try {
+      if (this.agent?.getContextOrchestrator) {
+        const orchestrator = this.agent.getContextOrchestrator();
+        const tools = this.agent.getToolDefinitions?.() ?? [];
+        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 {
+      return {
+        systemPrompt: 0,
+        tools: 0,
+        messages: 0,
+        mcpTools: 0,
+        memoryFiles: 0,
+        total: 0
+      };
+    }
+  }
+  /**
+   * Set context compaction enabled/disabled
+   */
+  async handleSetContextCompact(params) {
+    try {
+      this.agent?.setContextCompaction(params.enabled);
+      return { enabled: params.enabled };
+    } catch {
+      return { enabled: this.agent?.isContextCompactionEnabled?.() ?? false };
+    }
+  }
+  /**
+   * Reload plugins
+   */
+  async handleReloadPlugins() {
+    try {
+      const reloadedPlugins = ["skills"];
+      return {
+        success: true,
+        reloadedPlugins
+      };
+    } catch {
+      return {
+        success: false,
+        reloadedPlugins: []
+      };
+    }
+  }
+  /**
+   * Get account info
+   */
+  async handleGetAccountInfo() {
+    try {
+      return {
+        email: "user@example.com"
+      };
+    } catch {
+      return {
+        email: ""
+      };
+    }
+  }
+  /**
+   * Toggle MCP server
+   */
+  async handleMcpToggleServer(params) {
+    try {
+      return {
+        success: true,
+        serverName: params.serverName,
+        status: params.enabled ? "enabled" : "disabled"
+      };
+    } catch {
+      return {
+        success: false,
+        serverName: params.serverName,
+        status: "disabled"
+      };
+    }
+  }
+  /**
+   * Reconnect MCP server
+   */
+  async handleMcpReconnectServer(params) {
+    try {
+      return {
+        success: true,
+        serverName: params.serverName,
+        status: "connected"
+      };
+    } catch {
+      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 {
+      return {
+        success: false,
+        configuredServers: []
+      };
+    }
+  }
+};
+function parseRpcGoalStatus(value) {
+  if (value === "active" || value === "paused" || value === "complete" || value === "budgetLimited") {
+    return value;
+  }
+  return void 0;
+}
+
+// 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 import("./browserToolBridge-F5N66PE7.js");
+  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 loadConfig(options.config, process.cwd());
+    const normalizedYolo = normalizeYoloInput(options.yolo);
+    if (normalizedYolo) {
+      try {
+        const yoloPattern = parseYoloPattern(normalizedYolo);
+        options.yolo = normalizedYolo;
+        config.permissions = {
+          ...config.permissions,
+          ...buildPermissionSettingsFromYolo(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 = options.path ?? process.cwd();
+    let workspaceRoot = originalWorkspaceRoot;
+    const workspacePathValidation = await validateWorkspacePath(originalWorkspaceRoot);
+    if (!workspacePathValidation.valid) {
+      writeErrorResponse(
+        null,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        workspacePathValidation.error || "Invalid workspace path"
+      );
+      process.exit(1);
+    }
+    const safetyCheck = checkWorkspaceSafety(originalWorkspaceRoot);
+    if (!safetyCheck.safe) {
+      writeErrorResponse(
+        null,
+        JSON_RPC_ERROR_CODES.INTERNAL_ERROR,
+        `Unsafe workspace: ${safetyCheck.reason || originalWorkspaceRoot}`
+      );
+      process.exit(1);
+    }
+    const isAuthed = await checkAuthenticated(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 (isSessionWorktreeEnabled(options.worktree)) {
+      const sessionWorktree = prepareSessionWorktree({
+        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 = path.resolve(dir);
+        if (!await fs.pathExists(resolvedDir)) {
+          throw new Error(`Additional directory does not exist: ${dir}`);
+        }
+        const stats = await fs.stat(resolvedDir);
+        if (!stats.isDirectory()) {
+          throw new Error(`Additional path is not a directory: ${dir}`);
+        }
+        const addDirSafetyCheck = checkWorkspaceSafety(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 = ProviderFactory.create(config);
+    if (options.model) {
+      provider.setModel(options.model);
+    }
+    const files = new FileActionManager(workspaceRoot, additionalDirs);
+    agent = new AutohandAgent(provider, files, runtime);
+    await agent.initializeForRPC();
+    const conversation = ConversationManager.getInstance();
+    try {
+      const { CHROME_AUTOMATION_SYSTEM_PROMPT } = await import("./chromeSkill-53TH55PM.js");
+      conversation.addSystemNote(CHROME_AUTOMATION_SYSTEM_PROMPT);
+    } catch {
+    }
+    adapter = new RPCAdapter();
+    adapter.initialize(
+      agent,
+      conversation,
+      options.model ?? config.openrouter?.model ?? "unknown",
+      workspaceRoot,
+      config,
+      config.mcp?.servers
+    );
+    agent.setConfirmationCallback(async (message, context) => {
+      if (!adapter) {
+        throw new Error("RPC adapter not initialized");
+      }
+      const tool = context?.tool ?? "action";
+      const description = message;
+      const permContext = {};
+      if (context?.command) permContext.command = context.command;
+      if (context?.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);
+      }
+    }
+    adapter?.shutdown("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}`);
+    adapter?.shutdown("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 (!promptParams?.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(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, messagesParams?.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 (!handoffAttachParams?.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 (!permParams?.requestId || permParams?.decision === void 0 && permParams?.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 (!ackParams?.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 (!dirParams?.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 (!dirAckParams?.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 (!decisionParams?.batchId || !decisionParams?.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 (!installParams?.skillName || !installParams?.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 (!startParams?.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, cancelParams?.reason);
+        break;
+      }
+      case RPC_METHODS.AUTOMODE_GET_LOG: {
+        const logParams = params;
+        result = adapter.handleAutomodeGetLog(id, logParams?.limit);
+        break;
+      }
+      case RPC_METHODS.PLAN_MODE_SET: {
+        const planParams = params;
+        if (planParams?.enabled === void 0) {
+          if (shouldRespond) {
+            return createErrorResponse(
+              id,
+              JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+              "Missing required parameter: enabled"
+            );
+          }
+          return null;
+        }
+        const planModeManager = getPlanModeManager();
+        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 (!yoloParams?.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 (!setToolsParams?.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 (!invokeParams?.requestId || invokeParams?.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 import("./browserToolBridge-F5N66PE7.js");
+          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 (!generateParams?.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 (!setPermParams?.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 (!applyFlagsParams?.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.GOAL_GET: {
+        result = await adapter.handleGoalGet();
+        break;
+      }
+      case RPC_METHODS.GOAL_CREATE: {
+        const goalParams = params;
+        if (!goalParams?.objective) {
+          if (shouldRespond) {
+            return createErrorResponse(id, JSON_RPC_ERROR_CODES.INVALID_PARAMS, "Missing required parameter: objective");
+          }
+          return null;
+        }
+        result = await adapter.handleGoalCreate(goalParams);
+        break;
+      }
+      case RPC_METHODS.GOAL_UPDATE: {
+        result = await adapter.handleGoalUpdate(params ?? {});
+        break;
+      }
+      case RPC_METHODS.GOAL_CLEAR: {
+        result = await adapter.handleGoalClear();
+        break;
+      }
+      case RPC_METHODS.GOAL_QUEUE: {
+        const queueParams = params;
+        if (!queueParams?.objective) {
+          result = await adapter.handleGoalGet();
+        } else {
+          result = await adapter.handleGoalQueue(queueParams);
+        }
+        break;
+      }
+      case RPC_METHODS.GOAL_START_QUEUED: {
+        result = await adapter.handleGoalStartQueued();
+        break;
+      }
+      case RPC_METHODS.GOAL_LIST_TEMPLATES: {
+        result = await adapter.handleGoalListTemplates();
+        break;
+      }
+      case RPC_METHODS.SET_CONTEXT_COMPACT: {
+        const compactParams = params;
+        if (compactParams?.enabled === void 0) {
+          if (shouldRespond) {
+            return {
+              jsonrpc: "2.0",
+              error: { code: -32602, message: "Missing enabled parameter" },
+              id: 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 (!toggleParams?.serverName || toggleParams?.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 (!reconnectParams?.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 (!setServersParams?.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;
+  }
+}
+export {
+  JSON_RPC_ERROR_CODES,
+  LineReader,
+  MAX_IMAGE_SIZE,
+  RPCAdapter,
+  RPC_METHODS,
+  RPC_NOTIFICATIONS,
+  VALID_IMAGE_MIME_TYPES,
+  createErrorResponse,
+  createNotification,
+  createRequest,
+  createResponse,
+  createTimestamp,
+  generateId,
+  isJsonRpcBatch,
+  isJsonRpcRequest,
+  isJsonRpcResponse,
+  isNotification,
+  isValidImageMimeType,
+  parseRequest,
+  restoreConsole,
+  runRpcMode,
+  serialize,
+  serializeBatch,
+  writeBatchResponse,
+  writeErrorResponse,
+  writeInternalError,
+  writeInvalidRequestError,
+  writeMethodNotFoundError,
+  writeNotification,
+  writeParseError,
+  writeResponse
+};