orkestrator 2.30.0-beta → 2.31.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"]);
@@ -3764,7 +3771,86 @@ 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 entries of Object.values(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 });
+    }
+  }
+  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]");
 
 // ../../bridges/claude-bridge/src/services/json-file-cache.ts
 import { createHash as createHash4 } from "node:crypto";
@@ -3866,10 +3952,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 +3978,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 +3992,13 @@ 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
-      });
-    }
-  }
-  return plugins;
+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 +4014,19 @@ 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) {
+async function getMergedPlugins(cwd, includeProjectSources = true) {
   const [global2, cliInstalled, projectGlobal, projectLocal] = await Promise.all([
     loadGlobalPlugins(),
     loadCliInstalledPlugins(),
-    loadProjectOverridesFromGlobal(cwd),
-    loadProjectPlugins(cwd)
+    includeProjectSources ? loadProjectOverridesFromGlobal(cwd) : [],
+    includeProjectSources ? loadProjectPlugins(cwd) : []
   ]);
-  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());
+  return mergeClaudePluginLayers({ global: global2, cliInstalled, projectGlobal, projectLocal }, { cwd, home: claudeHome(), includeProjectSources }).map((path) => ({ type: "local", path }));
 }
 async function getPluginsForSdk(cwd, includeProjectSources = true) {
-  const configs = includeProjectSources ? await getMergedPlugins(cwd) : [...await loadGlobalPlugins(), ...await loadCliInstalledPlugins()];
+  const configs = await getMergedPlugins(cwd, includeProjectSources);
   const validPlugins = [];
   for (const config of configs) {
     if (await pathExists(config.path)) {
@@ -4117,90 +4152,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 +4226,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 +4386,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, "_");
@@ -4882,6 +4935,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";
 }
@@ -7385,7 +7446,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(),
@@ -7487,8 +7547,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 +7703,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 +7860,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 +8142,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 +9471,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 +9496,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 +9515,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 +9533,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 +10504,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 +10527,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 +10558,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 +10789,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 +10901,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 +10956,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 +11001,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 +11044,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 +11059,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 +11090,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 +11098,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 +11114,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
@@ -11769,7 +11849,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,
@@ -12332,7 +12415,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 +12435,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 +12450,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 +12465,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 +12474,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 +12554,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 +12568,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 +12771,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 +13053,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 +13075,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 +13112,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 +13361,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 +13369,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 +13551,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 +13700,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`);
       }
@@ -13973,7 +14086,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 +14110,7 @@ var COORDINATOR_CONTROL_TOOL_NAMES = Object.freeze([
   "list_node_environments",
   "list_nodes",
   "list_projects",
+  "list_schedules",
   "list_tabs",
   "list_tickets",
   "list_workflows",
@@ -14968,7 +15084,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,
@@ -15022,6 +15137,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 +15278,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 +15425,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 +15797,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 +16243,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 +16252,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 +16329,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 };
   }
@@ -16735,9 +16847,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 +16869,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
     });
@@ -17326,14 +17438,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 +17479,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 +17722,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 +17742,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 +17769,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 +17799,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 +17810,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 +17862,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 +17870,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 +17896,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 +17937,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 +18040,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")
@@ -18229,7 +18341,7 @@ session.get("/:id", async (c) => {
     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 +18441,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 {