@bastani/atomic 0.9.16-alpha.10 → 0.9.16-alpha.11

package/dist/builtin/workflows/src/extension/index.bundle.mjs

@@ -1126,15 +1126,15 @@ ${chalk.bold("Options:")}
   --name, -n <name>              Set session display name
   --models <patterns>            Comma-separated model patterns for ctrl+p cycling
                                  Supports globs (anthropic/*, *sonnet*) and fuzzy matching
-  --no-tools, -nt                Disable all tools by default (built-in and extension)
+  --no-tools, -nt                Disable every tool except mandatory ordinary intercom
   --no-builtin-tools, -nbt       Disable built-in tools by default but keep extension/custom tools enabled
-  --tools, -t <tools>            Comma-separated allowlist of tool names to enable
-                                 Applies to built-in, extension, and custom tools
-  --exclude-tools, -xt <tools>   Comma-separated denylist of tool names to disable
-                                 Applies to built-in, extension, and custom tools
+  --tools, -t <tools>            Comma-separated allowlist of non-mandatory tool names
+                                 Mandatory ordinary intercom remains available
+  --exclude-tools, -xt <tools>   Comma-separated denylist of non-mandatory tool names
+                                 Mandatory ordinary intercom cannot be excluded
   --thinking <level>             Set thinking level: off, minimal, low, medium, high, xhigh, max
   --extension, -e <path>         Load an extension file (can be used multiple times)
-  --no-extensions, -ne           Disable extension discovery (explicit -e paths still work)
+  --no-extensions, -ne           Disable optional extension discovery; mandatory bundled Intercom remains loaded
   --skill <path>                 Load a skill file or directory (can be used multiple times)
   --no-skills, -ns               Disable skills discovery and loading
   --prompt-template <path>       Load a prompt template file or directory (can be used multiple times)
@@ -10019,11 +10019,13 @@ function runSynchronousCallback(descriptor, callback) {
   }
 }
 async function runCallback(descriptor, callback) {
+  if (!reporter)
+    return callback();
+  await yieldToEventLoop();
   const active = beginActivity(descriptor);
   if (!active)
     return callback();
   try {
-    await yieldToEventLoop();
     return await callback();
   } finally {
     active.reporter.finished(active.activity.id);
@@ -13013,12 +13015,45 @@ var init_runner_events = __esm(() => {
   init_callback_activity();
 });
 
+// src/core/mandatory-runtime-tools.ts
+function markTrustedMandatoryRuntimeExtension(extension) {
+  extension.sourceInfo = { ...extension.sourceInfo, configurationOrigin: "bundled" };
+  for (const registration of extension.tools.values()) {
+    registration.sourceInfo = extension.sourceInfo;
+    if (MANDATORY_TOOL_NAMES.has(registration.definition.name)) {
+      TRUSTED_MANDATORY_DEFINITIONS.add(registration.definition);
+    }
+  }
+  for (const command of extension.commands.values())
+    command.sourceInfo = extension.sourceInfo;
+}
+function isTrustedMandatoryRuntimeTool(registration) {
+  return MANDATORY_TOOL_NAMES.has(registration.definition.name) && TRUSTED_MANDATORY_DEFINITIONS.has(registration.definition);
+}
+function isMandatoryRuntimeTool(name) {
+  return MANDATORY_TOOL_NAMES.has(name);
+}
+function appendRegisteredMandatoryTools(tools, registry) {
+  for (const name of MANDATORY_TOOL_NAMES) {
+    const tool = registry.get(name);
+    if (tool && !tools.some((candidate) => candidate.name === name))
+      tools.push(tool);
+  }
+  return tools;
+}
+var MANDATORY_TOOL_NAMES, TRUSTED_MANDATORY_DEFINITIONS;
+var init_mandatory_runtime_tools = __esm(() => {
+  MANDATORY_TOOL_NAMES = new Set(["intercom"]);
+  TRUSTED_MANDATORY_DEFINITIONS = new WeakSet;
+});
+
 // src/core/extensions/runner-registries.ts
 function collectRegisteredTools(extensions) {
   const toolsByName = new Map;
   for (const ext of extensions) {
     for (const tool of ext.tools.values()) {
-      if (!toolsByName.has(tool.definition.name)) {
+      const existing = toolsByName.get(tool.definition.name);
+      if (!existing || isMandatoryRuntimeTool(tool.definition.name) && isTrustedMandatoryRuntimeTool(tool)) {
         toolsByName.set(tool.definition.name, tool);
       }
     }
@@ -13026,13 +13061,16 @@ function collectRegisteredTools(extensions) {
   return Array.from(toolsByName.values());
 }
 function findToolDefinition(extensions, toolName) {
+  let first;
   for (const ext of extensions) {
     const tool = ext.tools.get(toolName);
-    if (tool) {
+    if (!tool)
+      continue;
+    first ??= tool;
+    if (isMandatoryRuntimeTool(toolName) && isTrustedMandatoryRuntimeTool(tool))
       return tool.definition;
-    }
   }
-  return;
+  return first?.definition;
 }
 function collectFlags(extensions) {
   const allFlags = new Map;
@@ -13100,6 +13138,9 @@ function resolveRegisteredCommands(extensions) {
     return { ...command, invocationName };
   });
 }
+var init_runner_registries = __esm(() => {
+  init_mandatory_runtime_tools();
+});
 
 // src/core/extensions/runner-shortcuts.ts
 function resolveExtensionShortcuts(extensions, resolvedKeybindings, hasUI) {
@@ -13163,6 +13204,7 @@ var init_runner_shortcuts = __esm(() => {
     "app.thinking.toggle",
     "app.editor.external",
     "app.message.followUp",
+    "app.message.copy",
     "tui.input.submit",
     "tui.select.confirm",
     "tui.select.cancel",
@@ -13654,6 +13696,7 @@ var init_runner = __esm(() => {
   init_loader_runtime();
   init_runner_context();
   init_runner_events();
+  init_runner_registries();
   init_runner_shortcuts();
   init_runner_ui();
   init_stale_context();
@@ -17600,14 +17643,13 @@ function getToolDefinition(name) {
 }
 function setActiveToolsByName(toolNames) {
   const tools = [];
-  const validToolNames = [];
   for (const name of toolNames) {
     const tool = this._toolRegistry.get(name);
-    if (tool) {
+    if (tool)
       tools.push(tool);
-      validToolNames.push(name);
-    }
   }
+  appendRegisteredMandatoryTools(tools, this._toolRegistry);
+  const validToolNames = tools.map((tool) => tool.name);
   this.agent.state.tools = tools;
   this._baseSystemPrompt = this._rebuildSystemPrompt(validToolNames);
   this.agent.state.systemPrompt = this._systemPromptOverride ?? this._baseSystemPrompt;
@@ -17664,7 +17706,7 @@ function _rebuildSystemPrompt(toolNames) {
     customPrompt: loaderSystemPrompt,
     appendSystemPrompt,
     selectedTools: validToolNames,
-    excludedTools: this._excludedToolNames ? Array.from(this._excludedToolNames) : undefined,
+    excludedTools: this._excludedToolNames ? Array.from(this._excludedToolNames).filter((name) => !isMandatoryRuntimeTool(name)) : undefined,
     toolSnippets,
     promptGuidelines
   };
@@ -17677,6 +17719,7 @@ function _refreshBaseSystemPromptFromActiveTools() {
 }
 var agentSessionStateMethods;
 var init_agent_session_state = __esm(() => {
+  init_mandatory_runtime_tools();
   init_skill_catalog();
   init_system_prompt();
   agentSessionStateMethods = {
@@ -18705,31 +18748,14 @@ function _installAgentToolHooks() {
 function _installAgentNextTurnRefresh() {
   const previousPrepareNextTurnWithContext = this.agent.prepareNextTurnWithContext ?? (this.agent.prepareNextTurn ? async (_turn, signal) => await this.agent.prepareNextTurn?.(signal) : undefined);
   const previousShouldStopAfterTurn = this.agent.shouldStopAfterTurn;
-  let pendingStopResult;
-  const pendingStopMatches = (turn) => {
-    const pending = pendingStopResult;
-    return pending?.message === turn.message && pending.toolResults === turn.toolResults && pending.newMessages === turn.newMessages;
-  };
-  const clearPendingStopResult = (turn) => {
-    if (pendingStopMatches(turn))
-      pendingStopResult = undefined;
-  };
   this.agent.shouldStopAfterTurn = async (turn, signal) => {
-    const pending = pendingStopResult;
-    if (pending && pendingStopMatches(turn)) {
-      pendingStopResult = undefined;
-      return pending.shouldStop;
-    }
-    return await previousShouldStopAfterTurn?.(turn, signal) ?? false;
-  };
-  const cacheStopResult = async (turn, signal) => {
+    const toolCallIds = turn.message.content.filter((part) => part.type === "toolCall").map((part) => part.id);
+    const terminatingBatch = toolCallIds.length > 0 && toolCallIds.every((id) => this._terminatingToolCallIds.has(id));
+    for (const id of toolCallIds)
+      this._terminatingToolCallIds.delete(id);
     const shouldStop = await previousShouldStopAfterTurn?.(turn, signal) ?? false;
-    pendingStopResult = {
-      message: turn.message,
-      toolResults: turn.toolResults,
-      newMessages: turn.newMessages,
-      shouldStop
-    };
+    this._stopAfterTurnBlockedContinuation = shouldStop;
+    await settleFallbackAfterTurn(this, turn, terminatingBatch);
     return shouldStop;
   };
   const previousTransformContext = this.agent.transformContext;
@@ -18757,68 +18783,7 @@ function _installAgentNextTurnRefresh() {
       thinkingLevel: this.agent.state.thinkingLevel
     };
   };
-  let deferredPreparation;
-  const prepareDeferredTurn = async (loopConfig) => {
-    const deferred = deferredPreparation;
-    if (!deferred)
-      return;
-    deferredPreparation = undefined;
-    const snapshot = await prepareTurn(deferred.turn, deferred.signal);
-    const nextContext = snapshot.context ?? deferred.turn.context;
-    deferred.loopContext.systemPrompt = nextContext.systemPrompt;
-    deferred.loopContext.messages = nextContext.messages;
-    deferred.loopContext.tools = nextContext.tools;
-    loopConfig.model = snapshot.model ?? loopConfig.model;
-    loopConfig.reasoning = snapshot.thinkingLevel === undefined ? loopConfig.reasoning : snapshot.thinkingLevel === "off" ? undefined : snapshot.thinkingLevel;
-  };
-  const agentLoopDoor = this.agent;
-  const previousCreateLoopConfig = agentLoopDoor.createLoopConfig.bind(this.agent);
-  agentLoopDoor.createLoopConfig = (options) => {
-    deferredPreparation = undefined;
-    this._stopAfterTurnBlockedContinuation = false;
-    const loopConfig = previousCreateLoopConfig(options);
-    const wrapQueuePoll = (poll) => async function() {
-      const messages = await poll?.() ?? [];
-      if (messages.length > 0)
-        await prepareDeferredTurn(this);
-      return messages;
-    };
-    loopConfig.getSteeringMessages = wrapQueuePoll(loopConfig.getSteeringMessages);
-    loopConfig.getFollowUpMessages = wrapQueuePoll(loopConfig.getFollowUpMessages);
-    return loopConfig;
-  };
-  this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-    const toolCallIds = turn.message.content.filter((part) => part.type === "toolCall").map((part) => part.id);
-    const terminatingBatch = toolCallIds.length > 0 && toolCallIds.every((id) => this._terminatingToolCallIds.has(id));
-    for (const id of toolCallIds)
-      this._terminatingToolCallIds.delete(id);
-    const shouldStop = await cacheStopResult(turn, signal);
-    try {
-      if (shouldStop) {
-        deferredPreparation = undefined;
-        this._stopAfterTurnBlockedContinuation = true;
-        await settleFallbackAfterTurn(this, turn, terminatingBatch);
-        return;
-      }
-      if (turn.toolResults.length > 0 && !terminatingBatch) {
-        deferredPreparation = undefined;
-        const snapshot = await prepareTurn(turn, signal);
-        await settleFallbackAfterTurn(this, turn, terminatingBatch);
-        return snapshot;
-      }
-      await settleFallbackAfterTurn(this, turn, terminatingBatch);
-      const loopContext = {
-        ...turn.context,
-        messages: turn.context.messages.slice(),
-        tools: turn.context.tools?.slice()
-      };
-      deferredPreparation = { turn, signal, loopContext };
-      return { context: loopContext };
-    } catch (error) {
-      clearPendingStopResult(turn);
-      throw error;
-    }
-  };
+  this.agent.prepareNextTurnWithContext = prepareTurn;
 }
 async function settleFallbackAfterTurn(session, turn, terminatingBatch) {
   const preserveFallbackForFailure = turn.message.role === "assistant" && !session.agent.hasQueuedMessages() && (turn.message.stopReason === "length" || session._isEmptyCompletion?.(turn.message) === true || session._isSafetyRefusal?.(turn.message) === true);
@@ -19723,6 +19688,14 @@ var init_loader_virtual_modules = __esm(() => {
 
 // src/core/extensions/loader-core.ts
 import * as path7 from "node:path";
+function getExtensionRuntimeEventBus(runtime) {
+  let eventBus = runtimeEventBuses.get(runtime);
+  if (!eventBus) {
+    eventBus = createEventBus();
+    runtimeEventBuses.set(runtime, eventBus);
+  }
+  return eventBus;
+}
 function createExtension(extensionPath, resolvedPath) {
   const source = extensionPath.startsWith("<") && extensionPath.endsWith(">") ? extensionPath.slice(1, -1).split(":")[0] || "temporary" : "local";
   const baseDir = extensionPath.startsWith("<") ? undefined : path7.dirname(resolvedPath);
@@ -19788,6 +19761,7 @@ async function loadExtensionsInternal(paths, cwd, eventBus, workflowResourceProv
   const resolvedCwd = cacheToken?.cwd ?? resolvePath(cwd);
   const resolvedEventBus = eventBus ?? createEventBus();
   const resolvedRuntime = runtime ?? createExtensionRuntime();
+  runtimeEventBuses.set(resolvedRuntime, resolvedEventBus);
   let processedExtensionCount = 0;
   let lastYieldAt = Date.now();
   for (const extPath of paths) {
@@ -19819,7 +19793,7 @@ async function loadExtensions(paths, cwd, eventBus, workflowResourceProvider = e
 async function loadExtensionsCached(paths, cwd, eventBus, workflowResourceProvider = emptyWorkflowResourceProvider, runtime, resourceLoaderInheritanceSnapshotProvider) {
   return loadExtensionsInternal(paths, cwd, eventBus, workflowResourceProvider, runtime, resourceLoaderInheritanceSnapshotProvider, true);
 }
-var INTER_EXTENSION_YIELD_THRESHOLD_MS = 16;
+var runtimeEventBuses, INTER_EXTENSION_YIELD_THRESHOLD_MS = 16;
 var init_loader_core = __esm(() => {
   init_event_loop();
   init_paths();
@@ -19829,6 +19803,7 @@ var init_loader_core = __esm(() => {
   init_loader_resources();
   init_loader_runtime();
   init_loader_virtual_modules();
+  runtimeEventBuses = new WeakMap;
 });
 
 // src/core/package-manager-manifest.ts
@@ -28367,7 +28342,7 @@ class FastModeSelectorComponent {
   }
   invalidate() {}
   render(width) {
-    const lines = [truncateToWidth10(theme.bold(theme.fg("accent", "Codex fast mode")), width)];
+    const lines = [truncateToWidth10(theme.bold(theme.fg("accent", "Fast mode")), width)];
     for (const line of wrapTextWithAnsi3(DESCRIPTION, Math.max(20, width))) {
       lines.push(theme.fg("muted", line));
     }
@@ -28450,7 +28425,7 @@ class FastModeSelectorComponent {
     return this.getFocusedRow() === row ? theme.fg("muted", text) : theme.fg("dim", text);
   }
 }
-var ROWS, LABEL_WIDTH = 16, DESCRIPTION = "Priority tier for supported OpenAI and shared ChatGPT Codex transports.", ROW_DETAILS;
+var ROWS, LABEL_WIDTH = 16, DESCRIPTION = "Use faster routing for the selected model when supported by its provider.", ROW_DETAILS;
 var init_fast_mode_selector = __esm(() => {
   init_theme();
   ROWS = ["chat", "workflow"];
@@ -29756,6 +29731,10 @@ var init_keybindings = __esm(() => {
       defaultKeys: windowsKeybindings ? "alt+q" : "alt+up",
       description: "Restore queued messages"
     },
+    "app.message.copy": {
+      defaultKeys: "ctrl+x",
+      description: "Copy fullscreen selection or last agent message"
+    },
     "app.clipboard.pasteImage": {
       defaultKeys: windowsKeybindings ? "alt+v" : "ctrl+v",
       description: "Paste image from clipboard (text fallback)"
@@ -31148,6 +31127,9 @@ function createSettingsChangeHandler(callbacks) {
       case "fullscreen-exit-output":
         callbacks.onFullscreenExitOutputChange(newValue);
         break;
+      case "fullscreen-copy-on-select":
+        callbacks.onFullscreenCopyOnSelectChange(newValue === "true");
+        break;
       case "editor-padding":
         callbacks.onEditorPaddingXChange(parseInt(newValue, 10));
         break;
@@ -31535,6 +31517,13 @@ function insertUiToggles(items, config) {
     values: ["transcript", "resume-hint"]
   });
   insertAfter(items, "fullscreen-exit-output", {
+    id: "fullscreen-copy-on-select",
+    label: "Fullscreen copy on select",
+    description: "Copy selected transcript text automatically on mouse release",
+    currentValue: config.fullscreenCopyOnSelect ? "true" : "false",
+    values: ["true", "false"]
+  });
+  insertAfter(items, "fullscreen-copy-on-select", {
     id: "editor-padding",
     label: "Editor padding",
     description: "Horizontal padding for input editor (0-3)",
@@ -44812,6 +44801,8 @@ function _refreshToolRegistry(options) {
   const allowedToolNames = this._allowedToolNames;
   const excludedToolNames = this._excludedToolNames;
   const isExposedTool = (name) => {
+    if (isMandatoryRuntimeTool(name))
+      return true;
     if (allowedToolNames && !allowedToolNames.has(name)) {
       return false;
     }
@@ -44820,10 +44811,10 @@ function _refreshToolRegistry(options) {
     }
     return true;
   };
-  const registeredTools = this._extensionRunner.getAllRegisteredTools();
+  const registeredTools = this._extensionRunner.getAllRegisteredTools().filter((tool) => !isMandatoryRuntimeTool(tool.definition.name) || isTrustedMandatoryRuntimeTool(tool));
   const allCustomTools = [
     ...registeredTools,
-    ...this._customTools.map((definition) => ({
+    ...this._customTools.filter((definition) => !isMandatoryRuntimeTool(definition.name)).map((definition) => ({
       definition,
       sourceInfo: createSyntheticSourceInfo(`<sdk:${definition.name}>`, { source: "sdk" })
     }))
@@ -44944,6 +44935,7 @@ function _buildRuntime(options) {
 var agentSessionToolRegistryMethods;
 var init_agent_session_tool_registry = __esm(() => {
   init_extensions();
+  init_mandatory_runtime_tools();
   init_model_registry();
   init_tools();
   init_session_temp_dir();
@@ -46374,6 +46366,23 @@ function getBuiltinPackagePaths() {
     return packageDir ? [packageDir] : [];
   });
 }
+function getMandatoryBuiltinPackagePaths() {
+  const context = getBuiltinPackageCandidateContext();
+  return BUILTIN_PACKAGES.filter((descriptor) => descriptor.mandatory).flatMap((descriptor) => {
+    const packageDir = firstExistingPackageDir([...descriptor.sourceCandidates(context), ...distCandidates(context, descriptor)], descriptor);
+    return packageDir ? [packageDir] : [];
+  });
+}
+function getMandatoryBuiltinExtensionPaths() {
+  return getMandatoryBuiltinPackagePaths().flatMap((packageDir) => {
+    try {
+      const manifest = JSON.parse(stripBom(readFileSync21(join43(packageDir, "package.json"), "utf-8")));
+      return (manifest.atomic?.extensions ?? manifest.pi?.extensions ?? []).map((entry) => resolve12(packageDir, entry));
+    } catch {
+      return [];
+    }
+  });
+}
 var WORKSPACE_BUILTINS, BUILTIN_PACKAGES;
 var init_builtin_packages = __esm(() => {
   init_config();
@@ -46384,11 +46393,12 @@ var init_builtin_packages = __esm(() => {
     { packageName: "@bastani/subagents", workspaceDirName: "subagents", distDirName: "subagents" },
     { packageName: "@bastani/mcp", workspaceDirName: "mcp", distDirName: "mcp" },
     { packageName: "@bastani/web-access", workspaceDirName: "web-access", distDirName: "web-access" },
-    { packageName: "@bastani/intercom", workspaceDirName: "intercom", distDirName: "intercom" }
+    { packageName: "@bastani/intercom", workspaceDirName: "intercom", distDirName: "intercom", mandatory: true }
   ];
   BUILTIN_PACKAGES = WORKSPACE_BUILTINS.map((spec) => ({
     packageName: spec.packageName,
     distDirName: spec.distDirName,
+    mandatory: spec.mandatory === true,
     requiredEntries: requiredEntriesForBuiltin(spec.distDirName),
     sourceCandidates: ({ here, packageDir, isSourceCheckout }) => isSourceCheckout ? [join43(packageDir, "..", spec.workspaceDirName), join43(here, "..", "..", "..", spec.workspaceDirName)] : []
   }));
@@ -52363,6 +52373,13 @@ function getEnabledResources(resources, metadataByPath) {
 function getEnabledPaths(resources, metadataByPath) {
   return getEnabledResources(resources, metadataByPath).map((r) => r.path);
 }
+function getBuiltinExtensionPaths(resources, metadataByPath, noExtensions) {
+  for (const resource of resources) {
+    if (!metadataByPath.has(resource.path))
+      metadataByPath.set(resource.path, resource.metadata);
+  }
+  return noExtensions ? [] : resources.filter((resource) => resource.enabled).map((resource) => resource.path);
+}
 function mapSkillPath(resource, metadataByPath) {
   if (resource.metadata.source !== "auto" && resource.metadata.origin !== "package") {
     return resource.path;
@@ -52406,12 +52423,12 @@ async function loadProjectTrustExtensions(loader) {
   const metadataByPath = new Map;
   const cliEnabledExtensions = getEnabledPaths(cliExtensionPaths.extensions, metadataByPath);
   const enabledExtensions = getEnabledPaths(resolvedPaths.extensions, metadataByPath);
-  const builtinEnabledExtensions = state.noExtensions ? [] : getEnabledPaths(builtinPackagePaths.extensions, metadataByPath);
+  const builtinEnabledExtensions = getBuiltinExtensionPaths(builtinPackagePaths.extensions, metadataByPath, state.noExtensions);
   const workflowResources = collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths);
   state.workflowResources = workflowResources;
   const workflowResourceProvider = createWorkflowResourceProvider(loader);
   const inheritanceSnapshotProvider = createInheritanceSnapshotProvider(loader);
-  const extensionPaths = state.noExtensions ? cliEnabledExtensions : mergeResourcePaths(state.cwd, cliEnabledExtensions, [...enabledExtensions, ...builtinEnabledExtensions]);
+  const extensionPaths = mergeResourcePaths(state.cwd, cliEnabledExtensions, state.noExtensions ? builtinEnabledExtensions : [...enabledExtensions, ...builtinEnabledExtensions]);
   const extensionsResult = await loadExtensionsCached(extensionPaths, state.cwd, state.eventBus, workflowResourceProvider, undefined, inheritanceSnapshotProvider);
   const inlineExtensions = await loadExtensionFactories(loader, extensionsResult.runtime, workflowResourceProvider, inheritanceSnapshotProvider);
   extensionsResult.extensions.push(...inlineExtensions.extensions);
@@ -52491,7 +52508,7 @@ async function reloadDefaultResourceLoader(loader, options) {
   const enabledSkillResources = getEnabledResources(resolvedPaths.skills, metadataByPath);
   const enabledPrompts = getEnabledPaths(resolvedPaths.prompts, metadataByPath);
   const enabledThemes = getEnabledPaths(resolvedPaths.themes, metadataByPath);
-  const builtinEnabledExtensions = state.noExtensions ? [] : getEnabledPaths(builtinPackagePaths.extensions, metadataByPath);
+  const builtinEnabledExtensions = getBuiltinExtensionPaths(builtinPackagePaths.extensions, metadataByPath, state.noExtensions);
   const builtinEnabledSkillResources = state.noSkills ? [] : getEnabledResources(builtinPackagePaths.skills, metadataByPath);
   const builtinEnabledPrompts = state.noPromptTemplates ? [] : getEnabledPaths(builtinPackagePaths.prompts, metadataByPath);
   const builtinEnabledThemes = state.noThemes ? [] : getEnabledPaths(builtinPackagePaths.themes, metadataByPath);
@@ -52505,9 +52522,13 @@ async function reloadDefaultResourceLoader(loader, options) {
   const workflowResources = collectWorkflowResources(resolvedPaths, cliExtensionPaths, builtinPackagePaths);
   state.workflowResources = workflowResources;
   const workflowResourceProvider = createWorkflowResourceProvider(loader);
-  const extensionPaths = state.noExtensions ? cliEnabledExtensions : mergeResourcePaths(state.cwd, cliEnabledExtensions, [...enabledExtensions, ...builtinEnabledExtensions]);
+  const extensionPaths = mergeResourcePaths(state.cwd, cliEnabledExtensions, state.noExtensions ? builtinEnabledExtensions : [...enabledExtensions, ...builtinEnabledExtensions]);
   const inheritanceSnapshotProvider = createInheritanceSnapshotProvider(loader);
   const extensionsResult = options?.deferExtensions ? { extensions: [], errors: [], runtime: createExtensionRuntime() } : await loadFinalExtensionSet(loader, extensionPaths, preTrustExtensions, workflowResourceProvider, inheritanceSnapshotProvider);
+  const mandatoryExtensionPaths = new Set(getMandatoryBuiltinExtensionPaths().map((path16) => resolvePath(path16, state.cwd, { normalizeUnicodeSpaces: true })));
+  const loadedMandatoryExtensions = new Set(extensionsResult.extensions.filter((extension) => mandatoryExtensionPaths.has(resolvePath(extension.resolvedPath, state.cwd, { normalizeUnicodeSpaces: true }))));
+  for (const extension of loadedMandatoryExtensions)
+    markTrustedMandatoryRuntimeExtension(extension);
   for (const p of state.additionalExtensionPaths) {
     if (isLocalPath(p)) {
       const resolved = resolveResourcePath(state.cwd, p);
@@ -52518,6 +52539,12 @@ async function reloadDefaultResourceLoader(loader, options) {
   }
   state.extensionsResult = state.extensionsOverride ? state.extensionsOverride(extensionsResult) : extensionsResult;
   applyExtensionSourceInfo(loader, state.extensionsResult.extensions, metadataByPath);
+  for (const extension of state.extensionsResult.extensions) {
+    const registration = extension.tools.get("intercom");
+    if (loadedMandatoryExtensions.has(extension) && registration && isTrustedMandatoryRuntimeTool(registration)) {
+      markTrustedMandatoryRuntimeExtension(extension);
+    }
+  }
   resolveInheritedExtensionOverlaps(state.extensionsResult);
   const skillPaths = state.noSkills ? mergeResourcePaths(state.cwd, cliEnabledSkills, state.additionalSkillPaths) : mergeResourcePaths(state.cwd, [...cliEnabledSkills, ...enabledSkills, ...builtinEnabledSkills], state.additionalSkillPaths);
   state.lastSkillPaths = skillPaths;
@@ -52597,7 +52624,9 @@ async function reloadDefaultResourceLoader(loader, options) {
 var init_resource_loader_reload = __esm(() => {
   init_event_loop();
   init_paths();
+  init_builtin_packages();
   init_loader();
+  init_mandatory_runtime_tools();
   init_resource_loader_assets();
   init_resource_loader_context_files();
   init_resource_loader_discovery();
@@ -53754,6 +53783,28 @@ var init_settings_manager_ui_accessors = __esm(() => {
       state.markModified("fullscreenExitOutput");
       state.save();
     },
+    getFullscreenCopyOnSelect() {
+      return settingsInternals(this).settings.fullscreenCopyOnSelect !== false;
+    },
+    setFullscreenCopyOnSelect(enabled) {
+      const state = settingsInternals(this);
+      state.globalSettings.fullscreenCopyOnSelect = enabled;
+      state.markModified("fullscreenCopyOnSelect");
+      state.save();
+    },
+    getTerminalCapabilityOverrides() {
+      const terminal = settingsInternals(this).settings.terminal;
+      const overrides = {};
+      if (typeof terminal?.hyperlinks === "boolean")
+        overrides.hyperlinks = terminal.hyperlinks;
+      if (terminal?.images === "kitty" || terminal?.images === "iterm2")
+        overrides.images = terminal.images;
+      else if (terminal?.images === false)
+        overrides.images = null;
+      if (typeof terminal?.trueColor === "boolean")
+        overrides.trueColor = terminal.trueColor;
+      return overrides;
+    },
     getEditorPaddingX() {
       return settingsInternals(this).settings.editorPaddingX ?? 0;
     },
@@ -54304,6 +54355,105 @@ function restoreAnthropicReplayThinkingBlocks(payload, sourceMessages, model) {
   return { ...payload, messages: nextPayloadMessages };
 }
 
+// src/core/mandatory-resource-loader.ts
+function hasTrustedIntercom(extension) {
+  const registration = extension.tools.get("intercom");
+  return registration !== undefined && isTrustedMandatoryRuntimeTool(registration);
+}
+async function restoreMandatoryExtensions(target, cwd) {
+  if (target.extensions.some(hasTrustedIntercom))
+    return target;
+  const loaded = await loadExtensions(getMandatoryBuiltinExtensionPaths(), cwd, getExtensionRuntimeEventBus(target.runtime), undefined, target.runtime);
+  for (const extension of loaded.extensions)
+    markTrustedMandatoryRuntimeExtension(extension);
+  const restored = {
+    ...target,
+    extensions: [...target.extensions, ...loaded.extensions],
+    errors: [...target.errors, ...loaded.errors]
+  };
+  if (!restored.extensions.some(hasTrustedIntercom)) {
+    const detail = loaded.errors.map(({ error }) => error).join("; ") || "extension did not register intercom";
+    throw new Error(`Mandatory bundled Intercom is unavailable: ${detail}`);
+  }
+  return restored;
+}
+
+class MandatoryResourceLoader {
+  delegate;
+  cwd;
+  extensionsResult;
+  toolOnly = false;
+  constructor(delegate, cwd, extensionsResult) {
+    this.delegate = delegate;
+    this.cwd = cwd;
+    this.extensionsResult = extensionsResult;
+  }
+  limitToTool() {
+    this.toolOnly = true;
+    this.removeLocalInteractionSurfaces();
+  }
+  removeLocalInteractionSurfaces() {
+    const extension = this.extensionsResult.extensions.find(hasTrustedIntercom);
+    extension?.commands.delete("intercom");
+    extension?.shortcuts.delete("alt+m");
+  }
+  getExtensions() {
+    return this.extensionsResult;
+  }
+  getSkills() {
+    return this.delegate.getSkills();
+  }
+  getSkillCatalog() {
+    return this.delegate.getSkillCatalog?.() ?? buildSkillCatalog(this.delegate.getSkills().skills);
+  }
+  getPrompts() {
+    return this.delegate.getPrompts();
+  }
+  getThemes() {
+    return this.delegate.getThemes();
+  }
+  getAgentsFiles() {
+    return this.delegate.getAgentsFiles();
+  }
+  getSystemPrompt() {
+    return this.delegate.getSystemPrompt();
+  }
+  getSystemPromptSource() {
+    return this.delegate.getSystemPromptSource();
+  }
+  getAppendSystemPrompt() {
+    return this.delegate.getAppendSystemPrompt();
+  }
+  getAppendSystemPromptSources() {
+    return this.delegate.getAppendSystemPromptSources();
+  }
+  extendResources(paths) {
+    return this.delegate.extendResources(paths);
+  }
+  async reload(options) {
+    await this.delegate.reload(options);
+    this.extensionsResult = await restoreMandatoryExtensions(this.delegate.getExtensions(), this.cwd);
+    if (this.toolOnly)
+      this.removeLocalInteractionSurfaces();
+  }
+}
+async function withMandatoryResourceLoader(loader, cwd) {
+  if (loader instanceof MandatoryResourceLoader)
+    return loader;
+  const extensionsResult = await restoreMandatoryExtensions(loader.getExtensions(), cwd);
+  return new MandatoryResourceLoader(loader, cwd, extensionsResult);
+}
+function limitMandatoryIntercomToTool(loader) {
+  if (loader instanceof MandatoryResourceLoader)
+    loader.limitToTool();
+}
+var init_mandatory_resource_loader = __esm(() => {
+  init_builtin_packages();
+  init_loader();
+  init_mandatory_runtime_tools();
+  init_skill_catalog();
+});
+
 // src/core/model-resolver-defaults.ts
 function findPreferredAvailableModel(availableModels) {
   for (const [provider, defaultId] of Object.entries(defaultModelPerProvider)) {
@@ -55133,14 +55283,16 @@ async function createAgentSessionServices(options) {
   const settingsSpan = startTimingSpan("createAgentSessionServices.settingsManager");
   const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
   endTimingSpan(settingsSpan);
-  const resourceLoader = new DefaultResourceLoader({
-    ...options.resourceLoaderOptions ?? {},
+  const resourceLoaderOptions = options.resourceLoaderOptions ?? {};
+  const defaultResourceLoader = new DefaultResourceLoader({
+    ...resourceLoaderOptions,
     cwd,
     agentDir,
     settingsManager
   });
   const reloadSpan = startTimingSpan("createAgentSessionServices.resourceLoader.reload");
-  await resourceLoader.reload(options.resourceLoaderReloadOptions);
+  await defaultResourceLoader.reload(options.resourceLoaderReloadOptions);
+  const resourceLoader = await withMandatoryResourceLoader(defaultResourceLoader, cwd);
   endTimingSpan(reloadSpan);
   const diagnostics = [];
   const providerSpan = startTimingSpan("createAgentSessionServices.providerRegistrations");
@@ -55193,6 +55345,7 @@ async function createAgentSessionFromServices(options) {
 var init_agent_session_services = __esm(() => {
   init_config();
   init_paths();
+  init_mandatory_resource_loader();
   init_model_runtime();
   init_resource_loader();
   init_sdk();
@@ -55575,6 +55728,7 @@ async function createAgentSession(options = {}) {
     await resourceLoader.reload();
     time("resourceLoader.reload");
   }
+  resourceLoader = await withMandatoryResourceLoader(resourceLoader, cwd);
   const existingSession = sessionManager.buildSessionContext();
   const repairedMessages = repairOrphanToolResults(existingSession.messages, { repairTrailing: true });
   const existingMessages = options.initialContextTransform ? options.initialContextTransform(repairedMessages) : repairedMessages;
@@ -55800,6 +55954,7 @@ var init_sdk = __esm(() => {
   init_agent_session();
   init_auth_guidance();
   init_codex_fast_mode();
+  init_mandatory_resource_loader();
   init_messages();
   init_model_resolver();
   init_model_runtime();
@@ -56376,8 +56531,14 @@ var init_list_models = __esm(() => {
 
 // src/cli/startup-ui.ts
 import { existsSync as existsSync45 } from "node:fs";
-import { ProcessTerminal, setKeybindings, TuiMainScreen } from "@earendil-works/pi-tui";
+import {
+  ProcessTerminal,
+  setCapabilityOverrides,
+  setKeybindings,
+  TuiMainScreen
+} from "@earendil-works/pi-tui";
 function createStartupTui(settingsManager) {
+  setCapabilityOverrides(settingsManager.getTerminalCapabilityOverrides());
   initTheme(settingsManager.getTheme());
   setKeybindings(KeybindingsManager.create());
   const ui = new TuiMainScreen(new ProcessTerminal, settingsManager.getShowHardwareCursor(), getAgentDir());
@@ -58207,8 +58368,9 @@ async function applyCliRuntimeApiKey(modelRuntime, providerId, apiKey, signal) {
 }
 
 // src/cli/session-picker.ts
-import { ProcessTerminal as ProcessTerminal2, setKeybindings as setKeybindings2, TuiMainScreen as TuiMainScreen2 } from "@earendil-works/pi-tui";
-async function selectSession(currentSessionsLoader, allSessionsLoader) {
+import { ProcessTerminal as ProcessTerminal2, setCapabilityOverrides as setCapabilityOverrides2, setKeybindings as setKeybindings2, TuiMainScreen as TuiMainScreen2 } from "@earendil-works/pi-tui";
+async function selectSession(currentSessionsLoader, allSessionsLoader, settingsManager) {
+  setCapabilityOverrides2(settingsManager.getTerminalCapabilityOverrides());
   return new Promise((resolve23) => {
     const ui = new TuiMainScreen2(new ProcessTerminal2, undefined, getAgentDir());
     const keybindings = KeybindingsManager.create();
@@ -58246,7 +58408,7 @@ var init_session_picker = __esm(() => {
 
 // src/main-session.ts
 import { createInterface as createInterface3 } from "node:readline";
-import { ProcessTerminal as ProcessTerminal3, setKeybindings as setKeybindings3, TuiMainScreen as TuiMainScreen3 } from "@earendil-works/pi-tui";
+import { ProcessTerminal as ProcessTerminal3, setCapabilityOverrides as setCapabilityOverrides3, setKeybindings as setKeybindings3, TuiMainScreen as TuiMainScreen3 } from "@earendil-works/pi-tui";
 import chalk10 from "chalk";
 async function findLocalSessionByExactId(sessionId, cwd, sessionDir) {
   const localSessions = await SessionManager.list(cwd, sessionDir);
@@ -58385,7 +58547,7 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
   if (parsed.resume) {
     initTheme(settingsManager.getTheme(), true);
     try {
-      const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress));
+      const selectedPath = await selectSession((onProgress) => SessionManager.list(cwd, sessionDir, onProgress), (onProgress) => SessionManager.listAll(sessionDir, onProgress), settingsManager);
       if (!selectedPath) {
         console.log(chalk10.dim("No session selected"));
         process.exit(0);
@@ -58408,6 +58570,7 @@ async function createSessionManager(parsed, cwd, sessionDir, settingsManager) {
   return SessionManager.create(cwd, sessionDir, { id: parsed.sessionId });
 }
 async function promptForMissingSessionCwd(issue, settingsManager) {
+  setCapabilityOverrides3(settingsManager.getTerminalCapabilityOverrides());
   initTheme(settingsManager.getTheme());
   setKeybindings3(KeybindingsManager.create());
   return new Promise((resolve23) => {
@@ -61993,7 +62156,7 @@ var init_slash_commands = __esm(() => {
     { name: "tree", description: "Navigate session tree (switch branches)" },
     { name: "thinking", description: "Set thinking level", argumentHint: "<level>" },
     { name: "scoped-models", description: "Enable/disable models for ctrl+p cycling" },
-    { name: "fast", description: "Configure OpenAI fast mode for chat and workflows in supported models" },
+    { name: "fast", description: "Configure fast mode for chat and workflows on supported models" },
     { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
     { name: "import", description: "Import and resume a session from a JSONL file" },
     { name: "share", description: "Share session as a secret GitHub gist" },
@@ -62629,6 +62792,7 @@ function createFullscreenTui(options) {
       openUrl: openBrowser
     }),
     onRightClickPaste: options.onRightClickPaste,
+    copyOnSelect: options.copyOnSelect,
     copySelection: options.copySelection ?? copySelectionToHostClipboard
   }, options.shouldHandleViewportInput, options.onOverlayUnhandledInput);
 }
@@ -62670,7 +62834,7 @@ function createInteractiveTuiReference(getTui) {
     getPrototypeOf: () => Reflect.getPrototypeOf(getTui())
   });
 }
-var viewportInputListeners, viewportInputGates, overlayUnhandledInputHandlers, viewportInputReplays, viewportInputSubscriptions, SGR_MOUSE_SEQUENCE, LEFT_MOUSE_MODIFIER_MASK, AtomicTuiAltScreen, AtomicTuiMainScreen;
+var viewportInputListeners, viewportInputGates, overlayUnhandledInputHandlers, viewportInputReplays, overlayOwnedSelections, viewportInputSubscriptions, SGR_MOUSE_SEQUENCE, LEFT_MOUSE_MODIFIER_MASK, AtomicTuiAltScreen, AtomicTuiMainScreen;
 var init_interactive_tui = __esm(() => {
   init_clipboard();
   init_open_browser();
@@ -62679,6 +62843,7 @@ var init_interactive_tui = __esm(() => {
   viewportInputGates = new WeakMap;
   overlayUnhandledInputHandlers = new WeakMap;
   viewportInputReplays = new WeakSet;
+  overlayOwnedSelections = new WeakSet;
   viewportInputSubscriptions = new WeakMap;
   SGR_MOUSE_SEQUENCE = /^\x1b\[<(\d+);\d+;\d+([Mm])/;
   LEFT_MOUSE_MODIFIER_MASK = 4 | 8 | 16;
@@ -62694,8 +62859,20 @@ var init_interactive_tui = __esm(() => {
       deferral.shouldDeferViewportInputToOverlay = () => !viewportInputReplays.has(this) && deferToOverlay?.() === true;
     }
     applyLineResets(lines) {
+      if (overlayOwnedSelections.has(this) && !this.isFocusedOverlay())
+        this.clearOverlayOwnedSelection();
       return stripOverlayActiveRowMarker(super.applyLineResets(lines));
     }
+    clearOverlayOwnedSelection() {
+      const selection = this;
+      selection.selectionAnchor = undefined;
+      selection.selectionFocus = undefined;
+      selection.selectionInitialRange = undefined;
+      selection.selectionPressActive = false;
+      selection.selectionDragged = false;
+      selection.lastClick = undefined;
+      overlayOwnedSelections.delete(this);
+    }
     isPiTuiMouseSequence(data) {
       if (parseMouseSequences(data))
         return true;
@@ -62772,6 +62949,7 @@ var init_interactive_tui = __esm(() => {
         if (isLeftMouseButton(sequence))
           viewportListener(sequence.data);
       }
+      overlayOwnedSelections.add(this);
     }
     replayViewportInput(viewportListener, data) {
       viewportInputReplays.add(this);
@@ -62839,7 +63017,11 @@ var init_interactive_tui = __esm(() => {
 });
 
 // src/modes/interactive/interactive-mode-base.ts
-import { isKeyRelease as isKeyRelease3, isViewportTUI } from "@earendil-works/pi-tui";
+import {
+  isKeyRelease as isKeyRelease3,
+  isViewportTUI,
+  setCapabilityOverrides as setCapabilityOverrides4
+} from "@earendil-works/pi-tui";
 function isFullscreenViewportAction(data, keybindings) {
   return FULLSCREEN_VIEWPORT_ACTIONS.some((action) => keybindings.matches(data, action));
 }
@@ -62900,6 +63082,18 @@ class InteractiveModeBase {
       return false;
     return this.defaultEditor.handleInput(data);
   }
+  setFullscreenCopyOnSelect(enabled) {
+    if (this.renderer.mode === "fullscreen")
+      this.renderer.setCopyOnSelect(enabled);
+  }
+  getFullscreenCopyOnSelect() {
+    return this.renderer.mode === "fullscreen" ? this.renderer.getCopyOnSelect() : undefined;
+  }
+  async copyActiveFullscreenSelection() {
+    if (this.renderer.mode !== "fullscreen" || !this.renderer.hasActiveSelection())
+      return;
+    return this.renderer.copyActiveSelectionToClipboard();
+  }
   onRightClickPaste = () => {
     this.handleRightClickPaste();
   };
@@ -63099,11 +63293,13 @@ class InteractiveModeBase {
       await this.rebindCurrentSession();
       await this.themeController.applyFromSettings();
     });
+    setCapabilityOverrides4(this.settingsManager.getTerminalCapabilityOverrides());
     this.version = VERSION;
     this.renderer = createInteractiveTui({
       showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
       logDirectory: runtimeHost.services.agentDir,
       terminal: options.terminal,
+      copyOnSelect: this.settingsManager.getFullscreenCopyOnSelect(),
       onRightClickPaste: this.onRightClickPaste,
       shouldHandleViewportInput: this.shouldHandleViewportInput,
       onOverlayUnhandledInput: this.onOverlayUnhandledInput,
@@ -64226,6 +64422,7 @@ var init_interactive_deferred_startup = __esm(() => {
     try {
       await this.bindCurrentSessionExtensions();
       await this.session.reload({ reason: "startup" });
+      this.applyRuntimeSettings();
       this.rebuildChatFromMessages();
       if (!this.promptTurnWorkingLoaderActive) {
         this.stopWorkingLoader();
@@ -64914,6 +65111,7 @@ ${warningLines}`, 0, 0));
 });
 
 // src/modes/interactive/interactive-session-runtime.ts
+import { setCapabilityOverrides as setCapabilityOverrides5 } from "@earendil-works/pi-tui";
 var init_interactive_session_runtime = __esm(() => {
   init_interactive_mode_base();
   init_interactive_mode_deps();
@@ -65000,6 +65198,8 @@ var init_interactive_session_runtime = __esm(() => {
     }
   };
   InteractiveModeBase.prototype.applyRuntimeSettings = function() {
+    setCapabilityOverrides5(this.settingsManager.getTerminalCapabilityOverrides());
+    this.setFullscreenCopyOnSelect(this.settingsManager.getFullscreenCopyOnSelect());
     this.transcriptScrollView?.setScrollbar(this.settingsManager.getFullscreenScrollbar());
     this.footer.setSession(this.session);
     this.usageMeter.setSession(this.session);
@@ -66516,6 +66716,9 @@ var init_interactive_input_handling = __esm(() => {
     });
     this.defaultEditor.onAction("app.message.followUp", () => this.handleFollowUp());
     this.defaultEditor.onAction("app.message.dequeue", () => this.handleDequeue());
+    this.defaultEditor.onAction("app.message.copy", () => {
+      this.handleCopyCommand({ preferSelection: true });
+    });
     this.defaultEditor.onAction("app.session.new", () => this.handleClearCommand());
     this.defaultEditor.onAction("app.session.tree", () => this.showTreeSelector());
     this.defaultEditor.onAction("app.session.fork", () => this.showUserMessageSelector());
@@ -68440,7 +68643,7 @@ var init_interactive_selectors = __esm(() => {
   };
   InteractiveModeBase.prototype.showFastModeSelector = function() {
     if (!this.hasCodexFastModeSupportedModels()) {
-      this.showWarning("Codex fast mode requires a supported OpenAI or shared ChatGPT Codex transport model.");
+      this.showWarning("Fast mode isn't available for any configured model.");
       return;
     }
     this.showSelector((done) => {
@@ -68499,6 +68702,7 @@ var init_interactive_selectors = __esm(() => {
         showHardwareCursor: this.settingsManager.getShowHardwareCursor(),
         fullscreenScrollbar: this.settingsManager.getFullscreenScrollbar(),
         fullscreenExitOutput: this.settingsManager.getFullscreenExitOutput(),
+        fullscreenCopyOnSelect: this.settingsManager.getFullscreenCopyOnSelect(),
         editorPaddingX: this.settingsManager.getEditorPaddingX(),
         outputPad: this.settingsManager.getOutputPad(),
         showCacheMissNotices: this.settingsManager.getShowCacheMissNotices(),
@@ -68616,6 +68820,10 @@ var init_interactive_selectors = __esm(() => {
         onFullscreenExitOutputChange: (output) => {
           this.settingsManager.setFullscreenExitOutput(output);
         },
+        onFullscreenCopyOnSelectChange: (enabled) => {
+          this.settingsManager.setFullscreenCopyOnSelect(enabled);
+          this.setFullscreenCopyOnSelect(enabled);
+        },
         onEditorPaddingXChange: (padding) => {
           this.settingsManager.setEditorPaddingX(padding);
           this.defaultEditor.setPaddingX(padding);
@@ -69602,18 +69810,8 @@ var init_interactive_slash_commands = __esm(() => {
         activeHeader.setExpanded(this.toolOutputExpanded);
       }
       setRegisteredThemes(this.session.resourceLoader.getThemes().themes);
-      this.hideThinkingBlock = this.settingsManager.getHideThinkingBlock();
+      this.applyRuntimeSettings();
       await this.themeController.applyFromSettings();
-      const editorPaddingX = this.settingsManager.getEditorPaddingX();
-      const autocompleteMaxVisible = this.settingsManager.getAutocompleteMaxVisible();
-      this.defaultEditor.setPaddingX(editorPaddingX);
-      this.defaultEditor.setAutocompleteMaxVisible(autocompleteMaxVisible);
-      if (this.editor !== this.defaultEditor) {
-        this.editor.setPaddingX?.(editorPaddingX);
-        this.editor.setAutocompleteMaxVisible?.(autocompleteMaxVisible);
-      }
-      this.ui.setShowHardwareCursor(this.settingsManager.getShowHardwareCursor());
-      this.ui.setClearOnShrink(this.settingsManager.getClearOnShrink());
       this.setupAutocompleteProvider();
       const runner = this.session.extensionRunner;
       this.setupExtensionShortcuts(runner);
@@ -69806,7 +70004,12 @@ Gist: ${hyperlink3(gistUrl, gistUrl)}`);
       }
     }
   };
-  InteractiveModeBase.prototype.handleCopyCommand = async function() {
+  InteractiveModeBase.prototype.handleCopyCommand = async function(options = {}) {
+    if (options.preferSelection && this.getFullscreenCopyOnSelect() === false) {
+      const selectionCopied = await this.copyActiveFullscreenSelection();
+      if (selectionCopied !== undefined)
+        return;
+    }
     const text = this.session.getLastAssistantText();
     if (!text) {
       this.showError("No agent messages to copy yet.");
@@ -73860,6 +74063,8 @@ var init_rpc_extension_ui = __esm(() => {
 });
 
 // src/modes/rpc/rpc-session-binding.ts
+import { setCapabilityOverrides as setCapabilityOverrides6 } from "@earendil-works/pi-tui";
+
 class RpcSessionBinding {
   session;
   unsubscribe;
@@ -73903,6 +74108,7 @@ class RpcSessionBinding {
     this.session = this.runtimeHost.session;
     this.disposeSubscriptions();
     const session = this.session;
+    setCapabilityOverrides6(session.settingsManager.getTerminalCapabilityOverrides());
     this.renderService?.bindSession(session);
     this.footerDataProvider = new FooterDataProvider(session.sessionManager.getCwd());
     const models = session.scopedModels.length > 0 ? session.scopedModels.map((scoped) => scoped.model) : session.modelRuntime.getAvailableSnapshot();
@@ -74798,8 +75004,9 @@ var init_config_selector = __esm(() => {
 });
 
 // src/cli/config-selector.ts
-import { ProcessTerminal as ProcessTerminal6, TuiMainScreen as TuiMainScreen8 } from "@earendil-works/pi-tui";
+import { ProcessTerminal as ProcessTerminal6, setCapabilityOverrides as setCapabilityOverrides7, TuiMainScreen as TuiMainScreen8 } from "@earendil-works/pi-tui";
 async function selectConfig(options) {
+  setCapabilityOverrides7(options.settingsManager.getTerminalCapabilityOverrides());
   initTheme(options.settingsManager.getTheme(), true);
   return new Promise((resolve23) => {
     const ui = new TuiMainScreen8(new ProcessTerminal6, undefined, options.agentDir);
@@ -75652,6 +75859,7 @@ var init_package_manager_cli = __esm(() => {
 });
 
 // src/main.ts
+import { setCapabilityOverrides as setCapabilityOverrides8 } from "@earendil-works/pi-tui";
 import chalk15 from "chalk";
 function authCheckErrorMessage(error) {
   return error instanceof AuthCommandError ? error.message : "Failed to check provider readiness";
@@ -75886,6 +76094,7 @@ async function main(argv, options) {
     startupEarlyInputCapture = undefined;
   }
   const startupSettingsManager = SettingsManager.create(cwd, agentDir, { projectTrusted: startupProjectTrusted });
+  setCapabilityOverrides8(startupSettingsManager.getTerminalCapabilityOverrides());
   const startupSettingsDiagnostics = collectSettingsDiagnostics(startupSettingsManager, "startup session lookup");
   if (appMode === "interactive" && parsed.useTheme !== undefined) {
     startupSettingsManager.applyOverrides({ theme: parsed.useTheme });
@@ -76020,6 +76229,8 @@ async function main(argv, options) {
         extensionFactories: isolateInteractiveHost ? undefined : extensionFactories
       }
     });
+    if (isolateInteractiveHost)
+      limitMandatoryIntercomToTool(services2.resourceLoader);
     const { settingsManager: settingsManager2, modelRuntime: modelRuntime2, resourceLoader: resourceLoader2 } = services2;
     const diagnostics = [
       ...services2.diagnostics,
@@ -76082,6 +76293,7 @@ async function main(argv, options) {
   endTimingSpan(runtimeCreationSpan);
   const { services, session, modelFallbackMessage } = runtime;
   const { settingsManager, modelRuntime, resourceLoader } = services;
+  setCapabilityOverrides8(settingsManager.getTerminalCapabilityOverrides());
   applyHttpProxySettings(settingsManager.getGlobalSettings().httpProxy);
   configureHttpDispatcher(settingsManager.getHttpIdleTimeoutMs());
   if (parsed.help) {
@@ -76213,6 +76425,7 @@ var init_main = __esm(() => {
   init_auth_storage();
   init_builtin_packages();
   init_http_dispatcher();
+  init_mandatory_resource_loader();
   init_model_resolver();
   init_model_runtime();
   init_output_guard();
@@ -93328,8 +93541,8 @@ class DbosDurableBackend {
   locallyRegistered = new Set;
   promptReservations;
   executorId;
-  writeQueue = Promise.resolve();
-  writeErrors = [];
+  writeQueues = new Map;
+  writeErrors = new Map;
   constructor(sdk, options) {
     this.sdk = sdk;
     this.executorId = options?.executorId ?? getAtomicExecutorId();
@@ -93337,7 +93550,7 @@ class DbosDurableBackend {
       pendingPrompts: (workflowId) => this.mem.getWorkflow(workflowId)?.pendingPrompts ?? 0,
       adjustPendingPrompts: (workflowId, delta) => this.mem.adjustPendingPrompts(workflowId, delta),
       persist: (workflowId, stepName, output) => {
-        this.enqueueWrite(() => this.sdk.recordStepOutput(workflowId, stepName, output));
+        this.enqueueWrite(workflowId, () => this.sdk.recordStepOutput(workflowId, stepName, output));
       }
     });
   }
@@ -93350,14 +93563,14 @@ class DbosDurableBackend {
     this.locallyRegistered.add(handle.workflowId);
     const pendingPrompts2 = this.promptReservations.registerWorkflow(handle.workflowId, handle.pendingPrompts, this.mem.getWorkflow(handle.workflowId)?.pendingPrompts ?? 0);
     this.mem.registerWorkflow({ ...handle, pendingPrompts: pendingPrompts2 });
-    this.enqueueWrite(async () => {
+    this.enqueueWrite(handle.workflowId, async () => {
       await this.sdk.startWorkflow(handle.workflowId, handle.name, handle.inputs);
       await this.writeMetadata(handle.workflowId);
     });
   }
   async persistPendingStageMessages(workflowId, messages2, logicalRunId = workflowId) {
     let persisted = false;
-    await this.enqueueWrite(async () => {
+    await this.enqueueWrite(workflowId, async () => {
       if (!this.isWorkflowLoadable(workflowId))
         return;
       const handle = this.mem.getWorkflow(workflowId);
@@ -93382,7 +93595,7 @@ class DbosDurableBackend {
     if (!this.isWorkflowLoadable(checkpoint.workflowId))
       return;
     this.mem.recordCheckpoint(checkpoint);
-    this.enqueueWrite(() => this.persistCheckpoint(checkpoint));
+    this.enqueueWrite(checkpoint.workflowId, () => this.persistCheckpoint(checkpoint));
   }
   async recordCheckpointAsync(checkpoint, options) {
     if (!this.isWorkflowLoadable(checkpoint.workflowId))
@@ -93390,7 +93603,7 @@ class DbosDurableBackend {
     const signal = options?.signal;
     if (signal?.aborted)
       throw abortSignalReason(signal);
-    await this.enqueueWrite(async () => {
+    await this.enqueueWrite(checkpoint.workflowId, async () => {
       if (signal?.aborted || !this.isWorkflowLoadable(checkpoint.workflowId))
         return;
       const persist = (async () => {
@@ -93427,7 +93640,7 @@ class DbosDurableBackend {
     if (!this.isWorkflowLoadable(checkpoint.workflowId))
       return true;
     const encoded = encodeCheckpoint(checkpoint);
-    return await this.enqueueBestEffortWrite(async () => {
+    return await this.enqueueBestEffortWrite(checkpoint.workflowId, async () => {
       if (!this.isWorkflowLoadable(checkpoint.workflowId))
         return;
       await this.sdk.recordStepOutput(checkpoint.workflowId, checkpoint.checkpointId, encoded);
@@ -93472,7 +93685,7 @@ class DbosDurableBackend {
       this.promptReservations.setBaseline(workflowId, pendingPrompts2);
     }
     this.mem.setWorkflowStatus(workflowId, status, pendingPrompts2, resumable, failure2);
-    this.enqueueWrite(async () => {
+    this.enqueueWrite(workflowId, async () => {
       if (!this.isWorkflowLoadable(workflowId))
         return;
       if (status === "cancelled")
@@ -93486,14 +93699,14 @@ class DbosDurableBackend {
     return await transitionDbosWorkflowStatus({
       expectedStatuses: expected,
       status,
-      flush: () => this.flush(),
+      flush: () => this.flush(workflowId),
       local: () => this.getLoadableWorkflow(workflowId),
       read: async () => classifyLatestMetadata(await this.sdk.listStepRecords(workflowId), workflowId),
       reconcile: (entry) => this.mem.setWorkflowStatus(workflowId, entry.status, undefined, entry.resumable),
       claim: (authoritative, generation) => this.claimStatusTransition(workflowId, authoritative, generation, status, pendingPrompts2, resumable),
       write: async () => {
         this.setWorkflowStatus(workflowId, status, pendingPrompts2, resumable);
-        await this.flush();
+        await this.flush(workflowId);
       }
     });
   }
@@ -93555,13 +93768,13 @@ class DbosDurableBackend {
     this.locallyRegistered.delete(workflowId);
     this.promptReservations.delete(workflowId);
     await this.mem.deleteWorkflow(workflowId);
-    await this.enqueueWrite(async () => {
+    await this.enqueueWrite(workflowId, async () => {
       await this.sdk.deleteWorkflowData(workflowId);
       await this.sdk.recordStepOutput(workflowId, DBOS_DELETION_STEP, encodeDbosDeletionTombstone(workflowId));
     });
   }
   async deleteWorkflowIfInactive(workflowId) {
-    await this.flush();
+    await this.flush(workflowId);
     await this.hydrateWorkflow(workflowId);
     const handle = this.getLoadableWorkflow(workflowId);
     if (handle === undefined)
@@ -93572,7 +93785,7 @@ class DbosDurableBackend {
     if (!guarded)
       return { ok: false, reason: "running" };
     await this.deleteWorkflow(workflowId);
-    await this.flush();
+    await this.flush(workflowId);
     return { ok: true };
   }
   isWorkflowLoadable(workflowId) {
@@ -93584,16 +93797,19 @@ class DbosDurableBackend {
     this.current.clear();
     this.locallyRegistered.clear();
     this.promptReservations.clear();
-    this.writeQueue = Promise.resolve();
-    this.writeErrors = [];
-  }
-  async flush() {
-    await this.writeQueue;
-    if (this.writeErrors.length === 0)
-      return;
-    const [first] = this.writeErrors;
-    this.writeErrors = [];
-    throw first;
+    this.writeQueues.clear();
+    this.writeErrors.clear();
+  }
+  async flush(workflowId) {
+    const workflowIds = workflowId === undefined ? [...new Set([...this.writeQueues.keys(), ...this.writeErrors.keys()])] : [workflowId];
+    await Promise.all(workflowIds.map(async (id) => await this.writeQueues.get(id)));
+    for (const id of workflowIds) {
+      const errors = this.writeErrors.get(id);
+      if (errors === undefined || errors.length === 0)
+        continue;
+      this.writeErrors.delete(id);
+      throw errors[0];
+    }
   }
   async hydrateWorkflow(workflowId) {
     await this.hydrateWorkflowForInspection(workflowId);
@@ -93687,21 +93903,33 @@ class DbosDurableBackend {
     this.promptReservations.delete(workflowId);
     await this.mem.deleteWorkflow(workflowId);
   }
-  enqueueWrite(fn) {
-    const next = this.writeQueue.then(fn, fn);
-    this.writeQueue = next.catch((err) => {
+  enqueueWrite(workflowId, fn) {
+    const previous2 = this.writeQueues.get(workflowId) ?? Promise.resolve();
+    const next = previous2.then(fn, fn);
+    const tracked = next.catch((err) => {
       const error = err instanceof Error ? err : new Error(String(err));
-      this.writeErrors.push(error);
+      const errors = this.writeErrors.get(workflowId) ?? [];
+      errors.push(error);
+      this.writeErrors.set(workflowId, errors);
     });
+    this.trackWriteQueue(workflowId, tracked);
     return next;
   }
-  async enqueueBestEffortWrite(fn) {
-    const next = this.writeQueue.then(fn, fn);
-    this.writeQueue = next.catch(() => {
+  async enqueueBestEffortWrite(workflowId, fn) {
+    const previous2 = this.writeQueues.get(workflowId) ?? Promise.resolve();
+    const next = previous2.then(fn, fn);
+    this.trackWriteQueue(workflowId, next.catch(() => {
       return;
-    });
+    }));
     return await next.then(() => true, () => false);
   }
+  trackWriteQueue(workflowId, queue) {
+    this.writeQueues.set(workflowId, queue);
+    queue.finally(() => {
+      if (this.writeQueues.get(workflowId) === queue)
+        this.writeQueues.delete(workflowId);
+    });
+  }
   async writeMetadata(workflowId) {
     const value = this.mem.toMetadata(workflowId);
     if (value === undefined)
@@ -96705,7 +96933,7 @@ async function markDurableQuit(runId, run) {
   if (!transitioned)
     return "refused";
   recordRunTimingCheckpoint(backend, run);
-  await backend.flush();
+  await backend.flush(runId);
   return "transitioned";
 }
 function discoverDurableQuitBackend(runId) {
@@ -96933,7 +97161,7 @@ async function markDurableResumed(runId) {
       const authoritative = getLoadableDurableWorkflow(backend, runId);
       return authoritative?.status === "running" ? "not_needed" : "refused";
     }
-    await backend.flush();
+    await backend.flush(runId);
     pending.delete(runId);
     return "transitioned";
   } catch (error) {
@@ -105635,6 +105863,8 @@ import { extname as extname2, isAbsolute as isAbsolute20, join as join100, resol
 // dist/builtin/workflows/src/extension/workflow-module-loader.ts
 import { createJiti as createJiti2 } from "jiti/static";
 import * as typeboxModule from "typebox";
+import * as typeboxCompileModule from "typebox/compile";
+import * as typeboxValueModule from "typebox/value";
 
 // dist/builtin/workflows/src/sdk-surface.ts
 var exports_sdk_surface = {};
@@ -106973,8 +107203,8 @@ class ScopedDurableBackend {
   async recordAdditiveCheckpointBestEffort(checkpoint) {
     return await this.inner.recordAdditiveCheckpointBestEffort(this.remap(checkpoint));
   }
-  flush() {
-    return this.inner.flush();
+  flush(workflowId) {
+    return workflowId === undefined ? this.inner.flush() : this.inner.flush(this.scope.rootWorkflowId);
   }
   getToolOutput(_workflowId, argsHash) {
     return this.inner.getToolOutput(this.scope.rootWorkflowId, this.scopeKey(argsHash));
@@ -110328,17 +110558,7 @@ function resolveStageGroup(stageOptions, workflowGroup) {
   const trimmed = group.trim();
   return trimmed.length > 0 ? trimmed : undefined;
 }
-function stageHasIntercomAccess(stageOptions) {
-  if (!stageOptions)
-    return true;
-  if (stageOptions.noTools === "all")
-    return false;
-  const tools = stageOptions.tools;
-  if (Array.isArray(tools) && !tools.includes("intercom"))
-    return false;
-  const excluded = stageOptions.excludedTools;
-  if (Array.isArray(excluded) && excluded.includes("intercom"))
-    return false;
+function stageHasIntercomAccess(_stageOptions) {
   return true;
 }
 function stageCanUseWorkflowPendingStageRoute(stageOptions, workflowGroup) {
@@ -110762,11 +110982,11 @@ function wrapUiWithDurable(base, deps) {
   };
   const releasePending = async (identity, token) => {
     releaseDurablePrompt(deps.backend, deps.workflowId, identity.hash, token);
-    await deps.backend.flush();
+    await deps.backend.flush(deps.workflowId);
   };
   const beginPending = (identity) => {
     const token = reserveDurablePrompt(deps.backend, deps.workflowId, identity.hash);
-    const write = deps.backend.flush();
+    const write = deps.backend.flush(deps.workflowId);
     return { token, write };
   };
   const waitForPendingWrite = async (identity, pending) => {
@@ -110777,7 +110997,7 @@ function wrapUiWithDurable(base, deps) {
     } catch (error) {
       releaseDurablePrompt(deps.backend, deps.workflowId, identity.hash, pending.token);
       try {
-        await deps.backend.flush();
+        await deps.backend.flush(deps.workflowId);
       } catch {}
       throw error;
     }
@@ -111074,7 +111294,7 @@ async function admitDurableRootRun(args) {
     args.backend.setWorkflowStatus(args.runId, "running");
   }
   if (!args.isChildRun)
-    await args.backend.flush();
+    await args.backend.flush(args.runId);
 }
 
 // dist/builtin/workflows/src/engine/run-durable-finalize.ts
@@ -111105,7 +111325,7 @@ async function finalizeDurableTerminalStatus(input2) {
     } : undefined;
     input2.durableBackend.setWorkflowStatus(input2.runId, durableStatus, undefined, input2.runSnapshot.resumable, failure2);
   }
-  await input2.durableBackend.flush();
+  await input2.durableBackend.flush(input2.runId);
 }
 function toDurableStatus(status) {
   switch (status) {
@@ -111660,7 +111880,7 @@ async function resumeDurableWorkflow(workflowId, deps, catalog) {
     });
   } catch (error) {
     backend.setWorkflowStatus(resolved.workflowId, handle.status, handle.pendingPrompts, handle.resumable);
-    await backend.flush();
+    await backend.flush(resolved.workflowId);
     return {
       ok: false,
       reason: "startup_failed",
@@ -111674,7 +111894,7 @@ async function resumeDurableWorkflow(workflowId, deps, catalog) {
     const error = workflowStartupFailureMessage(admission, snapshot2?.error, `Workflow ${resolved.workflowId} ended before startup admission`);
     deps.baseRunOpts.store?.removeRun(accepted2.runId);
     backend.setWorkflowStatus(resolved.workflowId, handle.status, handle.pendingPrompts, handle.resumable);
-    await backend.flush();
+    await backend.flush(resolved.workflowId);
     return {
       ok: false,
       reason: "startup_failed",
@@ -117625,7 +117845,7 @@ async function run(def, inputs, opts = {}) {
     const result = normalizeWorkflowRunOutput(def.name, rawResult);
     assertWorkflowRunOutputs(def.name, result, def.outputs);
     assertWorkflowCreatedExecution(runSnapshot);
-    await durableBackend.flush();
+    await durableBackend.flush(runId);
     const returned = classifyReturnedRunStatus(result, runSnapshot);
     const recorded = activeStore.recordRunEnd(runId, returned.status, result, returned.error, returned.metadata);
     appendRunEndWhenRecorded(opts.persistence, recorded, {
@@ -117641,7 +117861,7 @@ async function run(def, inputs, opts = {}) {
     if (opts.parentRun === undefined)
       recordRunTimingCheckpoint(durableBackend, runSnapshot);
     durableBackend.setWorkflowStatus(runId, returned.status, undefined, returned.metadata?.resumable);
-    await durableBackend.flush();
+    await durableBackend.flush(runId);
     return reconcileTerminalRunResult(runId, runSnapshot, activeStore, { status: returned.status, result, error: returned.error }, opts.onRunEnd);
   } catch (err) {
     terminalEvents.selectFailure(err);
@@ -117798,10 +118018,21 @@ function createWorkflowVirtualModules(moduleSpecifier) {
     [`${builtinModuleSpecifier}/steering-context`]: exports_steering_context
   };
 }
+var TYPEBOX_COMPILE_MODULE = {
+  ...typeboxCompileModule
+};
+var TYPEBOX_VALUE_MODULE = {
+  ...typeboxValueModule
+};
 var WORKFLOWS_VIRTUAL_MODULES = {
   ...createWorkflowVirtualModules(WORKFLOWS_MODULE_SPECIFIER),
   ...createWorkflowVirtualModules(LEGACY_WORKFLOWS_MODULE_SPECIFIER),
-  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE
+  [TYPEBOX_MODULE_SPECIFIER]: TYPEBOX_MODULE,
+  "typebox/compile": TYPEBOX_COMPILE_MODULE,
+  "typebox/value": TYPEBOX_VALUE_MODULE,
+  "@sinclair/typebox": TYPEBOX_MODULE,
+  "@sinclair/typebox/compile": TYPEBOX_COMPILE_MODULE,
+  "@sinclair/typebox/value": TYPEBOX_VALUE_MODULE
 };
 var workflowModuleLoader = createJiti2(import.meta.url, {
   moduleCache: false,
@@ -118178,7 +118409,7 @@ async function discardUnadmittedRun(runId, activeStore) {
   const handle = backend.getWorkflow(runId);
   if (handle?.status === "running") {
     backend.setWorkflowStatus(runId, "failed", handle.pendingPrompts, false);
-    await backend.flush();
+    await backend.flush(runId);
   }
   const deleted = await backend.deleteWorkflowIfInactive(runId);
   if (!deleted.ok && deleted.reason !== "not_found") {
@@ -118341,7 +118572,7 @@ async function discardFailedActiveBlockedContinuation(backend, runId, store2) {
   const handle = backend.getWorkflow(runId);
   if (handle?.status === "running") {
     backend.setWorkflowStatus(runId, "failed", handle.pendingPrompts, false);
-    await backend.flush();
+    await backend.flush(runId);
   }
   const deleted = await backend.deleteWorkflowIfInactive(runId);
   if (!deleted.ok && deleted.reason !== "not_found") {
@@ -124785,7 +125016,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - Cyclic workflow graphs are unsupported. Workflow authors and coding agents MUST NOT create self-edges or dependency edges from the current frontier to an existing ancestor. Every materialized execution topology must remain a DAG. Redesign or stop before launch if a cycle cannot be removed.
   - Bounded loops must create distinct tracked work for every iteration; never reopen an ancestor below its downstream work. Stacked implementation slices are unrolled, not looped: each slice gets a fresh child boundary and distinct tracked nodes, and no slice may add an edge back to the current frontier, itself, or an ancestor. If a retained session receives follow-up without new dependency work, keep it as non-topological activity metadata rather than adding a back-edge. Before launch, sketch nodes and dependencies for every branch and loop and reject any proposed parent edge to the node itself or an ancestor.
   - Treat dynamic graph validation during execution, replay, and DBOS hydration as the authoritative cycle boundary. If runtime topology code changes, require incremental edge checks and DBOS hydration validation; prompt guidance and TypeScript types cannot replace those runtime checks.
-  - Every workflow invocation automatically receives one stable, non-default Intercom group named \`workflow:<rootRunId>\`. Intercom-capable stages inherit it, nested workflows keep the top-level invocation group, and subagents inherit their launching stage's group. Do not mint or thread group names through ordinary workflow definitions. Use an explicit \`group\` only for an intentional override: a named group or \`group: true\` creates a subgroup, while \`group: "default"\` opts into the shared default group. Stages without Intercom access receive no group, and \`contact_supervisor\` still crosses group boundaries for authorized escalation.
+  - Every workflow invocation automatically receives one stable, non-default Intercom group named \`workflow:<rootRunId>\`. Every model stage inherits it because ordinary \`intercom\` is mandatory even under tool and extension restrictions; nested workflows keep the top-level invocation group, and subagents inherit their launching stage's group. Do not mint or thread group names through ordinary workflow definitions. Use an explicit \`group\` only for an intentional override: a named group or \`group: true\` creates a subgroup, while \`group: "default"\` opts into the shared default group. \`contact_supervisor\` still crosses group boundaries only for authorized subagent escalation.
   - Prefer \`ctx.tool(name, args, fn)\` for workflow-owned TypeScript operations with side effects, such as filesystem writes, network mutations, and external API actions. It creates a tracked, non-attachable durable graph node before invoking \`fn\`; it may be used before, between, after, or without model stages. A completed \`ctx.tool\` call is durably checkpointed with its serializable result, so resume replays that result without rerunning \`fn\`. For checks that may fail during a bounded repair loop, opt into \`failureMode: "return"\`, branch on the typed outcome, and pass only the needed error fields to the repair stage or artifact yourself; Atomic does not inject failure evidence into later prompts. Retries do not bound a hung callback, so every \`ctx.tool\` callback that starts a child process or performs network I/O MUST set an explicit positive finite \`timeoutMs\` and forward the supplied \`signal\` to cancellable work. A timeout applies per attempt, aborts that attempt's signal, and gives retries a fresh deadline and signal. Cancellation and storage faults still throw. Keep pure computation and side-effect-free transformations as ordinary TypeScript. Do not wrap agent-stage internals or every function call indiscriminately; this rule applies to side effects orchestrated directly by the workflow definition.
   - Pass large stage context through files/artifacts and \`reads\` with an explicit \`Read the file at <path>...\` prompt rather than large \`previous\` payloads or injected session history.
   - Wrap critical stage-prompt content in \`<keepContext>\` / \`</keepContext>\`. Tagged content survives compression verbatim regardless of the compression ratio, and every line of the span including the tag lines is protected. A long-running stage will be compacted, and compaction ranks lines individually: an objective is verbose and restated while the constraint that narrows it is usually one line, so the constraint is the cheaper deletion and what survives reads as broader permission than intended. Tag role constraints that bound a stage to part of the work, acceptance criteria and immutable contracts, explicit prohibitions, and identifiers a stage must not lose such as a target branch, worktree path, or run ID. Do not tag bulk context: protected lines count against the keep target rather than raising it, so a large protected span makes the surrounding transcript compress harder — tag the constraint, not the material it applies to.