orkestrator 2.31.0-beta → 2.32.0-beta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orkestrator",
-  "version": "2.31.0-beta",
+  "version": "2.32.0-beta",
   "description": "Run the Orkestrator backend service without the desktop application",
   "homepage": "https://orkestrator.dev",
   "repository": {
@@ -39,8 +39,8 @@
     "sharp": "0.35.5"
   },
   "devDependencies": {
-    "@orkestrator/protocol": "2.31.0-beta",
-    "@orkestrator/toolchain": "2.31.0-beta"
+    "@orkestrator/protocol": "2.32.0-beta",
+    "@orkestrator/toolchain": "2.32.0-beta"
   },
   "engines": {
     "bun": ">=1.4.4"

package/resources/claude-bridge/dist/index.js

@@ -2529,6 +2529,10 @@ function claudeHome() {
 function claudeJsonPath() {
   return join(claudeHome(), ".claude.json");
 }
+function claudeUserSettingsPath() {
+  const configDir = overrideHome === null ? process.env.CLAUDE_CONFIG_DIR?.trim() : undefined;
+  return join(configDir || join(claudeHome(), ".claude"), "settings.json");
+}
 function claudePluginsDir() {
   return join(claudeHome(), ".claude", "plugins");
 }
@@ -2556,7 +2560,8 @@ function parseTurnInFlightMark(value) {
   return {
     bridgeInstanceId: record.bridgeInstanceId,
     pid: record.pid,
-    startedAt: record.startedAt
+    startedAt: record.startedAt,
+    ...typeof record.requestId === "string" && record.requestId.length > 0 && record.requestId.length <= 200 ? { requestId: record.requestId } : {}
   };
 }
 var MAX_SHELL_TASK_DETAILS = 256;
@@ -3799,7 +3804,7 @@ function remapInstalledPlugins(pluginsDir, installedPlugins, onUnsafe) {
   const pluginsRoot = path.resolve(pluginsDir);
   if (!isRecord(installedPlugins.plugins))
     return plugins;
-  for (const entries of Object.values(installedPlugins.plugins)) {
+  for (const [installedId, entries] of Object.entries(installedPlugins.plugins)) {
     if (!Array.isArray(entries))
       continue;
     for (const entry of entries) {
@@ -3819,7 +3824,7 @@ function remapInstalledPlugins(pluginsDir, installedPlugins, onUnsafe) {
       } else {
         resolvedPath = installPath;
       }
-      plugins.push({ type: "local", path: resolvedPath });
+      plugins.push({ type: "local", path: resolvedPath, installedId });
     }
   }
   return plugins;
@@ -3851,6 +3856,26 @@ function mergeClaudePluginLayers(layers, options) {
   return paths;
 }
 var INVALID_PLUGIN_NAME = new RegExp("[@:\\s/\\\\\\u0000-\\u001f\\u007f\\u200b-\\u200f\\u2028-\\u202e\\u2060-\\u2064\\ufeff]");
+var CLAUDE_PLUGIN_SETTING_SOURCES = ["local", "project", "user"];
+function claudeInstalledPluginIdEnablement(id, settings, loadedSources) {
+  const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+  for (const source of ["local", "project", "user"]) {
+    if (!loadedSources.includes(source))
+      continue;
+    const document = settings[source];
+    const enabledPlugins = isRecord(document) ? document.enabledPlugins : undefined;
+    if (!isRecord(enabledPlugins) || !Object.hasOwn(enabledPlugins, id))
+      continue;
+    return { enabled: enabledPlugins[id] === true, decidedBy: { source, key: id } };
+  }
+  return { enabled: false };
+}
+function enabledInstalledPlugins(plugins, settings, loadedSources) {
+  return plugins.filter((plugin) => plugin.installedId === undefined || claudeInstalledPluginIdEnablement(plugin.installedId, settings, loadedSources).enabled);
+}
+function claudePluginSettingSources(settingSources) {
+  return CLAUDE_PLUGIN_SETTING_SOURCES.filter((source) => settingSources.includes(source));
+}
 
 // ../../bridges/claude-bridge/src/services/json-file-cache.ts
 import { createHash as createHash4 } from "node:crypto";
@@ -3994,6 +4019,23 @@ async function loadCliInstalledPlugins() {
   }
   return remapInstalledPlugins2(pluginsDir, { plugins });
 }
+function pluginSettingsPath(source, cwd) {
+  switch (source) {
+    case "user":
+      return claudeUserSettingsPath();
+    case "project":
+      return join3(cwd, ".claude", "settings.json");
+    case "local":
+      return join3(cwd, ".claude", "settings.local.json");
+  }
+}
+async function loadPluginSettings(cwd, sources) {
+  const entries = await Promise.all(sources.map(async (source) => {
+    const enabledPlugins = await readJsonSliceCached(pluginSettingsPath(source, cwd), "enabledPlugins", (config) => config?.enabledPlugins ?? null);
+    return [source, enabledPlugins === null ? undefined : { enabledPlugins }];
+  }));
+  return Object.fromEntries(entries);
+}
 function remapInstalledPlugins2(pluginsDir, installedPlugins) {
   return remapInstalledPlugins(pluginsDir, installedPlugins, (installPath) => console.warn(`[plugin-config] Skipping plugin with unsafe install path: "${installPath}"`));
 }
@@ -4016,17 +4058,27 @@ async function readPluginManifest(pluginPath) {
 function resolvePath(pluginPath, cwd) {
   return resolveClaudePluginPath(pluginPath, cwd, claudeHome());
 }
-async function getMergedPlugins(cwd, includeProjectSources = true) {
-  const [global2, cliInstalled, projectGlobal, projectLocal] = await Promise.all([
+function defaultSettingSources(includeProjectSources) {
+  return includeProjectSources ? ["user", "project"] : ["user"];
+}
+async function getMergedPlugins(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
+  const sources = claudePluginSettingSources(settingSources);
+  const [global2, cliInstalled, projectGlobal, projectLocal, settings] = await Promise.all([
     loadGlobalPlugins(),
     loadCliInstalledPlugins(),
     includeProjectSources ? loadProjectOverridesFromGlobal(cwd) : [],
-    includeProjectSources ? loadProjectPlugins(cwd) : []
+    includeProjectSources ? loadProjectPlugins(cwd) : [],
+    loadPluginSettings(cwd, sources)
   ]);
-  return mergeClaudePluginLayers({ global: global2, cliInstalled, projectGlobal, projectLocal }, { cwd, home: claudeHome(), includeProjectSources }).map((path) => ({ type: "local", path }));
-}
-async function getPluginsForSdk(cwd, includeProjectSources = true) {
-  const configs = await getMergedPlugins(cwd, includeProjectSources);
+  return mergeClaudePluginLayers({
+    global: global2,
+    cliInstalled: enabledInstalledPlugins(cliInstalled, settings, sources),
+    projectGlobal,
+    projectLocal
+  }, { cwd, home: claudeHome(), includeProjectSources }).map((path) => ({ type: "local", path }));
+}
+async function getPluginsForSdk(cwd, includeProjectSources = true, settingSources = defaultSettingSources(includeProjectSources)) {
+  const configs = await getMergedPlugins(cwd, includeProjectSources, settingSources);
   const validPlugins = [];
   for (const config of configs) {
     if (await pathExists(config.path)) {
@@ -4737,7 +4789,7 @@ function claudeReadOnlyAllowedTools(options) {
 }
 function claudeReadOnlySandbox(policy, options = {}) {
   return {
-    enabled: true,
+    enabled: options.commandSandbox !== "unavailable",
     failIfUnavailable: options.commandSandbox !== "unavailable",
     autoAllowBashIfSandboxed: true,
     allowUnsandboxedCommands: false,
@@ -4985,7 +5037,7 @@ async function resolveClaudeDiscoveryConfig(sessionPolicy, inputs) {
   const policy = claudeTurnPolicy(sessionPolicy, inputs.readOnly);
   const cwd = claudeWorkspaceCwd();
   const settingSources = claudeSettingSources(policy, inputs.includeLocalSettings);
-  const plugins = await getPluginsForSdk(cwd, policy?.projectResources !== false);
+  const plugins = await getPluginsForSdk(cwd, policy?.projectResources !== false, settingSources);
   return {
     cwd,
     settingSources,
@@ -6874,21 +6926,31 @@ function turnInFlight(session) {
 function syncTurnInFlightMark(session, options = {}) {
   if (session.deleting)
     return;
+  if (options.started)
+    session.turnInFlightRequestId = options.requestId;
   writeTurnInFlightMark(session, options.stopped !== true && turnInFlight(session), options.started);
 }
 function clearTurnInFlightMarkForClose(session) {
   writeTurnInFlightMark(session, false);
 }
 function writeTurnInFlightMark(session, wanted, claim = false) {
-  if (wanted === (session.turnInFlightMarked === true) && !(wanted && claim && !session.turnInFlightMarkOwned))
+  const renamed = claim && session.turnInFlightMarkOwned === true && session.turnInFlightMarkRequestId !== session.turnInFlightRequestId;
+  if (wanted === (session.turnInFlightMarked === true) && !(wanted && claim && (!session.turnInFlightMarkOwned || renamed)))
     return;
   const sdkSessionId = session.sdkSessionId ?? sdkSessionIdFromBridgeId(session.id);
   if (!sdkSessionId)
     return;
   session.turnInFlightMarked = wanted;
   session.turnInFlightMarkOwned = wanted;
+  const requestId = wanted ? session.turnInFlightRequestId : undefined;
+  session.turnInFlightMarkRequestId = requestId;
   const update = {
-    turnInFlight: wanted ? { bridgeInstanceId: BRIDGE_INSTANCE_ID, pid: process.pid, startedAt: Date.now() } : undefined
+    turnInFlight: wanted ? {
+      bridgeInstanceId: BRIDGE_INSTANCE_ID,
+      pid: process.pid,
+      startedAt: Date.now(),
+      ...requestId ? { requestId } : {}
+    } : undefined
   };
   updateSessionPreferences(sdkSessionId, update).catch((error) => {
     debugLog("[session-manager] Failed to record the turn-in-flight mark:", error instanceof Error ? error.message : String(error));
@@ -6907,6 +6969,7 @@ function restoredTurnInterruption(preferences) {
     status: "error",
     error: CLAUDE_RESTARTED_MID_TURN_MESSAGE,
     interruption: "restart",
+    ...mark.requestId ? { interruptedRequestId: mark.requestId } : {},
     turnInFlightMarked: true
   };
 }
@@ -7481,6 +7544,13 @@ function claudeLaunchedProfile(session, options) {
     settingSources: JSON.stringify(claudeSettingSources(claudeTurnPolicy(session.executionPolicy, options?.readOnly), options?.includeLocalSettings))
   };
 }
+function claudeTurnSettingSources(session, options) {
+  const policy = claudeTurnPolicy(session.executionPolicy, options?.readOnly);
+  const running = openClaudeRuntime(session);
+  if (options?.includeLocalSettings === undefined && running?.launch.settingSources !== undefined && !claudeLaunchConflict(running.launch, claudeLaunchProfile(session, options)))
+    return JSON.parse(running.launch.settingSources);
+  return claudeSettingSources(policy, options?.includeLocalSettings);
+}
 function assertClaudeRuntimeStaticAccepts(session, options) {
   const runtime = openClaudeRuntime(session);
   if (!runtime || !claudeRuntimeOwesWork(runtime))
@@ -7502,7 +7572,7 @@ async function assertClaudeRuntimeAccepts(session, options, resources) {
   if (!resources) {
     const policy = claudeTurnPolicy(session.executionPolicy, options?.readOnly);
     const [plugins, environment] = await Promise.all([
-      getPluginsForSdk(request.cwd, policy?.projectResources !== false),
+      getPluginsForSdk(request.cwd, policy?.projectResources !== false, claudeTurnSettingSources(session, options)),
       runtimeEnvironmentForAgentQuery()
     ]);
     resources = claudeLaunchResourceProfile(plugins, environment);
@@ -11791,6 +11861,7 @@ function captureTurnStartup(session) {
     abortController: session.abortController,
     error: session.error,
     interruption: session.interruption,
+    interruptedRequestId: session.interruptedRequestId,
     lastActivity: session.lastActivity,
     persistedMessagesLoaded: session.persistedMessagesLoaded,
     structuredOutput: session.structuredOutput,
@@ -11963,6 +12034,7 @@ async function applyPromptPlanMode(admission, planMode) {
       session.turnStartedAt = beforeStartup.turnStartedAt;
       session.error = beforeStartup.error;
       session.interruption = beforeStartup.interruption;
+      session.interruptedRequestId = beforeStartup.interruptedRequestId;
       session.lastActivity = beforeStartup.lastActivity;
       session.persistedMessagesLoaded = beforeStartup.persistedMessagesLoaded;
       if (needsTranscriptHydration)
@@ -11983,6 +12055,7 @@ function beginPromptActivity(admission) {
   const { session, sessionId } = admission;
   session.error = undefined;
   session.interruption = undefined;
+  session.interruptedRequestId = undefined;
   session.lastActivity = new Date;
   if (session.promptSuggestion !== undefined) {
     session.promptSuggestion = undefined;
@@ -14074,6 +14147,132 @@ function backgroundCommandInstruction(env) {
 // ../../bridges/claude-bridge/src/services/claude-execution-sandbox.ts
 import { realpathSync } from "node:fs";
 
+// ../protocol/src/node/claude-linux-sandbox.ts
+import { spawnSync } from "node:child_process";
+import { accessSync, constants as constants2, existsSync as existsSync2, readFileSync as readFileSync3 } from "node:fs";
+import { delimiter as delimiter2, join as join11 } from "node:path";
+var CLAUDE_LINUX_SANDBOX_PROGRAMS = Object.freeze(["bwrap", "socat"]);
+var APPARMOR_BWRAP_PROFILE = "/etc/apparmor.d/bwrap-userns-restrict";
+var CLAUDE_LINUX_SANDBOX_PROBE_TIMEOUT_MS = 5000;
+var CLAUDE_LINUX_SANDBOX_PROBE_TTL_MS = 5 * 60000;
+var BWRAP_ARGS = Object.freeze([
+  "--new-session",
+  "--die-with-parent",
+  "--unshare-user",
+  "--unshare-pid",
+  "--ro-bind",
+  "/",
+  "/",
+  "--dev",
+  "/dev",
+  "--proc",
+  "/proc",
+  "--"
+]);
+var NESTED_ARGS = Object.freeze([
+  "unshare",
+  "--user",
+  "--map-root-user",
+  "--pid",
+  "--mount",
+  "--fork",
+  "--mount-proc",
+  "true"
+]);
+function executableOnPath(name, path = process.env.PATH) {
+  for (const directory of (path ?? "").split(delimiter2)) {
+    if (!directory)
+      continue;
+    try {
+      accessSync(join11(directory, name), constants2.X_OK);
+      return true;
+    } catch {}
+  }
+  return false;
+}
+function runProbeCommand(command, args) {
+  const result = spawnSync(command, [...args], {
+    timeout: CLAUDE_LINUX_SANDBOX_PROBE_TIMEOUT_MS,
+    killSignal: "SIGKILL",
+    stdio: ["ignore", "ignore", "pipe"],
+    encoding: "utf8",
+    maxBuffer: 64 * 1024
+  });
+  if (result.error)
+    return { ok: false, stderr: result.error.message };
+  return { ok: result.status === 0, stderr: result.stderr ?? "" };
+}
+function appArmorBwrapProfileInstalled() {
+  try {
+    const enabled = readFileSync3("/sys/module/apparmor/parameters/enabled", "utf8");
+    return enabled.trim().startsWith("Y") && existsSync2(APPARMOR_BWRAP_PROFILE);
+  } catch {
+    return false;
+  }
+}
+function probeDetail(stderr) {
+  const line = stderr.split(`
+`).map((entry) => entry.trim()).find(Boolean) ?? "no error output";
+  return line.length > 200 ? `${line.slice(0, 199)}…` : line;
+}
+var UNAVAILABLE = "Claude's command sandbox cannot run commands on this host";
+function probeClaudeLinuxSandbox(dependencies = {}) {
+  const onPath = dependencies.onPath ?? ((name) => executableOnPath(name));
+  const run = dependencies.run ?? runProbeCommand;
+  const appArmorBwrapProfile = dependencies.appArmorBwrapProfile ?? appArmorBwrapProfileInstalled;
+  const missing = CLAUDE_LINUX_SANDBOX_PROGRAMS.filter((name) => !onPath(name));
+  if (missing.length > 0) {
+    return {
+      available: false,
+      failure: "missing-programs",
+      reason: `${UNAVAILABLE}: the Claude CLI's Linux sandbox needs bubblewrap and socat on PATH, and ${missing.join(" and ")} ${missing.length === 1 ? "is" : "are"} missing. Install the bubblewrap and socat packages.`
+    };
+  }
+  if (!onPath("unshare")) {
+    return {
+      available: false,
+      failure: "probe-unavailable",
+      reason: `${UNAVAILABLE}: whether a user namespace can be nested inside bubblewrap's, which the Claude CLI needs, could not be checked because unshare (util-linux) is not on PATH.`
+    };
+  }
+  const nested = run("bwrap", [...BWRAP_ARGS, ...NESTED_ARGS]);
+  if (nested.ok)
+    return { available: true };
+  const outer = run("bwrap", [...BWRAP_ARGS, "true"]);
+  if (!outer.ok) {
+    return {
+      available: false,
+      failure: "user-namespace",
+      reason: `${UNAVAILABLE}: bubblewrap cannot create a user namespace (${probeDetail(outer.stderr)}). Unprivileged user namespaces are turned off or restricted here, for example by kernel.unprivileged_userns_clone, AppArmor's kernel.apparmor_restrict_unprivileged_userns, or a container's seccomp profile.`
+    };
+  }
+  const detail = probeDetail(nested.stderr);
+  if (appArmorBwrapProfile()) {
+    return {
+      available: false,
+      failure: "nested-user-namespace",
+      reason: `${UNAVAILABLE}: bubblewrap starts, but AppArmor's bwrap-userns-restrict profile strips capabilities from the user namespace the Claude CLI nests inside it, so every sandboxed command would fail (${detail}). Allow nested namespaces for bubblewrap with a local AppArmor profile, or remove bwrap-userns-restrict on a dedicated host; Orkestrator does not change AppArmor policy itself.`
+    };
+  }
+  return {
+    available: false,
+    failure: "nested-user-namespace",
+    reason: `${UNAVAILABLE}: bubblewrap starts, but a user namespace nested inside it is refused (${detail}), and the Claude CLI's command helper needs one, so every sandboxed command would fail. In a container this is usually the container's seccomp profile or missing capabilities.`
+  };
+}
+var cached;
+var pinned;
+function claudeLinuxSandboxStatus(now = Date.now()) {
+  if (pinned)
+    return pinned;
+  if (cached && now - cached.at >= 0 && now - cached.at < CLAUDE_LINUX_SANDBOX_PROBE_TTL_MS) {
+    return cached.status;
+  }
+  const status = probeClaudeLinuxSandbox();
+  cached = { status, at: now };
+  return status;
+}
+
 // ../protocol/src/coordinator.ts
 var COORDINATOR_COMMAND_SANDBOX_ENV = "ORKESTRATOR_COORDINATOR_COMMAND_SANDBOX";
 function coordinatorCommandSandboxFromEnv(env) {
@@ -14168,6 +14367,16 @@ function claudeExecutionSandbox(policy, asksForApproval, readOnly = {}) {
     }
   };
 }
+function claudeSandboxRefusal(policy, options = {}) {
+  if ((options.platform ?? process.platform) !== "linux" || !policy)
+    return;
+  const launcher = "commandSandbox" in options ? options.commandSandbox : process.env[COORDINATOR_COMMAND_SANDBOX_ENV];
+  const required = isCoordinatorReadOnlyPolicy(policy) ? launcher !== undefined && launcher !== "unavailable" : policy.sandbox === "provider";
+  if (!required)
+    return;
+  const status = (options.linuxSandbox ?? claudeLinuxSandboxStatus)();
+  return status.available ? undefined : status.reason;
+}
 
 // ../protocol/src/agent-interaction-deadline.ts
 var SYSTEM_CLOCK = {
@@ -14929,14 +15138,19 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   const effortLevel = options?.effort ?? "high";
   const cwd = claudeWorkspaceCwd();
   const policy = claudeTurnPolicy(session.executionPolicy, options?.readOnly);
+  const sandboxRefusal = claudeSandboxRefusal(policy);
+  if (sandboxRefusal)
+    throw sessionOperationError("invalid", sandboxRefusal);
   session.commandDiscoveryInputs = {
     readOnly: options?.readOnly === true,
     includeLocalSettings: options?.includeLocalSettings === true
   };
   const includeProjectResources = policy?.projectResources !== false;
+  const settingSources = claudeTurnSettingSources(session, options);
+  session.commandDiscoveryInputs.includeLocalSettings = settingSources.includes("local");
   const [{ servers: mcpServers, names: mcpServerNames, revision: mcpConfigRevision }, plugins] = await Promise.all([
     getMcpRuntimeConfig(cwd, process.env, options?.agentMcp, mcpSourceScopeForPolicy(policy)),
-    getPluginsForSdk(cwd, includeProjectResources)
+    getPluginsForSdk(cwd, includeProjectResources, settingSources)
   ]);
   turn.mcpServerNames = mcpServerNames;
   const mcpServerCount = Object.keys(mcpServers).length;
@@ -15001,6 +15215,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   });
   const mcpServersKey = createHash10("sha256").update(JSON.stringify(mcpServers)).digest("hex");
   return {
+    settingSources,
     cwd,
     policy,
     effortLevel,
@@ -15111,7 +15326,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
 
 `)
     },
-    settingSources: claudeSettingSources(policy, options?.includeLocalSettings),
+    settingSources: plan.settingSources,
     ...(fastMode || ultracode) && {
       settings: {
         ...fastMode && { fastMode: true },
@@ -16639,6 +16854,7 @@ function endClaudeRuntime(runtime, failure) {
     session.status = "error";
     session.error = claudeProcessKilledMessage(killedBy);
     session.interruption = "restart";
+    session.interruptedRequestId = session.turnInFlightRequestId;
     session.turnStartedAt = undefined;
     session.abortController = undefined;
     session.completionBlockedByBackgroundTasks = false;
@@ -16697,7 +16913,10 @@ async function prepareJoin(turn, plan, running) {
   const { session, options } = turn;
   const { mcpServers, plugins, sdkPrompt, queryEnvironment, liveSettings, mcpServersKey } = plan;
   const required = mcpServers[AGENT_MCP_SERVER_NAME] ? [AGENT_MCP_SERVER_NAME, ...options?.agentMcp?.design ? ["orkestrator-design"] : []] : [];
-  await assertClaudeRuntimeAccepts(session, options, claudeLaunchResourceProfile(plugins, queryEnvironment));
+  await assertClaudeRuntimeAccepts(session, options, {
+    ...claudeLaunchResourceProfile(plugins, queryEnvironment),
+    settingSources: JSON.stringify(plan.settingSources)
+  });
   session.queryControl = running.control;
   turn.queryIteratorControl = running.control;
   try {
@@ -16755,6 +16974,7 @@ function launchClaudeRuntime(turn, plan) {
     activeTaskIds: stream.activeTaskIds,
     launch: {
       ...claudeLaunchedProfile(session, options),
+      settingSources: JSON.stringify(plan.settingSources),
       ...claudeLaunchResourceProfile(plugins, queryEnvironment)
     },
     mcpServers: mcpServersKey,
@@ -16791,7 +17011,7 @@ function markQueryStarted(turn, testHooks) {
   }, { once: true });
   session.finishTurnInputIfSettled = turn.finishTurnInputForThisTurn;
   turn.queryStarted = true;
-  syncTurnInFlightMark(session, { started: true });
+  syncTurnInFlightMark(session, { started: true, requestId: turn.dispatchRequestId });
   testHooks?.onQueryStarted?.();
   readLiveCommandInventory(session, control);
   reportUltracodeRuntime(session, control);
@@ -16805,6 +17025,7 @@ function joinableRuntime(turn, plan) {
     return running;
   const requested = {
     ...claudeLaunchProfile(turn.session, turn.options),
+    settingSources: JSON.stringify(plan.settingSources),
     ...claudeLaunchResourceProfile(plan.plugins, plan.queryEnvironment)
   };
   return claudeLaunchConflict(running.launch, requested) ? undefined : running;
@@ -16938,6 +17159,7 @@ function settleFailedTurn(turn, error) {
     session.abortController = turn.beforeStartup.abortController;
     session.error = turn.beforeStartup.error;
     session.interruption = turn.beforeStartup.interruption;
+    session.interruptedRequestId = turn.beforeStartup.interruptedRequestId;
     session.inProgressUsage = turn.beforeStartup.inProgressUsage;
     session.inProgressUsageGeneration = turn.beforeStartup.inProgressUsageGeneration;
     const index = session.messages.indexOf(userMessage);
@@ -16966,6 +17188,7 @@ function settleFailedTurn(turn, error) {
     session.turnStartedAt = undefined;
     session.error = failure;
     session.interruption = killedBy ? "restart" : undefined;
+    session.interruptedRequestId = killedBy ? turn.dispatchRequestId : undefined;
     session.abortController = undefined;
     session.completionBlockedByBackgroundTasks = false;
     cleanupPendingInteractions(sessionId);
@@ -18168,9 +18391,14 @@ function compressTranscriptReads(app) {
 function query3(c) {
   return (name) => c.req.query(name);
 }
-function registerSessionTranscriptRoutes(app, generation) {
-  app.get("/:id/transcript", (c) => {
+function registerSessionTranscriptRoutes(app, generation, materialize) {
+  app.get("/:id/transcript", async (c) => {
     const id = c.req.param("id");
+    if (!peekSession(id)) {
+      const resolved = await materialize(id);
+      if (!resolved.ok)
+        return c.json(resolved.body, resolved.status);
+    }
     const read = claudeTranscriptSource(id, generation);
     if (!read)
       return c.json({ error: "Session not found" }, 404);
@@ -18337,7 +18565,10 @@ session.get("/:id", async (c) => {
     createdAt: sessionData.createdAt.toISOString(),
     lastActivity: sessionData.lastActivity.toISOString(),
     error: sessionData.error,
-    ...sessionData.status === "error" && sessionData.interruption ? { interruption: sessionData.interruption } : {},
+    ...sessionData.status === "error" && sessionData.interruption ? {
+      interruption: sessionData.interruption,
+      ...sessionData.interruptedRequestId ? { interruptedRequestId: sessionData.interruptedRequestId } : {}
+    } : {},
     structuredOutputRequestId: sessionData.structuredOutputRequestId,
     structuredOutput: sessionData.structuredOutput,
     contextUsage: sessionData.inProgressUsage ?? sessionData.usage,
@@ -18533,7 +18764,7 @@ session.get("/:id/messages", async (c) => {
   const limit = parseTranscriptTailLimit(c.req.query("limit") ?? null);
   return c.json(boundClaudeTranscriptResponse(messages, limit ?? undefined));
 });
-registerSessionTranscriptRoutes(session, TRANSCRIPT_GENERATION);
+registerSessionTranscriptRoutes(session, TRANSCRIPT_GENERATION, (id) => resolveSession(id, "Failed to load session transcript"));
 session.post("/:id/prompt", async (c) => {
   const id = c.req.param("id");
   const resolved = await resolveSession(id, "Failed to send prompt");
@@ -18639,6 +18870,10 @@ session.post("/:id/prompt", async (c) => {
       await answerIdleSteerPrompt(sessionData, prompt, requestId);
       return c.json({ status: "accepted", requestId, local: true });
     }
+    const sandboxRefusal = claudeSandboxRefusal(claudeTurnPolicy(sessionData.executionPolicy, typeof readOnly === "boolean" ? readOnly : undefined));
+    if (sandboxRefusal) {
+      return c.json({ error: sandboxRefusal, kind: "sandbox-unavailable" }, 422);
+    }
     await assertClaudeRuntimeAccepts(sessionData, {
       ...typeof readOnly === "boolean" ? { readOnly } : {},
       agent,
@@ -18891,14 +19126,14 @@ session.get("/:id/runtime-health", (c) => {
   return c.json(sessionRuntimeHealthBody(peekSession(c.req.param("id"))));
 });
 session.get("/:id/dispatch", async (c) => {
-  const answer = (dispatch) => c.json({ dispatch });
+  const answer = (dispatch, pending) => c.json({ dispatch, ...pending !== undefined ? { pending } : {} });
   const requestId = c.req.query("requestId")?.trim();
   if (!requestId)
     return answer("unknown");
   const id = c.req.param("id");
   const state = getPromptDispatchState(id, requestId);
   if (state === "processing" || state === "already-processed")
-    return answer("dispatched");
+    return answer("dispatched", state === "processing");
   if (state === "new") {
     return answer(restoredDispatchClaimLost(peekSession(id), requestId) ? "lost" : "unknown");
   }
@@ -19741,7 +19976,7 @@ var X_ALREADY_SENT = "x-hono-already-sent";
 
 // ../../node_modules/.bun/@hono+node-server@2.1.5+c539cad7f494f5c9/node_modules/@hono/node-server/dist/index.mjs
 import { STATUS_CODES, ServerResponse, createServer } from "node:http";
-import { Http2ServerRequest, constants as constants2 } from "node:http2";
+import { Http2ServerRequest, constants as constants3 } from "node:http2";
 import { Readable } from "node:stream";
 
 // ../../node_modules/.bun/hono@4.13.13/node_modules/hono/dist/helper/websocket/index.js
@@ -20660,7 +20895,7 @@ var drainIncoming = (incoming) => {
   incomingWithDrainState[incomingDraining] = true;
   if (incoming instanceof Http2ServerRequest) {
     try {
-      incoming.stream?.close?.(constants2.NGHTTP2_NO_ERROR);
+      incoming.stream?.close?.(constants3.NGHTTP2_NO_ERROR);
     } catch {}
     return;
   }