@caspian2026/agent-sdk 0.0.9 → 0.0.11

package/dist/gateway/worker.js

@@ -32893,6 +32893,14 @@ var init_platform = __esm(() => {
 });
 
 // src/utils/windowsPaths.ts
+var exports_windowsPaths = {};
+__export(exports_windowsPaths, {
+  windowsPathToPosixPath: () => windowsPathToPosixPath,
+  setShellIfWindows: () => setShellIfWindows,
+  posixPathToWindowsPath: () => posixPathToWindowsPath,
+  findGitBashPathSafe: () => findGitBashPathSafe,
+  findGitBashPath: () => findGitBashPath
+});
 import * as path8 from "path";
 import * as pathWin32 from "path/win32";
 function checkPathExists(path9) {
@@ -32937,7 +32945,18 @@ function findExecutable(executable) {
     return null;
   }
 }
-var findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath;
+function setShellIfWindows() {
+  if (getPlatform() === "windows") {
+    const gitBashPath = findGitBashPathSafe();
+    if (gitBashPath) {
+      process.env.SHELL = gitBashPath;
+      logForDebugging(`Using bash path: "${gitBashPath}"`);
+    } else {
+      logForDebugging("Git Bash not found on Windows; shell detection will fall back to system PATH. " + "Set CLAUDE_CODE_GIT_BASH_PATH or install Git for Windows.");
+    }
+  }
+}
+var findGitBashPathSafe, findGitBashPath, windowsPathToPosixPath, posixPathToWindowsPath;
 var init_windowsPaths = __esm(() => {
   init_memoize();
   init_cwd();
@@ -32945,13 +32964,13 @@ var init_windowsPaths = __esm(() => {
   init_execSyncWrapper();
   init_memoize2();
   init_platform();
-  findGitBashPath = memoize_default(() => {
+  findGitBashPathSafe = memoize_default(() => {
     if (process.env.CLAUDE_CODE_GIT_BASH_PATH) {
       if (checkPathExists(process.env.CLAUDE_CODE_GIT_BASH_PATH)) {
         return process.env.CLAUDE_CODE_GIT_BASH_PATH;
       }
-      console.error(`Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"`);
-      process.exit(1);
+      logForDebugging(`CLAUDE_CODE_GIT_BASH_PATH "${process.env.CLAUDE_CODE_GIT_BASH_PATH}" does not exist`);
+      return null;
     }
     const gitPath = findExecutable("git");
     if (gitPath) {
@@ -32960,7 +32979,13 @@ var init_windowsPaths = __esm(() => {
         return bashPath;
       }
     }
-    console.error("Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe");
+    return null;
+  });
+  findGitBashPath = memoize_default(() => {
+    const result = findGitBashPathSafe();
+    if (result)
+      return result;
+    console.error(process.env.CLAUDE_CODE_GIT_BASH_PATH ? `Claude Code was unable to find CLAUDE_CODE_GIT_BASH_PATH path "${process.env.CLAUDE_CODE_GIT_BASH_PATH}"` : "Claude Code on Windows requires git-bash (https://git-scm.com/downloads/win). If installed but not in PATH, set environment variable pointing to your bash.exe, similar to: CLAUDE_CODE_GIT_BASH_PATH=C:\\Program Files\\Git\\bin\\bash.exe");
     process.exit(1);
   });
   windowsPathToPosixPath = memoizeWithLRU((windowsPath) => {
@@ -116173,7 +116198,7 @@ var init_metadata = __esm(() => {
       isClaudeAiAuth: false,
       version: "2.1.888",
       versionBase: getVersionBase(),
-      buildTime: "2026-05-02T02:41:49.506Z",
+      buildTime: "2026-05-05T17:34:10.461Z",
       deploymentEnvironment: env3.detectDeploymentEnvironment(),
       ...isEnvTruthy(process.env.GITHUB_ACTIONS) && {
         githubEventName: process.env.GITHUB_EVENT_NAME,
@@ -374701,6 +374726,34 @@ var init_VerifyPlanExecutionTool = __esm(() => {
 });
 
 // src/tools.ts
+var exports_tools = {};
+__export(exports_tools, {
+  parseToolPreset: () => parseToolPreset,
+  getToolsForDefaultPreset: () => getToolsForDefaultPreset,
+  getTools: () => getTools,
+  getMergedTools: () => getMergedTools,
+  getAllBaseTools: () => getAllBaseTools,
+  filterToolsByDenyRules: () => filterToolsByDenyRules,
+  assembleToolPool: () => assembleToolPool,
+  TOOL_PRESETS: () => TOOL_PRESETS,
+  REPL_ONLY_TOOLS: () => REPL_ONLY_TOOLS,
+  CUSTOM_AGENT_DISALLOWED_TOOLS: () => CUSTOM_AGENT_DISALLOWED_TOOLS,
+  COORDINATOR_MODE_ALLOWED_TOOLS: () => COORDINATOR_MODE_ALLOWED_TOOLS,
+  ASYNC_AGENT_ALLOWED_TOOLS: () => ASYNC_AGENT_ALLOWED_TOOLS,
+  ALL_AGENT_DISALLOWED_TOOLS: () => ALL_AGENT_DISALLOWED_TOOLS
+});
+function parseToolPreset(preset) {
+  const presetString = preset.toLowerCase();
+  if (!TOOL_PRESETS.includes(presetString)) {
+    return null;
+  }
+  return presetString;
+}
+function getToolsForDefaultPreset() {
+  const tools = getAllBaseTools();
+  const isEnabled2 = tools.map((tool) => tool.isEnabled());
+  return tools.filter((_2, i3) => isEnabled2[i3]).map((tool) => tool.name);
+}
 function getAllBaseTools() {
   return [
     AgentTool,
@@ -374760,11 +374813,15 @@ function assembleToolPool(permissionContext, mcpTools) {
   const byName = (a2, b3) => a2.name.localeCompare(b3.name);
   return uniqBy_default([...builtInTools].sort(byName).concat(allowedMcpTools.sort(byName)), "name");
 }
+function getMergedTools(permissionContext, mcpTools) {
+  const builtInTools = getTools(permissionContext);
+  return [...builtInTools, ...mcpTools];
+}
 var REPLTool2, SuggestBackgroundPRTool2, SleepTool = null, cronTools, RemoteTriggerTool = null, MonitorTool = null, SendUserFileTool = null, PushNotificationTool = null, SubscribePRTool = null, getTeamCreateTool = () => (init_TeamCreateTool(), __toCommonJS(exports_TeamCreateTool)).TeamCreateTool, getTeamDeleteTool = () => (init_TeamDeleteTool(), __toCommonJS(exports_TeamDeleteTool)).TeamDeleteTool, getSendMessageTool = () => (init_SendMessageTool(), __toCommonJS(exports_SendMessageTool)).SendMessageTool, VerifyPlanExecutionTool2, OverflowTestTool = null, CtxInspectTool = null, TerminalCaptureTool = null, WebBrowserTool = null, SnipTool = null, ListPeersTool = null, WorkflowTool = null, getPowerShellTool2 = () => {
   if (!isPowerShellToolEnabled())
     return null;
   return (init_PowerShellTool(), __toCommonJS(exports_PowerShellTool)).PowerShellTool;
-}, getTools = (permissionContext) => {
+}, TOOL_PRESETS, getTools = (permissionContext) => {
   if (isEnvTruthy(process.env.CLAUDE_CODE_SIMPLE)) {
     if (isReplModeEnabled() && REPLTool2) {
       const replSimple = [REPLTool2];
@@ -374843,6 +374900,7 @@ var init_tools2 = __esm(() => {
     (init_CronListTool(), __toCommonJS(exports_CronListTool)).CronListTool
   ];
   VerifyPlanExecutionTool2 = process.env.CLAUDE_CODE_VERIFY_PLAN === "true" ? (init_VerifyPlanExecutionTool(), __toCommonJS(exports_VerifyPlanExecutionTool)).VerifyPlanExecutionTool : null;
+  TOOL_PRESETS = ["default"];
 });
 
 // src/hooks/useDoublePress.ts
@@ -384379,7 +384437,7 @@ function getAnthropicEnvMetadata() {
 function getBuildAgeMinutes() {
   if (false)
     ;
-  const buildTime = new Date("2026-05-02T02:41:49.506Z").getTime();
+  const buildTime = new Date("2026-05-05T17:34:10.461Z").getTime();
   if (isNaN(buildTime))
     return;
   return Math.floor((Date.now() - buildTime) / 60000);
@@ -452685,7 +452743,7 @@ var init_bridge_kick = __esm(() => {
 var call55 = async () => {
   return {
     type: "text",
-    value: `${"2.1.888"} (built ${"2026-05-02T02:41:49.506Z"})`
+    value: `${"2.1.888"} (built ${"2026-05-05T17:34:10.461Z"})`
   };
 }, version2, version_default;
 var init_version = __esm(() => {
@@ -480760,6 +480818,70 @@ var init_MessageSelector = __esm(() => {
   jsx_dev_runtime356 = __toESM(require_jsx_dev_runtime(), 1);
 });
 
+// packages/sdk/src/adapters/permissions.ts
+var exports_permissions3 = {};
+__export(exports_permissions3, {
+  createHeadlessCanUseTool: () => createHeadlessCanUseTool
+});
+function createHeadlessCanUseTool(handler) {
+  return async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => {
+    if (forceDecision !== undefined) {
+      return forceDecision;
+    }
+    if (handler.deniedTools?.includes(tool.name)) {
+      return {
+        behavior: "deny",
+        decisionReason: { type: "other", reason: "Tool is in the denied list" },
+        message: `Permission to use ${tool.name} has been denied.`
+      };
+    }
+    if (handler.allowedTools?.includes(tool.name)) {
+      return {
+        behavior: "allow",
+        updatedInput: input,
+        decisionReason: { type: "other", reason: "Tool is in the allowed list" }
+      };
+    }
+    const result = await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID);
+    if (result.behavior === "allow" || result.behavior === "deny") {
+      return result;
+    }
+    if (handler.onPermissionRequest) {
+      const description = tool.getActivityDescription?.(input) ?? tool.name;
+      const request = {
+        toolName: tool.name,
+        input,
+        description,
+        toolUseId: toolUseID
+      };
+      const response = await handler.onPermissionRequest(request);
+      if (response.allowed) {
+        return {
+          behavior: "allow",
+          updatedInput: response.updatedInput ?? input,
+          decisionReason: { type: "other", reason: "Approved by permission handler" }
+        };
+      }
+      return {
+        behavior: "deny",
+        message: response.message ?? `Permission denied for ${tool.name}`,
+        decisionReason: { type: "other", reason: "Denied by permission handler" }
+      };
+    }
+    return {
+      behavior: "deny",
+      decisionReason: {
+        type: "other",
+        reason: "No permission handler configured"
+      },
+      message: "Permission denied (no handler configured)"
+    };
+  };
+}
+var init_permissions6 = __esm(() => {
+  init_permissions2();
+});
+
 // src/entrypoints/gateway/worker.ts
 import { parentPort, workerData } from "node:worker_threads";
 
@@ -481199,6 +481321,7 @@ class QueryEngine {
   readFileState;
   discoveredSkillNames = new Set;
   loadedNestedMemoryPaths = new Set;
+  destroyed = false;
   constructor(config5) {
     this.config = config5;
     this.mutableMessages = config5.initialMessages ?? [];
@@ -481520,6 +481643,8 @@ class QueryEngine {
       maxTurns,
       taskBudget
     })) {
+      if (this.destroyed)
+        return;
       if (message.type === "assistant" || message.type === "user" || message.type === "system" && message.subtype === "compact_boundary") {
         if (persistSession && message.type === "system" && message.subtype === "compact_boundary") {
           const compactMsg = message;
@@ -481860,9 +481985,39 @@ class QueryEngine {
   getSessionId() {
     return getSessionId();
   }
-  setModel(model) {
+  updateModel(model) {
     this.config.userSpecifiedModel = model;
   }
+  updatePermission(canUseTool) {
+    this.config.canUseTool = canUseTool;
+  }
+  updateMcpClients(mcpClients, tools) {
+    this.config.mcpClients = mcpClients;
+    this.config.tools = tools;
+  }
+  updateSystemPrompt(prompt) {
+    this.config.customSystemPrompt = prompt;
+  }
+  updateMaxTurns(maxTurns) {
+    this.config.maxTurns = maxTurns;
+  }
+  updateEnv(env6) {
+    Object.assign(process.env, env6);
+  }
+  updateThinking(config5) {
+    this.config.thinkingConfig = config5;
+  }
+  updateAppendSystemPrompt(prompt) {
+    this.config.appendSystemPrompt = prompt;
+  }
+  destroy() {
+    this.destroyed = true;
+    this.mutableMessages = [];
+    this.abortController.abort();
+    this.permissionDenials = [];
+    this.discoveredSkillNames.clear();
+    this.loadedNestedMemoryPaths.clear();
+  }
 }
 
 // packages/sdk/src/adapters/app-state.ts
@@ -481889,63 +482044,8 @@ function createHeadlessStore(config5 = {}) {
   return createStore(initialState);
 }
 
-// packages/sdk/src/adapters/permissions.ts
-init_permissions2();
-function createHeadlessCanUseTool(handler) {
-  return async (tool, input, toolUseContext, assistantMessage, toolUseID, forceDecision) => {
-    if (forceDecision !== undefined) {
-      return forceDecision;
-    }
-    if (handler.deniedTools?.includes(tool.name)) {
-      return {
-        behavior: "deny",
-        decisionReason: { type: "other", reason: "Tool is in the denied list" },
-        message: `Permission to use ${tool.name} has been denied.`
-      };
-    }
-    if (handler.allowedTools?.includes(tool.name)) {
-      return {
-        behavior: "allow",
-        updatedInput: input,
-        decisionReason: { type: "other", reason: "Tool is in the allowed list" }
-      };
-    }
-    const result = await hasPermissionsToUseTool(tool, input, toolUseContext, assistantMessage, toolUseID);
-    if (result.behavior === "allow" || result.behavior === "deny") {
-      return result;
-    }
-    if (handler.onPermissionRequest) {
-      const description = tool.getActivityDescription?.(input) ?? tool.name;
-      const request = {
-        toolName: tool.name,
-        input,
-        description,
-        toolUseId: toolUseID
-      };
-      const response = await handler.onPermissionRequest(request);
-      if (response.allowed) {
-        return {
-          behavior: "allow",
-          updatedInput: response.updatedInput ?? input,
-          decisionReason: { type: "other", reason: "Approved by permission handler" }
-        };
-      }
-      return {
-        behavior: "deny",
-        message: response.message ?? `Permission denied for ${tool.name}`,
-        decisionReason: { type: "other", reason: "Denied by permission handler" }
-      };
-    }
-    return {
-      behavior: "deny",
-      decisionReason: {
-        type: "other",
-        reason: "No permission handler configured"
-      },
-      message: "Permission denied (no handler configured)"
-    };
-  };
-}
+// packages/sdk/src/adapters/bootstrap.ts
+init_permissions6();
 
 // packages/sdk/src/adapters/tool-context.ts
 init_abortController();
@@ -482015,13 +482115,71 @@ function bootstrap(config5 = {}, permissionHandler = {}, mcpClients) {
   };
 }
 
+// packages/sdk/src/state-machine.ts
+var SESSION_TRANSITIONS = [
+  { from: "created", to: "idle" },
+  { from: "idle", to: "prompting" },
+  { from: "prompting", to: "idle" },
+  { from: "prompting", to: "aborting" },
+  { from: "aborting", to: "idle" },
+  { from: "idle", to: "updating" },
+  { from: "updating", to: "idle" },
+  { from: ["created", "idle", "prompting", "aborting", "updating"], to: "destroying" },
+  { from: "destroying", to: "destroyed" }
+];
+
+class SessionStateMachine {
+  _state = "created";
+  _history = [];
+  get state() {
+    return this._state;
+  }
+  get history() {
+    return this._history;
+  }
+  canTransition(to) {
+    return SESSION_TRANSITIONS.some((rule) => rule.to === to && (Array.isArray(rule.from) ? rule.from.includes(this._state) : rule.from === this._state));
+  }
+  transition(to, reason) {
+    if (!this.canTransition(to)) {
+      throw new Error(`Invalid state transition: ${this._state} → ${to}`);
+    }
+    const from = this._state;
+    this._history.push({ from, to, timestamp: Date.now(), reason });
+    if (this._history.length > 100) {
+      this._history = this._history.slice(-100);
+    }
+    this._state = to;
+  }
+  reset() {
+    this._history = [];
+    this._state = "created";
+  }
+}
+
+class SessionDestroyedError extends Error {
+  constructor() {
+    super("Session has been destroyed");
+    this.name = "SessionDestroyedError";
+  }
+}
+
+class SessionBusyError extends Error {
+  constructor() {
+    super("Session is busy processing a prompt");
+    this.name = "SessionBusyError";
+  }
+}
+
 // packages/sdk/src/session.ts
 class Session {
   sessionId;
   engine;
   bootstrapResult;
-  destroyed = false;
-  mcpClients = [];
+  mcpClients;
+  sm = new SessionStateMachine;
+  createdAt = Date.now();
+  lastPromptAt;
   constructor(config5 = {}, permissionHandler = {}, extraOptions) {
     const mcpClients = extraOptions?.mcpClients ?? [];
     this.mcpClients = mcpClients;
@@ -482045,26 +482203,137 @@ class Session {
       maxTurns: config5.maxTurns,
       maxBudgetUsd: config5.maxBudgetUsd,
       abortController: result.abortController,
-      includePartialMessages: config5.includePartialMessages ?? true
+      includePartialMessages: config5.includePartialMessages ?? true,
+      initialMessages: extraOptions?.initialMessages
     });
+    this.sm.transition("idle", "bootstrap complete");
   }
   async* prompt(input) {
-    this.assertAlive();
-    yield* this.engine.submitMessage(input);
+    const state = this.sm.state;
+    if (state === "destroyed" || state === "destroying") {
+      throw new SessionDestroyedError;
+    }
+    if (state === "prompting" || state === "aborting") {
+      throw new SessionBusyError;
+    }
+    this.sm.transition("prompting", `prompt(${input.slice(0, 50)})`);
+    this.lastPromptAt = Date.now();
+    try {
+      yield* this.engine.submitMessage(input);
+    } finally {
+      const currentState = this.sm.state;
+      if (currentState === "prompting" || currentState === "aborting") {
+        this.sm.transition("idle", "prompt complete");
+      }
+    }
+  }
+  async update(config5) {
+    if (this.sm.state === "destroyed" || this.sm.state === "destroying") {
+      throw new SessionDestroyedError;
+    }
+    if (this.sm.state !== "idle") {
+      throw new SessionBusyError;
+    }
+    this.sm.transition("updating", "update()");
+    const changes = [];
+    try {
+      if (config5.model) {
+        this.engine.updateModel(config5.model);
+        changes.push(`model: ${config5.model}`);
+      }
+      if (config5.systemPrompt !== undefined) {
+        this.engine.updateSystemPrompt(config5.systemPrompt);
+        changes.push("systemPrompt updated");
+      }
+      if (config5.maxTurns !== undefined) {
+        this.engine.updateMaxTurns(config5.maxTurns);
+        changes.push(`maxTurns: ${config5.maxTurns}`);
+      }
+      if (config5.permissionHandler) {
+        const { createHeadlessCanUseTool: createHeadlessCanUseTool2 } = await Promise.resolve().then(() => (init_permissions6(), exports_permissions3));
+        const canUseTool = createHeadlessCanUseTool2(config5.permissionHandler);
+        this.engine.updatePermission(canUseTool);
+        changes.push("permission updated");
+      }
+      if (config5.mcpClients !== undefined) {
+        for (const client2 of this.mcpClients) {
+          if (client2.type === "connected" && client2.cleanup) {
+            try {
+              await client2.cleanup();
+            } catch {}
+          }
+        }
+        const { getTools: getTools2, assembleToolPool: assembleToolPool2 } = await Promise.resolve().then(() => (init_tools2(), exports_tools));
+        const toolPermissionContext = this.bootstrapResult.toolUseContext.getAppState().toolPermissionContext;
+        const builtInTools = getTools2(toolPermissionContext);
+        const allTools = config5.mcpTools ? assembleToolPool2(toolPermissionContext, config5.mcpTools) : builtInTools;
+        this.engine.updateMcpClients(config5.mcpClients, allTools);
+        this.mcpClients = config5.mcpClients;
+        changes.push(`mcpClients: ${config5.mcpClients.length} clients`);
+      }
+      if (config5.additionalDirectories) {
+        changes.push(`additionalDirectories: ${config5.additionalDirectories.length} dirs`);
+      }
+      if (config5.env) {
+        this.engine.updateEnv(config5.env);
+        changes.push("env updated");
+      }
+      if (config5.thinking) {
+        this.engine.updateThinking(config5.thinking);
+        changes.push("thinking updated");
+      }
+      if (config5.appendSystemPrompt !== undefined) {
+        this.engine.updateAppendSystemPrompt(config5.appendSystemPrompt);
+        changes.push("appendSystemPrompt updated");
+      }
+      this.sm.transition("idle", `update(${changes.join(", ")})`);
+    } catch (err2) {
+      this.sm.transition("idle", "update failed");
+      throw err2;
+    }
   }
   abort() {
-    this.engine.interrupt();
+    if (this.sm.state === "destroyed" || this.sm.state === "destroying")
+      return;
+    if (this.sm.state === "prompting") {
+      this.engine.interrupt();
+      this.sm.transition("aborting", "abort()");
+    }
   }
-  destroy() {
-    if (this.destroyed)
+  async destroy() {
+    const state = this.sm.state;
+    if (state === "destroyed")
       return;
-    this.destroyed = true;
+    if (state === "prompting") {
+      this.engine.interrupt();
+      this.sm.transition("aborting", "destroy() during prompt");
+      const drainDeadline = Date.now() + 5000;
+      while (this.sm.state === "aborting" && Date.now() < drainDeadline) {
+        await new Promise((r) => setTimeout(r, 10));
+      }
+    }
+    this.sm.transition("destroying", "destroy()");
+    this.engine.destroy();
     this.bootstrapResult.cleanup();
     for (const client2 of this.mcpClients) {
       if (client2.type === "connected" && client2.cleanup) {
-        client2.cleanup().catch(() => {});
+        try {
+          await client2.cleanup();
+        } catch {}
       }
     }
+    this.sm.transition("destroyed", "cleanup complete");
+  }
+  getState() {
+    return {
+      state: this.sm.state,
+      sessionId: this.sessionId,
+      createdAt: this.createdAt,
+      lastPromptAt: this.lastPromptAt
+    };
+  }
+  getStateHistory() {
+    return this.sm.history;
   }
   static resume(sessionId, config5, permissionHandler) {
     const session2 = new Session(config5 ?? {}, permissionHandler ?? {});
@@ -482080,20 +482349,22 @@ class Session {
     const sessions = await listSessionsImpl2(options);
     return sessions.find((s) => s.sessionId === sessionId);
   }
-  assertAlive() {
-    if (this.destroyed) {
-      throw new Error("Session has been destroyed");
-    }
-  }
 }
 
 // src/entrypoints/gateway/worker.ts
 var config5 = workerData;
 var { sessionKey } = config5;
 var PERMISSION_TIMEOUT_MS = 60000;
+var messageQueue = [];
+var processingMessage = false;
+function logState(reason) {
+  const state = session2.getState().state;
+  process.stderr.write(`[Worker ${sessionKey}] State: ${state}${reason ? ` (${reason})` : ""}
+`);
+}
 var pendingPermissions = new Map;
+var savedPermissionCallback;
 var session2;
-var running = false;
 function send(msg) {
   parentPort.postMessage(msg);
 }
@@ -482106,37 +482377,72 @@ function buildScopedMcpConfigs(mcpServers) {
   }
   return scoped;
 }
-async function connectMcpServers() {
-  const mcpConfigs = buildScopedMcpConfigs(config5.session.mcpServers);
+async function connectMcpServers(mcpServers) {
+  const mcpConfigs = buildScopedMcpConfigs(mcpServers);
   if (!mcpConfigs)
-    return [];
-  try {
-    const { prefetchAllMcpResources: prefetchAllMcpResources2 } = await Promise.resolve().then(() => (init_client5(), exports_client));
-    const { clients } = await prefetchAllMcpResources2(mcpConfigs);
-    return clients;
-  } catch (err2) {
-    process.stderr.write(`MCP connection failed: ${err2 instanceof Error ? err2.message : String(err2)}
-`);
-    return [];
-  }
+    return { clients: [], mcpTools: [] };
+  const { prefetchAllMcpResources: prefetchAllMcpResources2 } = await Promise.resolve().then(() => (init_client5(), exports_client));
+  const { clients, tools: mcpTools } = await prefetchAllMcpResources2(mcpConfigs);
+  return { clients, mcpTools };
 }
 async function start() {
+  process.stderr.write(`[Worker ${sessionKey}] Starting worker
+`);
   if (config5.env) {
     Object.assign(process.env, config5.env);
   }
   const { enableConfigs: enableConfigs2 } = await Promise.resolve().then(() => (init_config(), exports_config));
   enableConfigs2();
+  let initialMessages;
+  if (config5.resume) {
+    const { switchSession: switchSession2 } = await Promise.resolve().then(() => (init_state(), exports_state));
+    const { getLastSessionLog: getLastSessionLog2 } = await Promise.resolve().then(() => (init_sessionStorage(), exports_sessionStorage));
+    switchSession2(config5.resume);
+    process.stderr.write(`[Worker ${sessionKey}] Resuming session: ${config5.resume}
+`);
+    try {
+      const log2 = await getLastSessionLog2(config5.resume);
+      initialMessages = log2?.messages ?? undefined;
+      if (initialMessages) {
+        process.stderr.write(`[Worker ${sessionKey}] Loaded ${initialMessages.length} history messages
+`);
+      }
+    } catch (err2) {
+      process.stderr.write(`[Worker ${sessionKey}] Failed to load session history: ${err2 instanceof Error ? err2.message : String(err2)}
+`);
+    }
+  }
+  if (process.platform === "win32") {
+    const { setShellIfWindows: setShellIfWindows2 } = await Promise.resolve().then(() => (init_windowsPaths(), exports_windowsPaths));
+    setShellIfWindows2();
+    process.stderr.write(`[Worker ${sessionKey}] Shell: ${process.env.SHELL ?? "not found"}
+`);
+  }
   if (config5.session.additionalDirectories?.length) {
     const { setAdditionalDirectoriesForClaudeMd: setAdditionalDirectoriesForClaudeMd2 } = await Promise.resolve().then(() => (init_state(), exports_state));
     setAdditionalDirectoriesForClaudeMd2(config5.session.additionalDirectories);
   }
-  const mcpClients = await connectMcpServers();
+  let mcpClients = [];
+  try {
+    const result = await connectMcpServers(config5.session.mcpServers);
+    mcpClients = result.clients;
+  } catch (err2) {
+    process.stderr.write(`[Worker ${sessionKey}] Initial MCP connection failed, continuing without MCP: ${err2 instanceof Error ? err2.message : String(err2)}
+`);
+  }
+  const sessionExtraOptions = {};
+  if (mcpClients.length > 0)
+    sessionExtraOptions.mcpClients = mcpClients;
+  if (initialMessages)
+    sessionExtraOptions.initialMessages = initialMessages;
   session2 = new Session(config5.session, {
     mode: config5.permission.mode,
     allowedTools: config5.permission.allowed_tools,
     deniedTools: config5.permission.denied_tools,
-    onPermissionRequest: async (request) => {
+    onPermissionRequest: savedPermissionCallback = async (request) => {
       const requestId = crypto.randomUUID();
+      process.stderr.write(`[Worker ${sessionKey}] Permission request: ${request.toolName}
+`);
       send({
         type: "permission_request",
         session_key: sessionKey,
@@ -482149,44 +482455,79 @@ async function start() {
       return await new Promise((resolve43, reject2) => {
         const timer = setTimeout(() => {
           pendingPermissions.delete(requestId);
+          process.stderr.write(`[Worker ${sessionKey}] Permission request timed out: ${requestId}
+`);
           reject2(new Error("Permission request timed out"));
         }, PERMISSION_TIMEOUT_MS);
         pendingPermissions.set(requestId, { resolve: resolve43, reject: reject2, timer });
       });
     }
-  }, mcpClients.length > 0 ? { mcpClients } : undefined);
+  }, sessionExtraOptions);
+  logState("session ready");
+  const { getSessionId: getSessionId3 } = await Promise.resolve().then(() => (init_state(), exports_state));
+  process.stderr.write(`[Worker ${sessionKey}] Session ready, sessionId: ${session2.sessionId}, stateSessionId: ${getSessionId3()}
+`);
   send({
     type: "ready",
     session_key: sessionKey,
-    session_id: session2.sessionId
+    session_id: session2.sessionId,
+    state_session_id: getSessionId3()
   });
   parentPort.on("message", (msg) => {
     switch (msg.type) {
-      case "prompt":
-        handlePrompt(msg.text);
-        break;
       case "interrupt":
+        process.stderr.write(`[Worker ${sessionKey}] Session interrupted
+`);
         session2.abort();
         break;
-      case "destroy":
-        session2.destroy();
-        break;
       case "permission_response":
         handlePermissionResponse(msg.request_id, msg.result);
         break;
+      default:
+        if (processingMessage) {
+          messageQueue.push(msg);
+        } else {
+          dequeueAndProcess(msg);
+        }
+        break;
     }
   });
 }
+async function dequeueAndProcess(msg) {
+  processingMessage = true;
+  try {
+    switch (msg.type) {
+      case "prompt":
+        await handlePrompt(msg.text);
+        break;
+      case "update":
+        await handleUpdate(msg.config);
+        break;
+      case "destroy":
+        await handleDestroy();
+        break;
+    }
+  } finally {
+    processingMessage = false;
+    const next = messageQueue.shift();
+    if (next) {
+      dequeueAndProcess(next);
+    }
+  }
+}
 async function handlePrompt(text2) {
-  if (running) {
+  const state = session2.getState().state;
+  if (state !== "idle") {
+    process.stderr.write(`[Worker ${sessionKey}] Prompt rejected: session state is ${state}
+`);
     send({
       type: "error",
       session_key: sessionKey,
-      error: "Session is already running a prompt"
+      error: `Session is busy (state: ${state})`
     });
     return;
   }
-  running = true;
+  logState(`prompt(${text2.slice(0, 50)})`);
   try {
     for await (const sdkMsg of session2.prompt(text2)) {
       send({
@@ -482200,16 +482541,113 @@ async function handlePrompt(text2) {
       session_key: sessionKey,
       session_id: session2.sessionId
     });
+    process.stderr.write(`[Worker ${sessionKey}] Prompt completed successfully
+`);
   } catch (err2) {
+    const errorMsg = err2 instanceof Error ? err2.message : String(err2);
+    process.stderr.write(`[Worker ${sessionKey}] Prompt failed: ${errorMsg}
+`);
     send({
       type: "error",
       session_key: sessionKey,
-      error: err2 instanceof Error ? err2.message : String(err2)
+      error: errorMsg
     });
   } finally {
-    running = false;
+    logState("prompt done");
   }
 }
+async function handleUpdate(updateConfig2) {
+  const state = session2.getState().state;
+  if (state !== "idle") {
+    send({
+      type: "error",
+      session_key: sessionKey,
+      error: `Cannot update: session state is ${state}`
+    });
+    return;
+  }
+  logState("session.update starting");
+  const changes = [];
+  try {
+    if (updateConfig2.env) {
+      Object.assign(process.env, updateConfig2.env);
+      changes.push("env");
+    }
+    const batchUpdate = {};
+    if (updateConfig2.mcp_servers !== undefined) {
+      const { clients, mcpTools } = await connectMcpServers(updateConfig2.mcp_servers);
+      batchUpdate.mcpClients = clients;
+      batchUpdate.mcpTools = mcpTools;
+      changes.push(`mcpServers: ${clients.length} clients`);
+    }
+    if (updateConfig2.additional_directories) {
+      const { setAdditionalDirectoriesForClaudeMd: setAdditionalDirectoriesForClaudeMd2 } = await Promise.resolve().then(() => (init_state(), exports_state));
+      setAdditionalDirectoriesForClaudeMd2(updateConfig2.additional_directories);
+      batchUpdate.additionalDirectories = updateConfig2.additional_directories;
+      changes.push(`additionalDirectories: ${updateConfig2.additional_directories.length} dirs`);
+    }
+    if (updateConfig2.system_prompt !== undefined) {
+      batchUpdate.systemPrompt = updateConfig2.system_prompt;
+      changes.push("systemPrompt");
+    }
+    if (updateConfig2.append_system_prompt !== undefined) {
+      batchUpdate.appendSystemPrompt = updateConfig2.append_system_prompt;
+      changes.push("appendSystemPrompt");
+    }
+    if (updateConfig2.model) {
+      batchUpdate.model = updateConfig2.model;
+      changes.push(`model: ${updateConfig2.model}`);
+    }
+    if (updateConfig2.max_turns !== undefined) {
+      batchUpdate.maxTurns = updateConfig2.max_turns;
+      changes.push(`maxTurns: ${updateConfig2.max_turns}`);
+    }
+    if (updateConfig2.thinking) {
+      batchUpdate.thinking = updateConfig2.thinking;
+      changes.push("thinking");
+    }
+    if (updateConfig2.permission_mode !== undefined || updateConfig2.allowed_tools !== undefined) {
+      batchUpdate.permissionHandler = {
+        mode: updateConfig2.permission_mode,
+        allowedTools: updateConfig2.allowed_tools,
+        deniedTools: updateConfig2.denied_tools,
+        onPermissionRequest: savedPermissionCallback
+      };
+      changes.push("permission");
+    }
+    if (Object.keys(batchUpdate).length > 0) {
+      await session2.update(batchUpdate);
+    }
+    process.stderr.write(`[Worker ${sessionKey}] Session updated: ${changes.join(", ")}
+`);
+    send({ type: "updated", session_key: sessionKey });
+  } catch (err2) {
+    const errorMsg = err2 instanceof Error ? err2.message : String(err2);
+    process.stderr.write(`[Worker ${sessionKey}] Update failed: ${errorMsg}
+`);
+    send({ type: "error", session_key: sessionKey, error: errorMsg });
+  } finally {
+    logState("update done");
+  }
+}
+async function handleDestroy() {
+  const state = session2.getState().state;
+  if (state === "destroyed")
+    return;
+  logState("destroy");
+  process.stderr.write(`[Worker ${sessionKey}] Destroying session
+`);
+  try {
+    await session2.destroy();
+    logState("cleanup done");
+  } catch (err2) {
+    const errorMsg = err2 instanceof Error ? err2.message : String(err2);
+    process.stderr.write(`[Worker ${sessionKey}] Destroy error (forcing exit): ${errorMsg}
+`);
+    logState("destroy error");
+  }
+  process.exit(0);
+}
 function handlePermissionResponse(requestId, result) {
   const pending = pendingPermissions.get(requestId);
   if (pending) {
@@ -482226,16 +482664,24 @@ start().catch((err2) => {
   });
 });
 process.on("uncaughtException", (err2) => {
+  const errorDetails = err2 instanceof Error ? err2.stack || err2.message : String(err2);
+  process.stderr.write(`[Worker ${sessionKey}] Uncaught exception: ${errorDetails}
+`);
   send({
     type: "error",
     session_key: sessionKey,
-    error: `Uncaught exception: ${err2 instanceof Error ? err2.stack || err2.message : String(err2)}`
+    error: `Uncaught exception: ${errorDetails}`
   });
+  setTimeout(() => process.exit(1), 100);
 });
 process.on("unhandledRejection", (reason) => {
+  const reasonDetails = reason instanceof Error ? reason.stack || reason.message : String(reason);
+  process.stderr.write(`[Worker ${sessionKey}] Unhandled rejection: ${reasonDetails}
+`);
   send({
     type: "error",
     session_key: sessionKey,
-    error: `Unhandled rejection: ${reason instanceof Error ? reason.stack || reason.message : String(reason)}`
+    error: `Unhandled rejection: ${reasonDetails}`
   });
+  setTimeout(() => process.exit(1), 100);
 });