orkestrator 2.30.0-beta → 2.32.0-beta

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

@@ -1866,7 +1866,14 @@ var QUESTION_KEYS = new Set([
   "allowFreeText",
   "options"
 ]);
-var OPTION_KEYS = new Set(["id", "label", "providerValue", "description", "amendment"]);
+var OPTION_KEYS = new Set([
+  "id",
+  "label",
+  "providerValue",
+  "description",
+  "preview",
+  "amendment"
+]);
 var AMENDMENT_KEYS = new Set(["kind", "detail"]);
 var ANSWER_KEYS = new Set(["version", "interactionId", "sessionId", "answers"]);
 var QUESTION_ANSWER_KEYS = new Set(["questionId", "optionIds", "freeText"]);
@@ -2522,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");
 }
@@ -2549,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;
@@ -3764,7 +3776,106 @@ import { createHash as createHash5 } from "node:crypto";
 
 // ../../bridges/claude-bridge/src/services/plugin-config.ts
 import { readdir, access } from "node:fs/promises";
-import { join as join3, resolve, relative, isAbsolute } from "node:path";
+import { join as join3 } from "node:path";
+
+// ../protocol/src/node/claude-plugin-set.ts
+import path from "node:path";
+var CLAUDE_PLUGINS_MARKER = "/.claude/plugins/";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function claudePluginConfigList(value) {
+  if (!Array.isArray(value))
+    return [];
+  const plugins = [];
+  for (const item of value) {
+    if (isRecord(item) && typeof item.path === "string" && item.path) {
+      plugins.push({ type: "local", path: item.path });
+    }
+  }
+  return plugins;
+}
+function isPathWithin(parentDir, candidatePath) {
+  const relativePath = path.relative(parentDir, candidatePath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+}
+function remapInstalledPlugins(pluginsDir, installedPlugins, onUnsafe) {
+  const plugins = [];
+  const pluginsRoot = path.resolve(pluginsDir);
+  if (!isRecord(installedPlugins.plugins))
+    return plugins;
+  for (const [installedId, entries] of Object.entries(installedPlugins.plugins)) {
+    if (!Array.isArray(entries))
+      continue;
+    for (const entry of entries) {
+      if (!isRecord(entry) || typeof entry.installPath !== "string")
+        continue;
+      const installPath = entry.installPath;
+      const markerIdx = installPath.indexOf(CLAUDE_PLUGINS_MARKER);
+      let resolvedPath;
+      if (markerIdx !== -1) {
+        const relativePath = installPath.substring(markerIdx + CLAUDE_PLUGINS_MARKER.length);
+        const remappedPath = path.resolve(pluginsDir, relativePath);
+        if (!isPathWithin(pluginsRoot, remappedPath)) {
+          onUnsafe?.(installPath);
+          continue;
+        }
+        resolvedPath = remappedPath;
+      } else {
+        resolvedPath = installPath;
+      }
+      plugins.push({ type: "local", path: resolvedPath, installedId });
+    }
+  }
+  return plugins;
+}
+function resolveClaudePluginPath(pluginPath, cwd, home) {
+  if (pluginPath.startsWith("~"))
+    return path.join(home, pluginPath.slice(1));
+  if (pluginPath.startsWith("/"))
+    return pluginPath;
+  return path.join(cwd, pluginPath);
+}
+function mergeClaudePluginLayers(layers, options) {
+  const ordered = [
+    claudePluginConfigList(layers.global),
+    layers.cliInstalled,
+    ...options.includeProjectSources ? [claudePluginConfigList(layers.projectGlobal), claudePluginConfigList(layers.projectLocal)] : []
+  ];
+  const seen = new Set;
+  const paths = [];
+  for (const layer of ordered) {
+    for (const plugin of layer) {
+      const resolved = resolveClaudePluginPath(plugin.path, options.cwd, options.home);
+      if (seen.has(resolved))
+        continue;
+      seen.add(resolved);
+      paths.push(resolved);
+    }
+  }
+  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";
@@ -3866,10 +3977,6 @@ async function pathExists(path) {
     return false;
   }
 }
-function isPathWithin(parentDir, candidatePath) {
-  const relativePath = relative(parentDir, candidatePath);
-  return relativePath === "" || !relativePath.startsWith("..") && !isAbsolute(relativePath);
-}
 async function scanCliPluginsDirectory(pluginsDir) {
   if (!await pathExists(pluginsDir)) {
     return [];
@@ -3896,11 +4003,11 @@ async function scanCliPluginsDirectory(pluginsDir) {
   }
 }
 async function loadGlobalPlugins() {
-  const plugins = await readJsonSliceCached(claudeJsonPath(), "plugins", (config) => config?.plugins);
+  const plugins = await readJsonSliceCached(claudeJsonPath(), "plugins", (config) => claudePluginConfigList(config?.plugins));
   return plugins ?? [];
 }
 async function loadProjectPlugins(cwd) {
-  const plugins = await readJsonSliceCached(join3(cwd, ".claude", "plugins.json"), "plugins", (config) => config?.plugins);
+  const plugins = await readJsonSliceCached(join3(cwd, ".claude", "plugins.json"), "plugins", (config) => claudePluginConfigList(config?.plugins));
   return plugins ?? [];
 }
 async function loadCliInstalledPlugins() {
@@ -3910,37 +4017,30 @@ async function loadCliInstalledPlugins() {
   if (!plugins) {
     return scanCliPluginsDirectory(pluginsDir);
   }
-  return remapInstalledPlugins(pluginsDir, { plugins });
+  return remapInstalledPlugins2(pluginsDir, { plugins });
 }
-function remapInstalledPlugins(pluginsDir, installedPlugins) {
-  const plugins = [];
-  const CLAUDE_PLUGINS_MARKER = "/.claude/plugins/";
-  const pluginsRoot = resolve(pluginsDir);
-  for (const entries of Object.values(installedPlugins.plugins)) {
-    for (const entry of entries) {
-      const markerIdx = entry.installPath.indexOf(CLAUDE_PLUGINS_MARKER);
-      let resolvedPath;
-      if (markerIdx !== -1) {
-        const relativePath = entry.installPath.substring(markerIdx + CLAUDE_PLUGINS_MARKER.length);
-        const remappedPath = resolve(pluginsDir, relativePath);
-        if (!isPathWithin(pluginsRoot, remappedPath)) {
-          console.warn(`[plugin-config] Skipping plugin with unsafe install path: "${entry.installPath}"`);
-          continue;
-        }
-        resolvedPath = remappedPath;
-      } else {
-        resolvedPath = entry.installPath;
-      }
-      plugins.push({
-        type: "local",
-        path: resolvedPath
-      });
-    }
+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");
   }
-  return plugins;
+}
+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}"`));
 }
 async function loadProjectOverridesFromGlobal(cwd) {
-  const plugins = await readJsonSliceCached(claudeJsonPath(), `projects:${cwd}:plugins`, (config) => config?.projects?.[cwd]?.plugins);
+  const plugins = await readJsonSliceCached(claudeJsonPath(), `projects:${cwd}:plugins`, (config) => claudePluginConfigList(config?.projects?.[cwd]?.plugins));
   return plugins ?? [];
 }
 async function readPluginManifest(pluginPath) {
@@ -3956,42 +4056,29 @@ async function readPluginManifest(pluginPath) {
   };
 }
 function resolvePath(pluginPath, cwd) {
-  if (pluginPath.startsWith("~")) {
-    return join3(claudeHome(), pluginPath.slice(1));
-  }
-  if (pluginPath.startsWith("/")) {
-    return pluginPath;
-  }
-  return join3(cwd, pluginPath);
+  return resolveClaudePluginPath(pluginPath, cwd, claudeHome());
 }
-async function getMergedPlugins(cwd) {
-  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(),
-    loadProjectOverridesFromGlobal(cwd),
-    loadProjectPlugins(cwd)
+    includeProjectSources ? loadProjectOverridesFromGlobal(cwd) : [],
+    includeProjectSources ? loadProjectPlugins(cwd) : [],
+    loadPluginSettings(cwd, sources)
   ]);
-  const pluginMap = new Map;
-  for (const plugin of global2) {
-    const resolved = resolvePath(plugin.path, cwd);
-    pluginMap.set(resolved, { ...plugin, path: resolved });
-  }
-  for (const plugin of cliInstalled) {
-    const resolved = resolvePath(plugin.path, cwd);
-    pluginMap.set(resolved, { ...plugin, path: resolved });
-  }
-  for (const plugin of projectGlobal) {
-    const resolved = resolvePath(plugin.path, cwd);
-    pluginMap.set(resolved, { ...plugin, path: resolved });
-  }
-  for (const plugin of projectLocal) {
-    const resolved = resolvePath(plugin.path, cwd);
-    pluginMap.set(resolved, { ...plugin, path: resolved });
-  }
-  return Array.from(pluginMap.values());
-}
-async function getPluginsForSdk(cwd, includeProjectSources = true) {
-  const configs = includeProjectSources ? await getMergedPlugins(cwd) : [...await loadGlobalPlugins(), ...await loadCliInstalledPlugins()];
+  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)) {
@@ -4117,90 +4204,18 @@ async function runtimeEnvironmentForAgentQuery(env = process.env, readTextFile =
   return snapshot;
 }
 
-// ../protocol/src/coordinator-web-research.ts
-var COORDINATOR_WEB_RESEARCH_MODES = ["off", "search", "search-and-mcp"];
-var DEFAULT_COORDINATOR_RESEARCH_MCP_SERVERS = Object.freeze([{ name: "context7", url: "https://mcp.context7.com/mcp" }]);
-var MAX_COORDINATOR_RESEARCH_MCP_SERVERS = 8;
-var COORDINATOR_WEB_RESEARCH_ENV = "ORKESTRATOR_COORDINATOR_WEB_RESEARCH";
-var COORDINATOR_RESEARCH_MCP_ENV = "ORKESTRATOR_COORDINATOR_RESEARCH_MCP";
-var RESERVED_SERVER_NAME = /^orkestrator/;
-var SERVER_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
-function isCoordinatorWebResearch(value) {
-  return typeof value === "string" && COORDINATOR_WEB_RESEARCH_MODES.includes(value);
-}
-function coordinatorResearchMcpServerProblem(server) {
-  if (!SERVER_NAME.test(server.name)) {
-    return "Use 1 to 32 lowercase letters, digits or hyphens for the name.";
-  }
-  if (RESERVED_SERVER_NAME.test(server.name))
-    return "Names starting with orkestrator are reserved.";
-  let url;
-  try {
-    url = new URL(server.url);
-  } catch {
-    return "The URL is not valid.";
-  }
-  if (url.protocol !== "https:")
-    return "Only https:// research servers are allowed.";
-  if (url.username || url.password)
-    return "Credentials in the URL are not allowed.";
-  return;
-}
-function normalizeCoordinatorResearchMcpServers(value) {
-  if (value === undefined)
-    return DEFAULT_COORDINATOR_RESEARCH_MCP_SERVERS.map((s) => ({ ...s }));
-  if (!Array.isArray(value))
-    return [];
-  const servers = [];
-  const names = new Set;
-  for (const entry of value) {
-    if (servers.length >= MAX_COORDINATOR_RESEARCH_MCP_SERVERS)
-      break;
-    if (!entry || typeof entry !== "object")
-      continue;
-    const { name, url } = entry;
-    if (typeof name !== "string" || typeof url !== "string")
-      continue;
-    const server = { name: name.trim(), url: url.trim() };
-    if (coordinatorResearchMcpServerProblem(server) || names.has(server.name))
-      continue;
-    names.add(server.name);
-    servers.push(server);
-  }
-  return servers;
-}
-function coordinatorWebResearchFromEnv(env) {
-  const value = env[COORDINATOR_WEB_RESEARCH_ENV];
-  return isCoordinatorWebResearch(value) ? value : "off";
-}
-function coordinatorResearchMcpServersFromEnv(env) {
-  if (coordinatorWebResearchFromEnv(env) !== "search-and-mcp")
-    return [];
-  const raw = env[COORDINATOR_RESEARCH_MCP_ENV];
-  if (!raw)
-    return [];
-  try {
-    return normalizeCoordinatorResearchMcpServers(JSON.parse(raw));
-  } catch {
-    return [];
-  }
-}
-var COORDINATOR_DENIED = Object.freeze([
-  "file.write",
-  "file.patch",
-  "shell.mutate",
-  "network"
-]);
-function coordinatorCapabilityPolicy(mode) {
-  return {
-    deny: [...COORDINATOR_DENIED],
-    ...mode === "off" ? {} : { allow: ["web.search"] }
-  };
-}
-
 // ../protocol/src/native-agent-transcript-patch.ts
 var FORBIDDEN_KEYS = new Set(["__proto__", "constructor", "prototype"]);
 
+// ../protocol/src/native-agent-policy-effects.ts
+function appendNativeAgentPolicyNote(policy, note) {
+  return { ...policy, note: policy.note ? `${policy.note} ${note}` : note };
+}
+var READ_ONLY_TURN_POLICY_NOTE = "The current turn is read-only, so it runs under the read-only policy rather than this session's own.";
+function readOnlyTurnReportedPolicy(turnPolicy) {
+  return appendNativeAgentPolicyNote(turnPolicy, READ_ONLY_TURN_POLICY_NOTE);
+}
+
 // ../protocol/src/native-agent-steer-rejection.ts
 var NATIVE_AGENT_STEER_REJECTION_HTTP_STATUS = 429;
 var MAX_STEER_JOURNAL_BYTES = 1024 * 1024 * 1024;
@@ -4263,6 +4278,15 @@ var NATIVE_AGENT_APPROVAL_MODES = Object.freeze({
     }
   ]
 });
+var CODEX_CONTAINER_APPROVAL_DESCRIPTIONS = Object.freeze({
+  ask: {
+    "on-request": "Codex has no sandbox of its own in a container, so this asks before any command Codex does not trust, like Untrusted"
+  },
+  "auto-approve": {
+    "on-request": "Codex has no sandbox of its own in a container, so this never asks; choose Untrusted to approve commands",
+    "auto-review": "Codex has no sandbox of its own in a container, so the reviewer is never consulted and everything runs"
+  }
+});
 var DISPATCH_OUTCOME_LOST_KIND = "dispatch-outcome-lost";
 var NATIVE_AGENT_RETIRED_DISPATCH_TTL_MS = 24 * 60 * 60 * 1000;
 var SUPPRESSED_COMPOSER_PARAMETERS = Object.freeze({
@@ -4414,6 +4438,87 @@ var OPTIONAL_PROJECTION_FIELD_SET = new Set([
   "slashCommandCatalogue"
 ]);
 
+// ../protocol/src/coordinator-web-research.ts
+var COORDINATOR_WEB_RESEARCH_MODES = ["off", "search", "search-and-mcp"];
+var DEFAULT_COORDINATOR_RESEARCH_MCP_SERVERS = Object.freeze([{ name: "context7", url: "https://mcp.context7.com/mcp" }]);
+var MAX_COORDINATOR_RESEARCH_MCP_SERVERS = 8;
+var COORDINATOR_WEB_RESEARCH_ENV = "ORKESTRATOR_COORDINATOR_WEB_RESEARCH";
+var COORDINATOR_RESEARCH_MCP_ENV = "ORKESTRATOR_COORDINATOR_RESEARCH_MCP";
+var RESERVED_SERVER_NAME = /^orkestrator/;
+var SERVER_NAME = /^[a-z0-9][a-z0-9-]{0,31}$/;
+function isCoordinatorWebResearch(value) {
+  return typeof value === "string" && COORDINATOR_WEB_RESEARCH_MODES.includes(value);
+}
+function coordinatorResearchMcpServerProblem(server) {
+  if (!SERVER_NAME.test(server.name)) {
+    return "Use 1 to 32 lowercase letters, digits or hyphens for the name.";
+  }
+  if (RESERVED_SERVER_NAME.test(server.name))
+    return "Names starting with orkestrator are reserved.";
+  let url;
+  try {
+    url = new URL(server.url);
+  } catch {
+    return "The URL is not valid.";
+  }
+  if (url.protocol !== "https:")
+    return "Only https:// research servers are allowed.";
+  if (url.username || url.password)
+    return "Credentials in the URL are not allowed.";
+  return;
+}
+function normalizeCoordinatorResearchMcpServers(value) {
+  if (value === undefined)
+    return DEFAULT_COORDINATOR_RESEARCH_MCP_SERVERS.map((s) => ({ ...s }));
+  if (!Array.isArray(value))
+    return [];
+  const servers = [];
+  const names = new Set;
+  for (const entry of value) {
+    if (servers.length >= MAX_COORDINATOR_RESEARCH_MCP_SERVERS)
+      break;
+    if (!entry || typeof entry !== "object")
+      continue;
+    const { name, url } = entry;
+    if (typeof name !== "string" || typeof url !== "string")
+      continue;
+    const server = { name: name.trim(), url: url.trim() };
+    if (coordinatorResearchMcpServerProblem(server) || names.has(server.name))
+      continue;
+    names.add(server.name);
+    servers.push(server);
+  }
+  return servers;
+}
+function coordinatorWebResearchFromEnv(env) {
+  const value = env[COORDINATOR_WEB_RESEARCH_ENV];
+  return isCoordinatorWebResearch(value) ? value : "off";
+}
+function coordinatorResearchMcpServersFromEnv(env) {
+  if (coordinatorWebResearchFromEnv(env) !== "search-and-mcp")
+    return [];
+  const raw = env[COORDINATOR_RESEARCH_MCP_ENV];
+  if (!raw)
+    return [];
+  try {
+    return normalizeCoordinatorResearchMcpServers(JSON.parse(raw));
+  } catch {
+    return [];
+  }
+}
+var COORDINATOR_DENIED = Object.freeze([
+  "file.write",
+  "file.patch",
+  "shell.mutate",
+  "network"
+]);
+function coordinatorCapabilityPolicy(mode) {
+  return {
+    deny: [...COORDINATOR_DENIED],
+    ...mode === "off" ? {} : { allow: ["web.search"] }
+  };
+}
+
 // ../../bridges/claude-bridge/src/services/mcp-tool-prefix.ts
 function claudeMcpToolPrefix(name) {
   let normalized = name.replace(/[^a-zA-Z0-9_-]/g, "_");
@@ -4684,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,
@@ -4882,6 +4987,14 @@ function claudeWorkspaceCwd() {
 function claudeTurnPolicy(sessionPolicy, readOnly) {
   return effectiveExecutionPolicy(readOnly ? structuredClone(READ_ONLY_TURN_POLICY) : sessionPolicy);
 }
+function claudeReportedPolicy(session) {
+  if (session.status === "running" && session.commandDiscoveryInputs?.readOnly === true) {
+    const turnPolicy = claudeTurnPolicy(session.executionPolicy, true);
+    if (turnPolicy)
+      return readOnlyTurnReportedPolicy(turnPolicy);
+  }
+  return session.executionPolicy;
+}
 function claudePolicyPermissionMode(policy) {
   return isRestrictivePolicy(policy) ? "default" : "bypassPermissions";
 }
@@ -4924,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,
@@ -6813,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));
@@ -6846,6 +6969,7 @@ function restoredTurnInterruption(preferences) {
     status: "error",
     error: CLAUDE_RESTARTED_MID_TURN_MESSAGE,
     interruption: "restart",
+    ...mark.requestId ? { interruptedRequestId: mark.requestId } : {},
     turnInFlightMarked: true
   };
 }
@@ -7385,7 +7509,6 @@ function claudeLaunchProfile(session, options) {
     context1m: effectiveClaudeContext1m(options),
     promptSuggestions: options?.promptSuggestions === true,
     chrome: effectiveClaudeChrome(policy, options),
-    maxBudgetUsd: typeof options?.maxBudgetUsd === "number" && options.maxBudgetUsd > 0 ? options.maxBudgetUsd : null,
     thinking: typeof options?.parameterValues?.thinking === "string" ? options.parameterValues.thinking : "adaptive",
     bypassCapable: claudePolicyPermissionMode(policy) === "bypassPermissions",
     cwd: claudeWorkspaceCwd(),
@@ -7421,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))
@@ -7442,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);
@@ -7487,8 +7617,6 @@ function claudeRuntimeOwesWork(runtime) {
 function claudeLaunchConflict(runtime, request) {
   if (runtime.chrome !== request.chrome)
     return "Chrome setting";
-  if (runtime.maxBudgetUsd !== request.maxBudgetUsd)
-    return "cost budget";
   if (runtime.context1m !== request.context1m)
     return "1M context setting";
   if (runtime.promptSuggestions !== request.promptSuggestions)
@@ -7645,7 +7773,7 @@ function noMessages() {
 // ../../bridges/claude-bridge/src/services/session-manager-persistence.ts
 import { constants } from "node:fs";
 import { lstat as lstat2, open as open2, realpath } from "node:fs/promises";
-import { isAbsolute as isAbsolute3, join as join8, relative as relative2, resolve as resolve3, sep } from "node:path";
+import { isAbsolute as isAbsolute2, join as join8, relative, resolve as resolve2, sep } from "node:path";
 
 // ../protocol/src/node/command-change-journal.ts
 import { appendFile, mkdir as mkdir2, readFile as readFile4, rename as rename2, rm as rm2, stat as stat3, writeFile as writeFile2 } from "node:fs/promises";
@@ -7802,7 +7930,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { rmSync } from "node:fs";
 import { copyFile, lstat, mkdtemp, rm as rm3 } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { delimiter, isAbsolute as isAbsolute2, join as join4, resolve as resolve2 } from "node:path";
+import { delimiter, isAbsolute, join as join4, resolve } from "node:path";
 var DEFAULT_MAX_UNTRACKED_FILE_BYTES = 2 * 1024 * 1024;
 var DEFAULT_MAX_UNTRACKED_FILES = 5000;
 var DEFAULT_SLOW_SNAPSHOT_MS = 500;
@@ -8084,8 +8212,8 @@ class WorkspaceChangeProbe {
           return;
         return {
           root,
-          indexPath: isAbsolute2(index) ? index : resolve2(cwd, index),
-          objectsPath: isAbsolute2(objects) ? objects : resolve2(cwd, objects)
+          indexPath: isAbsolute(index) ? index : resolve(cwd, index),
+          objectsPath: isAbsolute(objects) ? objects : resolve(cwd, objects)
         };
       }).catch(() => {
         return;
@@ -9413,14 +9541,14 @@ function record(value) {
 function text(value) {
   return typeof value === "string" ? value : undefined;
 }
-function path(value) {
+function path2(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 function claudeProposalEvidence(toolName, input) {
   const fields = record(input);
   switch (toolName) {
     case "Edit": {
-      const filePath = path(fields.file_path);
+      const filePath = path2(fields.file_path);
       if (!filePath)
         return [];
       return [
@@ -9438,7 +9566,7 @@ function claudeProposalEvidence(toolName, input) {
       ];
     }
     case "MultiEdit": {
-      const filePath = path(fields.file_path);
+      const filePath = path2(fields.file_path);
       if (!filePath || !Array.isArray(fields.edits))
         return [];
       return fields.edits.map((edit, index) => {
@@ -9457,7 +9585,7 @@ function claudeProposalEvidence(toolName, input) {
       });
     }
     case "Write": {
-      const filePath = path(fields.file_path);
+      const filePath = path2(fields.file_path);
       if (!filePath)
         return [];
       return [
@@ -9475,7 +9603,7 @@ function claudeProposalEvidence(toolName, input) {
       ];
     }
     case "NotebookEdit": {
-      const filePath = path(fields.notebook_path);
+      const filePath = path2(fields.notebook_path);
       if (!filePath)
         return [];
       const deleting = fields.edit_mode === "delete";
@@ -10446,17 +10574,17 @@ function parseBase64ImageData(value) {
 var BRIDGE_ATTACHMENT_ROOT_ENV = "ORKESTRATOR_BRIDGE_ATTACHMENT_ROOT";
 function configuredAttachmentRoot(env = process.env) {
   const value = env[BRIDGE_ATTACHMENT_ROOT_ENV]?.trim();
-  return value && isAbsolute3(value) ? resolve3(value) : undefined;
+  return value && isAbsolute2(value) ? resolve2(value) : undefined;
 }
 function attachmentContainmentRoot(filePath, cwd, extraRoot = configuredAttachmentRoot()) {
-  if (extraRoot && isAbsolute3(filePath) && isPathWithin2(extraRoot, resolve3(filePath))) {
+  if (extraRoot && isAbsolute2(filePath) && isPathWithin2(extraRoot, resolve2(filePath))) {
     return extraRoot;
   }
-  return resolve3(cwd);
+  return resolve2(cwd);
 }
 function isPathWithin2(rootPath, targetPath) {
-  const childPath = relative2(rootPath, targetPath);
-  return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute3(childPath);
+  const childPath = relative(rootPath, targetPath);
+  return childPath === "" || childPath !== ".." && !childPath.startsWith(`..${sep}`) && !isAbsolute2(childPath);
 }
 function attachmentErrorForFsFailure(error) {
   const code = error?.code;
@@ -10469,7 +10597,7 @@ function attachmentErrorForFsFailure(error) {
   return new ClaudeAttachmentError("attachment_read_failed", "Image attachment could not be read safely from the workspace.");
 }
 async function assertNoSymlinkComponents(lexicalRoot, targetPath) {
-  const childPath = relative2(lexicalRoot, targetPath);
+  const childPath = relative(lexicalRoot, targetPath);
   let currentPath = lexicalRoot;
   for (const segment of childPath.split(sep).filter(Boolean)) {
     currentPath = join8(currentPath, segment);
@@ -10500,7 +10628,7 @@ async function assertOpenedWorkspaceFile(targetPath, canonicalRoot, openedStats)
 }
 async function readWorkspaceImageAttachment(filePath, cwd, afterSymlinkValidation, afterCanonicalValidation, afterInitialValidation) {
   const lexicalRoot = attachmentContainmentRoot(filePath, cwd);
-  const targetPath = isAbsolute3(filePath) ? resolve3(filePath) : resolve3(lexicalRoot, filePath);
+  const targetPath = isAbsolute2(filePath) ? resolve2(filePath) : resolve2(lexicalRoot, filePath);
   if (!isPathWithin2(lexicalRoot, targetPath)) {
     throw new ClaudeAttachmentError("attachment_outside_workspace", "Image attachment must be contained in the current workspace.");
   }
@@ -10731,57 +10859,97 @@ var MAX_TRACKED_STREAM_ROWS = 256;
 var MAX_SUBAGENT_PARTS_PER_CALL = 128;
 var sessionStreamRows = new WeakMap;
 function createPromptStreamState(session, sessionId, options) {
-  let streamEventFlushTimer = null;
-  const { flushIntervalMs, maxBlockIndex } = options;
-  const toolTracker = options.toolTracker ?? new ToolTracker;
-  const taskRegistry = session.taskRegistry ??= new TaskRegistry;
-  const rows = [];
-  let sharedState = sessionStreamRows.get(session);
-  if (!sharedState || sharedState.messages !== session.messages) {
-    sharedState = { messages: session.messages, rows: new Map };
-    sessionStreamRows.set(session, sharedState);
-  }
-  const sharedRows = sharedState.rows;
-  const rowByApiMessage = new Map;
-  const rowByToolUseId = new Map;
-  let currentRow = null;
-  let rowSequence = 0;
-  const parentTaskByApiMessage = new Map;
-  let currentStreamApiMessageId = null;
-  let syntheticMessageKeyCounter = 0;
-  const dirtyRows = new Set;
-  const rowOfMessage = new Map;
-  let assistantOutputSeen = false;
-  const forgetRow = (row) => {
-    if (dirtyRows.delete(row))
-      materializeRow(row, true);
+  return new PromptStream(session, sessionId, options);
+}
+function explicitParentTaskUseId(partialMessage) {
+  return typeof partialMessage.parent_tool_use_id === "string" && partialMessage.parent_tool_use_id.length > 0 ? partialMessage.parent_tool_use_id : undefined;
+}
+function materializeEntryValue(entry) {
+  if (entry.pendingChunks) {
+    entry.value += entry.pendingChunks.join("");
+    entry.pendingChunks = undefined;
+  }
+}
+
+class PromptStream {
+  session;
+  sessionId;
+  toolTracker;
+  taskRegistry;
+  activeTaskIds;
+  pendingApiRetryMessageId;
+  flushIntervalMs;
+  maxBlockIndex;
+  streamEventFlushTimer = null;
+  rows = [];
+  sharedRows;
+  rowByApiMessage = new Map;
+  rowByToolUseId = new Map;
+  currentRow = null;
+  rowSequence = 0;
+  parentTaskByApiMessage = new Map;
+  currentStreamApiMessageId = null;
+  syntheticMessageKeyCounter = 0;
+  dirtyRows = new Set;
+  rowOfMessage = new Map;
+  outputSeen = false;
+  blockTarget = null;
+  flushOnTimer = () => {
+    this.streamEventFlushTimer = null;
+    this.flushStreamedAssistantMessage();
+  };
+  constructor(session, sessionId, options) {
+    this.session = session;
+    this.sessionId = sessionId;
+    this.flushIntervalMs = options.flushIntervalMs;
+    this.maxBlockIndex = options.maxBlockIndex;
+    this.toolTracker = options.toolTracker ?? new ToolTracker;
+    this.taskRegistry = session.taskRegistry ??= new TaskRegistry;
+    this.activeTaskIds = options.activeTaskIds ?? new Set;
+    let sharedState = sessionStreamRows.get(session);
+    if (!sharedState || sharedState.messages !== session.messages) {
+      sharedState = { messages: session.messages, rows: new Map };
+      sessionStreamRows.set(session, sharedState);
+    }
+    this.sharedRows = sharedState.rows;
+  }
+  get currentAssistantMessage() {
+    return this.currentRow?.message ?? null;
+  }
+  get assistantOutputSeen() {
+    return this.outputSeen;
+  }
+  forgetRow(row) {
+    if (this.dirtyRows.delete(row))
+      this.materializeRow(row, true);
     for (const apiMessageId of row.blocksByApiMessage.keys()) {
-      if (rowByApiMessage.get(apiMessageId) !== row)
+      if (this.rowByApiMessage.get(apiMessageId) !== row)
         continue;
-      rowByApiMessage.delete(apiMessageId);
-      parentTaskByApiMessage.delete(apiMessageId);
+      this.rowByApiMessage.delete(apiMessageId);
+      this.parentTaskByApiMessage.delete(apiMessageId);
     }
     for (const toolUseId of row.toolUseIds) {
-      if (rowByToolUseId.get(toolUseId) === row)
-        rowByToolUseId.delete(toolUseId);
+      if (this.rowByToolUseId.get(toolUseId) === row)
+        this.rowByToolUseId.delete(toolUseId);
     }
     if (row.message)
-      rowOfMessage.delete(row.message);
-  };
-  const createRow = (key, modelId) => {
+      this.rowOfMessage.delete(row.message);
+  }
+  createRow(key, modelId) {
+    const { rows, sharedRows, session } = this;
     const shared = sharedRows.get(key);
     if (shared && (!shared.message || session.messages.includes(shared.message))) {
       rows.push(shared);
       if (shared.message)
-        rowOfMessage.set(shared.message, shared);
+        this.rowOfMessage.set(shared.message, shared);
       while (rows.length > MAX_TRACKED_STREAM_ROWS)
-        forgetRow(rows.shift());
+        this.forgetRow(rows.shift());
       for (const id of shared.toolUseIds)
-        rowByToolUseId.set(id, shared);
+        this.rowByToolUseId.set(id, shared);
       return shared;
     }
     const row = {
-      sequence: rowSequence += 1,
+      sequence: this.rowSequence += 1,
       key,
       message: null,
       blocksByApiMessage: new Map,
@@ -10803,41 +10971,35 @@ function createPromptStreamState(session, sessionId, options) {
     rows.push(row);
     while (rows.length > MAX_TRACKED_STREAM_ROWS) {
       const oldest = rows.shift();
-      forgetRow(oldest);
+      this.forgetRow(oldest);
     }
     return row;
-  };
-  const rowForApiMessage = (messageKey, opensRow, parentToolUseId, modelId) => {
-    const known = rowByApiMessage.get(messageKey);
+  }
+  rowForApiMessage(messageKey, opensRow, parentToolUseId, modelId) {
+    const known = this.rowByApiMessage.get(messageKey);
     if (known)
       return known;
     let row;
     if (!opensRow) {
-      row = (parentToolUseId ? rowByToolUseId.get(parentToolUseId) : undefined) ?? currentRow ?? undefined;
+      row = (parentToolUseId ? this.rowByToolUseId.get(parentToolUseId) : undefined) ?? this.currentRow ?? undefined;
     }
     if (!row) {
-      flushStreamedAssistantMessage();
-      row = createRow(messageKey, modelId);
-      currentRow = row;
+      this.flushStreamedAssistantMessage();
+      row = this.createRow(messageKey, modelId);
+      this.currentRow = row;
     }
-    rowByApiMessage.set(messageKey, row);
+    this.rowByApiMessage.set(messageKey, row);
     return row;
-  };
-  const getBlocks = (row, messageKey) => {
+  }
+  getBlocks(row, messageKey) {
     let blocks = row.blocksByApiMessage.get(messageKey);
     if (!blocks) {
       blocks = new Map;
       row.blocksByApiMessage.set(messageKey, blocks);
     }
     return blocks;
-  };
-  const materializeEntryValue = (entry) => {
-    if (entry.pendingChunks) {
-      entry.value += entry.pendingChunks.join("");
-      entry.pendingChunks = undefined;
-    }
-  };
-  const rebuildOrderedParts = (row) => {
+  }
+  rebuildOrderedParts(row) {
     const located = [];
     for (const [messageKey, blocks] of row.blocksByApiMessage) {
       const blockIndices = Array.from(blocks.keys()).sort((a, b) => a - b);
@@ -10864,17 +11026,14 @@ function createPromptStreamState(session, sessionId, options) {
       blocks.delete(blockIndex);
       if (entry.type === "tool-ref") {
         row.toolUseIds.delete(entry.value);
-        if (rowByToolUseId.get(entry.value) === row)
-          rowByToolUseId.delete(entry.value);
+        if (this.rowByToolUseId.get(entry.value) === row)
+          this.rowByToolUseId.delete(entry.value);
       }
     }
     row.orderedParts = shed.size === 0 ? located.map(({ entry }) => entry) : located.filter(({ entry }) => !shed.has(entry)).map(({ entry }) => entry);
-  };
-  const activeTaskIds = options.activeTaskIds ?? new Set;
-  let pendingPlanRejectionFeedback = null;
-  let planApprovedThisTurn = false;
-  let pendingPlanApprovalContinuation = null;
-  const emitRow = (row) => {
+  }
+  emitRow(row) {
+    const { session, sessionId } = this;
     const message = row.message;
     if (!message)
       return;
@@ -10912,34 +11071,36 @@ function createPromptStreamState(session, sessionId, options) {
         revision: message.revision
       }
     });
-  };
-  const newestRowMessage = () => {
-    for (let index = rows.length - 1;index >= 0; index -= 1) {
-      const message = rows[index].message;
+  }
+  newestRowMessage() {
+    for (let index = this.rows.length - 1;index >= 0; index -= 1) {
+      const message = this.rows[index].message;
       if (message)
         return message;
     }
     return null;
-  };
-  const insertAfterAnchor = (row, message) => {
-    const anchorIndex = row.anchor ? session.messages.lastIndexOf(row.anchor) : -1;
+  }
+  insertAfterAnchor(row, message) {
+    const messages = this.session.messages;
+    const anchorIndex = row.anchor ? messages.lastIndexOf(row.anchor) : -1;
     if (anchorIndex < 0) {
-      session.messages.push(message);
+      messages.push(message);
       return;
     }
     let index = anchorIndex + 1;
-    while (index < session.messages.length) {
-      const owner = rowOfMessage.get(session.messages[index]);
+    while (index < messages.length) {
+      const owner = this.rowOfMessage.get(messages[index]);
       if (!owner || owner.sequence > row.sequence)
         break;
       index += 1;
     }
-    session.messages.splice(index, 0, message);
-  };
-  const materializeRow = (row, rebuildBlocks) => {
+    messages.splice(index, 0, message);
+  }
+  materializeRow(row, rebuildBlocks) {
+    const { session } = this;
     if (rebuildBlocks)
-      rebuildOrderedParts(row);
-    const parts = buildMessageParts(row.orderedParts, toolTracker);
+      this.rebuildOrderedParts(row);
+    const parts = buildMessageParts(row.orderedParts, this.toolTracker);
     const content = getMessageTextFromParts(parts);
     if (!row.message) {
       if (parts.length === 0 && !content)
@@ -10953,9 +11114,9 @@ function createPromptStreamState(session, sessionId, options) {
         ...row.modelId ? { modelId: row.modelId } : {},
         ...row.sdkUuid ? { sdkUuid: row.sdkUuid } : {}
       };
-      rowOfMessage.set(row.message, row);
-      insertAfterAnchor(row, row.message);
-      assistantOutputSeen = true;
+      this.rowOfMessage.set(row.message, row);
+      this.insertAfterAnchor(row, row.message);
+      this.outputSeen = true;
     } else {
       row.message.content = content;
       row.message.parts = parts;
@@ -10968,32 +11129,26 @@ function createPromptStreamState(session, sessionId, options) {
       (session.revisedRows ??= new RecentlyRevisedRows).note(row.message.id);
     }
     markTranscriptChanged(session);
-    emitRow(row);
-  };
-  function flushStreamedAssistantMessage() {
-    if (streamEventFlushTimer) {
-      clearTimeout(streamEventFlushTimer);
-      streamEventFlushTimer = null;
-    }
-    if (dirtyRows.size === 0)
+    this.emitRow(row);
+  }
+  flushStreamedAssistantMessage() {
+    this.clearFlushTimer();
+    if (this.dirtyRows.size === 0)
       return;
-    const pending = [...dirtyRows].sort((a, b) => a.sequence - b.sequence);
-    dirtyRows.clear();
+    const pending = [...this.dirtyRows].sort((a, b) => a.sequence - b.sequence);
+    this.dirtyRows.clear();
     for (const row of pending)
-      materializeRow(row, true);
-  }
-  const scheduleStreamedAssistantMessageFlush = (row) => {
-    dirtyRows.add(row);
-    streamEventFlushTimer ??= setTimeout(() => {
-      streamEventFlushTimer = null;
-      flushStreamedAssistantMessage();
-    }, flushIntervalMs);
-  };
-  const applyAssistantRecord = (record) => {
-    const messageKey = record.apiMessageId ?? record.uuid ?? `assistant-${syntheticMessageKeyCounter += 1}`;
+      this.materializeRow(row, true);
+  }
+  scheduleStreamedAssistantMessageFlush(row) {
+    this.dirtyRows.add(row);
+    this.streamEventFlushTimer ??= setTimeout(this.flushOnTimer, this.flushIntervalMs);
+  }
+  applyAssistantRecord(record) {
+    const messageKey = record.apiMessageId ?? record.uuid ?? `assistant-${this.syntheticMessageKeyCounter += 1}`;
     const opensRow = record.isRoot && record.apiMessageId !== undefined;
-    const row = rowForApiMessage(messageKey, opensRow, record.parentToolUseId, record.modelId);
-    const blocks = getBlocks(row, messageKey);
+    const row = this.rowForApiMessage(messageKey, opensRow, record.parentToolUseId, record.modelId);
+    const blocks = this.getBlocks(row, messageKey);
     const blockIndexBase = row.finalizedBlockCounts.get(messageKey) ?? 0;
     for (const part of record.orderedParts) {
       const blockIndex = blockIndexBase + (part.blockOffset ?? 0);
@@ -11005,7 +11160,7 @@ function createPromptStreamState(session, sessionId, options) {
       });
       if (part.type === "tool-ref") {
         row.toolUseIds.add(part.value);
-        rowByToolUseId.set(part.value, row);
+        this.rowByToolUseId.set(part.value, row);
       }
     }
     row.finalizedBlockCounts.set(messageKey, blockIndexBase + record.contentBlockCount);
@@ -11013,15 +11168,15 @@ function createPromptStreamState(session, sessionId, options) {
       row.modelId = record.modelId;
     if (record.isRoot && record.uuid)
       row.sdkUuid = record.uuid;
-    dirtyRows.delete(row);
-    materializeRow(row, true);
-  };
-  const refreshToolRows = (toolUseIds) => {
+    this.dirtyRows.delete(row);
+    this.materializeRow(row, true);
+  }
+  refreshToolRows(toolUseIds) {
     const affected = new Set;
-    if (currentRow)
-      affected.add(currentRow);
+    if (this.currentRow)
+      affected.add(this.currentRow);
     for (const toolUseId of toolUseIds) {
-      const row = rowByToolUseId.get(toolUseId);
+      const row = this.rowByToolUseId.get(toolUseId);
       if (row)
         affected.add(row);
     }
@@ -11029,150 +11184,145 @@ function createPromptStreamState(session, sessionId, options) {
     for (const row of [...affected].sort((a, b) => a.sequence - b.sequence)) {
       if (!row.message)
         continue;
-      const rebuildBlocks = dirtyRows.delete(row);
-      materializeRow(row, rebuildBlocks);
+      const rebuildBlocks = this.dirtyRows.delete(row);
+      this.materializeRow(row, rebuildBlocks);
       published.add(row.message);
     }
     return published;
-  };
-  const applyPartialAssistantMessage = (partialMessage) => {
+  }
+  rowHoldingTool(toolUseId) {
+    return this.rowByToolUseId.get(toolUseId)?.message ?? this.currentRow?.message ?? this.newestRowMessage();
+  }
+  publishRow(message) {
+    const row = this.rowOfMessage.get(message);
+    if (row)
+      this.emitRow(row);
+  }
+  applyPartialAssistantMessage(partialMessage) {
     const streamEvent = partialMessage.event;
-    const eventType = streamEvent?.type;
-    const explicitParentTaskUseId = typeof partialMessage.parent_tool_use_id === "string" && partialMessage.parent_tool_use_id.length > 0 ? partialMessage.parent_tool_use_id : undefined;
-    if (eventType === "message_start") {
-      const apiMessageId = typeof streamEvent.message?.id === "string" ? streamEvent.message.id : undefined;
-      currentStreamApiMessageId = apiMessageId ?? null;
-      const isRootAssistant = isRootAssistantRecord(partialMessage.parent_tool_use_id, partialMessage.isSidechain);
-      const modelId = isRootAssistant ? normalizeBackendModelId(streamEvent.message?.model) : undefined;
-      if (apiMessageId) {
-        if (explicitParentTaskUseId) {
-          parentTaskByApiMessage.set(apiMessageId, explicitParentTaskUseId);
-        }
-        const row = rowForApiMessage(apiMessageId, isRootAssistant, explicitParentTaskUseId, modelId);
-        if (modelId)
-          row.modelId = modelId;
-        getBlocks(row, apiMessageId);
+    switch (streamEvent?.type) {
+      case "message_start":
+        return this.applyMessageStart(partialMessage, streamEvent);
+      case "message_stop":
+        return this.applyMessageStop();
+      case "content_block_start": {
+        const target = this.locateStreamBlock(partialMessage, streamEvent);
+        return target ? this.applyContentBlockStart(target, streamEvent.content_block) : false;
       }
-      return false;
-    }
-    if (eventType === "message_stop") {
-      currentStreamApiMessageId = null;
-      return false;
+      case "content_block_delta": {
+        const target = this.locateStreamBlock(partialMessage, streamEvent);
+        return target ? this.applyContentBlockDelta(target, streamEvent.delta) : false;
+      }
+      default:
+        this.locateStreamBlock(partialMessage, streamEvent);
+        return false;
     }
-    const blockIndex = Number.isInteger(streamEvent?.index) && streamEvent.index >= 0 && streamEvent.index <= maxBlockIndex ? streamEvent.index : undefined;
-    if (blockIndex === undefined) {
-      return false;
+  }
+  applyMessageStart(partialMessage, streamEvent) {
+    const apiMessageId = typeof streamEvent.message?.id === "string" ? streamEvent.message.id : undefined;
+    this.currentStreamApiMessageId = apiMessageId ?? null;
+    const isRootAssistant = isRootAssistantRecord(partialMessage.parent_tool_use_id, partialMessage.isSidechain);
+    const modelId = isRootAssistant ? normalizeBackendModelId(streamEvent.message?.model) : undefined;
+    if (apiMessageId) {
+      const parentTaskUseId = explicitParentTaskUseId(partialMessage);
+      if (parentTaskUseId)
+        this.parentTaskByApiMessage.set(apiMessageId, parentTaskUseId);
+      const row = this.rowForApiMessage(apiMessageId, isRootAssistant, parentTaskUseId, modelId);
+      if (modelId)
+        row.modelId = modelId;
+      this.getBlocks(row, apiMessageId);
     }
-    const messageKey = currentStreamApiMessageId ?? (typeof partialMessage.uuid === "string" ? partialMessage.uuid : undefined);
-    if (!messageKey) {
+    return false;
+  }
+  applyMessageStop() {
+    this.currentStreamApiMessageId = null;
+    return false;
+  }
+  locateStreamBlock(partialMessage, streamEvent) {
+    const blockIndex = Number.isInteger(streamEvent?.index) && streamEvent.index >= 0 && streamEvent.index <= this.maxBlockIndex ? streamEvent.index : undefined;
+    if (blockIndex === undefined)
+      return null;
+    const messageKey = this.currentStreamApiMessageId ?? (typeof partialMessage.uuid === "string" ? partialMessage.uuid : undefined);
+    if (!messageKey)
+      return null;
+    const explicitParent = explicitParentTaskUseId(partialMessage);
+    const parentTaskUseId = explicitParent ?? this.parentTaskByApiMessage.get(messageKey);
+    if (explicitParent)
+      this.parentTaskByApiMessage.set(messageKey, explicitParent);
+    const row = this.rowForApiMessage(messageKey, false, parentTaskUseId);
+    const blocks = this.getBlocks(row, messageKey);
+    const target = this.blockTarget ??= { row, blocks, blockIndex, messageKey, parentTaskUseId };
+    target.row = row;
+    target.blocks = blocks;
+    target.blockIndex = blockIndex;
+    target.messageKey = messageKey;
+    target.parentTaskUseId = parentTaskUseId;
+    return target;
+  }
+  applyContentBlockStart(target, contentBlock) {
+    let type;
+    let value;
+    if (contentBlock?.type === "text") {
+      type = "text";
+      value = typeof contentBlock.text === "string" ? contentBlock.text : "";
+    } else if (contentBlock?.type === "thinking") {
+      type = "thinking";
+      value = typeof contentBlock.thinking === "string" ? contentBlock.thinking : "";
+    } else {
       return false;
     }
-    const parentTaskUseId = explicitParentTaskUseId ?? parentTaskByApiMessage.get(messageKey);
-    if (explicitParentTaskUseId) {
-      parentTaskByApiMessage.set(messageKey, explicitParentTaskUseId);
-    }
-    const row = rowForApiMessage(messageKey, false, parentTaskUseId);
-    const entriesForMessage = getBlocks(row, messageKey);
-    let entry = entriesForMessage.get(blockIndex);
-    const appendStreamedDelta = (type, chunk) => {
-      if (entry?.type === type) {
-        entry.parentTaskUseId ??= parentTaskUseId;
-        (entry.pendingChunks ??= []).push(chunk);
-        return entry;
-      }
-      if (entry)
-        materializeEntryValue(entry);
-      return {
-        type,
-        value: `${entry?.value ?? ""}${chunk}`,
-        timestamp: entry?.timestamp ?? new Date().toISOString(),
-        messageUuid: messageKey,
-        parentTaskUseId: entry?.parentTaskUseId ?? parentTaskUseId
-      };
-    };
-    if (eventType === "content_block_start") {
-      const contentBlock = streamEvent.content_block;
-      if (contentBlock?.type === "text") {
-        entry = {
-          type: "text",
-          value: typeof contentBlock.text === "string" ? contentBlock.text : "",
-          timestamp: entry?.timestamp ?? new Date().toISOString(),
-          messageUuid: messageKey,
-          parentTaskUseId
-        };
-      } else if (contentBlock?.type === "thinking") {
-        entry = {
-          type: "thinking",
-          value: typeof contentBlock.thinking === "string" ? contentBlock.thinking : "",
-          timestamp: entry?.timestamp ?? new Date().toISOString(),
-          messageUuid: messageKey,
-          parentTaskUseId
-        };
-      } else {
-        return false;
-      }
-    } else if (eventType === "content_block_delta") {
-      const delta = streamEvent.delta;
-      if (delta?.type === "text_delta") {
-        entry = appendStreamedDelta("text", typeof delta.text === "string" ? delta.text : "");
-      } else if (delta?.type === "thinking_delta") {
-        entry = appendStreamedDelta("thinking", typeof delta.thinking === "string" ? delta.thinking : "");
-      } else {
-        return false;
-      }
+    const existing = target.blocks.get(target.blockIndex);
+    this.storeStreamedEntry(target, {
+      type,
+      value,
+      timestamp: existing?.timestamp ?? new Date().toISOString(),
+      messageUuid: target.messageKey,
+      parentTaskUseId: target.parentTaskUseId
+    });
+    return true;
+  }
+  applyContentBlockDelta(target, delta) {
+    if (delta?.type === "text_delta") {
+      const chunk = typeof delta.text === "string" ? delta.text : "";
+      this.storeStreamedEntry(target, this.appendStreamedDelta(target, "text", chunk));
+    } else if (delta?.type === "thinking_delta") {
+      const chunk = typeof delta.thinking === "string" ? delta.thinking : "";
+      this.storeStreamedEntry(target, this.appendStreamedDelta(target, "thinking", chunk));
     } else {
       return false;
     }
-    entriesForMessage.set(blockIndex, entry);
-    scheduleStreamedAssistantMessageFlush(row);
     return true;
-  };
-  return {
-    get currentAssistantMessage() {
-      return currentRow?.message ?? null;
-    },
-    get assistantOutputSeen() {
-      return assistantOutputSeen;
-    },
-    toolTracker,
-    taskRegistry,
-    activeTaskIds,
-    get pendingPlanRejectionFeedback() {
-      return pendingPlanRejectionFeedback;
-    },
-    set pendingPlanRejectionFeedback(value) {
-      pendingPlanRejectionFeedback = value;
-    },
-    get planApprovedThisTurn() {
-      return planApprovedThisTurn;
-    },
-    set planApprovedThisTurn(value) {
-      planApprovedThisTurn = value;
-    },
-    get pendingPlanApprovalContinuation() {
-      return pendingPlanApprovalContinuation;
-    },
-    set pendingPlanApprovalContinuation(value) {
-      pendingPlanApprovalContinuation = value;
-    },
-    applyAssistantRecord,
-    refreshToolRows,
-    rowHoldingTool: (toolUseId) => rowByToolUseId.get(toolUseId)?.message ?? currentRow?.message ?? newestRowMessage(),
-    publishRow: (message) => {
-      const row = rowOfMessage.get(message);
-      if (row)
-        emitRow(row);
-    },
-    flushStreamedAssistantMessage,
-    applyPartialAssistantMessage,
-    beginPostSteerScope: flushStreamedAssistantMessage,
-    clearFlushTimer: () => {
-      if (streamEventFlushTimer) {
-        clearTimeout(streamEventFlushTimer);
-        streamEventFlushTimer = null;
-      }
+  }
+  appendStreamedDelta(target, type, chunk) {
+    const entry = target.blocks.get(target.blockIndex);
+    if (entry?.type === type) {
+      entry.parentTaskUseId ??= target.parentTaskUseId;
+      (entry.pendingChunks ??= []).push(chunk);
+      return entry;
     }
-  };
+    if (entry)
+      materializeEntryValue(entry);
+    return {
+      type,
+      value: `${entry?.value ?? ""}${chunk}`,
+      timestamp: entry?.timestamp ?? new Date().toISOString(),
+      messageUuid: target.messageKey,
+      parentTaskUseId: entry?.parentTaskUseId ?? target.parentTaskUseId
+    };
+  }
+  storeStreamedEntry(target, entry) {
+    target.blocks.set(target.blockIndex, entry);
+    this.scheduleStreamedAssistantMessageFlush(target.row);
+  }
+  beginPostSteerScope() {
+    this.flushStreamedAssistantMessage();
+  }
+  clearFlushTimer() {
+    if (this.streamEventFlushTimer) {
+      clearTimeout(this.streamEventFlushTimer);
+      this.streamEventFlushTimer = null;
+    }
+  }
 }
 
 // ../protocol/src/structured-output-text.ts
@@ -11711,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,
@@ -11769,7 +11920,10 @@ function createTurnState(session, sessionId, init) {
     settlingResult: false,
     localCommandOutputSeen: false,
     lastThinkingTokensEmitAt: 0,
-    compactedTokensBefore: undefined
+    compactedTokensBefore: undefined,
+    pendingPlanRejectionFeedback: null,
+    planApprovedThisTurn: false,
+    pendingPlanApprovalContinuation: null
   };
   const diagnostics = createBridgeDiagnostics("claude", {
     id: sessionId,
@@ -11880,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)
@@ -11900,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;
@@ -12332,7 +12488,7 @@ function commandBindingRevision(parts) {
   }
   return hash.toString(16).padStart(16, "0");
 }
-function isRecord(value) {
+function isRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function boundedIdentity(value, maxBytes) {
@@ -12352,7 +12508,7 @@ function displayCommandName(name) {
   return name.startsWith("/") || name.startsWith("$") ? name : `/${name}`;
 }
 function normalizeAvailability(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
   if (typeof value.state !== "string")
     return;
@@ -12367,7 +12523,7 @@ function normalizeAvailability(value) {
   };
 }
 function normalizeInputPolicy(value) {
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return;
   const policy = {};
   if (value.arguments === "none" || value.arguments === "optional" || value.arguments === "required") {
@@ -12382,7 +12538,7 @@ function normalizeInputPolicy(value) {
   return Object.keys(policy).length > 0 ? policy : undefined;
 }
 function normalizeCommandCataloguePayload(payload, options = {}) {
-  const record = isRecord(payload) ? payload : {};
+  const record = isRecord2(payload) ? payload : {};
   const enhanced = record.catalogueVersion === NATIVE_AGENT_COMMAND_CATALOGUE_VERSION;
   const rows = Array.isArray(record.commands) ? record.commands : [];
   const byId = new Map;
@@ -12391,7 +12547,7 @@ function normalizeCommandCataloguePayload(payload, options = {}) {
   let aliasBudget = COMMAND_CATALOGUE_LIMITS.maxAliasesTotal;
   for (const candidate of rows.slice(0, COMMAND_CATALOGUE_LIMITS.maxCommands)) {
     const row = typeof candidate === "string" ? { name: candidate } : candidate;
-    if (!isRecord(row)) {
+    if (!isRecord2(row)) {
       rejected += 1;
       continue;
     }
@@ -12471,7 +12627,8 @@ function normalizeCommandCataloguePayload(payload, options = {}) {
     ...status ? { status } : {},
     ...revision !== undefined ? { revision } : {},
     ...generation ? { generation } : {},
-    ...freshness ? { freshness } : {}
+    ...freshness ? { freshness } : {},
+    ...enhanced && status === "stale" && record.attachPending === true ? { attachPending: true } : {}
   };
 }
 var LEGACY_ID_PREFIX = "legacy:";
@@ -12484,7 +12641,7 @@ function commandCatalogueBytes(commands) {
 function parseBridgeCommandInvocation(value) {
   if (value === undefined || value === null)
     return { ok: true };
-  if (!isRecord(value))
+  if (!isRecord2(value))
     return { ok: false, error: "command must be an object" };
   const id = boundedIdentity(value.id, COMMAND_CATALOGUE_LIMITS.maxIdBytes);
   const name = boundedIdentity(value.name, COMMAND_CATALOGUE_LIMITS.maxNameBytes);
@@ -12687,6 +12844,40 @@ function redactSecrets(value) {
   return result;
 }
 
+// ../../bridges/claude-bridge/src/services/mcp-runtime-status.ts
+function mcpScope(scope, name, source) {
+  if (name === "orkestrator")
+    return "orkestrator";
+  if (source?.includes("plugin") || scope?.includes("plugin"))
+    return "plugin";
+  if (scope === "project" || scope === "local")
+    return scope;
+  return "user";
+}
+function mcpRuntimeState(status) {
+  switch (status) {
+    case "connected":
+    case "failed":
+    case "needs-auth":
+    case "disabled":
+      return status;
+    case "pending":
+      return "connecting";
+    default:
+      return "unknown";
+  }
+}
+function initMcpServerStatus(raw) {
+  const source = typeof raw.source === "string" ? raw.source : undefined;
+  return {
+    name: raw.name,
+    status: mcpRuntimeState(raw.status),
+    ...source ? { scope: mcpScope(source, raw.name) } : {},
+    ...typeof raw.error === "string" && raw.error ? { error: raw.error } : {},
+    ...Array.isArray(raw.tools) ? { tools: raw.tools.filter((tool) => typeof tool === "string") } : {}
+  };
+}
+
 // ../../bridges/claude-bridge/src/services/claude-sign-in.ts
 var AUTH_CACHE_TTL_MS = 30000;
 var FAILED_AUTH_CACHE_TTL_MS = 5000;
@@ -12935,15 +13126,6 @@ function createProbe() {
     ...claudeExecutableOptions()
   });
 }
-function mcpScope(scope, name) {
-  if (name === "orkestrator")
-    return "orkestrator";
-  if (scope?.includes("plugin"))
-    return "plugin";
-  if (scope === "project" || scope === "local")
-    return "project";
-  return "user";
-}
 function mcpTransport(status) {
   const type = status.config?.type;
   if (type === "stdio" || type === "sse" || type === "http")
@@ -12966,7 +13148,7 @@ function normalizeMcp(status) {
     id: status.name,
     name: status.serverInfo?.name || status.name,
     status: mappedStatus,
-    scope: mcpScope(status.scope, status.name),
+    scope: mcpScope(status.scope, status.name, status.source),
     ...transport ? { transport } : {},
     toolCount: tools.length,
     ...tools.length ? { tools } : {},
@@ -13003,8 +13185,12 @@ async function performSessionMcpAction(sessionId, serverId, action) {
   const session = sessions.get(sessionId);
   if (!session)
     throw new Error("Session not found");
+  const live = readableControl(session);
+  if (!live && action !== "reconnect" && action !== "enable" && action !== "disable") {
+    throw new Error("Claude can sign in to an MCP server only while this session's Claude is running. Send a message, then sign in again; the sign-in link appears as a card in the conversation.");
+  }
   let probe;
-  const control = readableControl(session) ?? (probe = createProbe());
+  const control = live ?? (probe = createProbe());
   try {
     if (action === "reconnect")
       await control.reconnectMcpServer?.(serverId);
@@ -13248,7 +13434,7 @@ function boundedMessage(error, fallback) {
   const message = error instanceof Error && error.message ? error.message : fallback;
   return truncateUtf8(message, MAX_MESSAGE_BYTES);
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function sdkRows(value) {
@@ -13256,7 +13442,7 @@ function sdkRows(value) {
     return [];
   const rows = [];
   for (const candidate of value.slice(0, COMMAND_CATALOGUE_LIMITS.maxCommands)) {
-    if (!isRecord2(candidate) || typeof candidate.name !== "string" || !candidate.name)
+    if (!isRecord3(candidate) || typeof candidate.name !== "string" || !candidate.name)
       continue;
     rows.push(candidate);
   }
@@ -13438,7 +13624,7 @@ function recordInitCommandInventory(session) {
   reannotate(session);
 }
 function recordCommandsChanged(session, message) {
-  if (!isRecord2(message) || !Array.isArray(message.commands))
+  if (!isRecord3(message) || !Array.isArray(message.commands))
     return;
   applyInventory(session, "replacement", sdkRows(message.commands));
 }
@@ -13587,10 +13773,10 @@ async function refreshClaudeCommandCatalogue(sessionId) {
         else
           failures.push(`${label}: ${boundedMessage(result.reason, "reload failed")}`);
       }
-      if (skills.status === "fulfilled" && isRecord2(skills.value)) {
+      if (skills.status === "fulfilled" && isRecord3(skills.value)) {
         session.commandSkillNames = sdkRows(skills.value.skills).map((skill) => skill.name);
       }
-      const errorCount = plugins.status === "fulfilled" && isRecord2(plugins.value) ? plugins.value.error_count : undefined;
+      const errorCount = plugins.status === "fulfilled" && isRecord3(plugins.value) ? plugins.value.error_count : undefined;
       if (typeof errorCount === "number" && errorCount > 0) {
         failures.push(`plugins: ${errorCount} failed to load`);
       }
@@ -13961,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) {
@@ -13973,7 +14285,9 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "adopt_workflow",
   "cancel_build_pipeline",
   "cancel_multi_review",
+  "cancel_schedule",
   "compare_project_files",
+  "create_schedule",
   "create_ticket",
   "get_build_pipeline",
   "get_environment",
@@ -13995,6 +14309,7 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "list_node_environments",
   "list_nodes",
   "list_projects",
+  "list_schedules",
   "list_tabs",
   "list_tickets",
   "list_workflows",
@@ -14052,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 = {
@@ -14813,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;
@@ -14885,6 +15215,7 @@ async function resolveQueryPlan(turn, sdkTextPrompt, testHooks) {
   });
   const mcpServersKey = createHash10("sha256").update(JSON.stringify(mcpServers)).digest("hex");
   return {
+    settingSources,
     cwd,
     policy,
     effortLevel,
@@ -14968,7 +15299,6 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
     } : { type: "adaptive", display: "summarized" },
     ...effectiveClaudeContext1m(options) ? { betas: ["context-1m-2025-08-07"] } : {},
     extraArgs: effectiveClaudeChrome(policy, options) ? { chrome: null } : { "no-chrome": null },
-    ...typeof options?.maxBudgetUsd === "number" && options.maxBudgetUsd > 0 ? { maxBudgetUsd: options.maxBudgetUsd } : {},
     includePartialMessages: true,
     forwardSubagentText: true,
     allowedTools,
@@ -14996,7 +15326,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
 
 `)
     },
-    settingSources: claudeSettingSources(policy, options?.includeLocalSettings),
+    settingSources: plan.settingSources,
     ...(fastMode || ultracode) && {
       settings: {
         ...fastMode && { fastMode: true },
@@ -15022,6 +15352,7 @@ function claudeQueryOptions(turn, plan, turnFor, mcp) {
       PostCompact: [{ hooks: [latestTurnHook((target) => target.recordPostCompact)] }]
     },
     includeHookEvents: true,
+    toolConfig: { askUserQuestion: { previewFormat: "markdown" } },
     canUseTool: (toolName, input, permissionContext) => turnFor(permissionContext?.toolUseID).canUseTool(toolName, input, permissionContext),
     onElicitation: (request, elicitationOptions) => answerClaudeElicitation(session, sessionId, request, elicitationOptions),
     onUserDialog: async () => ({ behavior: "cancelled" })
@@ -15162,11 +15493,11 @@ function handleAssistantMessage(turn, message) {
     state: "success"
   });
   reclaimReleasedTurnForAssistant(turn, message);
-  if (stream.pendingPlanRejectionFeedback) {
+  if (turn.pendingPlanRejectionFeedback) {
     debugLog("[session-manager] Claude responded after plan denial, clearing re-prompt feedback", {
       sessionId
     });
-    stream.pendingPlanRejectionFeedback = null;
+    turn.pendingPlanRejectionFeedback = null;
   }
   const { orderedParts, newTaskIds, contentBlockCount } = parseMessageContent(message, toolTracker, turn.mcpServerNames, activeTaskIds, taskRegistry, receivedAt, recordUnknownContentBlock);
   const evidenceParent = message.parent_tool_use_id;
@@ -15309,12 +15640,7 @@ async function handleInitMessage(turn, message) {
   }
   const allMcpServers = initMsg.mcp_servers || [];
   const regularMcpServers = allMcpServers.filter((s) => !s.name?.startsWith("plugin:"));
-  const mcpServerStatuses = regularMcpServers.map((s) => ({
-    name: s.name,
-    status: s.status === "connected" ? "connected" : "failed",
-    error: s.error,
-    tools: s.tools
-  }));
+  const mcpServerStatuses = regularMcpServers.map(initMcpServerStatus);
   const { statuses: pluginStatuses, errors: pluginErrors } = pluginStatusesFromInit(initMsg);
   const previousPluginErrors = new Set(session.pluginErrorSignatures);
   session.pluginErrorSignatures = pluginErrors.map(({ plugin, type, message, path, loaded }) => JSON.stringify([plugin, type, message, path, loaded]));
@@ -15686,14 +16012,6 @@ async function handleResultMessage(turn, message) {
         createdAt: new Date().toISOString()
       });
     }
-    if (resultMsg.subtype === "error_max_budget_usd") {
-      appendTranscriptNotice(session, sessionId, (event) => eventEmitter.emit(event), {
-        type: "status",
-        content: "Claude stopped because this session reached its spending cap.",
-        severity: "warning",
-        createdAt: new Date().toISOString()
-      });
-    }
     if (turn.options?.outputSchema) {
       const failure = structuredOutputFailure("claude", resultMsg.subtype === "error_max_structured_output_retries" ? "schema_retry_exhausted" : "provider_error", resultError, {
         requestId: turn.structuredRequestId,
@@ -16140,7 +16458,7 @@ function handleUserMessage(turn, message) {
   for (const taskId of completedTaskIds) {
     activeTaskIds.delete(taskId);
   }
-  if (stream.planApprovedThisTurn) {
+  if (turn.planApprovedThisTurn) {
     for (const tool of toolTracker.getTools()) {
       if (tool.toolName === "ExitPlanMode" && tool.toolState === "failure" && tool.toolUseId) {
         console.warn("[session-manager] ExitPlanMode reported failure despite user approval — overriding to success and scheduling continuation re-prompt", { sessionId, toolUseId: tool.toolUseId, sdkError: tool.toolError });
@@ -16149,8 +16467,8 @@ function handleUserMessage(turn, message) {
           output: "Plan approved by the user. Proceeding with implementation.",
           error: undefined
         });
-        if (!stream.pendingPlanApprovalContinuation) {
-          stream.pendingPlanApprovalContinuation = "The user has approved your plan. Please proceed with implementing it now. You are no longer in plan mode and may write, edit, and run commands as needed.";
+        if (!turn.pendingPlanApprovalContinuation) {
+          turn.pendingPlanApprovalContinuation = "The user has approved your plan. Please proceed with implementing it now. You are no longer in plan mode and may write, edit, and run commands as needed.";
         }
       }
     }
@@ -16226,214 +16544,223 @@ function boundedPlan(content) {
     planTruncated: true
   };
 }
-async function turnCanUseTool(turn, toolName, input, permissionContext) {
-  const { session, sessionId, stream } = turn;
-  if (toolName === "AskUserQuestion") {
-    const questions = Array.isArray(input.questions) ? input.questions : [];
-    const questionTexts = questions.map((question) => question.question);
-    if (new Set(questionTexts).size !== questionTexts.length) {
-      return {
-        behavior: "deny",
-        message: "AskUserQuestion contains duplicate question text. Ask the questions again with distinct wording."
-      };
-    }
-    const questionId = permissionContext?.requestId || generateMessageId();
-    const requestedAt = Date.now();
-    const questionRequest = {
-      id: questionId,
-      sessionId,
-      questions,
-      toolUseId: permissionContext?.toolUseID ?? questionId,
-      requestedAt,
-      expiresAt: requestedAt + QUESTION_TIMEOUT_MS
+async function askUserQuestion(turn, input, permissionContext) {
+  const { sessionId } = turn;
+  const questions = Array.isArray(input.questions) ? input.questions : [];
+  const questionTexts = questions.map((question) => question.question);
+  if (new Set(questionTexts).size !== questionTexts.length) {
+    return {
+      behavior: "deny",
+      message: "AskUserQuestion contains duplicate question text. Ask the questions again with distinct wording."
     };
-    if (!canAdmitInteraction(questionRequest, "questions")) {
-      return {
-        behavior: "deny",
-        message: "Too many pending interactions. Answer an existing request first."
-      };
-    }
-    let rejectOnExpiry;
-    const timeoutPromise = new Promise((_, reject) => {
-      rejectOnExpiry = reject;
-    });
-    const deadline = new InteractionDeadline({
-      requestedAt,
-      windowMs: QUESTION_TIMEOUT_MS,
-      onExpire: () => rejectOnExpiry(new Error(interactionExpiryMessage("Question", deadline)))
-    });
-    const releaseDeadline = registerInteractionDeadline("questions", questionRequest, deadline);
-    pendingQuestions.set(questionId, questionRequest);
-    eventEmitter.emit({
-      type: "question.asked",
-      sessionId,
-      data: questionRequest
-    });
-    const answerPromise = new Promise((resolve, reject) => {
-      questionResolvers.set(questionId, { resolve, reject });
+  }
+  const questionId = permissionContext?.requestId || generateMessageId();
+  const requestedAt = Date.now();
+  const questionRequest = {
+    id: questionId,
+    sessionId,
+    questions,
+    toolUseId: permissionContext?.toolUseID ?? questionId,
+    requestedAt,
+    expiresAt: requestedAt + QUESTION_TIMEOUT_MS
+  };
+  if (!canAdmitInteraction(questionRequest, "questions")) {
+    return {
+      behavior: "deny",
+      message: "Too many pending interactions. Answer an existing request first."
+    };
+  }
+  let rejectOnExpiry;
+  const timeoutPromise = new Promise((_, reject) => {
+    rejectOnExpiry = reject;
+  });
+  const deadline = new InteractionDeadline({
+    requestedAt,
+    windowMs: QUESTION_TIMEOUT_MS,
+    onExpire: () => rejectOnExpiry(new Error(interactionExpiryMessage("Question", deadline)))
+  });
+  const releaseDeadline = registerInteractionDeadline("questions", questionRequest, deadline);
+  pendingQuestions.set(questionId, questionRequest);
+  eventEmitter.emit({
+    type: "question.asked",
+    sessionId,
+    data: questionRequest
+  });
+  const answerPromise = new Promise((resolve, reject) => {
+    questionResolvers.set(questionId, { resolve, reject });
+  });
+  try {
+    const answers = await Promise.race([answerPromise, timeoutPromise]);
+    console.log("[session-manager] Received question answers", {
+      questionId,
+      answerCount: Object.keys(answers).length
     });
-    try {
-      const answers = await Promise.race([answerPromise, timeoutPromise]);
-      console.log("[session-manager] Received question answers", {
-        questionId,
-        answerCount: Object.keys(answers).length
-      });
-      return {
-        behavior: "allow",
-        updatedInput: {
-          questions: input.questions,
-          answers
-        }
-      };
-    } catch (error) {
-      console.error("[session-manager] Error waiting for answer:", error);
-      const message = error instanceof Error ? error.message : "Question was cancelled";
-      if (pendingQuestions.has(questionId)) {
-        eventEmitter.emit({
-          type: "question.answered",
-          sessionId,
-          data: { requestId: questionId, cancelled: true }
-        });
+    return {
+      behavior: "allow",
+      updatedInput: {
+        questions: input.questions,
+        answers
       }
-      return { behavior: "deny", message };
-    } finally {
-      releaseDeadline();
-      pendingQuestions.delete(questionId);
-      questionResolvers.delete(questionId);
+    };
+  } catch (error) {
+    console.error("[session-manager] Error waiting for answer:", error);
+    const message = error instanceof Error ? error.message : "Question was cancelled";
+    if (pendingQuestions.has(questionId)) {
+      eventEmitter.emit({
+        type: "question.answered",
+        sessionId,
+        data: { requestId: questionId, cancelled: true }
+      });
     }
+    return { behavior: "deny", message };
+  } finally {
+    releaseDeadline();
+    pendingQuestions.delete(questionId);
+    questionResolvers.delete(questionId);
   }
-  if (toolName === "EnterPlanMode") {
-    debugLog("[session-manager] EnterPlanMode requested", { sessionId });
-    try {
-      await applySessionPlanMode(session, true);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Failed to persist plan mode";
-      return {
-        behavior: "deny",
-        message: `Plan mode could not be persisted safely: ${message}`
-      };
-    }
-    eventEmitter.emit({
-      type: "plan.enter-requested",
-      sessionId,
-      data: { sessionId }
-    });
+}
+async function enterPlanMode(turn, input) {
+  const { session, sessionId } = turn;
+  debugLog("[session-manager] EnterPlanMode requested", { sessionId });
+  try {
+    await applySessionPlanMode(session, true);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to persist plan mode";
     return {
-      behavior: "allow",
-      updatedInput: input
+      behavior: "deny",
+      message: `Plan mode could not be persisted safely: ${message}`
     };
   }
-  if (toolName === "ExitPlanMode") {
-    debugLog("[session-manager] ExitPlanMode requested, waiting for user approval", {
-      sessionId
-    });
-    const approvalId = permissionContext?.requestId || generateMessageId();
-    const directPlan = boundedPlan(input?.plan);
-    const requestedAt = Date.now();
-    const approvalRequest = {
-      id: approvalId,
-      sessionId,
-      toolUseId: permissionContext?.toolUseID ?? approvalId,
-      ...directPlan,
-      requestedAt,
-      expiresAt: requestedAt + PLAN_APPROVAL_TIMEOUT_MS
+  eventEmitter.emit({
+    type: "plan.enter-requested",
+    sessionId,
+    data: { sessionId }
+  });
+  return {
+    behavior: "allow",
+    updatedInput: input
+  };
+}
+async function requestPlanApproval(turn, input, permissionContext) {
+  const { session, sessionId } = turn;
+  debugLog("[session-manager] ExitPlanMode requested, waiting for user approval", {
+    sessionId
+  });
+  const approvalId = permissionContext?.requestId || generateMessageId();
+  const directPlan = boundedPlan(input?.plan);
+  const requestedAt = Date.now();
+  const approvalRequest = {
+    id: approvalId,
+    sessionId,
+    toolUseId: permissionContext?.toolUseID ?? approvalId,
+    ...directPlan,
+    requestedAt,
+    expiresAt: requestedAt + PLAN_APPROVAL_TIMEOUT_MS
+  };
+  if (!canAdmitInteraction(approvalRequest, "approvals")) {
+    return {
+      behavior: "deny",
+      message: "Too many pending interactions. Answer an existing request first."
     };
-    if (!canAdmitInteraction(approvalRequest, "approvals")) {
-      return {
-        behavior: "deny",
-        message: "Too many pending interactions. Answer an existing request first."
-      };
-    }
-    let rejectOnExpiry;
-    const timeoutPromise = new Promise((_, reject) => {
-      rejectOnExpiry = reject;
-    });
-    const deadline = new InteractionDeadline({
-      requestedAt,
-      windowMs: PLAN_APPROVAL_TIMEOUT_MS,
-      onExpire: () => rejectOnExpiry(new Error(interactionExpiryMessage("Plan approval", deadline)))
-    });
-    const releaseDeadline = registerInteractionDeadline("plan-approvals", approvalRequest, deadline);
-    pendingPlanApprovals.set(approvalId, approvalRequest);
-    const approvalPromise = new Promise((resolve, reject) => {
-      planApprovalResolvers.set(approvalId, { resolve, reject });
-    });
-    eventEmitter.emit({
-      type: "plan.approval-requested",
-      sessionId,
-      data: approvalRequest
+  }
+  let rejectOnExpiry;
+  const timeoutPromise = new Promise((_, reject) => {
+    rejectOnExpiry = reject;
+  });
+  const deadline = new InteractionDeadline({
+    requestedAt,
+    windowMs: PLAN_APPROVAL_TIMEOUT_MS,
+    onExpire: () => rejectOnExpiry(new Error(interactionExpiryMessage("Plan approval", deadline)))
+  });
+  const releaseDeadline = registerInteractionDeadline("plan-approvals", approvalRequest, deadline);
+  pendingPlanApprovals.set(approvalId, approvalRequest);
+  const approvalPromise = new Promise((resolve, reject) => {
+    planApprovalResolvers.set(approvalId, { resolve, reject });
+  });
+  eventEmitter.emit({
+    type: "plan.approval-requested",
+    sessionId,
+    data: approvalRequest
+  });
+  try {
+    const response = await Promise.race([approvalPromise, timeoutPromise]);
+    console.log("[session-manager] Plan approval result", {
+      approvalId,
+      approved: response.approved,
+      hasFeedback: typeof response.feedback === "string" && response.feedback.length > 0
     });
-    try {
-      const response = await Promise.race([approvalPromise, timeoutPromise]);
-      console.log("[session-manager] Plan approval result", {
-        approvalId,
-        approved: response.approved,
-        hasFeedback: typeof response.feedback === "string" && response.feedback.length > 0
-      });
-      if (response.approved) {
+    if (response.approved) {
+      try {
+        const control = session.queryControl;
+        if (!control?.setPermissionMode)
+          throw new Error("Claude permission control is unavailable");
+        await control.setPermissionMode(claudePermissionMode(claudeTurnPolicy(session.executionPolicy, turn.options?.readOnly), turn.options?.approvalMode));
+        await applySessionPlanMode(session, false);
+      } catch (error) {
         try {
           const control = session.queryControl;
           if (!control?.setPermissionMode)
             throw new Error("Claude permission control is unavailable");
-          await control.setPermissionMode(claudePermissionMode(claudeTurnPolicy(session.executionPolicy, turn.options?.readOnly), turn.options?.approvalMode));
-          await applySessionPlanMode(session, false);
-        } catch (error) {
-          try {
-            const control = session.queryControl;
-            if (!control?.setPermissionMode)
-              throw new Error("Claude permission control is unavailable");
-            await control.setPermissionMode("plan");
-          } catch {
-            abortSession(sessionId);
-          }
-          const message = error instanceof Error ? error.message : "Failed to persist plan mode";
-          return {
-            behavior: "deny",
-            message: `Plan mode could not be exited safely: ${message}`
-          };
+          await control.setPermissionMode("plan");
+        } catch {
+          abortSession(sessionId);
         }
-        stream.planApprovedThisTurn = true;
-        eventEmitter.emit({
-          type: "plan.exit-requested",
-          sessionId,
-          data: { sessionId }
-        });
-        return {
-          behavior: "allow",
-          updatedInput: input
-        };
-      } else {
-        const feedbackMessage = response.feedback ? `User feedback: "${response.feedback}"` : "No specific feedback was provided.";
-        const denyMessage = `User rejected the plan. ${feedbackMessage} Please revise your approach based on this feedback.`;
-        stream.pendingPlanRejectionFeedback = response.feedback ? `I've reviewed the plan and I'd like changes: ${response.feedback}
-
-Please revise the plan based on this feedback.` : `I've reviewed the plan and I don't approve it as-is. Please revise your approach.`;
+        const message = error instanceof Error ? error.message : "Failed to persist plan mode";
         return {
           behavior: "deny",
-          message: denyMessage
+          message: `Plan mode could not be exited safely: ${message}`
         };
       }
-    } catch (error) {
-      console.error("[session-manager] Error waiting for plan approval:", error);
-      const errorMessage = error instanceof Error ? error.message : "Plan approval was cancelled";
-      if (pendingPlanApprovals.has(approvalId)) {
-        eventEmitter.emit({
-          type: "plan.approval-responded",
-          sessionId,
-          data: {
-            requestId: approvalId,
-            approved: false,
-            cancelled: true
-          }
-        });
-      }
-      return { behavior: "deny", message: errorMessage };
-    } finally {
-      releaseDeadline();
-      pendingPlanApprovals.delete(approvalId);
-      planApprovalResolvers.delete(approvalId);
+      turn.planApprovedThisTurn = true;
+      eventEmitter.emit({
+        type: "plan.exit-requested",
+        sessionId,
+        data: { sessionId }
+      });
+      return {
+        behavior: "allow",
+        updatedInput: input
+      };
+    } else {
+      const feedbackMessage = response.feedback ? `User feedback: "${response.feedback}"` : "No specific feedback was provided.";
+      const denyMessage = `User rejected the plan. ${feedbackMessage} Please revise your approach based on this feedback.`;
+      turn.pendingPlanRejectionFeedback = response.feedback ? `I've reviewed the plan and I'd like changes: ${response.feedback}
+
+Please revise the plan based on this feedback.` : `I've reviewed the plan and I don't approve it as-is. Please revise your approach.`;
+      return {
+        behavior: "deny",
+        message: denyMessage
+      };
+    }
+  } catch (error) {
+    console.error("[session-manager] Error waiting for plan approval:", error);
+    const errorMessage = error instanceof Error ? error.message : "Plan approval was cancelled";
+    if (pendingPlanApprovals.has(approvalId)) {
+      eventEmitter.emit({
+        type: "plan.approval-responded",
+        sessionId,
+        data: {
+          requestId: approvalId,
+          approved: false,
+          cancelled: true
+        }
+      });
     }
+    return { behavior: "deny", message: errorMessage };
+  } finally {
+    releaseDeadline();
+    pendingPlanApprovals.delete(approvalId);
+    planApprovalResolvers.delete(approvalId);
   }
+}
+async function turnCanUseTool(turn, toolName, input, permissionContext) {
+  const { session, sessionId } = turn;
+  if (toolName === "AskUserQuestion")
+    return askUserQuestion(turn, input, permissionContext);
+  if (toolName === "EnterPlanMode")
+    return enterPlanMode(turn, input);
+  if (toolName === "ExitPlanMode")
+    return requestPlanApproval(turn, input, permissionContext);
   if ((claudeWorkflowResultTools(turn.mcpServerNames).includes(toolName) || claudeArtifactServerTools(turn.mcpServerNames).includes(toolName)) && !session.executionPolicy?.toolPolicy?.deny?.includes(toolName)) {
     return { behavior: "allow", updatedInput: input };
   }
@@ -16527,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;
@@ -16585,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 {
@@ -16643,6 +16974,7 @@ function launchClaudeRuntime(turn, plan) {
     activeTaskIds: stream.activeTaskIds,
     launch: {
       ...claudeLaunchedProfile(session, options),
+      settingSources: JSON.stringify(plan.settingSources),
       ...claudeLaunchResourceProfile(plugins, queryEnvironment)
     },
     mcpServers: mcpServersKey,
@@ -16679,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);
@@ -16693,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;
@@ -16735,9 +17068,9 @@ function settleTurnEnd(turn) {
     }
     return;
   }
-  if (stream.pendingPlanRejectionFeedback && !abortController.signal.aborted && !options?._isReprompt && !turn.superseded) {
-    const feedbackPrompt = stream.pendingPlanRejectionFeedback;
-    stream.pendingPlanRejectionFeedback = null;
+  if (turn.pendingPlanRejectionFeedback && !abortController.signal.aborted && !options?._isReprompt && !turn.superseded) {
+    const feedbackPrompt = turn.pendingPlanRejectionFeedback;
+    turn.pendingPlanRejectionFeedback = null;
     debugLog("[session-manager] Re-prompting with plan rejection feedback", { sessionId });
     session.status = "idle";
     session.abortController = undefined;
@@ -16757,9 +17090,9 @@ function settleTurnEnd(turn) {
       failureLog: "[session-manager] Failed to re-prompt with plan feedback:"
     };
   }
-  if (stream.pendingPlanApprovalContinuation && !abortController.signal.aborted && !options?._isReprompt && !turn.superseded) {
-    const continuationPrompt = stream.pendingPlanApprovalContinuation;
-    stream.pendingPlanApprovalContinuation = null;
+  if (turn.pendingPlanApprovalContinuation && !abortController.signal.aborted && !options?._isReprompt && !turn.superseded) {
+    const continuationPrompt = turn.pendingPlanApprovalContinuation;
+    turn.pendingPlanApprovalContinuation = null;
     debugLog("[session-manager] Re-prompting after approved-plan ExitPlanMode failure", {
       sessionId
     });
@@ -16826,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);
@@ -16854,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);
@@ -17326,14 +17661,14 @@ var SESSION_ACTIVITY_BATCH_LIMITS = {
 };
 var SESSION_ACTIVITY_STATES = new Set(["idle", "working", "waiting", "missing"]);
 var encoder3 = new TextEncoder;
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isBatchableSessionId(value) {
   return typeof value === "string" && value.length > 0 && encoder3.encode(value).byteLength <= SESSION_ACTIVITY_BATCH_LIMITS.maxSessionIdBytes;
 }
 function parseSessionActivityObservation(value) {
-  if (!isRecord3(value))
+  if (!isRecord4(value))
     return;
   const { activity, readyForInput, completionPending, asyncQuestionItemIds, closing } = value;
   const { contentRevision } = value;
@@ -17367,7 +17702,7 @@ function isContentRevision(value) {
   return typeof value === "string" && value.length > 0 && value.length <= SESSION_ACTIVITY_BATCH_LIMITS.maxContentRevisionLength;
 }
 function parseSessionActivityBatchRequest(value) {
-  if (!isRecord3(value))
+  if (!isRecord4(value))
     return { ok: false, error: "Expected a JSON object" };
   if (value.version !== SESSION_ACTIVITY_BATCH_VERSION) {
     return { ok: false, error: "Unsupported activity batch version" };
@@ -17610,7 +17945,7 @@ function decodeLocator(locator) {
   }
   try {
     const body = JSON.parse(Buffer3.from(locator.slice(LOCATOR_PREFIX.length), "base64url").toString("utf8"));
-    if (!isRecord4(body))
+    if (!isRecord5(body))
       return;
     const { m, p, d } = body;
     if (typeof m !== "string" || typeof d !== "string" || !Array.isArray(p))
@@ -17630,12 +17965,12 @@ var DETAIL_FIELDS = new Set([
   "toolDiff",
   "fileDataUrl"
 ]);
-function isRecord4(value) {
+function isRecord5(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function heavyDiff(part) {
   const diff = part.toolDiff;
-  if (!isRecord4(diff))
+  if (!isRecord5(diff))
     return;
   return typeof diff.diff === "string" || typeof diff.before === "string" || typeof diff.after === "string" ? diff : undefined;
 }
@@ -17657,7 +17992,7 @@ function detailPayload(part) {
   return Object.keys(payload).length > 0 ? payload : undefined;
 }
 function detailInputs(part) {
-  const diff = isRecord4(part.toolDiff) ? part.toolDiff : undefined;
+  const diff = isRecord5(part.toolDiff) ? part.toolDiff : undefined;
   return [
     part.type,
     part.content,
@@ -17687,7 +18022,7 @@ function digestPayload(payload) {
   };
 }
 function topLevelKey(part, index) {
-  if (isRecord4(part)) {
+  if (isRecord5(part)) {
     if (typeof part.sourcePartId === "string" && part.sourcePartId.length <= 512) {
       return `s:${part.sourcePartId}`;
     }
@@ -17698,7 +18033,7 @@ function topLevelKey(part, index) {
   return `i:${index}`;
 }
 function summarizePart(raw, messageId, path, depth) {
-  if (!isRecord4(raw) || depth > MAX_SUMMARY_DEPTH)
+  if (!isRecord5(raw) || depth > MAX_SUMMARY_DEPTH)
     return raw;
   const part = raw;
   let summary;
@@ -17750,7 +18085,7 @@ function summarizePart(raw, messageId, path, depth) {
     if (changed)
       writable()[field] = next;
   }
-  if (isRecord4(part.task)) {
+  if (isRecord5(part.task)) {
     const task = summarizePart(part.task, messageId, [...path, "task"], depth + 1);
     if (task !== part.task)
       writable().task = task;
@@ -17758,7 +18093,7 @@ function summarizePart(raw, messageId, path, depth) {
   return summary ?? part;
 }
 function isSummarizable(message) {
-  return isRecord4(message) && typeof message.id === "string" && Array.isArray(message.parts);
+  return isRecord5(message) && typeof message.id === "string" && Array.isArray(message.parts);
 }
 function summarizeBridgeMessage(message) {
   if (!isSummarizable(message))
@@ -17784,15 +18119,15 @@ function resolvePath2(message, path) {
   let current;
   if (top.startsWith("s:")) {
     const id = top.slice(2);
-    current = message.parts.find((part) => isRecord4(part) && part.sourcePartId === id);
+    current = message.parts.find((part) => isRecord5(part) && part.sourcePartId === id);
   } else if (top.startsWith("t:")) {
     const id = top.slice(2);
-    current = message.parts.find((part) => isRecord4(part) && part.toolUseId === id && typeof part.sourcePartId !== "string");
+    current = message.parts.find((part) => isRecord5(part) && part.toolUseId === id && typeof part.sourcePartId !== "string");
   } else if (top.startsWith("i:")) {
     current = message.parts[Number(top.slice(2))];
   }
   for (let index = 0;index < rest.length; index += 1) {
-    if (!isRecord4(current))
+    if (!isRecord5(current))
       return;
     const field = rest[index];
     if (field === "task") {
@@ -17825,7 +18160,7 @@ function readBridgeTranscriptDetail(messages, locator) {
   if (!message)
     return { version: 1, status: "missing" };
   const part = resolvePath2(message, body.p);
-  if (!isRecord4(part))
+  if (!isRecord5(part))
     return { version: 1, status: "missing" };
   const payload = detailPayload(part);
   if (!payload)
@@ -17928,7 +18263,7 @@ function decodePageCursor(cursor) {
   }
   try {
     const body = JSON.parse(Buffer3.from(cursor.slice(PAGE_CURSOR_PREFIX.length), "base64url").toString("utf8"));
-    if (!isRecord4(body))
+    if (!isRecord5(body))
       return;
     const { g, e, b } = body;
     if (typeof g !== "string" || typeof e !== "string")
@@ -18056,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);
@@ -18225,11 +18565,14 @@ 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,
-    policy: sessionData.executionPolicy,
+    policy: claudeReportedPolicy(sessionData),
     rateLimits: sessionData.rateLimits,
     promptSuggestion: sessionData.promptSuggestion,
     activity: sessionData.activity,
@@ -18329,7 +18672,7 @@ session.post("/:id/config", async (c) => {
   } else if (permissionMode === "plan" || permissionMode === "bypassPermissions") {
     await setSessionPreferences(sessionData.id, { planMode: permissionMode === "plan" });
   }
-  return c.json({ ok: true, policy: sessionData.executionPolicy });
+  return c.json({ ok: true, policy: claudeReportedPolicy(sessionData) });
 });
 session.get("/:id/commands", async (c) => {
   try {
@@ -18421,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");
@@ -18527,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,
@@ -18779,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");
   }
@@ -19629,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
@@ -20548,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;
   }