@bastani/atomic 0.9.16-alpha.8 → 0.9.16

package/dist/builtin/workflows/builtin/{chunk-5n10x7j2.js → chunk-gdx0avpx.js}

@@ -324,15 +324,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)
@@ -5820,11 +5820,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);
@@ -8260,12 +8262,42 @@ async function runInputHandlers(extensions, ctx, text, images, source, streaming
   return currentText !== text || currentImages !== images ? { action: "transform", text: currentText, images: currentImages } : { action: "continue" };
 }
 
+// src/core/mandatory-runtime-tools.ts
+var MANDATORY_TOOL_NAMES = new Set(["intercom"]);
+var TRUSTED_MANDATORY_DEFINITIONS = new WeakSet;
+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;
+}
+
 // 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);
       }
     }
@@ -8273,13 +8305,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;
@@ -8362,6 +8397,7 @@ var RESERVED_KEYBINDINGS_FOR_EXTENSION_CONFLICTS = [
   "app.thinking.toggle",
   "app.editor.external",
   "app.message.followUp",
+  "app.message.copy",
   "tui.input.submit",
   "tui.select.confirm",
   "tui.select.cancel",
@@ -8558,6 +8594,8 @@ class ExtensionRunner {
   shortcutDiagnostics = [];
   commandDiagnostics = [];
   staleMessage;
+  uiPromptBinding = 0;
+  activeUIPrompt;
   constructor(extensions, runtime, cwd, sessionManager, modelRegistry, orchestrationContext, subagentPolicy) {
     this.extensions = extensions;
     this.runtime = runtime;
@@ -8652,9 +8690,71 @@ class ExtensionRunner {
     this.reloadHandler = async () => {};
   }
   setUIContext(uiContext, mode = "print") {
-    this.uiContext = uiContext ?? noOpUIContext;
+    this.endActiveUIPrompt();
+    const binding = ++this.uiPromptBinding;
+    this.uiContext = uiContext ? this.wrapUIPromptContext(uiContext, binding) : noOpUIContext;
     this.mode = mode;
   }
+  wrapUIPromptContext(ui, binding) {
+    return {
+      ...ui,
+      select: (title, options, opts) => this.withUIPrompt(binding, "select", title, () => ui.select(title, options, opts)),
+      confirm: (title, message, opts) => this.withUIPrompt(binding, "confirm", title, () => ui.confirm(title, message, opts)),
+      input: (title, placeholder, opts) => this.withUIPrompt(binding, "input", title, () => ui.input(title, placeholder, opts)),
+      editor: (title, prefill, opts) => this.withUIPrompt(binding, "editor", title, () => ui.editor(title, prefill, opts)),
+      custom: (factory, options) => this.withUIPrompt(binding, "custom", undefined, () => ui.custom(factory, options))
+    };
+  }
+  withUIPrompt(binding, kind, title, run) {
+    if (binding !== this.uiPromptBinding)
+      return run();
+    let prompt = this.activeUIPrompt;
+    if (!prompt) {
+      prompt = { depth: 0, kind, title };
+      this.activeUIPrompt = prompt;
+      this.emitUIPromptEvent({
+        type: "ui_prompt_start",
+        reason: "ui_prompt",
+        kind,
+        ...title === undefined ? {} : { title }
+      });
+    }
+    prompt.depth += 1;
+    let finished = false;
+    const finish = () => {
+      if (finished)
+        return;
+      finished = true;
+      if (this.activeUIPrompt !== prompt)
+        return;
+      prompt.depth -= 1;
+      if (prompt.depth === 0)
+        this.endActiveUIPrompt(prompt);
+    };
+    try {
+      return run().finally(finish);
+    } catch (error) {
+      finish();
+      throw error;
+    }
+  }
+  endActiveUIPrompt(prompt = this.activeUIPrompt) {
+    if (!prompt || this.activeUIPrompt !== prompt)
+      return;
+    this.activeUIPrompt = undefined;
+    prompt.depth = 0;
+    this.emitUIPromptEvent({
+      type: "ui_prompt_end",
+      reason: "ui_prompt",
+      kind: prompt.kind,
+      ...prompt.title === undefined ? {} : { title: prompt.title }
+    });
+  }
+  emitUIPromptEvent(event) {
+    queueMicrotask(() => {
+      this.emit(event);
+    });
+  }
   getUIContext() {
     return this.uiContext;
   }
@@ -11023,11 +11123,13 @@ async function _runAgentContinue() {
 }
 async function _continueQueuedAgentMessages() {
   await this._agentEventQueue;
-  while (!this._queuedMessagesPaused && this.agent.hasQueuedMessages()) {
+  while (!this._stopAfterTurnBlockedContinuation && !this._queuedMessagesPaused && this.agent.hasQueuedMessages()) {
     await this.agent.continue();
     await this.waitForRetry();
     await this._agentEventQueue;
   }
+  if (this._stopAfterTurnBlockedContinuation)
+    return;
   await answerAdmittedQueuedMessage(this);
 }
 async function answerAdmittedQueuedMessage(session) {
@@ -12711,14 +12813,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;
@@ -12775,7 +12876,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
   };
@@ -13786,6 +13887,17 @@ 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;
+  this.agent.shouldStopAfterTurn = 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;
+    this._stopAfterTurnBlockedContinuation = shouldStop;
+    await settleFallbackAfterTurn(this, turn, terminatingBatch);
+    return shouldStop;
+  };
   const previousTransformContext = this.agent.transformContext;
   this.agent.transformContext = async (messages, signal) => {
     const transformed = previousTransformContext ? await previousTransformContext(messages, signal) : messages;
@@ -13793,24 +13905,17 @@ function _installAgentNextTurnRefresh() {
     assertToolPairingInvariant(guarded);
     return guarded;
   };
-  this.agent.prepareNextTurnWithContext = async (turn, signal) => {
-    const previousSnapshot = await previousPrepareNextTurnWithContext?.(turn, signal);
-    const previousContext = previousSnapshot?.context ?? turn.context;
-    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 messages = turn.toolResults.length > 0 && !terminatingBatch ? await this._preflightPostToolContext(previousContext.messages, signal) : previousContext.messages;
-    const preserveFallbackForFailure = turn.message.role === "assistant" && !this.agent.hasQueuedMessages() && (turn.message.stopReason === "length" || this._isEmptyCompletion?.(turn.message) === true || this._isSafetyRefusal?.(turn.message) === true);
-    if (!preserveFallbackForFailure && (turn.toolResults.length === 0 || terminatingBatch)) {
-      await this._agentEventQueue;
-      await this._settleFallbackModelScope();
-    }
+  const prepareTurn = async (turn, signal) => {
+    const compactedMessages = turn.toolResults.length > 0 ? await this._preflightPostToolContext(turn.context.messages, signal) : turn.context.messages;
+    const compactedContext = compactedMessages === turn.context.messages ? turn.context : { ...turn.context, messages: compactedMessages };
+    const preparedTurn = compactedContext === turn.context ? turn : { ...turn, context: compactedContext };
+    const previousSnapshot = await previousPrepareNextTurnWithContext?.(preparedTurn, signal);
+    const previousContext = previousSnapshot?.context ?? compactedContext;
     return {
       ...previousSnapshot,
       context: {
         ...previousContext,
-        messages,
+        messages: previousContext.messages,
         systemPrompt: this._systemPromptOverride ?? this._baseSystemPrompt,
         tools: this.agent.state.tools.slice()
       },
@@ -13818,6 +13923,14 @@ function _installAgentNextTurnRefresh() {
       thinkingLevel: this.agent.state.thinkingLevel
     };
   };
+  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);
+  if (!preserveFallbackForFailure && (turn.toolResults.length === 0 || terminatingBatch)) {
+    await session._agentEventQueue;
+    await session._settleFallbackModelScope();
+  }
 }
 var agentSessionToolHooksMethods = {
   _installAgentToolHooks,
@@ -14311,7 +14424,7 @@ async function loadVirtualModules() {
     import("@bastani/pi-ai/oauth"),
     import("@bastani/pi-ai/api/cloudflare-gateway-binding"),
     import("proper-lockfile"),
-    import("./chunk-cdtd3m3w.js")
+    import("./chunk-dattsgxg.js")
   ]);
   return {
     typebox,
@@ -14696,6 +14809,15 @@ async function loadExtensionModule(extensionPath, cacheToken) {
 }
 
 // src/core/extensions/loader-core.ts
+var runtimeEventBuses = new WeakMap;
+function getExtensionRuntimeEventBus(runtime) {
+  let eventBus = runtimeEventBuses.get(runtime);
+  if (!eventBus) {
+    eventBus = createEventBus();
+    runtimeEventBuses.set(runtime, eventBus);
+  }
+  return eventBus;
+}
 var INTER_EXTENSION_YIELD_THRESHOLD_MS = 16;
 function createExtension(extensionPath, resolvedPath) {
   const source = extensionPath.startsWith("<") && extensionPath.endsWith(">") ? extensionPath.slice(1, -1).split(":")[0] || "temporary" : "local";
@@ -14762,6 +14884,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) {
@@ -23101,7 +23224,7 @@ class ExtensionSelectorComponent extends Container12 {
 import { matchesKey as matchesKey5, truncateToWidth as truncateToWidth10, wrapTextWithAnsi as wrapTextWithAnsi3 } from "@earendil-works/pi-tui";
 var ROWS = ["chat", "workflow"];
 var LABEL_WIDTH = 16;
-var DESCRIPTION = "Priority tier for supported OpenAI and shared ChatGPT Codex transports.";
+var DESCRIPTION = "Use faster routing for the selected model when supported by its provider.";
 var ROW_DETAILS = {
   chat: {
     label: "Chat",
@@ -23123,7 +23246,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));
     }
@@ -24397,6 +24520,10 @@ var KEYBINDINGS = {
     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)"
@@ -25815,6 +25942,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;
@@ -26201,6 +26331,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)",
@@ -39079,6 +39216,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;
     }
@@ -39087,10 +39226,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" })
     }))
@@ -40040,6 +40179,7 @@ class AgentSessionBase {
   _postToolCompactionPreflightError = undefined;
   _pendingPostToolCompactionGuard = undefined;
   _terminatingToolCallIds = new Set;
+  _stopAfterTurnBlockedContinuation = false;
   _disposed = false;
   _branchSummaryAbortController = undefined;
   _sessionSummaryAbortController = undefined;
@@ -40544,11 +40684,12 @@ var WORKSPACE_BUILTINS = [
   { 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 }
 ];
 var 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 ? [join29(packageDir, "..", spec.workspaceDirName), join29(here, "..", "..", "..", spec.workspaceDirName)] : []
 }));
@@ -40604,6 +40745,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(readFileSync16(join29(packageDir, "package.json"), "utf-8")));
+      return (manifest.atomic?.extensions ?? manifest.pi?.extensions ?? []).map((entry) => resolve9(packageDir, entry));
+    } catch {
+      return [];
+    }
+  });
+}
 // src/core/cloudflare-gateway-binding.ts
 import {
   CLOUDFLARE_GATEWAY_BINDING_AUTH_SENTINEL,
@@ -46382,6 +46540,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;
@@ -46425,12 +46590,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);
@@ -46510,7 +46675,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);
@@ -46524,9 +46689,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((path14) => resolvePath(path14, 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);
@@ -46537,6 +46706,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;
@@ -47739,6 +47914,28 @@ var uiAccessors = {
     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;
   },
@@ -48266,6 +48463,99 @@ 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();
+}
+
 // src/core/model-resolver-defaults.ts
 var defaultModelPerProvider = {
   "amazon-bedrock": "us.anthropic.claude-opus-4-6-v1",
@@ -48295,7 +48585,7 @@ var defaultModelPerProvider = {
   huggingface: "moonshotai/Kimi-K2.6",
   fireworks: "accounts/fireworks/models/kimi-k2p6",
   together: "moonshotai/Kimi-K2.6",
-  baseten: "zai-org/GLM-5.2",
+  baseten: "zai-org/GLM-5.3",
   opencode: "kimi-k2.6",
   "opencode-go": "kimi-k2.6",
   "kimi-coding": "kimi-for-coding",
@@ -49056,14 +49346,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");
@@ -49462,6 +49754,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;
@@ -49682,6 +49975,7 @@ async function createAgentSession(options = {}) {
   };
 }
 // src/main.ts
+import { setCapabilityOverrides as setCapabilityOverrides8 } from "@earendil-works/pi-tui";
 import chalk13 from "chalk";
 
 // src/cli/auth-check.ts
@@ -50232,8 +50526,14 @@ import chalk6 from "chalk";
 
 // src/cli/startup-ui.ts
 import { existsSync as existsSync35 } 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());
@@ -52012,12 +52312,13 @@ async function applyCliRuntimeApiKey(modelRuntime, providerId, apiKey, signal) {
 
 // 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 chalk8 from "chalk";
 
 // 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((resolve20) => {
     const ui = new TuiMainScreen2(new ProcessTerminal2, undefined, getAgentDir());
     const keybindings = KeybindingsManager.create();
@@ -52186,7 +52487,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(chalk8.dim("No session selected"));
         process.exit(0);
@@ -52209,6 +52510,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((resolve20) => {
@@ -55321,7 +55623,11 @@ function onInteractiveEngineRemoteCommandsChanged(runtime, listener) {
 }
 
 // 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";
 
 // src/modes/interactive-engine/engine-diagnostic-view.ts
 function renderEngineDiagnostic(diagnostic, view) {
@@ -55746,7 +56052,7 @@ var BUILTIN_SLASH_COMMANDS = [
   { 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" },
@@ -56203,6 +56509,7 @@ var viewportInputListeners = new WeakSet;
 var viewportInputGates = new WeakMap;
 var overlayUnhandledInputHandlers = new WeakMap;
 var viewportInputReplays = new WeakSet;
+var overlayOwnedSelections = new WeakSet;
 var viewportInputSubscriptions = new WeakMap;
 var SGR_MOUSE_SEQUENCE = /^\x1b\[<(\d+);\d+;\d+([Mm])/;
 var LEFT_MOUSE_MODIFIER_MASK = 4 | 8 | 16;
@@ -56271,8 +56578,20 @@ class AtomicTuiAltScreen extends TuiAltScreen {
     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;
@@ -56349,6 +56668,7 @@ class AtomicTuiAltScreen extends TuiAltScreen {
       if (isLeftMouseButton(sequence))
         viewportListener(sequence.data);
     }
+    overlayOwnedSelections.add(this);
   }
   replayViewportInput(viewportListener, data) {
     viewportInputReplays.add(this);
@@ -56429,6 +56749,7 @@ function createFullscreenTui(options) {
       openUrl: openBrowser
     }),
     onRightClickPaste: options.onRightClickPaste,
+    copyOnSelect: options.copyOnSelect,
     copySelection: options.copySelection ?? copySelectionToHostClipboard
   }, options.shouldHandleViewportInput, options.onOverlayUnhandledInput);
 }
@@ -56551,6 +56872,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();
   };
@@ -56750,11 +57083,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,
@@ -57782,6 +58117,7 @@ InteractiveModeBase.prototype.completeDeferredStartup = async function() {
   try {
     await this.bindCurrentSessionExtensions();
     await this.session.reload({ reason: "startup" });
+    this.applyRuntimeSettings();
     this.rebuildChatFromMessages();
     if (!this.promptTurnWorkingLoaderActive) {
       this.stopWorkingLoader();
@@ -58483,6 +58819,7 @@ ${warningLines}`, 0, 0));
 };
 
 // src/modes/interactive/interactive-session-runtime.ts
+import { setCapabilityOverrides as setCapabilityOverrides5 } from "@earendil-works/pi-tui";
 InteractiveModeBase.prototype.bindCurrentSessionExtensions = async function() {
   const uiContext = this.createExtensionUIContext();
   await this.session.bindExtensions({
@@ -58566,6 +58903,8 @@ InteractiveModeBase.prototype.bindCurrentSessionExtensions = async function() {
   }
 };
 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);
@@ -58628,7 +58967,7 @@ InteractiveModeBase.prototype.setupExtensionShortcuts = function(extensionRunner
   if (shortcuts.size === 0)
     return;
   const createContext = () => ({
-    ui: this.createExtensionUIContext(),
+    ui: extensionRunner.getUIContext(),
     mode: "tui",
     hasUI: true,
     cwd: this.sessionManager.getCwd(),
@@ -60029,6 +60368,9 @@ InteractiveModeBase.prototype.setupKeyHandlers = function() {
   });
   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());
@@ -60920,7 +61262,8 @@ InteractiveModeBase.prototype.handleEvent = async function(event) {
       } else if (event.reason === "manual") {
         this.manualCompactionTakeoverPending = false;
       }
-      if (!manualTakeoverPending && this.settingsManager.getShowTerminalProgress()) {
+      const resumesActiveRun = event.midTurn && !event.aborted && !event.errorMessage && !manualTakeoverPending;
+      if (!manualTakeoverPending && !resumesActiveRun && this.settingsManager.getShowTerminalProgress()) {
         this.ui.terminal.setProgress(false);
       }
       if (!manualTakeoverPending && this.autoCompactionEscapeHandlerSaved) {
@@ -61904,7 +62247,7 @@ InteractiveModeBase.prototype.showSelector = function(create) {
 };
 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) => {
@@ -61963,6 +62306,7 @@ InteractiveModeBase.prototype.showSettingsSelector = function() {
       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(),
@@ -62080,6 +62424,10 @@ InteractiveModeBase.prototype.showSettingsSelector = function() {
       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);
@@ -63032,18 +63380,8 @@ InteractiveModeBase.prototype.handleReloadCommand = async function() {
       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);
@@ -63236,7 +63574,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.");
@@ -66900,6 +67243,9 @@ class RpcOutputBuffer {
   }
 }
 
+// src/modes/rpc/rpc-session-binding.ts
+import { setCapabilityOverrides as setCapabilityOverrides6 } from "@earendil-works/pi-tui";
+
 // src/modes/rpc/rpc-extension-ui.ts
 import * as crypto5 from "node:crypto";
 function createDialogPromise({
@@ -67185,6 +67531,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();
@@ -67499,7 +67846,7 @@ import { join as join59 } from "node:path";
 import chalk12 from "chalk";
 
 // 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";
 
 // src/modes/interactive/components/config-selector.ts
 import {
@@ -68038,6 +68385,7 @@ class ConfigSelectorComponent extends Container35 {
 
 // src/cli/config-selector.ts
 async function selectConfig(options) {
+  setCapabilityOverrides7(options.settingsManager.getTerminalCapabilityOverrides());
   initTheme(options.settingsManager.getTheme(), true);
   return new Promise((resolve20) => {
     const ui = new TuiMainScreen8(new ProcessTerminal6, undefined, options.agentDir);
@@ -69088,6 +69436,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 });
@@ -69222,6 +69571,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,
@@ -69284,6 +69635,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) {