@leo000001/claude-code-mcp 1.6.0 → 2.0.0

package/dist/index.js

@@ -11,16 +11,16 @@ import { z } from "zod";
 var DEFAULT_SESSION_TTL_MS = 30 * 60 * 1e3;
 var DEFAULT_RUNNING_SESSION_MAX_MS = 4 * 60 * 60 * 1e3;
 var DEFAULT_CLEANUP_INTERVAL_MS = 6e4;
-var SessionManager = class {
+var DEFAULT_EVENT_BUFFER_MAX_SIZE = 1e3;
+var DEFAULT_EVENT_BUFFER_HARD_MAX_SIZE = 2e3;
+var SessionManager = class _SessionManager {
   sessions = /* @__PURE__ */ new Map();
+  runtime = /* @__PURE__ */ new Map();
   cleanupTimer;
-  sessionTtlMs;
-  runningSessionMaxMs;
-  constructor(opts) {
-    this.sessionTtlMs = opts?.sessionTtlMs !== void 0 ? opts.sessionTtlMs : DEFAULT_SESSION_TTL_MS;
-    this.runningSessionMaxMs = opts?.runningSessionMaxMs !== void 0 ? opts.runningSessionMaxMs : DEFAULT_RUNNING_SESSION_MAX_MS;
-    const cleanupIntervalMs = opts?.cleanupIntervalMs !== void 0 ? opts.cleanupIntervalMs : DEFAULT_CLEANUP_INTERVAL_MS;
-    this.cleanupTimer = setInterval(() => this.cleanup(), cleanupIntervalMs);
+  sessionTtlMs = DEFAULT_SESSION_TTL_MS;
+  runningSessionMaxMs = DEFAULT_RUNNING_SESSION_MAX_MS;
+  constructor() {
+    this.cleanupTimer = setInterval(() => this.cleanup(), DEFAULT_CLEANUP_INTERVAL_MS);
     if (this.cleanupTimer.unref) {
       this.cleanupTimer.unref();
     }
@@ -40,7 +40,7 @@ var SessionManager = class {
       totalCostUsd: 0,
       cwd: params.cwd,
       model: params.model,
-      permissionMode: params.permissionMode ?? "dontAsk",
+      permissionMode: params.permissionMode ?? "default",
       allowedTools: params.allowedTools,
       disallowedTools: params.disallowedTools,
       tools: params.tools,
@@ -69,11 +69,23 @@ var SessionManager = class {
       abortController: params.abortController
     };
     this.sessions.set(params.sessionId, info);
+    this.runtime.set(params.sessionId, {
+      buffer: {
+        events: [],
+        maxSize: DEFAULT_EVENT_BUFFER_MAX_SIZE,
+        hardMaxSize: DEFAULT_EVENT_BUFFER_HARD_MAX_SIZE,
+        nextId: 0
+      },
+      pendingPermissions: /* @__PURE__ */ new Map()
+    });
     return info;
   }
   get(sessionId) {
     return this.sessions.get(sessionId);
   }
+  updateStatus(sessionId, status) {
+    return this.update(sessionId, { status });
+  }
   list() {
     return Array.from(this.sessions.values());
   }
@@ -95,35 +107,199 @@ var SessionManager = class {
     info.status = "running";
     info.abortController = abortController;
     info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.clearTerminalEvents(sessionId);
     return info;
   }
-  cancel(sessionId) {
+  cancel(sessionId, opts) {
     const info = this.sessions.get(sessionId);
     if (!info) return false;
-    if (info.status !== "running") return false;
+    if (info.status !== "running" && info.status !== "waiting_permission") return false;
+    if (info.status === "waiting_permission") {
+      this.finishAllPending(
+        sessionId,
+        { behavior: "deny", message: "Session cancelled", interrupt: true },
+        "cancel"
+      );
+    }
     if (info.abortController) {
       info.abortController.abort();
     }
     info.status = "cancelled";
+    info.cancelledAt = (/* @__PURE__ */ new Date()).toISOString();
+    info.cancelledReason = opts?.reason ?? "Session cancelled";
+    info.cancelledSource = opts?.source ?? "cancel";
     info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
     return true;
   }
   delete(sessionId) {
+    this.finishAllPending(
+      sessionId,
+      { behavior: "deny", message: "Session deleted", interrupt: true },
+      "cleanup"
+    );
+    this.runtime.delete(sessionId);
     return this.sessions.delete(sessionId);
   }
+  setResult(sessionId, result) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return;
+    state.storedResult = result;
+  }
+  getResult(sessionId) {
+    return this.runtime.get(sessionId)?.storedResult;
+  }
+  setInitTools(sessionId, tools) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return;
+    state.initTools = tools;
+  }
+  getInitTools(sessionId) {
+    return this.runtime.get(sessionId)?.initTools;
+  }
+  pushEvent(sessionId, event) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return void 0;
+    const full = _SessionManager.pushEvent(
+      state.buffer,
+      event,
+      (requestId) => state.pendingPermissions.has(requestId)
+    );
+    const info = this.sessions.get(sessionId);
+    if (info) {
+      info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+      const data = event.data;
+      const toolUseId = typeof data?.tool_use_id === "string" && data.tool_use_id || typeof data?.toolUseID === "string" && data.toolUseID || typeof data?.parent_tool_use_id === "string" && data.parent_tool_use_id || void 0;
+      if (toolUseId) info.lastToolUseId = toolUseId;
+    }
+    return full;
+  }
+  getLastEventId(sessionId) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return void 0;
+    return state.buffer.nextId > 0 ? state.buffer.nextId - 1 : void 0;
+  }
+  readEvents(sessionId, cursor) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return { events: [], nextCursor: cursor ?? 0 };
+    return _SessionManager.readEvents(state.buffer, cursor);
+  }
+  clearTerminalEvents(sessionId) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return;
+    _SessionManager.clearTerminalEvents(state.buffer);
+  }
+  setPendingPermission(sessionId, req, finish, timeoutMs) {
+    const state = this.runtime.get(sessionId);
+    const info = this.sessions.get(sessionId);
+    if (!state || !info) return false;
+    if (!state.pendingPermissions.has(req.requestId)) {
+      const timeoutId = setTimeout(() => {
+        this.finishRequest(
+          sessionId,
+          req.requestId,
+          {
+            behavior: "deny",
+            message: `Permission request timed out after ${timeoutMs}ms.`,
+            interrupt: false
+          },
+          "timeout"
+        );
+      }, timeoutMs);
+      state.pendingPermissions.set(req.requestId, { record: req, finish, timeoutId });
+      info.status = "waiting_permission";
+      info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.pushEvent(sessionId, {
+        type: "permission_request",
+        data: req,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return true;
+    }
+    return false;
+  }
+  getPendingPermissionCount(sessionId) {
+    return this.runtime.get(sessionId)?.pendingPermissions.size ?? 0;
+  }
+  listPendingPermissions(sessionId) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return [];
+    return Array.from(state.pendingPermissions.values()).map((p) => p.record).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+  }
+  finishRequest(sessionId, requestId, result, source) {
+    const state = this.runtime.get(sessionId);
+    const info = this.sessions.get(sessionId);
+    if (!state || !info) return false;
+    const pending = state.pendingPermissions.get(requestId);
+    if (!pending) return false;
+    let finalResult = result;
+    if (finalResult.behavior === "allow") {
+      const disallowed = info.disallowedTools;
+      if (Array.isArray(disallowed) && disallowed.includes(pending.record.toolName) && pending.record.toolName.trim() !== "") {
+        finalResult = {
+          behavior: "deny",
+          message: `Tool '${pending.record.toolName}' is disallowed by session policy.`,
+          interrupt: false
+        };
+      }
+    }
+    if (pending.timeoutId) clearTimeout(pending.timeoutId);
+    state.pendingPermissions.delete(requestId);
+    this.pushEvent(sessionId, {
+      type: "permission_result",
+      data: { requestId, behavior: finalResult.behavior, source },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      pending.finish(finalResult);
+    } catch {
+    }
+    if (info.status === "waiting_permission" && state.pendingPermissions.size === 0) {
+      info.status = "running";
+      info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+    return true;
+  }
+  finishAllPending(sessionId, result, source) {
+    const state = this.runtime.get(sessionId);
+    if (!state) return;
+    for (const requestId of Array.from(state.pendingPermissions.keys())) {
+      this.finishRequest(sessionId, requestId, result, source);
+    }
+  }
   /** Remove sessions that have been idle for too long, or stuck running too long */
   cleanup() {
     const now = Date.now();
     for (const [id, info] of this.sessions) {
       const lastActive = new Date(info.lastActiveAt).getTime();
       if (Number.isNaN(lastActive)) {
+        this.finishAllPending(
+          id,
+          { behavior: "deny", message: "Session expired", interrupt: true },
+          "cleanup"
+        );
         this.sessions.delete(id);
+        this.runtime.delete(id);
       } else if (info.status === "running" && now - lastActive > this.runningSessionMaxMs) {
         if (info.abortController) info.abortController.abort();
         info.status = "error";
         info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
-      } else if (info.status !== "running" && now - lastActive > this.sessionTtlMs) {
+      } else if (info.status === "waiting_permission" && now - lastActive > this.runningSessionMaxMs) {
+        this.finishAllPending(
+          id,
+          { behavior: "deny", message: "Session timed out", interrupt: true },
+          "cleanup"
+        );
+        if (info.abortController) info.abortController.abort();
+        info.status = "error";
+        info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+      } else if (info.status !== "running" && info.status !== "waiting_permission" && now - lastActive > this.sessionTtlMs) {
+        this.finishAllPending(
+          id,
+          { behavior: "deny", message: "Session expired", interrupt: true },
+          "cleanup"
+        );
         this.sessions.delete(id);
+        this.runtime.delete(id);
       }
     }
   }
@@ -167,36 +343,97 @@ var SessionManager = class {
   destroy() {
     clearInterval(this.cleanupTimer);
     for (const info of this.sessions.values()) {
-      if (info.status === "running" && info.abortController) {
+      this.finishAllPending(
+        info.sessionId,
+        { behavior: "deny", message: "Server shutting down", interrupt: true },
+        "destroy"
+      );
+      if ((info.status === "running" || info.status === "waiting_permission") && info.abortController) {
         info.abortController.abort();
       }
       info.status = "cancelled";
+      info.cancelledAt = info.cancelledAt ?? (/* @__PURE__ */ new Date()).toISOString();
+      info.cancelledReason = info.cancelledReason ?? "Server shutting down";
+      info.cancelledSource = info.cancelledSource ?? "destroy";
+      info.lastActiveAt = (/* @__PURE__ */ new Date()).toISOString();
+    }
+  }
+  static pushEvent(buffer, event, isActivePermissionRequest) {
+    const pinned = event.pinned ?? (event.type === "permission_request" || event.type === "permission_result" || event.type === "result" || event.type === "error");
+    const full = {
+      id: buffer.nextId++,
+      type: event.type,
+      data: event.data,
+      timestamp: event.timestamp,
+      pinned
+    };
+    buffer.events.push(full);
+    while (buffer.events.length > buffer.maxSize) {
+      const idx = buffer.events.findIndex((e) => !e.pinned);
+      if (idx !== -1) {
+        buffer.events.splice(idx, 1);
+        continue;
+      }
+      const pinnedDropIdx = buffer.events.findIndex((e) => {
+        if (e.type === "permission_result") return true;
+        if (e.type === "permission_request") {
+          const requestId = e.data?.requestId;
+          if (typeof requestId !== "string") return true;
+          return isActivePermissionRequest ? !isActivePermissionRequest(requestId) : true;
+        }
+        return false;
+      });
+      if (pinnedDropIdx === -1) break;
+      buffer.events.splice(pinnedDropIdx, 1);
+    }
+    while (buffer.events.length > buffer.hardMaxSize) {
+      const idx = buffer.events.findIndex((e) => {
+        if (e.type === "permission_request") {
+          const requestId = e.data?.requestId;
+          if (typeof requestId !== "string") return true;
+          return isActivePermissionRequest ? !isActivePermissionRequest(requestId) : true;
+        }
+        if (e.type === "permission_result") return true;
+        return false;
+      });
+      if (idx === -1) break;
+      buffer.events.splice(idx, 1);
     }
+    return full;
+  }
+  static readEvents(buffer, cursor) {
+    let cursorResetTo;
+    if (cursor != null) {
+      const earliest = buffer.events[0]?.id;
+      if (earliest != null && earliest > cursor) cursorResetTo = earliest;
+      if (earliest == null && buffer.nextId > cursor) cursorResetTo = buffer.nextId;
+    }
+    const startFrom = cursorResetTo ?? cursor ?? 0;
+    const filtered = buffer.events.filter((e) => e.id >= startFrom);
+    const nextCursor = filtered.length > 0 ? filtered[filtered.length - 1].id + 1 : startFrom;
+    return { events: filtered, nextCursor, cursorResetTo };
+  }
+  static clearTerminalEvents(buffer) {
+    buffer.events = buffer.events.filter((e) => e.type !== "result" && e.type !== "error");
   }
 };
 
-// src/tools/claude-code.ts
-import { query, AbortError } from "@anthropic-ai/claude-agent-sdk";
-
 // src/types.ts
-var PERMISSION_MODES = [
-  "default",
-  "acceptEdits",
-  "bypassPermissions",
-  "plan",
-  "delegate",
-  "dontAsk"
-];
 var EFFORT_LEVELS = ["low", "medium", "high", "max"];
 var AGENT_MODELS = ["sonnet", "opus", "haiku", "inherit"];
-var CONFIGURE_ACTIONS = ["enable_bypass", "disable_bypass", "get_config"];
 var SESSION_ACTIONS = ["list", "get", "cancel"];
 var DEFAULT_SETTING_SOURCES = ["user", "project", "local"];
+var CHECK_ACTIONS = ["poll", "respond_permission"];
+var CHECK_RESPONSE_MODES = ["minimal", "full"];
+
+// src/tools/query-consumer.ts
+import { AbortError, query } from "@anthropic-ai/claude-agent-sdk";
 
 // src/utils/windows.ts
 import { existsSync } from "fs";
 import { execSync } from "child_process";
-import { join, dirname, normalize } from "path";
+import path from "path";
+var { join, dirname, normalize } = path.win32;
 function isWindows() {
   return process.platform === "win32";
 }
@@ -268,847 +505,1227 @@ function enhanceWindowsError(errorMessage) {
   return errorMessage;
 }
 
-// src/tools/claude-code.ts
-async function executeClaudeCode(input, sessionManager, serverCwd, allowBypass = false) {
-  const cwd = input.cwd !== void 0 ? input.cwd : serverCwd;
-  if (typeof cwd !== "string" || cwd.trim() === "") {
+// src/tools/query-consumer.ts
+var MAX_TRANSIENT_RETRIES = 3;
+var INITIAL_RETRY_DELAY_MS = 1e3;
+function classifyError(err, abortSignal) {
+  if (abortSignal.aborted) return "abort";
+  if (err instanceof AbortError || err instanceof Error && err.name === "AbortError") {
+    return "abort";
+  }
+  if (err instanceof Error && (err.message.includes("ECONNRESET") || err.message.includes("ETIMEDOUT") || err.message.includes("ECONNREFUSED") || err.message.includes("ENOTFOUND") || err.message.includes("EAI_AGAIN") || err.message.includes("EPIPE") || err.message.includes("stream ended unexpectedly") || err.message.includes("socket hang up"))) {
+    return "transient";
+  }
+  return "fatal";
+}
+function isSystemInitMessage(msg) {
+  return msg.type === "system" && msg.subtype === "init";
+}
+function summarizePermission(toolName, input) {
+  const keys = Object.keys(input ?? {}).slice(0, 5);
+  const suffix = keys.length > 0 ? ` (keys: ${keys.join(", ")})` : "";
+  return `${toolName} permission request${suffix}`;
+}
+function describeTool(toolName, toolCache) {
+  const tools = toolCache?.getTools();
+  const found = tools?.find((t) => t.name === toolName);
+  return found?.description;
+}
+function sdkResultToAgentResult(result) {
+  const base = {
+    sessionId: result.session_id,
+    durationMs: result.duration_ms,
+    durationApiMs: result.duration_api_ms,
+    numTurns: result.num_turns,
+    totalCostUsd: result.total_cost_usd,
+    stopReason: result.stop_reason,
+    usage: result.usage,
+    modelUsage: result.modelUsage,
+    permissionDenials: result.permission_denials
+  };
+  if (result.subtype === "success") {
     return {
-      sessionId: "",
-      result: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: cwd must be a non-empty string.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      ...base,
+      result: result.result,
+      structuredOutput: result.structured_output,
+      isError: false
     };
   }
-  let sessionId = "";
-  let resultText = "";
-  let isError = false;
-  let durationMs = 0;
-  let durationApiMs;
-  let numTurns = 0;
-  let totalCostUsd = 0;
-  let sessionTotalTurns;
-  let sessionTotalCostUsd;
-  let structuredOutput;
-  let stopReason;
-  let errorSubtype;
-  let usage;
-  let modelUsage;
-  let permissionDenials;
-  let seenResult = false;
-  let timedOut = false;
-  if (input.permissionMode === "bypassPermissions" && !allowBypass) {
+  const errors = Array.isArray(result.errors) && result.errors.length > 0 ? result.errors.map(String).join("\n") : `Error [${result.subtype}]: Unknown error`;
+  return {
+    ...base,
+    result: errors,
+    isError: true,
+    errorSubtype: result.subtype
+  };
+}
+function errorToAgentResult(sessionId, err) {
+  const message = err instanceof Error ? enhanceWindowsError(err.message) : enhanceWindowsError(String(err));
+  return {
+    sessionId,
+    result: `Error [${"INTERNAL" /* INTERNAL */}]: ${message}`,
+    isError: true,
+    durationMs: 0,
+    numTurns: 0,
+    totalCostUsd: 0
+  };
+}
+function messageToEvent(msg) {
+  if (msg.type === "assistant") {
     return {
-      sessionId: "",
-      result: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: bypassPermissions is disabled on this server. Use the claude_code_configure tool with action 'enable_bypass' to enable it.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      type: "output",
+      data: {
+        type: "assistant",
+        message: msg.message,
+        parent_tool_use_id: msg.parent_tool_use_id,
+        error: msg.error
+      }
     };
   }
-  const abortController = new AbortController();
-  let timeoutId;
-  try {
-    if (input.timeout !== void 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        abortController.abort();
-      }, input.timeout);
+  if (msg.type === "tool_use_summary") {
+    return { type: "progress", data: { type: "tool_use_summary", summary: msg.summary } };
+  }
+  if (msg.type === "tool_progress") {
+    return {
+      type: "progress",
+      data: {
+        type: "tool_progress",
+        tool_use_id: msg.tool_use_id,
+        tool_name: msg.tool_name,
+        elapsed_time_seconds: msg.elapsed_time_seconds
+      }
+    };
+  }
+  if (msg.type === "auth_status") {
+    return {
+      type: "progress",
+      data: {
+        type: "auth_status",
+        isAuthenticating: msg.isAuthenticating,
+        output: msg.output,
+        error: msg.error
+      }
+    };
+  }
+  if (msg.type === "system" && msg.subtype === "status") {
+    return {
+      type: "progress",
+      data: { type: "status", status: msg.status, permissionMode: msg.permissionMode }
+    };
+  }
+  if (msg.type === "system" && msg.subtype === "task_notification") {
+    return {
+      type: "progress",
+      data: {
+        type: "task_notification",
+        task_id: msg.task_id,
+        status: msg.status,
+        summary: msg.summary,
+        output_file: msg.output_file
+      }
+    };
+  }
+  return null;
+}
+function consumeQuery(params) {
+  let resolveSessionId;
+  let rejectSessionId;
+  const sdkSessionIdPromise = new Promise((resolve, reject) => {
+    resolveSessionId = resolve;
+    rejectSessionId = reject;
+  });
+  const waitForInitSessionId = params.mode !== "start" ? params.waitForInitSessionId ?? false : false;
+  const shouldWaitForInit = params.mode === "start" || waitForInitSessionId;
+  let sessionIdResolved = false;
+  let activeSessionId = "";
+  if (params.mode !== "start" && !waitForInitSessionId) {
+    sessionIdResolved = true;
+    activeSessionId = params.sessionId;
+    resolveSessionId(activeSessionId);
+  }
+  const getSessionId = async () => {
+    if (activeSessionId) return activeSessionId;
+    activeSessionId = await sdkSessionIdPromise;
+    return activeSessionId;
+  };
+  let initTimeoutId;
+  const canUseTool = async (toolName, input, options2) => {
+    const sessionId = await getSessionId();
+    const sessionInfo = params.sessionManager.get(sessionId);
+    if (sessionInfo) {
+      if (Array.isArray(sessionInfo.disallowedTools) && sessionInfo.disallowedTools.includes(toolName)) {
+        return { behavior: "deny", message: `Tool '${toolName}' is disallowed by session policy.` };
+      }
+      if (!options2.blockedPath && Array.isArray(sessionInfo.allowedTools) && sessionInfo.allowedTools.includes(toolName)) {
+        return { behavior: "allow" };
+      }
     }
-    const effectivePermissionMode = input.permissionMode ?? "dontAsk";
-    const options = {
-      cwd,
-      abortController,
-      permissionMode: effectivePermissionMode
+    const requestId = `${options2.toolUseID}:${toolName}:${Date.now()}:${Math.random().toString(16).slice(2)}`;
+    const record = {
+      requestId,
+      toolName,
+      input,
+      summary: summarizePermission(toolName, input),
+      description: describeTool(toolName, params.toolCache),
+      decisionReason: options2.decisionReason,
+      blockedPath: options2.blockedPath,
+      toolUseID: options2.toolUseID,
+      agentID: options2.agentID,
+      suggestions: options2.suggestions,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
     };
-    if (input.allowedTools !== void 0) options.allowedTools = input.allowedTools;
-    if (input.disallowedTools !== void 0) options.disallowedTools = input.disallowedTools;
-    if (input.maxTurns !== void 0) options.maxTurns = input.maxTurns;
-    if (input.model !== void 0) options.model = input.model;
-    if (input.maxBudgetUsd !== void 0) options.maxBudgetUsd = input.maxBudgetUsd;
-    if (input.agents !== void 0) options.agents = input.agents;
-    if (input.effort !== void 0) options.effort = input.effort;
-    if (input.betas !== void 0) options.betas = input.betas;
-    if (input.additionalDirectories !== void 0)
-      options.additionalDirectories = input.additionalDirectories;
-    if (input.outputFormat !== void 0) options.outputFormat = input.outputFormat;
-    if (input.thinking !== void 0) options.thinking = input.thinking;
-    if (input.tools !== void 0) options.tools = input.tools;
-    if (input.persistSession !== void 0) options.persistSession = input.persistSession;
-    if (input.pathToClaudeCodeExecutable !== void 0)
-      options.pathToClaudeCodeExecutable = input.pathToClaudeCodeExecutable;
-    if (input.agent !== void 0) options.agent = input.agent;
-    if (input.mcpServers !== void 0)
-      options.mcpServers = input.mcpServers;
-    if (input.sandbox !== void 0) options.sandbox = input.sandbox;
-    if (input.fallbackModel !== void 0) options.fallbackModel = input.fallbackModel;
-    if (input.enableFileCheckpointing !== void 0)
-      options.enableFileCheckpointing = input.enableFileCheckpointing;
-    if (input.includePartialMessages !== void 0)
-      options.includePartialMessages = input.includePartialMessages;
-    if (input.strictMcpConfig !== void 0) options.strictMcpConfig = input.strictMcpConfig;
-    if (input.settingSources !== void 0) options.settingSources = input.settingSources;
-    else options.settingSources = DEFAULT_SETTING_SOURCES;
-    if (input.debug !== void 0) options.debug = input.debug;
-    if (input.debugFile !== void 0) options.debugFile = input.debugFile;
-    if (input.env !== void 0) options.env = { ...process.env, ...input.env };
-    if (effectivePermissionMode === "bypassPermissions") {
-      options.allowDangerouslySkipPermissions = true;
+    return await new Promise((resolve) => {
+      let finished = false;
+      const abortListener = () => {
+        params.sessionManager.finishRequest(
+          sessionId,
+          requestId,
+          { behavior: "deny", message: "Session cancelled", interrupt: true },
+          "signal"
+        );
+      };
+      const finish = (result) => {
+        if (finished) return;
+        finished = true;
+        options2.signal.removeEventListener("abort", abortListener);
+        resolve(result);
+      };
+      const registered = params.sessionManager.setPendingPermission(
+        sessionId,
+        record,
+        finish,
+        params.permissionRequestTimeoutMs
+      );
+      if (!registered) {
+        finish({ behavior: "deny", message: "Session no longer exists.", interrupt: true });
+        return;
+      }
+      options2.signal.addEventListener("abort", abortListener, { once: true });
+      if (options2.signal.aborted) {
+        abortListener();
+      }
+    });
+  };
+  const options = {
+    ...params.options,
+    abortController: params.abortController,
+    permissionMode: "default",
+    canUseTool
+  };
+  const startQuery = (opts) => query({
+    prompt: params.prompt,
+    options: opts
+  });
+  if (params.mode === "resume" || params.mode === "disk-resume") {
+    options.resume = params.sessionId;
+  }
+  let activeQuery = startQuery(options);
+  const close = () => {
+    try {
+      activeQuery.close?.();
+    } finally {
+      params.abortController.abort();
+    }
+  };
+  const interrupt = () => {
+    activeQuery.interrupt?.();
+  };
+  const done = (async () => {
+    const preInit = [];
+    if (shouldWaitForInit) {
+      initTimeoutId = setTimeout(() => {
+        close();
+        rejectSessionId(
+          new Error(
+            `Error [${"TIMEOUT" /* TIMEOUT */}]: session init timed out after ${params.sessionInitTimeoutMs}ms.`
+          )
+        );
+      }, params.sessionInitTimeoutMs);
+    }
+    let retryCount = 0;
+    let currentStream = activeQuery;
+    while (true) {
+      try {
+        for await (const message of currentStream) {
+          if (isSystemInitMessage(message)) {
+            params.toolCache?.updateFromInit(message.tools);
+            params.onInit?.(message);
+            params.sessionManager.setInitTools(message.session_id, message.tools);
+            activeSessionId = message.session_id;
+            if (!sessionIdResolved && shouldWaitForInit) {
+              sessionIdResolved = true;
+              resolveSessionId(activeSessionId);
+              if (initTimeoutId) clearTimeout(initTimeoutId);
+              for (const buffered of preInit) {
+                const event2 = messageToEvent(buffered);
+                if (!event2) continue;
+                params.sessionManager.pushEvent(activeSessionId, {
+                  type: event2.type,
+                  data: event2.data,
+                  timestamp: (/* @__PURE__ */ new Date()).toISOString()
+                });
+              }
+              preInit.length = 0;
+            }
+            continue;
+          }
+          if (shouldWaitForInit && !sessionIdResolved) {
+            preInit.push(message);
+            continue;
+          }
+          if (message.type === "result") {
+            const sessionId2 = message.session_id ?? await getSessionId();
+            const agentResult = sdkResultToAgentResult(message);
+            const stored = {
+              type: agentResult.isError ? "error" : "result",
+              result: agentResult,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            params.sessionManager.setResult(sessionId2, stored);
+            params.sessionManager.clearTerminalEvents(sessionId2);
+            params.sessionManager.pushEvent(sessionId2, {
+              type: agentResult.isError ? "error" : "result",
+              data: agentResult,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            const current = params.sessionManager.get(sessionId2);
+            if (current && current.status !== "cancelled") {
+              params.sessionManager.update(sessionId2, {
+                status: agentResult.isError ? "error" : "idle",
+                totalTurns: agentResult.numTurns,
+                totalCostUsd: agentResult.totalCostUsd,
+                abortController: void 0
+              });
+            } else if (current) {
+              params.sessionManager.update(sessionId2, {
+                totalTurns: agentResult.numTurns,
+                totalCostUsd: agentResult.totalCostUsd,
+                abortController: void 0
+              });
+            }
+            return;
+          }
+          const sessionId = message.session_id ?? await getSessionId();
+          const event = messageToEvent(message);
+          if (event) {
+            params.sessionManager.pushEvent(sessionId, {
+              type: event.type,
+              data: event.data,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+          }
+        }
+        if (shouldWaitForInit && !sessionIdResolved) {
+          rejectSessionId(
+            new Error(
+              `Error [${"INTERNAL" /* INTERNAL */}]: query stream ended before receiving session init.`
+            )
+          );
+        } else if (activeSessionId) {
+          const sessionId = activeSessionId;
+          const current = params.sessionManager.get(sessionId);
+          if (current && current.status !== "cancelled") {
+            params.sessionManager.finishAllPending(
+              sessionId,
+              {
+                behavior: "deny",
+                message: "Session ended before permission was resolved.",
+                interrupt: true
+              },
+              "cleanup"
+            );
+            const agentResult = errorToAgentResult(
+              sessionId,
+              "No result message received from agent."
+            );
+            const stored = {
+              type: "error",
+              result: agentResult,
+              createdAt: (/* @__PURE__ */ new Date()).toISOString()
+            };
+            params.sessionManager.setResult(sessionId, stored);
+            params.sessionManager.clearTerminalEvents(sessionId);
+            params.sessionManager.pushEvent(sessionId, {
+              type: "error",
+              data: agentResult,
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            });
+            params.sessionManager.update(sessionId, {
+              status: "error",
+              abortController: void 0
+            });
+          }
+        }
+        return;
+      } catch (err) {
+        const errClass = classifyError(err, params.abortController.signal);
+        if (shouldWaitForInit && !sessionIdResolved) {
+          rejectSessionId(
+            new Error(
+              errClass === "abort" ? `Error [${"CANCELLED" /* CANCELLED */}]: session was cancelled before init.` : `Error [${"INTERNAL" /* INTERNAL */}]: ${enhanceWindowsError(err instanceof Error ? err.message : String(err))}`
+            )
+          );
+          return;
+        }
+        if (!activeSessionId) return;
+        const sessionId = activeSessionId;
+        if (errClass === "transient" && retryCount < MAX_TRANSIENT_RETRIES) {
+          retryCount++;
+          const delay = INITIAL_RETRY_DELAY_MS * Math.pow(2, retryCount - 1);
+          params.sessionManager.pushEvent(sessionId, {
+            type: "progress",
+            data: {
+              type: "retry",
+              attempt: retryCount,
+              maxRetries: MAX_TRANSIENT_RETRIES,
+              delayMs: delay,
+              error: err instanceof Error ? err.message : String(err)
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          await new Promise((r) => {
+            const timer = setTimeout(r, delay);
+            const onAbort = () => {
+              clearTimeout(timer);
+              r();
+            };
+            params.abortController.signal.addEventListener("abort", onAbort, { once: true });
+          });
+          if (params.abortController.signal.aborted) return;
+          params.sessionManager.finishAllPending(
+            sessionId,
+            { behavior: "deny", message: "Retrying after transient error.", interrupt: false },
+            "cleanup"
+          );
+          const retryOpts = {
+            ...options,
+            resume: sessionId
+          };
+          currentStream = startQuery(retryOpts);
+          activeQuery = currentStream;
+          continue;
+        }
+        const current = params.sessionManager.get(sessionId);
+        if (current && current.status !== "cancelled") {
+          params.sessionManager.finishAllPending(
+            sessionId,
+            {
+              behavior: "deny",
+              message: "Session failed before permission was resolved.",
+              interrupt: true
+            },
+            "cleanup"
+          );
+          const agentResult = errClass === "abort" ? {
+            sessionId,
+            result: `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`,
+            isError: true,
+            durationMs: 0,
+            numTurns: 0,
+            totalCostUsd: 0
+          } : errorToAgentResult(sessionId, err);
+          params.sessionManager.setResult(sessionId, {
+            type: "error",
+            result: agentResult,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          params.sessionManager.clearTerminalEvents(sessionId);
+          params.sessionManager.pushEvent(sessionId, {
+            type: "error",
+            data: agentResult,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          params.sessionManager.update(sessionId, { status: "error", abortController: void 0 });
+        }
+        return;
+      } finally {
+        if (initTimeoutId) clearTimeout(initTimeoutId);
+      }
+    }
+  })();
+  return { sdkSessionIdPromise, done, close, interrupt };
+}
+
+// src/utils/resume-token.ts
+import { createHmac } from "crypto";
+function getResumeSecret() {
+  const secret = process.env.CLAUDE_CODE_MCP_RESUME_SECRET;
+  if (typeof secret !== "string") return void 0;
+  const trimmed = secret.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function computeResumeToken(sessionId, secret) {
+  return createHmac("sha256", secret).update(sessionId).digest("base64url");
+}
+
+// src/utils/race-with-abort.ts
+function raceWithAbort(promise, signal, onAbort) {
+  if (!signal) return promise;
+  if (signal.aborted) {
+    try {
+      onAbort();
+    } catch {
     }
-    if (input.systemPrompt !== void 0) options.systemPrompt = input.systemPrompt;
-    for await (const message of query({
+    return Promise.reject(new Error(`Error [${"CANCELLED" /* CANCELLED */}]: request was cancelled.`));
+  }
+  return new Promise((resolve, reject) => {
+    const abortListener = () => {
+      try {
+        onAbort();
+      } catch {
+      }
+      reject(new Error(`Error [${"CANCELLED" /* CANCELLED */}]: request was cancelled.`));
+    };
+    signal.addEventListener("abort", abortListener, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", abortListener));
+  });
+}
+
+// src/utils/build-options.ts
+function buildOptions(src) {
+  const opts = { cwd: src.cwd };
+  if (src.allowedTools !== void 0) opts.allowedTools = src.allowedTools;
+  if (src.disallowedTools !== void 0) opts.disallowedTools = src.disallowedTools;
+  if (src.tools !== void 0) opts.tools = src.tools;
+  if (src.maxTurns !== void 0) opts.maxTurns = src.maxTurns;
+  if (src.model !== void 0) opts.model = src.model;
+  if (src.systemPrompt !== void 0) opts.systemPrompt = src.systemPrompt;
+  if (src.agents !== void 0) opts.agents = src.agents;
+  if (src.maxBudgetUsd !== void 0) opts.maxBudgetUsd = src.maxBudgetUsd;
+  if (src.effort !== void 0) opts.effort = src.effort;
+  if (src.betas !== void 0) opts.betas = src.betas;
+  if (src.additionalDirectories !== void 0)
+    opts.additionalDirectories = src.additionalDirectories;
+  if (src.outputFormat !== void 0) opts.outputFormat = src.outputFormat;
+  if (src.thinking !== void 0) opts.thinking = src.thinking;
+  if (src.persistSession !== void 0) opts.persistSession = src.persistSession;
+  if (src.resumeSessionAt !== void 0) opts.resumeSessionAt = src.resumeSessionAt;
+  if (src.pathToClaudeCodeExecutable !== void 0)
+    opts.pathToClaudeCodeExecutable = src.pathToClaudeCodeExecutable;
+  if (src.agent !== void 0) opts.agent = src.agent;
+  if (src.mcpServers !== void 0) opts.mcpServers = src.mcpServers;
+  if (src.sandbox !== void 0) opts.sandbox = src.sandbox;
+  if (src.fallbackModel !== void 0) opts.fallbackModel = src.fallbackModel;
+  if (src.enableFileCheckpointing !== void 0)
+    opts.enableFileCheckpointing = src.enableFileCheckpointing;
+  if (src.includePartialMessages !== void 0)
+    opts.includePartialMessages = src.includePartialMessages;
+  if (src.strictMcpConfig !== void 0) opts.strictMcpConfig = src.strictMcpConfig;
+  if (src.settingSources !== void 0) opts.settingSources = src.settingSources;
+  else opts.settingSources = DEFAULT_SETTING_SOURCES;
+  if (src.debug !== void 0) opts.debug = src.debug;
+  if (src.debugFile !== void 0) opts.debugFile = src.debugFile;
+  if (src.env !== void 0) opts.env = { ...process.env, ...src.env };
+  return opts;
+}
+
+// src/tools/claude-code.ts
+async function executeClaudeCode(input, sessionManager, serverCwd, toolCache, requestSignal) {
+  const cwd = input.cwd !== void 0 ? input.cwd : serverCwd;
+  if (typeof cwd !== "string" || cwd.trim() === "") {
+    return {
+      sessionId: "",
+      status: "error",
+      error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: cwd must be a non-empty string.`
+    };
+  }
+  const abortController = new AbortController();
+  const adv = input.advanced ?? {};
+  const permissionRequestTimeoutMs = input.permissionRequestTimeoutMs ?? 6e4;
+  const sessionInitTimeoutMs = adv.sessionInitTimeoutMs ?? 1e4;
+  const flat = {
+    cwd,
+    allowedTools: input.allowedTools,
+    disallowedTools: input.disallowedTools,
+    maxTurns: input.maxTurns,
+    model: input.model,
+    systemPrompt: input.systemPrompt,
+    ...adv
+  };
+  try {
+    const handle = consumeQuery({
+      mode: "start",
       prompt: input.prompt,
-      options
-    })) {
-      if (message.type === "system" && message.subtype === "init") {
-        if (sessionId) continue;
-        sessionId = message.session_id;
+      abortController,
+      options: buildOptions(flat),
+      permissionRequestTimeoutMs,
+      sessionInitTimeoutMs,
+      sessionManager,
+      toolCache,
+      onInit: (init) => {
+        if (sessionManager.get(init.session_id)) return;
         sessionManager.create({
-          sessionId,
+          sessionId: init.session_id,
           cwd,
           model: input.model,
-          permissionMode: effectivePermissionMode,
+          permissionMode: "default",
           allowedTools: input.allowedTools,
           disallowedTools: input.disallowedTools,
-          tools: input.tools,
+          tools: adv.tools,
           maxTurns: input.maxTurns,
           systemPrompt: input.systemPrompt,
-          agents: input.agents,
-          maxBudgetUsd: input.maxBudgetUsd,
-          effort: input.effort,
-          betas: input.betas,
-          additionalDirectories: input.additionalDirectories,
-          outputFormat: input.outputFormat,
-          thinking: input.thinking,
-          persistSession: input.persistSession,
-          pathToClaudeCodeExecutable: input.pathToClaudeCodeExecutable,
-          agent: input.agent,
-          mcpServers: input.mcpServers,
-          sandbox: input.sandbox,
-          fallbackModel: input.fallbackModel,
-          enableFileCheckpointing: input.enableFileCheckpointing,
-          includePartialMessages: input.includePartialMessages,
-          strictMcpConfig: input.strictMcpConfig,
-          settingSources: input.settingSources ?? DEFAULT_SETTING_SOURCES,
-          debug: input.debug,
-          debugFile: input.debugFile,
-          env: input.env,
+          agents: adv.agents,
+          maxBudgetUsd: adv.maxBudgetUsd,
+          effort: adv.effort,
+          betas: adv.betas,
+          additionalDirectories: adv.additionalDirectories,
+          outputFormat: adv.outputFormat,
+          thinking: adv.thinking,
+          persistSession: adv.persistSession,
+          pathToClaudeCodeExecutable: adv.pathToClaudeCodeExecutable,
+          agent: adv.agent,
+          mcpServers: adv.mcpServers,
+          sandbox: adv.sandbox,
+          fallbackModel: adv.fallbackModel,
+          enableFileCheckpointing: adv.enableFileCheckpointing,
+          includePartialMessages: adv.includePartialMessages,
+          strictMcpConfig: adv.strictMcpConfig,
+          settingSources: adv.settingSources ?? DEFAULT_SETTING_SOURCES,
+          debug: adv.debug,
+          debugFile: adv.debugFile,
+          env: adv.env,
           abortController
         });
       }
-      if (message.type === "result") {
-        if (seenResult) continue;
-        seenResult = true;
-        const result = message;
-        durationMs = result.duration_ms;
-        durationApiMs = result.duration_api_ms;
-        numTurns = result.num_turns;
-        totalCostUsd = result.total_cost_usd;
-        isError = result.is_error;
-        stopReason = result.stop_reason;
-        usage = result.usage;
-        modelUsage = result.modelUsage;
-        permissionDenials = result.permission_denials;
-        if (result.subtype === "success") {
-          resultText = result.result;
-          structuredOutput = result.structured_output;
-        } else {
-          isError = true;
-          errorSubtype = result.subtype;
-          resultText = result.errors.map(String).join("\n") || `Error [${result.subtype}]: Unknown error`;
-        }
-        break;
-      }
-    }
+    });
+    const sessionId = await raceWithAbort(
+      handle.sdkSessionIdPromise,
+      requestSignal,
+      () => abortController.abort()
+    );
+    const resumeSecret = getResumeSecret();
+    return {
+      sessionId,
+      status: "running",
+      pollInterval: 3e3,
+      resumeToken: resumeSecret ? computeResumeToken(sessionId, resumeSecret) : void 0
+    };
   } catch (err) {
-    isError = true;
-    const isAborted = abortController.signal.aborted || err instanceof AbortError || err instanceof Error && err.name === "AbortError";
-    if (isAborted) {
-      resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-    } else {
-      resultText = enhanceWindowsError(err instanceof Error ? err.message : String(err));
-    }
-    if (sessionId) {
-      const current = sessionManager.get(sessionId);
-      if (current) {
-        if (timedOut && current.status !== "cancelled" && current.status !== "error") {
-          sessionManager.update(sessionId, { status: "error" });
-        } else if (isAborted && current.status === "running") {
-          sessionManager.update(sessionId, { status: "cancelled" });
-        } else if (!isAborted && current.status !== "cancelled") {
-          sessionManager.update(sessionId, { status: "error" });
-        }
-      }
-    }
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
-  }
-  if (!seenResult && !isError && abortController.signal.aborted) {
-    isError = true;
-    resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-  }
-  if (sessionId && !seenResult && !isError) {
-    isError = true;
-    errorSubtype = errorSubtype ?? "missing_result";
-    const noResultMsg = `Error [${"INTERNAL" /* INTERNAL */}]: No result message received from agent.`;
-    resultText = resultText ? `${noResultMsg} Original: ${resultText}` : noResultMsg;
-  }
-  if (sessionId) {
-    const current = sessionManager.get(sessionId);
-    if (current && current.status !== "cancelled") {
-      sessionManager.update(sessionId, {
-        status: isError ? "error" : "idle",
-        totalTurns: numTurns,
-        totalCostUsd,
-        abortController: void 0
-      });
-      const updated = sessionManager.get(sessionId);
-      sessionTotalTurns = updated?.totalTurns;
-      sessionTotalCostUsd = updated?.totalCostUsd;
-    } else if (current) {
-      sessionManager.update(sessionId, {
-        totalTurns: numTurns,
-        totalCostUsd,
-        abortController: void 0
-      });
-      const updated = sessionManager.get(sessionId);
-      sessionTotalTurns = updated?.totalTurns;
-      sessionTotalCostUsd = updated?.totalCostUsd;
-    }
-  } else {
-    isError = true;
-    const noInitMsg = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms (no session ID received).` : `Error [${"INTERNAL" /* INTERNAL */}]: No session ID received from agent.`;
-    resultText = resultText ? `${noInitMsg} Original: ${resultText}` : noInitMsg;
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      sessionId: "",
+      status: "error",
+      error: message.includes("Error [") ? message : `Error [${"INTERNAL" /* INTERNAL */}]: ${message}`
+    };
   }
-  return {
-    sessionId,
-    result: resultText,
-    isError,
-    durationMs,
-    durationApiMs,
-    numTurns,
-    totalCostUsd,
-    sessionTotalTurns,
-    sessionTotalCostUsd,
-    structuredOutput,
-    stopReason,
-    errorSubtype,
-    usage,
-    modelUsage,
-    permissionDenials
-  };
 }
 
 // src/tools/claude-code-reply.ts
-import { query as query2, AbortError as AbortError2 } from "@anthropic-ai/claude-agent-sdk";
-async function executeClaudeCodeReply(input, sessionManager, allowBypass = false) {
-  const session = sessionManager.get(input.sessionId);
-  if (!session) {
+function toStartError(sessionId, err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const errorText = message.includes("Error [") ? message : `Error [${"INTERNAL" /* INTERNAL */}]: ${message}`;
+  return {
+    agentResult: {
+      sessionId,
+      result: errorText,
+      isError: true,
+      durationMs: 0,
+      numTurns: 0,
+      totalCostUsd: 0
+    },
+    errorText
+  };
+}
+function buildOptionsFromDiskResume(dr) {
+  if (dr.cwd === void 0 || typeof dr.cwd !== "string" || dr.cwd.trim() === "") {
+    throw new Error(`Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: cwd must be provided for disk resume.`);
+  }
+  return buildOptions(dr);
+}
+async function executeClaudeCodeReply(input, sessionManager, toolCache, requestSignal) {
+  const permissionRequestTimeoutMs = input.permissionRequestTimeoutMs ?? 6e4;
+  const sessionInitTimeoutMs = input.sessionInitTimeoutMs ?? 1e4;
+  const existing = sessionManager.get(input.sessionId);
+  if (!existing) {
     const allowDiskResume = process.env.CLAUDE_CODE_MCP_ALLOW_DISK_RESUME === "1";
     if (!allowDiskResume) {
       return {
         sessionId: input.sessionId,
-        result: `Error [${"SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */}]: Session '${input.sessionId}' not found or expired.`,
-        isError: true,
-        durationMs: 0,
-        numTurns: 0,
-        totalCostUsd: 0
+        status: "error",
+        error: `Error [${"SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */}]: Session '${input.sessionId}' not found or expired.`
+      };
+    }
+    const resumeSecret = getResumeSecret();
+    if (!resumeSecret) {
+      return {
+        sessionId: input.sessionId,
+        status: "error",
+        error: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: Disk resume is enabled but CLAUDE_CODE_MCP_RESUME_SECRET is not set.`
+      };
+    }
+    const dr = input.diskResumeConfig ?? {};
+    if (typeof dr.resumeToken !== "string" || dr.resumeToken.trim() === "") {
+      return {
+        sessionId: input.sessionId,
+        status: "error",
+        error: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: resumeToken is required for disk resume fallback.`
+      };
+    }
+    const expectedToken = computeResumeToken(input.sessionId, resumeSecret);
+    if (dr.resumeToken !== expectedToken) {
+      return {
+        sessionId: input.sessionId,
+        status: "error",
+        error: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: Invalid resumeToken for session '${input.sessionId}'.`
+      };
+    }
+    try {
+      const abortController2 = new AbortController();
+      const options2 = buildOptionsFromDiskResume(dr);
+      sessionManager.create({
+        sessionId: input.sessionId,
+        cwd: options2.cwd ?? dr.cwd ?? "",
+        model: dr.model,
+        permissionMode: "default",
+        allowedTools: dr.allowedTools,
+        disallowedTools: dr.disallowedTools,
+        tools: dr.tools,
+        maxTurns: dr.maxTurns,
+        systemPrompt: dr.systemPrompt,
+        agents: dr.agents,
+        maxBudgetUsd: dr.maxBudgetUsd,
+        effort: dr.effort,
+        betas: dr.betas,
+        additionalDirectories: dr.additionalDirectories,
+        outputFormat: dr.outputFormat,
+        thinking: dr.thinking,
+        persistSession: dr.persistSession,
+        pathToClaudeCodeExecutable: dr.pathToClaudeCodeExecutable,
+        agent: dr.agent,
+        mcpServers: dr.mcpServers,
+        sandbox: dr.sandbox,
+        fallbackModel: dr.fallbackModel,
+        enableFileCheckpointing: dr.enableFileCheckpointing,
+        includePartialMessages: dr.includePartialMessages,
+        strictMcpConfig: dr.strictMcpConfig,
+        settingSources: dr.settingSources ?? DEFAULT_SETTING_SOURCES,
+        debug: dr.debug,
+        debugFile: dr.debugFile,
+        env: dr.env,
+        abortController: abortController2
+      });
+      try {
+        consumeQuery({
+          mode: "disk-resume",
+          sessionId: input.sessionId,
+          prompt: input.prompt,
+          abortController: abortController2,
+          options: options2,
+          permissionRequestTimeoutMs,
+          sessionInitTimeoutMs,
+          sessionManager,
+          toolCache
+        });
+      } catch (err) {
+        const { agentResult, errorText } = toStartError(input.sessionId, err);
+        sessionManager.setResult(input.sessionId, {
+          type: "error",
+          result: agentResult,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        sessionManager.pushEvent(input.sessionId, {
+          type: "error",
+          data: agentResult,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        sessionManager.update(input.sessionId, { status: "error", abortController: void 0 });
+        return { sessionId: input.sessionId, status: "error", error: errorText };
+      }
+      return {
+        sessionId: input.sessionId,
+        status: "running",
+        pollInterval: 3e3,
+        resumeToken: computeResumeToken(input.sessionId, resumeSecret)
+      };
+    } catch (err) {
+      const { agentResult, errorText } = toStartError(input.sessionId, err);
+      if (sessionManager.get(input.sessionId)) {
+        sessionManager.setResult(input.sessionId, {
+          type: "error",
+          result: agentResult,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        sessionManager.pushEvent(input.sessionId, {
+          type: "error",
+          data: agentResult,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        });
+        sessionManager.update(input.sessionId, { status: "error", abortController: void 0 });
+      }
+      return {
+        sessionId: input.sessionId,
+        status: "error",
+        error: errorText
       };
     }
-    return executeClaudeCodeReplyDiskResume(input, sessionManager, allowBypass);
-  }
-  if (session.status === "running") {
-    return {
-      sessionId: input.sessionId,
-      result: `Error [${"SESSION_BUSY" /* SESSION_BUSY */}]: Session is currently running. Wait for it to complete or cancel it.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
-    };
   }
-  if (session.status === "cancelled") {
+  if (existing.status === "running" || existing.status === "waiting_permission") {
     return {
       sessionId: input.sessionId,
-      result: `Error [${"CANCELLED" /* CANCELLED */}]: Session '${input.sessionId}' has been cancelled and cannot be resumed.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      status: "error",
+      error: `Error [${"SESSION_BUSY" /* SESSION_BUSY */}]: Session is not available (status: ${existing.status}).`
     };
   }
-  if (session.permissionMode === "bypassPermissions" && !allowBypass) {
+  if (existing.status === "cancelled") {
     return {
       sessionId: input.sessionId,
-      result: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: Cannot resume a bypassPermissions session while bypass is disabled. Use the claude_code_configure tool with action 'enable_bypass' first.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      status: "error",
+      error: `Error [${"CANCELLED" /* CANCELLED */}]: Session '${input.sessionId}' has been cancelled and cannot be resumed.`
     };
   }
-  const originalStatus = session.status;
+  const originalStatus = existing.status;
   const abortController = new AbortController();
-  let timedOut = false;
   const acquired = sessionManager.tryAcquire(input.sessionId, originalStatus, abortController);
   if (!acquired) {
     const current = sessionManager.get(input.sessionId);
-    if (!current) {
-      return {
-        sessionId: input.sessionId,
-        result: `Error [${"SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */}]: Session '${input.sessionId}' not found or expired.`,
-        isError: true,
-        durationMs: 0,
-        numTurns: 0,
-        totalCostUsd: 0
-      };
-    }
     return {
       sessionId: input.sessionId,
-      result: `Error [${"SESSION_BUSY" /* SESSION_BUSY */}]: Session is not available (status: ${current.status}).`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      status: "error",
+      error: current ? `Error [${"SESSION_BUSY" /* SESSION_BUSY */}]: Session is not available (status: ${current.status}).` : `Error [${"SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */}]: Session '${input.sessionId}' not found or expired.`
     };
   }
-  let timeoutId;
-  if (input.timeout !== void 0) {
-    timeoutId = setTimeout(() => {
-      timedOut = true;
-      abortController.abort();
-    }, input.timeout);
-  }
-  let resultText = "";
-  let isError = false;
-  let durationMs = 0;
-  let durationApiMs;
-  let numTurns = 0;
-  let totalCostUsd = 0;
-  let sessionTotalTurns;
-  let sessionTotalCostUsd;
-  let newSessionId = input.sessionId;
-  let structuredOutput;
-  let stopReason;
-  let errorSubtype;
-  let usage;
-  let modelUsage;
-  let permissionDenials;
-  let seenResult = false;
-  let forkSessionCreated = false;
+  const options = buildOptions(existing);
+  if (input.forkSession) options.forkSession = true;
   try {
-    const options = {
-      resume: input.sessionId,
-      abortController,
-      cwd: session.cwd,
-      permissionMode: session.permissionMode
-    };
-    if (session.allowedTools !== void 0) options.allowedTools = session.allowedTools;
-    if (session.disallowedTools !== void 0) options.disallowedTools = session.disallowedTools;
-    if (session.maxTurns !== void 0) options.maxTurns = session.maxTurns;
-    if (session.model !== void 0) options.model = session.model;
-    if (session.maxBudgetUsd !== void 0) options.maxBudgetUsd = session.maxBudgetUsd;
-    if (session.agents !== void 0) options.agents = session.agents;
-    if (session.effort !== void 0) options.effort = session.effort;
-    if (session.betas !== void 0) options.betas = session.betas;
-    if (session.additionalDirectories !== void 0)
-      options.additionalDirectories = session.additionalDirectories;
-    if (session.outputFormat !== void 0) options.outputFormat = session.outputFormat;
-    if (session.thinking !== void 0) options.thinking = session.thinking;
-    if (session.tools !== void 0) options.tools = session.tools;
-    if (session.systemPrompt !== void 0) options.systemPrompt = session.systemPrompt;
-    if (session.persistSession !== void 0) options.persistSession = session.persistSession;
-    if (session.pathToClaudeCodeExecutable !== void 0)
-      options.pathToClaudeCodeExecutable = session.pathToClaudeCodeExecutable;
-    if (session.agent !== void 0) options.agent = session.agent;
-    if (session.mcpServers !== void 0)
-      options.mcpServers = session.mcpServers;
-    if (session.sandbox !== void 0) options.sandbox = session.sandbox;
-    if (session.fallbackModel !== void 0) options.fallbackModel = session.fallbackModel;
-    if (session.enableFileCheckpointing !== void 0)
-      options.enableFileCheckpointing = session.enableFileCheckpointing;
-    if (session.includePartialMessages !== void 0)
-      options.includePartialMessages = session.includePartialMessages;
-    if (session.strictMcpConfig !== void 0) options.strictMcpConfig = session.strictMcpConfig;
-    if (session.settingSources !== void 0) options.settingSources = session.settingSources;
-    else options.settingSources = DEFAULT_SETTING_SOURCES;
-    if (session.debug !== void 0) options.debug = session.debug;
-    if (session.debugFile !== void 0) options.debugFile = session.debugFile;
-    if (session.env !== void 0) options.env = { ...process.env, ...session.env };
-    if (session.permissionMode === "bypassPermissions") {
-      options.allowDangerouslySkipPermissions = true;
-    }
-    if (input.forkSession) {
-      options.forkSession = true;
-    }
-    for await (const message of query2({
+    const handle = consumeQuery({
+      mode: "resume",
+      sessionId: input.sessionId,
       prompt: input.prompt,
-      options
-    })) {
-      if (input.forkSession && message.type === "system" && message.subtype === "init") {
-        newSessionId = message.session_id;
-        if (!forkSessionCreated && newSessionId !== input.sessionId) {
+      abortController,
+      options,
+      permissionRequestTimeoutMs,
+      sessionInitTimeoutMs,
+      waitForInitSessionId: !!input.forkSession,
+      sessionManager,
+      toolCache,
+      onInit: (init) => {
+        if (!input.forkSession) return;
+        if (init.session_id === input.sessionId) return;
+        if (!sessionManager.get(init.session_id)) {
           sessionManager.create({
-            sessionId: newSessionId,
-            cwd: session.cwd,
-            model: session.model,
-            permissionMode: session.permissionMode,
-            allowedTools: session.allowedTools,
-            disallowedTools: session.disallowedTools,
-            tools: session.tools,
-            maxTurns: session.maxTurns,
-            systemPrompt: session.systemPrompt,
-            agents: session.agents,
-            maxBudgetUsd: session.maxBudgetUsd,
-            effort: session.effort,
-            betas: session.betas,
-            additionalDirectories: session.additionalDirectories,
-            outputFormat: session.outputFormat,
-            thinking: session.thinking,
-            persistSession: session.persistSession,
-            pathToClaudeCodeExecutable: session.pathToClaudeCodeExecutable,
-            agent: session.agent,
-            mcpServers: session.mcpServers,
-            sandbox: session.sandbox,
-            fallbackModel: session.fallbackModel,
-            enableFileCheckpointing: session.enableFileCheckpointing,
-            includePartialMessages: session.includePartialMessages,
-            strictMcpConfig: session.strictMcpConfig,
-            settingSources: session.settingSources ?? DEFAULT_SETTING_SOURCES,
-            debug: session.debug,
-            debugFile: session.debugFile,
-            env: session.env,
+            sessionId: init.session_id,
+            cwd: existing.cwd,
+            model: existing.model,
+            permissionMode: "default",
+            allowedTools: existing.allowedTools,
+            disallowedTools: existing.disallowedTools,
+            tools: existing.tools,
+            maxTurns: existing.maxTurns,
+            systemPrompt: existing.systemPrompt,
+            agents: existing.agents,
+            maxBudgetUsd: existing.maxBudgetUsd,
+            effort: existing.effort,
+            betas: existing.betas,
+            additionalDirectories: existing.additionalDirectories,
+            outputFormat: existing.outputFormat,
+            thinking: existing.thinking,
+            persistSession: existing.persistSession,
+            pathToClaudeCodeExecutable: existing.pathToClaudeCodeExecutable,
+            agent: existing.agent,
+            mcpServers: existing.mcpServers,
+            sandbox: existing.sandbox,
+            fallbackModel: existing.fallbackModel,
+            enableFileCheckpointing: existing.enableFileCheckpointing,
+            includePartialMessages: existing.includePartialMessages,
+            strictMcpConfig: existing.strictMcpConfig,
+            settingSources: existing.settingSources ?? DEFAULT_SETTING_SOURCES,
+            debug: existing.debug,
+            debugFile: existing.debugFile,
+            env: existing.env,
             abortController
           });
-          forkSessionCreated = true;
-        }
-      }
-      if (message.type === "result") {
-        if (seenResult) continue;
-        seenResult = true;
-        const result = message;
-        durationMs = result.duration_ms;
-        durationApiMs = result.duration_api_ms;
-        numTurns = result.num_turns;
-        totalCostUsd = result.total_cost_usd;
-        isError = result.is_error;
-        stopReason = result.stop_reason;
-        usage = result.usage;
-        modelUsage = result.modelUsage;
-        permissionDenials = result.permission_denials;
-        if (result.subtype === "success") {
-          resultText = result.result;
-          structuredOutput = result.structured_output;
-        } else {
-          isError = true;
-          errorSubtype = result.subtype;
-          resultText = result.errors.map(String).join("\n") || `Error [${result.subtype}]: Unknown error`;
         }
-        break;
+        sessionManager.update(input.sessionId, {
+          status: originalStatus,
+          abortController: void 0
+        });
       }
+    });
+    const sessionId = input.forkSession ? await raceWithAbort(
+      handle.sdkSessionIdPromise,
+      requestSignal,
+      () => abortController.abort()
+    ) : input.sessionId;
+    if (input.forkSession && sessionId === input.sessionId) {
+      return {
+        sessionId: input.sessionId,
+        status: "error",
+        error: `Error [${"INTERNAL" /* INTERNAL */}]: Fork requested but no new session ID received from agent.`
+      };
     }
+    const resumeSecret = getResumeSecret();
+    return {
+      sessionId,
+      status: "running",
+      pollInterval: 3e3,
+      resumeToken: resumeSecret ? computeResumeToken(sessionId, resumeSecret) : void 0
+    };
   } catch (err) {
-    isError = true;
-    const isAborted = abortController.signal.aborted || err instanceof AbortError2 || err instanceof Error && err.name === "AbortError";
-    if (isAborted) {
-      resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-    } else {
-      resultText = enhanceWindowsError(err instanceof Error ? err.message : String(err));
-    }
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
-  }
-  if (!seenResult && !isError && abortController.signal.aborted) {
-    isError = true;
-    resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-  }
-  if (!seenResult && !isError) {
-    isError = true;
-    errorSubtype = errorSubtype ?? "missing_result";
-    const noResultMsg = `Error [${"INTERNAL" /* INTERNAL */}]: No result message received from agent.`;
-    resultText = resultText ? `${noResultMsg} Original: ${resultText}` : noResultMsg;
-  }
-  if (input.forkSession && newSessionId !== input.sessionId) {
-    const forkedCurrent = sessionManager.get(newSessionId);
-    if (forkedCurrent && forkedCurrent.status !== "cancelled") {
-      sessionManager.update(newSessionId, {
-        status: isError ? "error" : "idle",
-        totalTurns: numTurns,
-        totalCostUsd,
-        abortController: void 0
-      });
-      const updatedFork = sessionManager.get(newSessionId);
-      sessionTotalTurns = updatedFork?.totalTurns;
-      sessionTotalCostUsd = updatedFork?.totalCostUsd;
-    } else if (forkedCurrent) {
-      sessionManager.update(newSessionId, {
-        totalTurns: numTurns,
-        totalCostUsd,
-        abortController: void 0
-      });
-      const updatedFork = sessionManager.get(newSessionId);
-      sessionTotalTurns = updatedFork?.totalTurns;
-      sessionTotalCostUsd = updatedFork?.totalCostUsd;
-    }
-    const origCurrent = sessionManager.get(input.sessionId);
-    if (origCurrent && origCurrent.status !== "cancelled") {
+    const { agentResult, errorText } = toStartError(input.sessionId, err);
+    if (input.forkSession) {
       sessionManager.update(input.sessionId, {
         status: originalStatus,
         abortController: void 0
       });
-    } else if (origCurrent) {
-      sessionManager.update(input.sessionId, {
-        abortController: void 0
-      });
-    }
-  } else {
-    const current = sessionManager.get(input.sessionId);
-    if (current && current.status !== "cancelled") {
-      sessionManager.update(input.sessionId, {
-        status: isError ? "error" : "idle",
-        totalTurns: (session.totalTurns ?? 0) + numTurns,
-        totalCostUsd: (session.totalCostUsd ?? 0) + totalCostUsd,
-        abortController: void 0
+    } else {
+      sessionManager.setResult(input.sessionId, {
+        type: "error",
+        result: agentResult,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
       });
-      const updated = sessionManager.get(input.sessionId);
-      sessionTotalTurns = updated?.totalTurns;
-      sessionTotalCostUsd = updated?.totalCostUsd;
-    } else if (current) {
-      sessionManager.update(input.sessionId, {
-        totalTurns: (session.totalTurns ?? 0) + numTurns,
-        totalCostUsd: (session.totalCostUsd ?? 0) + totalCostUsd,
-        abortController: void 0
+      sessionManager.pushEvent(input.sessionId, {
+        type: "error",
+        data: agentResult,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
       });
-      const updated = sessionManager.get(input.sessionId);
-      sessionTotalTurns = updated?.totalTurns;
-      sessionTotalCostUsd = updated?.totalCostUsd;
+      sessionManager.update(input.sessionId, { status: "error", abortController: void 0 });
     }
+    return {
+      sessionId: input.sessionId,
+      status: "error",
+      error: errorText
+    };
   }
-  const targetSessionId = input.forkSession ? newSessionId : input.sessionId;
-  if (input.forkSession && newSessionId === input.sessionId && !isError) {
-    isError = true;
-    const noForkMsg = `Error [${"INTERNAL" /* INTERNAL */}]: Fork requested but no new session ID received from agent.`;
-    resultText = resultText ? `${noForkMsg} Original: ${resultText}` : noForkMsg;
+}
+
+// src/tools/tool-discovery.ts
+var TOOL_CATALOG = {
+  Bash: {
+    description: "Run shell commands (e.g. npm install, git commit, ls) in the project directory.",
+    category: "execute"
+  },
+  Read: { description: "Read the contents of a file given its path.", category: "file_read" },
+  Write: {
+    description: "Create a new file or completely replace an existing file's contents.",
+    category: "file_write"
+  },
+  Edit: {
+    description: "Make targeted changes to specific parts of an existing file without rewriting the whole file.",
+    category: "file_write"
+  },
+  Glob: {
+    description: "Find files by name pattern (e.g. '**/*.ts' finds all TypeScript files).",
+    category: "file_read"
+  },
+  Grep: {
+    description: "Search inside files for text or regex patterns (like grep/ripgrep).",
+    category: "file_read"
+  },
+  NotebookEdit: {
+    description: "Edit individual cells in Jupyter notebooks (.ipynb files).",
+    category: "file_write"
+  },
+  WebFetch: {
+    description: "Download and read the content of a web page or API endpoint.",
+    category: "network"
+  },
+  WebSearch: { description: "Search the web and return relevant results.", category: "network" },
+  Task: {
+    description: "Spawn a subagent to handle a subtask independently (requires this tool to be in allowedTools).",
+    category: "agent"
+  },
+  TaskOutput: { description: "Get the output from a background subagent task.", category: "agent" },
+  TaskStop: { description: "Cancel a running background subagent task.", category: "agent" },
+  TodoWrite: {
+    description: "Create and update a structured task/todo checklist.",
+    category: "agent"
+  },
+  AskUserQuestion: {
+    description: "Ask the user a question and wait for their answer before continuing.",
+    category: "interaction"
   }
+};
+function uniq(items) {
+  return Array.from(new Set(items));
+}
+function discoverToolsFromInit(initTools) {
+  const names = uniq(initTools.filter((t) => typeof t === "string" && t.trim() !== ""));
+  return names.map((name) => ({
+    name,
+    description: TOOL_CATALOG[name]?.description ?? name,
+    category: TOOL_CATALOG[name]?.category
+  }));
+}
+function defaultCatalogTools() {
+  return Object.keys(TOOL_CATALOG).sort((a, b) => a.localeCompare(b)).map((name) => ({ name, ...TOOL_CATALOG[name] }));
+}
+var ToolDiscoveryCache = class {
+  cached;
+  constructor(initial) {
+    this.cached = initial ?? defaultCatalogTools();
+  }
+  getTools() {
+    return this.cached;
+  }
+  updateFromInit(initTools) {
+    const discovered = discoverToolsFromInit(initTools);
+    const next = mergeToolLists(discovered, defaultCatalogTools());
+    const updated = JSON.stringify(next) !== JSON.stringify(this.cached);
+    if (updated) this.cached = next;
+    return { updated, tools: this.cached };
+  }
+};
+function mergeToolLists(primary, fallback) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const t of fallback) byName.set(t.name, t);
+  for (const t of primary) byName.set(t.name, t);
+  return Array.from(byName.values()).sort((a, b) => a.name.localeCompare(b.name));
+}
+function groupByCategory(tools) {
+  const grouped = {};
+  for (const tool of tools) {
+    const category = tool.category ?? "other";
+    grouped[category] ??= [];
+    grouped[category].push(tool);
+  }
+  for (const category of Object.keys(grouped)) {
+    grouped[category].sort((a, b) => a.name.localeCompare(b.name));
+  }
+  return grouped;
+}
+function buildInternalToolsDescription(tools) {
+  const grouped = groupByCategory(tools);
+  const categories = Object.keys(grouped).sort((a, b) => a.localeCompare(b));
+  let desc = 'Start a new Claude Code agent session.\n\nLaunches an autonomous coding agent that can read/write files, run shell commands, search code, manage git, access the web, and more. Returns immediately with a sessionId \u2014 the agent runs asynchronously in the background.\n\nWorkflow:\n1. Call claude_code with a prompt \u2192 returns { sessionId, status: "running", pollInterval }\n2. Poll with claude_code_check (action="poll") to receive progress events and the final result\n3. If the agent needs permission for a tool call, approve or deny via claude_code_check (action="respond_permission")\n\n';
+  desc += "Defaults:\n- settingSources: ['user', 'project', 'local'] (loads ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, and CLAUDE.md)\n- persistSession: true\n- sessionInitTimeoutMs: 10000\n- permissionRequestTimeoutMs: 60000\n- allowedTools/disallowedTools: [] (none)\n- resumeToken: omitted unless CLAUDE_CODE_MCP_RESUME_SECRET is set on the server\n\n";
+  desc += "Internal tools available to the agent (use allowedTools/disallowedTools to control approval policy; authoritative list returned by claude_code_check with includeTools=true):\n";
+  for (const category of categories) {
+    desc += `
+[${category}]
+`;
+    for (const tool of grouped[category]) {
+      desc += `- ${tool.name}: ${tool.description}
+`;
+    }
+  }
+  desc += '\nUse `allowedTools` to pre-approve tools (no permission prompts). Use `disallowedTools` to permanently block specific tools. Any tool not in either list will pause the session (status: "waiting_permission") until approved or denied via claude_code_check.\n';
+  return desc;
+}
+
+// src/tools/claude-code-check.ts
+function pollIntervalForStatus(status) {
+  if (status === "waiting_permission") return 1e3;
+  if (status === "running") return 3e3;
+  return void 0;
+}
+function toPermissionResult(params) {
+  if (params.decision === "allow") {
+    return {
+      behavior: "allow",
+      updatedInput: params.updatedInput,
+      updatedPermissions: params.updatedPermissions
+    };
+  }
+  return {
+    behavior: "deny",
+    message: params.denyMessage ?? "Permission denied by caller",
+    interrupt: params.interrupt
+  };
+}
+function slimAssistantData(data) {
+  if (!data || typeof data !== "object") return data;
+  const d = data;
+  if (d.type !== "assistant") return data;
+  const msg = d.message;
+  if (!msg || typeof msg !== "object") return data;
+  const m = msg;
+  const slimmed = {};
+  if (m.role !== void 0) slimmed.role = m.role;
+  if (m.stop_reason !== void 0) slimmed.stop_reason = m.stop_reason;
+  if (Array.isArray(m.content)) {
+    slimmed.content = m.content.map((block) => {
+      const { cache_control, ...rest } = block;
+      return rest;
+    });
+  }
+  return {
+    type: d.type,
+    message: slimmed,
+    ...d.parent_tool_use_id ? { parent_tool_use_id: d.parent_tool_use_id } : {},
+    ...d.error ? { error: d.error } : {}
+  };
+}
+function toEvents(events, opts) {
+  return events.map((e) => {
+    if ((e.type === "result" || e.type === "error") && isAgentResult(e.data)) {
+      const redacted = redactAgentResult(e.data, opts);
+      return { id: e.id, type: e.type, data: redacted, timestamp: e.timestamp };
+    }
+    if (opts.slim && e.type === "output") {
+      return { id: e.id, type: e.type, data: slimAssistantData(e.data), timestamp: e.timestamp };
+    }
+    return { id: e.id, type: e.type, data: e.data, timestamp: e.timestamp };
+  });
+}
+function buildResult(sessionManager, toolCache, input) {
+  const responseMode = input.responseMode ?? "minimal";
+  const po = input.pollOptions ?? {};
+  const includeTools = po.includeTools;
+  const includeEvents = po.includeEvents ?? true;
+  const includeActions = po.includeActions ?? true;
+  const includeResult = po.includeResult ?? true;
+  const includeUsage = po.includeUsage ?? responseMode === "full";
+  const includeModelUsage = po.includeModelUsage ?? responseMode === "full";
+  const includeStructuredOutput = po.includeStructuredOutput ?? responseMode === "full";
+  const includeTerminalEvents = po.includeTerminalEvents ?? responseMode === "full";
+  const includeProgressEvents = po.includeProgressEvents ?? responseMode === "full";
+  const maxEvents = input.maxEvents ?? (responseMode === "minimal" ? 200 : void 0);
+  const sessionId = input.sessionId;
+  const session = sessionManager.get(sessionId);
+  const status = session?.status ?? "error";
+  const {
+    events: rawEvents,
+    nextCursor: rawNextCursor,
+    cursorResetTo
+  } = sessionManager.readEvents(sessionId, input.cursor);
+  let truncated = false;
+  const truncatedFields = [];
+  const windowEvents = maxEvents !== void 0 && rawEvents.length > maxEvents ? rawEvents.slice(0, maxEvents) : rawEvents;
+  const nextCursor = maxEvents !== void 0 && rawEvents.length > maxEvents ? windowEvents.length > 0 ? windowEvents[windowEvents.length - 1].id + 1 : rawNextCursor : rawNextCursor;
+  if (maxEvents !== void 0 && rawEvents.length > maxEvents) {
+    truncated = true;
+    truncatedFields.push("events");
+  }
+  const outputEvents = (() => {
+    if (!includeEvents) return [];
+    let filtered = windowEvents;
+    if (!includeTerminalEvents && includeResult && (status === "idle" || status === "error")) {
+      filtered = filtered.filter((e) => e.type !== "result" && e.type !== "error");
+    }
+    if (!includeProgressEvents) {
+      filtered = filtered.filter((e) => {
+        if (e.type !== "progress") return true;
+        const d = e.data;
+        const progressType = d?.type;
+        return progressType !== "tool_progress" && progressType !== "auth_status";
+      });
+    }
+    return filtered;
+  })();
+  const pending = status === "waiting_permission" ? sessionManager.listPendingPermissions(sessionId) : [];
+  const stored = status === "idle" || status === "error" ? sessionManager.getResult(sessionId) : void 0;
+  const initTools = includeTools ? sessionManager.getInitTools(sessionId) : void 0;
+  const availableTools = includeTools && initTools ? discoverToolsFromInit(initTools) : void 0;
   return {
-    sessionId: targetSessionId,
-    result: resultText,
-    isError,
-    durationMs,
+    sessionId,
+    status,
+    pollInterval: pollIntervalForStatus(status),
+    cursorResetTo,
+    truncated: truncated ? true : void 0,
+    truncatedFields: truncatedFields.length > 0 ? truncatedFields : void 0,
+    events: toEvents(outputEvents, {
+      includeUsage,
+      includeModelUsage,
+      includeStructuredOutput,
+      slim: responseMode === "minimal"
+    }),
+    nextCursor,
+    availableTools,
+    actions: includeActions && status === "waiting_permission" ? pending.map((req) => ({
+      type: "permission",
+      requestId: req.requestId,
+      toolName: req.toolName,
+      input: req.input,
+      summary: req.summary,
+      decisionReason: req.decisionReason,
+      blockedPath: req.blockedPath,
+      toolUseID: req.toolUseID,
+      agentID: req.agentID,
+      suggestions: req.suggestions,
+      description: req.description,
+      createdAt: req.createdAt
+    })) : void 0,
+    result: includeResult && stored?.result ? redactAgentResult(stored.result, {
+      includeUsage,
+      includeModelUsage,
+      includeStructuredOutput,
+      slim: responseMode === "minimal"
+    }) : void 0,
+    cancelledAt: session?.cancelledAt,
+    cancelledReason: session?.cancelledReason,
+    cancelledSource: session?.cancelledSource,
+    lastEventId: responseMode === "full" ? sessionManager.getLastEventId(sessionId) : void 0,
+    lastToolUseId: responseMode === "full" ? session?.lastToolUseId : void 0
+  };
+}
+function isAgentResult(value) {
+  if (!value || typeof value !== "object") return false;
+  const v = value;
+  return typeof v.sessionId === "string" && typeof v.result === "string" && typeof v.isError === "boolean" && typeof v.durationMs === "number" && typeof v.numTurns === "number" && typeof v.totalCostUsd === "number";
+}
+function redactAgentResult(result, opts) {
+  const {
+    usage,
+    modelUsage,
+    structuredOutput,
     durationApiMs,
-    numTurns,
-    totalCostUsd,
     sessionTotalTurns,
     sessionTotalCostUsd,
-    structuredOutput,
-    stopReason,
-    errorSubtype,
-    usage,
-    modelUsage,
-    permissionDenials
+    ...rest
+  } = result;
+  return {
+    ...rest,
+    durationApiMs: opts.slim ? void 0 : durationApiMs,
+    sessionTotalTurns: opts.slim ? void 0 : sessionTotalTurns,
+    sessionTotalCostUsd: opts.slim ? void 0 : sessionTotalCostUsd,
+    usage: opts.includeUsage ? usage : void 0,
+    modelUsage: opts.includeModelUsage ? modelUsage : void 0,
+    structuredOutput: opts.includeStructuredOutput ? structuredOutput : void 0
   };
 }
-async function executeClaudeCodeReplyDiskResume(input, sessionManager, allowBypass) {
-  if (input.cwd !== void 0 && (typeof input.cwd !== "string" || input.cwd.trim() === "")) {
+function executeClaudeCodeCheck(input, sessionManager, toolCache) {
+  if (typeof input.sessionId !== "string" || input.sessionId.trim() === "") {
     return {
-      sessionId: input.sessionId,
-      result: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: cwd must be a non-empty string.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      sessionId: "",
+      error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: sessionId must be a non-empty string.`,
+      isError: true
     };
   }
-  const effectivePermissionMode = input.permissionMode ?? "dontAsk";
-  if (effectivePermissionMode === "bypassPermissions" && !allowBypass) {
+  const session = sessionManager.get(input.sessionId);
+  if (!session) {
     return {
       sessionId: input.sessionId,
-      result: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: bypassPermissions is disabled on this server. Use the claude_code_configure tool with action 'enable_bypass' to enable it.`,
-      isError: true,
-      durationMs: 0,
-      numTurns: 0,
-      totalCostUsd: 0
+      error: `Error [${"SESSION_NOT_FOUND" /* SESSION_NOT_FOUND */}]: Session '${input.sessionId}' not found or expired.`,
+      isError: true
     };
   }
-  const abortController = new AbortController();
-  let timedOut = false;
-  let timeoutId;
-  if (input.timeout !== void 0) {
-    timeoutId = setTimeout(() => {
-      timedOut = true;
-      abortController.abort();
-    }, input.timeout);
-  }
-  let resultText = "";
-  let isError = false;
-  let durationMs = 0;
-  let durationApiMs;
-  let numTurns = 0;
-  let totalCostUsd = 0;
-  let sessionTotalTurns;
-  let sessionTotalCostUsd;
-  let newSessionId = input.sessionId;
-  let structuredOutput;
-  let stopReason;
-  let errorSubtype;
-  let usage;
-  let modelUsage;
-  let permissionDenials;
-  let seenResult = false;
-  if (!input.forkSession) {
-    const existing = sessionManager.get(input.sessionId);
-    if (!existing) {
-      const cwd = input.cwd ?? process.cwd();
-      if (typeof cwd !== "string" || cwd.trim() === "") {
-        return {
-          sessionId: input.sessionId,
-          result: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: cwd must be a non-empty string.`,
-          isError: true,
-          durationMs: 0,
-          numTurns: 0,
-          totalCostUsd: 0
-        };
-      }
-      try {
-        sessionManager.create({
-          sessionId: input.sessionId,
-          cwd,
-          model: input.model,
-          permissionMode: effectivePermissionMode,
-          allowedTools: input.allowedTools,
-          disallowedTools: input.disallowedTools,
-          tools: input.tools,
-          maxTurns: input.maxTurns,
-          systemPrompt: input.systemPrompt,
-          agents: input.agents,
-          maxBudgetUsd: input.maxBudgetUsd,
-          effort: input.effort,
-          betas: input.betas,
-          additionalDirectories: input.additionalDirectories,
-          outputFormat: input.outputFormat,
-          thinking: input.thinking,
-          persistSession: input.persistSession,
-          pathToClaudeCodeExecutable: input.pathToClaudeCodeExecutable,
-          agent: input.agent,
-          mcpServers: input.mcpServers,
-          sandbox: input.sandbox,
-          fallbackModel: input.fallbackModel,
-          enableFileCheckpointing: input.enableFileCheckpointing,
-          includePartialMessages: input.includePartialMessages,
-          strictMcpConfig: input.strictMcpConfig,
-          settingSources: input.settingSources ?? DEFAULT_SETTING_SOURCES,
-          debug: input.debug,
-          debugFile: input.debugFile,
-          env: input.env,
-          abortController
-        });
-      } catch {
-        return executeClaudeCodeReply(input, sessionManager, allowBypass);
-      }
-    }
+  if (input.action === "poll") {
+    return buildResult(sessionManager, toolCache, input);
   }
-  try {
-    const options = {
-      resume: input.sessionId,
-      abortController,
-      permissionMode: effectivePermissionMode
+  if (typeof input.requestId !== "string" || input.requestId.trim() === "") {
+    return {
+      sessionId: input.sessionId,
+      error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: requestId is required for respond_permission.`,
+      isError: true
     };
-    if (input.cwd !== void 0) options.cwd = input.cwd;
-    if (input.allowedTools !== void 0) options.allowedTools = input.allowedTools;
-    if (input.disallowedTools !== void 0) options.disallowedTools = input.disallowedTools;
-    if (input.maxTurns !== void 0) options.maxTurns = input.maxTurns;
-    if (input.model !== void 0) options.model = input.model;
-    if (input.maxBudgetUsd !== void 0) options.maxBudgetUsd = input.maxBudgetUsd;
-    if (input.agents !== void 0) options.agents = input.agents;
-    if (input.effort !== void 0) options.effort = input.effort;
-    if (input.betas !== void 0) options.betas = input.betas;
-    if (input.additionalDirectories !== void 0)
-      options.additionalDirectories = input.additionalDirectories;
-    if (input.outputFormat !== void 0) options.outputFormat = input.outputFormat;
-    if (input.thinking !== void 0) options.thinking = input.thinking;
-    if (input.tools !== void 0) options.tools = input.tools;
-    if (input.systemPrompt !== void 0) options.systemPrompt = input.systemPrompt;
-    if (input.persistSession !== void 0) options.persistSession = input.persistSession;
-    if (input.resumeSessionAt !== void 0) options.resumeSessionAt = input.resumeSessionAt;
-    if (input.pathToClaudeCodeExecutable !== void 0)
-      options.pathToClaudeCodeExecutable = input.pathToClaudeCodeExecutable;
-    if (input.agent !== void 0) options.agent = input.agent;
-    if (input.mcpServers !== void 0)
-      options.mcpServers = input.mcpServers;
-    if (input.sandbox !== void 0) options.sandbox = input.sandbox;
-    if (input.fallbackModel !== void 0) options.fallbackModel = input.fallbackModel;
-    if (input.enableFileCheckpointing !== void 0)
-      options.enableFileCheckpointing = input.enableFileCheckpointing;
-    if (input.includePartialMessages !== void 0)
-      options.includePartialMessages = input.includePartialMessages;
-    if (input.strictMcpConfig !== void 0) options.strictMcpConfig = input.strictMcpConfig;
-    if (input.settingSources !== void 0) options.settingSources = input.settingSources;
-    else options.settingSources = DEFAULT_SETTING_SOURCES;
-    if (input.debug !== void 0) options.debug = input.debug;
-    if (input.debugFile !== void 0) options.debugFile = input.debugFile;
-    if (input.env !== void 0) options.env = { ...process.env, ...input.env };
-    if (effectivePermissionMode === "bypassPermissions") {
-      options.allowDangerouslySkipPermissions = true;
-    }
-    if (input.forkSession) {
-      options.forkSession = true;
-    }
-    for await (const message of query2({
-      prompt: input.prompt,
-      options
-    })) {
-      if (message.type === "system" && message.subtype === "init") {
-        if (message.permissionMode === "bypassPermissions" && !allowBypass) {
-          isError = true;
-          resultText = `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: Cannot resume a bypassPermissions session while bypass is disabled. Use the claude_code_configure tool with action 'enable_bypass' first.`;
-          abortController.abort();
-          break;
-        }
-        if (input.forkSession) {
-          newSessionId = message.session_id;
-          if (newSessionId !== input.sessionId && !sessionManager.get(newSessionId)) {
-            try {
-              sessionManager.create({
-                sessionId: newSessionId,
-                cwd: message.cwd,
-                model: message.model,
-                permissionMode: effectivePermissionMode,
-                allowedTools: input.allowedTools,
-                disallowedTools: input.disallowedTools,
-                tools: input.tools ?? message.tools,
-                maxTurns: input.maxTurns,
-                systemPrompt: input.systemPrompt,
-                agents: input.agents,
-                maxBudgetUsd: input.maxBudgetUsd,
-                effort: input.effort,
-                betas: input.betas ?? message.betas,
-                additionalDirectories: input.additionalDirectories,
-                outputFormat: input.outputFormat,
-                thinking: input.thinking,
-                persistSession: input.persistSession,
-                pathToClaudeCodeExecutable: input.pathToClaudeCodeExecutable,
-                agent: input.agent,
-                mcpServers: input.mcpServers,
-                sandbox: input.sandbox,
-                fallbackModel: input.fallbackModel,
-                enableFileCheckpointing: input.enableFileCheckpointing,
-                includePartialMessages: input.includePartialMessages,
-                strictMcpConfig: input.strictMcpConfig,
-                settingSources: input.settingSources ?? DEFAULT_SETTING_SOURCES,
-                debug: input.debug,
-                debugFile: input.debugFile,
-                env: input.env,
-                abortController
-              });
-            } catch {
-              isError = true;
-              resultText = `Error [${"SESSION_BUSY" /* SESSION_BUSY */}]: Session is not available (status: running).`;
-              abortController.abort();
-              break;
-            }
-          }
-        } else {
-          sessionManager.update(input.sessionId, {
-            cwd: message.cwd,
-            model: message.model,
-            permissionMode: effectivePermissionMode,
-            betas: input.betas ?? message.betas,
-            tools: input.tools ?? message.tools
-          });
-        }
-      }
-      if (message.type === "result") {
-        if (seenResult) continue;
-        seenResult = true;
-        const result = message;
-        durationMs = result.duration_ms;
-        durationApiMs = result.duration_api_ms;
-        numTurns = result.num_turns;
-        totalCostUsd = result.total_cost_usd;
-        isError = result.is_error;
-        stopReason = result.stop_reason;
-        usage = result.usage;
-        modelUsage = result.modelUsage;
-        permissionDenials = result.permission_denials;
-        if (result.subtype === "success") {
-          resultText = result.result;
-          structuredOutput = result.structured_output;
-        } else {
-          isError = true;
-          errorSubtype = result.subtype;
-          resultText = result.errors.map(String).join("\n") || `Error [${result.subtype}]: Unknown error`;
-        }
-        break;
-      }
-    }
-  } catch (err) {
-    isError = true;
-    const isAborted = abortController.signal.aborted || err instanceof AbortError2 || err instanceof Error && err.name === "AbortError";
-    if (isAborted) {
-      resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-    } else {
-      resultText = enhanceWindowsError(err instanceof Error ? err.message : String(err));
-    }
-  } finally {
-    if (timeoutId) clearTimeout(timeoutId);
-  }
-  if (!seenResult && !isError && abortController.signal.aborted) {
-    isError = true;
-    resultText = timedOut ? `Error [${"TIMEOUT" /* TIMEOUT */}]: Session timed out after ${input.timeout}ms.` : `Error [${"CANCELLED" /* CANCELLED */}]: Session was cancelled.`;
-  }
-  if (!seenResult && !isError) {
-    isError = true;
-    errorSubtype = errorSubtype ?? "missing_result";
-    const noResultMsg = `Error [${"INTERNAL" /* INTERNAL */}]: No result message received from agent.`;
-    resultText = resultText ? `${noResultMsg} Original: ${resultText}` : noResultMsg;
-  }
-  const targetSessionId = input.forkSession ? newSessionId : input.sessionId;
-  const tracked = sessionManager.get(targetSessionId);
-  if (tracked) {
-    const nextTurns = input.forkSession ? numTurns : (tracked.totalTurns ?? 0) + numTurns;
-    const nextCost = input.forkSession ? totalCostUsd : (tracked.totalCostUsd ?? 0) + totalCostUsd;
-    if (tracked.status !== "cancelled") {
-      sessionManager.update(targetSessionId, {
-        status: isError ? "error" : "idle",
-        totalTurns: nextTurns,
-        totalCostUsd: nextCost,
-        abortController: void 0
-      });
-    } else {
-      sessionManager.update(targetSessionId, {
-        totalTurns: nextTurns,
-        totalCostUsd: nextCost,
-        abortController: void 0
-      });
-    }
-    const updated = sessionManager.get(targetSessionId);
-    sessionTotalTurns = updated?.totalTurns;
-    sessionTotalCostUsd = updated?.totalCostUsd;
   }
-  if (input.forkSession && newSessionId === input.sessionId && !isError) {
-    isError = true;
-    const noForkMsg = `Error [${"INTERNAL" /* INTERNAL */}]: Fork requested but no new session ID received from agent.`;
-    resultText = resultText ? `${noForkMsg} Original: ${resultText}` : noForkMsg;
+  if (input.decision !== "allow" && input.decision !== "deny") {
+    return {
+      sessionId: input.sessionId,
+      error: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: decision must be 'allow' or 'deny'.`,
+      isError: true
+    };
   }
-  return {
-    sessionId: targetSessionId,
-    result: resultText,
-    isError,
-    durationMs,
-    durationApiMs,
-    numTurns,
-    totalCostUsd,
-    sessionTotalTurns,
-    sessionTotalCostUsd,
-    structuredOutput,
-    stopReason,
-    errorSubtype,
-    usage,
-    modelUsage,
-    permissionDenials
-  };
+  const ok = sessionManager.finishRequest(
+    input.sessionId,
+    input.requestId,
+    toPermissionResult({
+      decision: input.decision,
+      updatedInput: input.permissionOptions?.updatedInput,
+      updatedPermissions: input.permissionOptions?.updatedPermissions,
+      denyMessage: input.denyMessage,
+      interrupt: input.interrupt
+    }),
+    "respond"
+  );
+  if (!ok) {
+    return {
+      sessionId: input.sessionId,
+      error: `Error [${"PERMISSION_REQUEST_NOT_FOUND" /* PERMISSION_REQUEST_NOT_FOUND */}]: requestId '${input.requestId}' not found (already finished or expired).`,
+      isError: true
+    };
+  }
+  return buildResult(sessionManager, toolCache, input);
 }
 
 // src/tools/claude-code-session.ts
@@ -1145,7 +1762,10 @@ function executeClaudeCodeSession(input, sessionManager) {
           isError: true
         };
       }
-      const cancelled = sessionManager.cancel(input.sessionId);
+      const cancelled = sessionManager.cancel(input.sessionId, {
+        reason: "Cancelled by caller",
+        source: "claude_code_session"
+      });
       if (!cancelled) {
         const session = sessionManager.get(input.sessionId);
         if (!session) {
@@ -1176,164 +1796,117 @@ function executeClaudeCodeSession(input, sessionManager) {
   }
 }
 
-// src/tools/claude-code-configure.ts
-function executeClaudeCodeConfigure(input, config) {
-  switch (input.action) {
-    case "enable_bypass":
-      config.setAllowBypass(true);
-      return {
-        allowBypass: true,
-        message: "bypassPermissions mode is now enabled for this server session. Use with caution."
-      };
-    case "disable_bypass":
-      config.setAllowBypass(false);
-      return {
-        allowBypass: false,
-        message: "bypassPermissions mode is now disabled."
-      };
-    case "get_config":
-      return {
-        allowBypass: config.getAllowBypass(),
-        message: `Current config: bypassPermissions ${config.getAllowBypass() ? "enabled" : "disabled"}.`
-      };
-    default:
-      return {
-        allowBypass: config.getAllowBypass(),
-        message: `Error [${"INVALID_ARGUMENT" /* INVALID_ARGUMENT */}]: Unknown action '${input.action}'. Use 'enable_bypass', 'disable_bypass', or 'get_config'.`,
-        isError: true
-      };
-  }
-}
-
 // src/server.ts
-var SERVER_VERSION = true ? "1.6.0" : "0.0.0-dev";
-function createServer(serverCwd, opts) {
-  const parsePositiveInt = (value) => {
-    if (value === void 0 || value.trim() === "") return void 0;
-    const parsed = Number.parseInt(value, 10);
-    if (!Number.isFinite(parsed) || parsed <= 0) return void 0;
-    return parsed;
-  };
-  const sessionManager = new SessionManager({
-    sessionTtlMs: parsePositiveInt(process.env.CLAUDE_CODE_MCP_SESSION_TTL_MS),
-    runningSessionMaxMs: parsePositiveInt(process.env.CLAUDE_CODE_MCP_RUNNING_SESSION_MAX_MS),
-    cleanupIntervalMs: parsePositiveInt(process.env.CLAUDE_CODE_MCP_CLEANUP_INTERVAL_MS)
-  });
-  let allowBypass = opts?.allowBypass ?? false;
-  const config = {
-    getAllowBypass: () => allowBypass,
-    setAllowBypass: (v) => {
-      allowBypass = v;
-    }
-  };
+var SERVER_VERSION = true ? "2.0.0" : "0.0.0-dev";
+function createServer(serverCwd) {
+  const sessionManager = new SessionManager();
+  const toolCache = new ToolDiscoveryCache();
   const server = new McpServer({
     name: "claude-code-mcp",
     version: SERVER_VERSION
   });
+  const agentDefinitionSchema = z.object({
+    description: z.string(),
+    prompt: z.string(),
+    tools: z.array(z.string()).optional(),
+    disallowedTools: z.array(z.string()).optional(),
+    model: z.enum(AGENT_MODELS).optional(),
+    maxTurns: z.number().int().positive().optional(),
+    mcpServers: z.array(z.union([z.string(), z.record(z.string(), z.unknown())])).optional(),
+    skills: z.array(z.string()).optional(),
+    criticalSystemReminder_EXPERIMENTAL: z.string().optional()
+  });
+  const systemPromptSchema = z.union([
+    z.string(),
+    z.object({
+      type: z.literal("preset"),
+      preset: z.literal("claude_code"),
+      append: z.string().optional().describe("Additional instructions to append to the preset")
+    })
+  ]);
+  const toolsConfigSchema = z.union([
+    z.array(z.string()),
+    z.object({
+      type: z.literal("preset"),
+      preset: z.literal("claude_code")
+    })
+  ]);
+  const thinkingSchema = z.union([
+    z.object({ type: z.literal("adaptive") }),
+    z.object({
+      type: z.literal("enabled"),
+      budgetTokens: z.number().int().positive().describe("Token budget for thinking")
+    }),
+    z.object({ type: z.literal("disabled") })
+  ]);
+  const outputFormatSchema = z.object({
+    type: z.literal("json_schema"),
+    schema: z.record(z.string(), z.unknown()).describe("JSON Schema for structured output")
+  });
+  const advancedOptionsSchema = z.object({
+    tools: toolsConfigSchema.optional().describe(
+      "Define the base tool set visible to the agent. Default: omitted (SDK/Claude Code default). Pass an array of tool names, or {type: 'preset', preset: 'claude_code'} for the default set."
+    ),
+    persistSession: z.boolean().optional().describe("Persist session history to disk (~/.claude/projects). Default: true."),
+    sessionInitTimeoutMs: z.number().int().positive().optional().describe("How long to wait (in ms) for the agent process to initialize. Default: 10000."),
+    agents: z.record(z.string(), agentDefinitionSchema).optional().describe(
+      "Define custom sub-agents the main agent can delegate tasks to. Each key is the agent name."
+    ),
+    agent: z.string().optional().describe("Name of a custom agent (defined in 'agents') to use as the primary agent."),
+    maxBudgetUsd: z.number().positive().optional().describe("Maximum budget in USD for this session."),
+    effort: z.enum(EFFORT_LEVELS).optional().describe("Effort level: 'low' | 'medium' | 'high' | 'max'."),
+    betas: z.array(z.string()).optional().describe("Beta features to enable."),
+    additionalDirectories: z.array(z.string()).optional().describe("Additional directories the agent can access beyond cwd."),
+    outputFormat: outputFormatSchema.optional().describe("Structured output format with JSON Schema."),
+    thinking: thinkingSchema.optional().describe("Thinking mode: 'adaptive' | 'enabled' (with budget) | 'disabled'."),
+    pathToClaudeCodeExecutable: z.string().optional().describe("Path to the Claude Code executable. Default: SDK-bundled."),
+    mcpServers: z.record(z.string(), z.record(z.string(), z.unknown())).optional().describe("MCP server configurations (key: server name, value: server config)."),
+    sandbox: z.record(z.string(), z.unknown()).optional().describe("Sandbox configuration for isolating shell command execution."),
+    fallbackModel: z.string().optional().describe("Fallback model if the primary model fails or is unavailable."),
+    enableFileCheckpointing: z.boolean().optional().describe("Enable file checkpointing to track file changes. Default: false."),
+    includePartialMessages: z.boolean().optional().describe("Include intermediate messages as events in claude_code_check. Default: false."),
+    strictMcpConfig: z.boolean().optional().describe("Enforce strict validation of MCP server configurations. Default: false."),
+    settingSources: z.array(z.enum(["user", "project", "local"])).optional().describe(
+      "Which local config files to load. Default: ['user', 'project', 'local']. Pass [] to disable all."
+    ),
+    debug: z.boolean().optional().describe("Enable debug mode. Default: false."),
+    debugFile: z.string().optional().describe("Write debug logs to a file path (implicitly enables debug mode)."),
+    env: z.record(z.string(), z.string().optional()).optional().describe("Environment variables to merge with process.env.")
+  }).optional().describe(
+    "Low-frequency SDK options. All fields are optional with sensible defaults. Most callers can omit this entirely."
+  );
   server.tool(
     "claude_code",
-    `Start a new Claude Code session. The agent autonomously performs coding tasks: reading/writing files, running shell commands, searching code, managing git, and interacting with APIs.
-Returns a sessionId that can be passed to claude_code_reply for multi-turn conversations.
-Defaults: permissionMode="dontAsk" (auto-approves allowed tools without prompting), loads all local Claude settings (user, project, local) including CLAUDE.md.`,
+    buildInternalToolsDescription(toolCache.getTools()),
     {
       prompt: z.string().describe("The task or question for Claude Code"),
-      cwd: z.string().optional().describe("Working directory (defaults to server cwd)"),
+      cwd: z.string().optional().describe("Working directory. Default: server cwd."),
       allowedTools: z.array(z.string()).optional().describe(
-        "List of tool names the agent can use without permission prompts. In the default 'dontAsk' mode, only tools in this list are available. Example: ['Bash', 'Read', 'Write', 'Edit']"
+        "Tools the agent can use without asking for permission. Default: [] (no auto-approvals). Example: ['Bash', 'Read', 'Write', 'Edit']. Tools not listed here or in disallowedTools will trigger a permission request via claude_code_check."
       ),
       disallowedTools: z.array(z.string()).optional().describe(
-        "List of tool names the agent is forbidden from using. Takes precedence over allowedTools."
-      ),
-      tools: z.union([
-        z.array(z.string()),
-        z.object({
-          type: z.literal("preset"),
-          preset: z.literal("claude_code")
-        })
-      ]).optional().describe(
-        "Define the base tool set for the session. Pass an array of tool name strings, or use {type: 'preset', preset: 'claude_code'} for the default Claude Code toolset. allowedTools/disallowedTools further filter on top of this base set."
-      ),
-      persistSession: z.boolean().optional().describe(
-        "Persist session history to disk (~/.claude/projects). Default: true. Set false to disable persistence."
+        "Tools the agent is forbidden from using. Default: [] (none). Takes priority over allowedTools."
       ),
-      permissionMode: z.enum(PERMISSION_MODES).optional().describe(
-        "Controls how the agent handles tool permissions. 'dontAsk' (default): auto-approve tools in allowedTools without prompting. 'bypassPermissions': skip all permission checks (requires enable_bypass via claude_code_configure). 'plan': require approval before executing."
+      maxTurns: z.number().int().positive().optional().describe("Maximum number of reasoning steps the agent can take."),
+      model: z.string().optional().describe("Model to use, e.g. 'claude-sonnet-4-5-20250929'."),
+      systemPrompt: systemPromptSchema.optional().describe(
+        "Override the agent's system prompt. Pass a string for full replacement, or use {type: 'preset', preset: 'claude_code', append: '...'} to extend the default."
       ),
-      maxTurns: z.number().int().positive().optional().describe(
-        "Maximum number of agent reasoning steps. Each step may involve one or more tool calls. Limits how many iterations the agent performs before stopping."
+      permissionRequestTimeoutMs: z.number().int().positive().optional().describe(
+        "How long to wait (in ms) for a permission decision via claude_code_check before auto-denying. Default: 60000."
       ),
-      model: z.string().optional().describe("Model to use, e.g. 'claude-sonnet-4-5-20250929'"),
-      systemPrompt: z.union([
-        z.string(),
-        z.object({
-          type: z.literal("preset"),
-          preset: z.literal("claude_code"),
-          append: z.string().optional().describe("Additional instructions to append to the preset")
-        })
-      ]).optional().describe(
-        "Override the agent's system prompt. Pass a string for full replacement, or use {type: 'preset', preset: 'claude_code', append: '...'} to extend the default Claude Code prompt with additional instructions."
-      ),
-      agents: z.record(
-        z.string(),
-        z.object({
-          description: z.string(),
-          prompt: z.string(),
-          tools: z.array(z.string()).optional(),
-          disallowedTools: z.array(z.string()).optional(),
-          model: z.enum(AGENT_MODELS).optional(),
-          maxTurns: z.number().int().positive().optional(),
-          mcpServers: z.array(z.union([z.string(), z.record(z.string(), z.unknown())])).optional(),
-          skills: z.array(z.string()).optional(),
-          criticalSystemReminder_EXPERIMENTAL: z.string().optional()
-        })
-      ).optional().describe(
-        "Define custom sub-agents that the main agent can delegate tasks to. Each key is the agent name; the value specifies its system prompt, available tools, model, and other constraints."
-      ),
-      maxBudgetUsd: z.number().positive().optional().describe("Maximum budget in USD for this session"),
-      effort: z.enum(EFFORT_LEVELS).optional().describe(
-        "Effort level: 'low' (fast), 'medium' (balanced), 'high' (thorough), 'max' (maximum)"
-      ),
-      betas: z.array(z.string()).optional().describe("Beta features to enable (e.g. ['context-1m-2025-08-07'])"),
-      additionalDirectories: z.array(z.string()).optional().describe("Additional directories the agent can access beyond cwd"),
-      outputFormat: z.object({
-        type: z.literal("json_schema"),
-        schema: z.record(z.string(), z.unknown()).describe("JSON Schema for structured output")
-      }).optional().describe("Structured output format with JSON Schema (omit for plain text output)"),
-      thinking: z.union([
-        z.object({ type: z.literal("adaptive") }),
-        z.object({
-          type: z.literal("enabled"),
-          budgetTokens: z.number().int().positive().describe("Token budget for thinking")
-        }),
-        z.object({ type: z.literal("disabled") })
-      ]).optional().describe("Thinking mode: 'adaptive' (auto), 'enabled' (with budget), or 'disabled'"),
-      timeout: z.number().int().positive().optional().describe("Timeout in milliseconds for this session"),
-      pathToClaudeCodeExecutable: z.string().optional().describe("Path to the Claude Code executable"),
-      agent: z.string().optional().describe(
-        "Name of a custom agent (defined in 'agents' parameter) to use as the primary agent for this session, applying its system prompt, tool restrictions, and model override."
-      ),
-      mcpServers: z.record(z.string(), z.record(z.string(), z.unknown())).optional().describe("MCP server configurations (key: server name, value: server config)"),
-      sandbox: z.record(z.string(), z.unknown()).optional().describe(
-        "Sandbox configuration for isolating shell command execution (e.g., Docker container settings). Controls the execution environment for Bash tool calls."
-      ),
-      fallbackModel: z.string().optional().describe("Fallback model if the primary model fails or is unavailable"),
-      enableFileCheckpointing: z.boolean().optional().describe("Enable file checkpointing to track file changes during the session"),
-      includePartialMessages: z.boolean().optional().describe(
-        "When true, includes intermediate streaming messages in the response (e.g., partial tool outputs as they arrive). Useful for real-time progress monitoring. Default: false."
-      ),
-      strictMcpConfig: z.boolean().optional().describe("Enforce strict validation of MCP server configurations"),
-      settingSources: z.array(z.enum(["user", "project", "local"])).optional().describe(
-        'Control which filesystem settings are loaded. Defaults to ["user", "project", "local"] (loads all settings including ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, and CLAUDE.md). Pass an empty array [] to disable all settings (SDK isolation mode).'
-      ),
-      debug: z.boolean().optional().describe("Enable debug mode for verbose logging"),
-      debugFile: z.string().optional().describe("Write debug logs to a specific file path (implicitly enables debug mode)"),
-      env: z.record(z.string(), z.string().optional()).optional().describe(
-        "Environment variables to merge with process.env and pass to the Claude Code process (user-provided values take precedence)"
-      )
+      advanced: advancedOptionsSchema
     },
-    async (args) => {
+    async (args, extra) => {
       try {
-        const result = await executeClaudeCode(args, sessionManager, serverCwd, allowBypass);
+        const result = await executeClaudeCode(
+          args,
+          sessionManager,
+          serverCwd,
+          toolCache,
+          extra.signal
+        );
+        const isError = typeof result.error === "string";
         return {
           content: [
             {
@@ -1341,7 +1914,7 @@ Defaults: permissionMode="dontAsk" (auto-approves allowed tools without promptin
               text: JSON.stringify(result, null, 2)
             }
           ],
-          isError: result.isError
+          isError
         };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1359,102 +1932,69 @@ Defaults: permissionMode="dontAsk" (auto-approves allowed tools without promptin
   );
   server.tool(
     "claude_code_reply",
-    `Continue an existing Claude Code session by sending a follow-up message. The agent retains full context from previous turns including files read, code analysis, and conversation history. Requires a sessionId returned by a previous claude_code call.
-Note: When CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 is set and the in-memory session has expired, the agent can resume from disk-persisted history. Parameters marked "(disk resume fallback)" are only used in this scenario to reconstruct the session.`,
+    `Send a follow-up message to an existing Claude Code session.
+
+The agent retains full context from previous turns (files read, code analyzed, conversation history). Returns immediately \u2014 use claude_code_check to poll for the result.
+
+Supports session forking (forkSession=true) to explore alternative approaches without modifying the original session.
+
+Defaults:
+- forkSession: false
+- sessionInitTimeoutMs: 10000 (only used when forkSession=true)
+- permissionRequestTimeoutMs: 60000
+- Disk resume: disabled unless CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1
+
+Disk resume: If the server restarted and the session is no longer in memory, set CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 to let the agent resume from its on-disk transcript. Pass diskResumeConfig with resumeToken and session parameters.`,
     {
       sessionId: z.string().describe("The session ID to continue (from a previous claude_code call)"),
       prompt: z.string().describe("Follow-up prompt or instruction"),
       forkSession: z.boolean().optional().describe(
-        "Create a branched copy of this session. The original session remains unchanged; the new session starts with the same context but diverges from this point. Useful for exploring alternative approaches."
-      ),
-      timeout: z.number().int().positive().optional().describe("Timeout in milliseconds for this reply"),
-      // Optional disk-resume overrides (only used when CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1
-      // and the in-memory session metadata is missing)
-      cwd: z.string().optional().describe("Working directory (disk resume fallback)"),
-      allowedTools: z.array(z.string()).optional().describe(
-        "Auto-approved tool names (disk resume fallback). See claude_code tool for details."
+        "Branch this session into a new copy that diverges from the current point. The original session remains unchanged. Default: false."
       ),
-      disallowedTools: z.array(z.string()).optional().describe("Forbidden tool names (disk resume fallback). See claude_code tool for details."),
-      tools: z.union([
-        z.array(z.string()),
-        z.object({
-          type: z.literal("preset"),
-          preset: z.literal("claude_code")
-        })
-      ]).optional().describe("Base tool set (disk resume fallback). See claude_code tool for details."),
-      persistSession: z.boolean().optional().describe("Persist session history to disk (~/.claude/projects). Default: true."),
-      permissionMode: z.enum(PERMISSION_MODES).optional().describe("Permission mode (disk resume fallback). See claude_code tool for details."),
-      maxTurns: z.number().int().positive().optional().describe("Maximum number of agent reasoning steps for this reply."),
-      model: z.string().optional().describe("Model to use, e.g. 'claude-sonnet-4-5-20250929'"),
-      systemPrompt: z.union([
-        z.string(),
-        z.object({
-          type: z.literal("preset"),
-          preset: z.literal("claude_code"),
-          append: z.string().optional().describe("Additional instructions to append to the preset")
-        })
-      ]).optional().describe("Override the agent's system prompt. See claude_code tool for details."),
-      agents: z.record(
-        z.string(),
-        z.object({
-          description: z.string(),
-          prompt: z.string(),
-          tools: z.array(z.string()).optional(),
-          disallowedTools: z.array(z.string()).optional(),
-          model: z.enum(AGENT_MODELS).optional(),
-          maxTurns: z.number().int().positive().optional(),
-          mcpServers: z.array(z.union([z.string(), z.record(z.string(), z.unknown())])).optional(),
-          skills: z.array(z.string()).optional(),
-          criticalSystemReminder_EXPERIMENTAL: z.string().optional()
-        })
-      ).optional().describe("Define custom sub-agents. See claude_code tool for details."),
-      maxBudgetUsd: z.number().positive().optional().describe("Maximum budget in USD for this reply"),
-      effort: z.enum(EFFORT_LEVELS).optional().describe(
-        "Effort level: 'low' (fast), 'medium' (balanced), 'high' (thorough), 'max' (maximum)"
+      sessionInitTimeoutMs: z.number().int().positive().optional().describe("How long to wait (in ms) for a forked session to initialize. Default: 10000."),
+      permissionRequestTimeoutMs: z.number().int().positive().optional().describe(
+        "How long to wait (in ms) for a permission decision via claude_code_check before auto-denying. Default: 60000."
       ),
-      betas: z.array(z.string()).optional().describe("Beta features to enable"),
-      additionalDirectories: z.array(z.string()).optional().describe("Additional directories the agent can access beyond cwd"),
-      outputFormat: z.object({
-        type: z.literal("json_schema"),
-        schema: z.record(z.string(), z.unknown()).describe("JSON Schema for structured output")
-      }).optional().describe("Structured output format with JSON Schema (omit for plain text output)"),
-      thinking: z.union([
-        z.object({ type: z.literal("adaptive") }),
-        z.object({
-          type: z.literal("enabled"),
-          budgetTokens: z.number().int().positive().describe("Token budget for thinking")
-        }),
-        z.object({ type: z.literal("disabled") })
-      ]).optional().describe("Thinking mode: 'adaptive' (auto), 'enabled' (with budget), or 'disabled'"),
-      resumeSessionAt: z.string().optional().describe(
-        "Resume only up to and including a specific message UUID (disk resume fallback only)"
-      ),
-      pathToClaudeCodeExecutable: z.string().optional().describe("Path to the Claude Code executable"),
-      agent: z.string().optional().describe(
-        "Name of a custom agent (defined in 'agents') to use as the primary agent. See claude_code tool for details."
-      ),
-      mcpServers: z.record(z.string(), z.record(z.string(), z.unknown())).optional().describe("MCP server configurations (key: server name, value: server config)"),
-      sandbox: z.record(z.string(), z.unknown()).optional().describe(
-        "Sandbox configuration for isolating shell command execution. See claude_code tool for details."
-      ),
-      fallbackModel: z.string().optional().describe("Fallback model if the primary model fails or is unavailable"),
-      enableFileCheckpointing: z.boolean().optional().describe("Enable file checkpointing to track file changes during the session"),
-      includePartialMessages: z.boolean().optional().describe(
-        "When true, includes intermediate streaming messages in the response (e.g., partial tool outputs as they arrive). Useful for real-time progress monitoring. Default: false."
-      ),
-      strictMcpConfig: z.boolean().optional().describe("Enforce strict validation of MCP server configurations"),
-      settingSources: z.array(z.enum(["user", "project", "local"])).optional().describe(
-        'Control which filesystem settings are loaded. Defaults to ["user", "project", "local"] (loads all settings including ~/.claude/settings.json, .claude/settings.json, .claude/settings.local.json, and CLAUDE.md). Pass an empty array [] to disable all settings (SDK isolation mode).'
-      ),
-      debug: z.boolean().optional().describe("Enable debug mode for verbose logging"),
-      debugFile: z.string().optional().describe("Write debug logs to a specific file path (implicitly enables debug mode)"),
-      env: z.record(z.string(), z.string().optional()).optional().describe(
-        "Environment variables to merge with process.env and pass to the Claude Code process (user-provided values take precedence)"
+      diskResumeConfig: z.object({
+        resumeToken: z.string().optional().describe(
+          "Resume token returned by claude_code / claude_code_reply. Required for disk resume."
+        ),
+        cwd: z.string().optional().describe("Working directory. Required for disk resume."),
+        allowedTools: z.array(z.string()).optional().describe("Tools the agent can use without permission."),
+        disallowedTools: z.array(z.string()).optional().describe("Tools the agent is forbidden from using."),
+        tools: toolsConfigSchema.optional().describe("Which tools the agent can see."),
+        persistSession: z.boolean().optional().describe("Persist session history to disk. Default: true."),
+        maxTurns: z.number().int().positive().optional().describe("Maximum reasoning steps."),
+        model: z.string().optional().describe("Model to use."),
+        systemPrompt: systemPromptSchema.optional().describe("Override the agent's system prompt."),
+        agents: z.record(z.string(), agentDefinitionSchema).optional().describe("Define custom sub-agents."),
+        agent: z.string().optional().describe("Name of a custom agent to use as primary."),
+        maxBudgetUsd: z.number().positive().optional().describe("Maximum budget in USD."),
+        effort: z.enum(EFFORT_LEVELS).optional().describe("Effort level."),
+        betas: z.array(z.string()).optional().describe("Beta features to enable."),
+        additionalDirectories: z.array(z.string()).optional().describe("Additional accessible directories."),
+        outputFormat: outputFormatSchema.optional().describe("Structured output format."),
+        thinking: thinkingSchema.optional().describe("Thinking mode configuration."),
+        resumeSessionAt: z.string().optional().describe("Resume only up to a specific message UUID."),
+        pathToClaudeCodeExecutable: z.string().optional().describe("Path to the Claude Code executable."),
+        mcpServers: z.record(z.string(), z.record(z.string(), z.unknown())).optional().describe("MCP server configurations."),
+        sandbox: z.record(z.string(), z.unknown()).optional().describe("Sandbox configuration."),
+        fallbackModel: z.string().optional().describe("Fallback model."),
+        enableFileCheckpointing: z.boolean().optional().describe("Enable file checkpointing. Default: false."),
+        includePartialMessages: z.boolean().optional().describe("Include intermediate messages as events. Default: false."),
+        strictMcpConfig: z.boolean().optional().describe("Enforce strict MCP validation. Default: false."),
+        settingSources: z.array(z.enum(["user", "project", "local"])).optional().describe("Which local config files to load."),
+        debug: z.boolean().optional().describe("Enable debug mode. Default: false."),
+        debugFile: z.string().optional().describe("Write debug logs to a file path."),
+        env: z.record(z.string(), z.string().optional()).optional().describe("Environment variables to merge with process.env.")
+      }).optional().describe(
+        "Disk resume fallback configuration. Only needed when CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 and the in-memory session is missing. Contains resumeToken + all session config overrides."
       )
     },
-    async (args) => {
+    async (args, extra) => {
       try {
-        const result = await executeClaudeCodeReply(args, sessionManager, allowBypass);
+        const result = await executeClaudeCodeReply(args, sessionManager, toolCache, extra.signal);
+        const isError = typeof result.error === "string";
         return {
           content: [
             {
@@ -1462,7 +2002,7 @@ Note: When CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 is set and the in-memory session
               text: JSON.stringify(result, null, 2)
             }
           ],
-          isError: result.isError
+          isError
         };
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
@@ -1480,32 +2020,19 @@ Note: When CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 is set and the in-memory session
   );
   server.tool(
     "claude_code_session",
-    `Manage Claude Code sessions. Actions: 'list' returns all sessions with status and metadata; 'get' returns detailed info for a specific session (requires sessionId); 'cancel' terminates a running session (requires sessionId).`,
+    `List, inspect, or cancel Claude Code sessions.
+
+- action="list": Get all sessions with their status, cost, turn count, and settings.
+- action="get": Get full details for one session (pass sessionId). Add includeSensitive=true to also see cwd, systemPrompt, agents, and additionalDirectories.
+- action="cancel": Stop a running session immediately (pass sessionId).`,
     {
       action: z.enum(SESSION_ACTIONS).describe("Action to perform: 'list', 'get', or 'cancel'"),
       sessionId: z.string().optional().describe("Session ID (required for 'get' and 'cancel')"),
       includeSensitive: z.boolean().optional().describe(
-        "When true, includes sensitive fields (cwd, systemPrompt, agents, additionalDirectories) in the response. Requires CLAUDE_CODE_MCP_ALLOW_SENSITIVE_SESSION_DETAILS=1 env var. Default: false."
+        "When true, includes sensitive fields (cwd, systemPrompt, agents, additionalDirectories) in the response. Default: false."
       )
     },
     async (args) => {
-      const allowSensitive = process.env.CLAUDE_CODE_MCP_ALLOW_SENSITIVE_SESSION_DETAILS === "1";
-      if (args.includeSensitive && !allowSensitive) {
-        const result2 = {
-          sessions: [],
-          message: `Error [${"PERMISSION_DENIED" /* PERMISSION_DENIED */}]: includeSensitive is disabled. Set CLAUDE_CODE_MCP_ALLOW_SENSITIVE_SESSION_DETAILS=1 to enable.`,
-          isError: true
-        };
-        return {
-          content: [
-            {
-              type: "text",
-              text: JSON.stringify(result2, null, 2)
-            }
-          ],
-          isError: true
-        };
-      }
       const result = executeClaudeCodeSession(args, sessionManager);
       return {
         content: [
@@ -1519,16 +2046,82 @@ Note: When CLAUDE_CODE_MCP_ALLOW_DISK_RESUME=1 is set and the in-memory session
     }
   );
   server.tool(
-    "claude_code_configure",
-    `Configure the Claude Code MCP server at runtime.
-Actions: 'enable_bypass' allows sessions to use permissionMode='bypassPermissions' (skips all tool permission checks \u2014 use with caution); 'disable_bypass' revokes this ability; 'get_config' returns the current server configuration.`,
+    "claude_code_check",
+    `Query a running session for new events, retrieve the final result, or respond to permission requests.
+
+Two actions:
+
+Defaults (poll):
+- responseMode: "minimal"
+- minimal mode strips verbose fields from assistant messages (usage, model, id, cache_control) and filters out noisy progress events (tool_progress, auth_status)
+- maxEvents: 200 in minimal mode (unlimited in full mode unless maxEvents is set)
+
+action="poll" \u2014 Retrieve events since the last poll.
+  Returns events (agent output, progress updates, permission requests, errors, final result).
+  Pass the cursor from the previous poll's nextCursor for incremental updates. Omit cursor to get all buffered events.
+  If the agent is waiting for permission, the response includes an "actions" array with pending requests.
+
+action="respond_permission" \u2014 Approve or deny a pending permission request.
+  Pass the requestId from the actions array, plus decision="allow" or decision="deny".
+  Approving resumes agent execution. Denying (with optional interrupt=true) can halt the entire session.
+  The response also includes the latest poll state (events, status, etc.), so a separate poll call is not needed.`,
     {
-      action: z.enum(CONFIGURE_ACTIONS).describe(
-        "Action to perform: 'enable_bypass' | 'disable_bypass' | 'get_config'. See tool description for details."
+      action: z.enum(CHECK_ACTIONS).describe('Action to perform: "poll" or "respond_permission"'),
+      sessionId: z.string().describe("Session ID to check"),
+      cursor: z.number().int().nonnegative().optional().describe(
+        "Event cursor for incremental polling. Pass nextCursor from the previous poll response."
+      ),
+      responseMode: z.enum(CHECK_RESPONSE_MODES).optional().describe("Response shaping preset. 'minimal' reduces payload size. Default: 'minimal'."),
+      maxEvents: z.number().int().positive().optional().describe(
+        "Max number of events to return per poll (pagination via nextCursor). Default: 200 in minimal mode."
+      ),
+      requestId: z.string().optional().describe(
+        "The permission request ID to respond to (from the actions array). Required for respond_permission."
+      ),
+      decision: z.enum(["allow", "deny"]).optional().describe(
+        "Whether to approve or reject the permission request. Required for respond_permission."
+      ),
+      denyMessage: z.string().optional().describe(
+        "Reason for denying, shown to the agent. Only used with decision='deny'. Default: 'Permission denied by caller'."
+      ),
+      interrupt: z.boolean().optional().describe(
+        "When true with decision='deny', stops the entire agent session. Default: false."
+      ),
+      pollOptions: z.object({
+        includeTools: z.boolean().optional().describe("Include availableTools array from session init. Default: false."),
+        includeEvents: z.boolean().optional().describe(
+          "When false, omits the events array (nextCursor still advances). Default: true."
+        ),
+        includeActions: z.boolean().optional().describe("When false, omits actions[] even if waiting_permission. Default: true."),
+        includeResult: z.boolean().optional().describe("When false, omits the top-level result when idle/error. Default: true."),
+        includeUsage: z.boolean().optional().describe("Include AgentResult.usage. Default: true in full mode, false in minimal."),
+        includeModelUsage: z.boolean().optional().describe(
+          "Include AgentResult.modelUsage. Default: true in full mode, false in minimal."
+        ),
+        includeStructuredOutput: z.boolean().optional().describe(
+          "Include AgentResult.structuredOutput. Default: true in full mode, false in minimal."
+        ),
+        includeTerminalEvents: z.boolean().optional().describe(
+          "Include terminal result/error events in events stream. Default: true in full, false in minimal."
+        ),
+        includeProgressEvents: z.boolean().optional().describe(
+          "Include progress events (tool_progress, auth_status). Default: true in full, false in minimal."
+        )
+      }).optional().describe(
+        "Fine-grained poll control. Overrides responseMode defaults for individual fields. Most callers can omit this."
+      ),
+      permissionOptions: z.object({
+        updatedInput: z.record(z.string(), z.unknown()).optional().describe(
+          "Modified tool input to use instead of the original. Only with decision='allow'."
+        ),
+        updatedPermissions: z.array(z.record(z.string(), z.unknown())).optional().describe("Permission rule updates to apply. Only with decision='allow'.")
+      }).optional().describe(
+        "Advanced permission response options. Only used with respond_permission + decision='allow'."
       )
     },
     async (args) => {
-      const result = executeClaudeCodeConfigure(args, config);
+      const result = executeClaudeCodeCheck(args, sessionManager, toolCache);
+      const isError = result.isError === true;
       return {
         content: [
           {
@@ -1536,7 +2129,7 @@ Actions: 'enable_bypass' allows sessions to use permissionMode='bypassPermission
             text: JSON.stringify(result, null, 2)
           }
         ],
-        isError: result.isError ?? false
+        isError
       };
     }
   );