@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.9

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

@@ -4589,10 +4589,10 @@ function hasAssistantMessage(entries) {
   return entries.some((entry) => entry.type === "message" && entry.message.role === "assistant");
 }
 function persistAppendedEntry(filePath, entries, entry, flushed) {
-  if (!hasAssistantMessage(entries))
-    return false;
   if (flushed)
     appendSessionEntry(filePath, entry);
+  else if (!hasAssistantMessage(entries))
+    return false;
   else
     appendSessionEntries(filePath, entries);
   return true;
@@ -10723,6 +10723,8 @@ function appendDurableDisplayCard(session, message, delivery) {
   const card = { ...message, excludeFromContext: true };
   const admitted = message;
   const intentEntryId = session.sessionManager.appendCustomMessageEntry(card.customType, card.content, card.display, card.details, true, { delivery }, admitted.stageAdmissionKey);
+  if (admitted.stageAdmissionKey !== undefined)
+    session.sessionManager.flush();
   session.agent.state.messages.push(card);
   return { card, intentEntryId };
 }
@@ -10948,12 +10950,17 @@ var init_agent_session_persistent_custom_messages = __esm(() => {
 });
 
 // src/core/agent-session-custom-message-commit.ts
+function appendDurableStageAdmission(session, message) {
+  session._appendCustomMessage(message);
+  if (message.stageAdmissionKey !== undefined)
+    session.sessionManager?.flush();
+}
 async function commitAdmittedCustomMessage(session, appMessage, options) {
   const owner = resolveWorkflowStageDeliveryTarget(session);
   if (owner !== session)
     return commitAdmittedCustomMessage(owner, appMessage, options);
   const self = session;
-  const useProtectedReconciliation = options?.persistWhenStreaming === true && options.triggerTurn === true && options.excludeFromContext !== true;
+  const useProtectedReconciliation = options?.persistWhenStreaming === true && options.excludeFromContext !== true && (options.triggerTurn === true || options.stageAdmissionKey !== undefined);
   if (options?.deliverAs === "nextTurn") {
     self._pendingNextTurnMessages.push(appMessage);
   } else if (self._queuedMessagesPaused) {
@@ -10967,20 +10974,20 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
     } else if (self.isStreaming) {
       self._pendingCustomMessages.push(appMessage);
     } else {
-      self._appendCustomMessage(appMessage);
+      appendDurableStageAdmission(self, appMessage);
     }
   } else if (options?.deliverAs === "interrupt" && options.triggerTurn) {
     const interrupt = self._enqueueInterruptCustomMessage(appMessage, options);
     self._workflowStageAdmission?.trackAdmittedWork(interrupt);
     interrupt.catch(() => {});
   } else if (self.isStreaming && options?.excludeFromContext === true && options.triggerTurn !== true && options.deliverAs === undefined) {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   } else if (self.isStreaming && options?.triggerTurn === false) {
     self._pendingCustomMessages.push(appMessage);
   } else if (self.isStreaming && useProtectedReconciliation) {
     await queueProtectedStreamingCustomMessage(self, appMessage, options?.deliverAs === "followUp" ? "followUp" : "steer");
   } else if (self.isStreaming && options?.persistWhenStreaming === true) {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   } else if (self.isStreaming && options?.triggerTurn !== false) {
     self._queueAgentMessage(appMessage, options?.deliverAs === "followUp" ? "followUp" : "steer");
   } else if (options?.triggerTurn) {
@@ -11003,7 +11010,7 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
       self._continueQueuedAgentMessages().catch(() => {});
     }
   } else {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   }
 }
 function _commitAdmittedCustomMessage(appMessage, options) {
@@ -13310,6 +13317,8 @@ class ExtensionRunner {
   shortcutDiagnostics = [];
   commandDiagnostics = [];
   staleMessage;
+  uiPromptBinding = 0;
+  activeUIPrompt;
   constructor(extensions, runtime, cwd, sessionManager, modelRegistry, orchestrationContext, subagentPolicy) {
     this.extensions = extensions;
     this.runtime = runtime;
@@ -13404,9 +13413,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;
   }
@@ -19160,6 +19231,7 @@ async function loadVirtualModules() {
     piAi,
     piAiOauth,
     piAiCloudflareGatewayBinding,
+    properLockfile,
     piCodingAgent
   ] = await Promise.all([
     import("typebox"),
@@ -19171,6 +19243,7 @@ async function loadVirtualModules() {
     import("@bastani/pi-ai/compat"),
     import("@bastani/pi-ai/oauth"),
     import("@bastani/pi-ai/api/cloudflare-gateway-binding"),
+    import("proper-lockfile"),
     Promise.resolve().then(() => (init_src(), exports_src))
   ]);
   return {
@@ -19191,6 +19264,7 @@ async function loadVirtualModules() {
     "@earendil-works/pi-ai/compat": piAi,
     "@earendil-works/pi-ai/oauth": piAiOauth,
     "@earendil-works/pi-ai/api/cloudflare-gateway-binding": piAiCloudflareGatewayBinding,
+    "proper-lockfile": properLockfile,
     "@bastani/atomic": piCodingAgent,
     "@mariozechner/pi-agent-core": piAgentCore,
     "@mariozechner/pi-tui": piTui,
@@ -26320,11 +26394,20 @@ function isCodexFastModeCandidateModelId(modelId) {
   const provider = modelId?.split("/", 1)[0];
   return provider !== undefined && isCodexFastModeSupportedProvider(provider);
 }
-function isCodexFastModeSupportedModel(model) {
-  return isCodexFastModeSupportedProvider(model.provider) || model.api === "openai-codex-responses";
+function isGitHubCopilotModel(model) {
+  return model.provider === "github-copilot";
 }
-function hasSupportedCodexFastModeModel(models) {
-  return models.some(isCodexFastModeSupportedModel);
+function isGitHubCopilotFastModeSupportedModel(model, credential) {
+  if (!isGitHubCopilotModel(model) || credential?.type !== "oauth")
+    return false;
+  const fastModelIds = credential.fastModelIds;
+  return Array.isArray(fastModelIds) && fastModelIds.every((modelId) => typeof modelId === "string") && fastModelIds.includes(`${model.id}-fast`);
+}
+function isCodexFastModeSupportedModel(model, copilotCredential) {
+  return isCodexFastModeSupportedProvider(model.provider) || model.api === "openai-codex-responses" || model.id !== undefined && isGitHubCopilotFastModeSupportedModel({ provider: model.provider, id: model.id }, copilotCredential);
+}
+function hasSupportedCodexFastModeModel(models, copilotCredential) {
+  return models.some((model) => isCodexFastModeSupportedModel(model, copilotCredential));
 }
 function isWorkflowStageOrchestrationContext(context) {
   return context?.kind === "workflow-stage";
@@ -26335,11 +26418,11 @@ function getCodexFastModeScope(context) {
 function isCodexFastModeEnabledForScope(settings, scope) {
   return settings[scope];
 }
-function shouldApplyCodexFastModeForScope(model, settings, scope) {
-  return isCodexFastModeSupportedModel(model) && isCodexFastModeEnabledForScope(settings, scope);
+function shouldApplyCodexFastModeForScope(model, settings, scope, copilotCredential) {
+  return isCodexFastModeSupportedModel(model, copilotCredential) && isCodexFastModeEnabledForScope(settings, scope);
 }
-function shouldApplyCodexFastMode(model, settings, context) {
-  return shouldApplyCodexFastModeForScope(model, settings, getCodexFastModeScope(context));
+function shouldApplyCodexFastMode(model, settings, context, copilotCredential) {
+  return shouldApplyCodexFastModeForScope(model, settings, getCodexFastModeScope(context), copilotCredential);
 }
 function usesFirstPartyCodexRouting(model) {
   return model.provider === "openai-codex" && isFirstPartyCodexBaseUrl(model.baseUrl);
@@ -26365,8 +26448,8 @@ function withCodexFastModeHeaders(model, headers, enabled) {
   setHeader(fastHeaders, CODEX_FAST_MODE_ROUTING_HEADER, `model=${model.id};tier=${CODEX_FAST_MODE_SERVICE_TIER}`);
   return fastHeaders;
 }
-function withCodexFastModeStreamOptions(_model, options, enabled) {
-  if (!enabled) {
+function withCodexFastModeStreamOptions(model, options, enabled) {
+  if (!enabled || model.provider === "github-copilot") {
     return options;
   }
   return {
@@ -26500,10 +26583,14 @@ function streamWithCodexFastMode(model, context, options, streamers = DEFAULT_CO
 function isObjectPayload(payload) {
   return typeof payload === "object" && payload !== null && !Array.isArray(payload);
 }
-function withCodexFastModePayload(payload, enabled) {
-  if (!enabled || !isObjectPayload(payload) || payload.service_tier !== undefined) {
+function withCodexFastModePayload(payload, enabled, model) {
+  if (!enabled || !isObjectPayload(payload))
     return payload;
+  if (model?.provider === "github-copilot") {
+    return payload.model === model.id ? { ...payload, model: `${model.id}-fast` } : payload;
   }
+  if (payload.service_tier !== undefined)
+    return payload;
   return {
     ...payload,
     service_tier: CODEX_FAST_MODE_SERVICE_TIER
@@ -26653,7 +26740,7 @@ class FooterComponent {
       pwd += ` • ${sessionName}`;
     const modelName = state.model?.id || "no-model";
     const fastModeSettings = this.session.settingsManager.getCodexFastModeSettings();
-    const fastModeEnabled = state.model ? shouldApplyCodexFastMode(state.model, fastModeSettings, this.session.orchestrationContext) : false;
+    const fastModeEnabled = state.model ? shouldApplyCodexFastMode(state.model, fastModeSettings, this.session.orchestrationContext, this.session.modelRuntime.getCredentialSnapshot?.("github-copilot")) : false;
     let modelLabel2 = modelName;
     if (state.model?.reasoning) {
       const thinkingLevel = state.thinkingLevel || "off";
@@ -45421,14 +45508,18 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 class WorkflowStageAdmissionBoundary {
   open = true;
-  completed = new Set;
+  completed;
   inFlight = new Map;
   pending = new Set;
   invocationContext = new AsyncLocalStorage;
   closePromise;
   drainAdmittedWork;
-  constructor(drainAdmittedWork = async () => {}) {
-    this.drainAdmittedWork = drainAdmittedWork;
+  constructor(drainAdmittedWork = undefined, completedKeys = []) {
+    this.drainAdmittedWork = drainAdmittedWork ?? (async () => {});
+    this.completed = new Set(completedKeys);
+  }
+  static restore(entries, drainAdmittedWork) {
+    return new WorkflowStageAdmissionBoundary(drainAdmittedWork, Array.from(entries).flatMap((entry) => entry.type === "custom_message" && typeof entry.stageAdmissionKey === "string" ? [entry.stageAdmissionKey] : []));
   }
   admit(key, deliver, routeLate) {
     if (key !== undefined) {
@@ -45667,7 +45758,7 @@ class AgentSessionBase {
     this._subagentPolicy = config.subagentPolicy;
     this._systemPromptTransform = config.systemPromptTransform;
     const stageContext = config.orchestrationContext?.kind === "workflow-stage" ? config.orchestrationContext : undefined;
-    this._workflowStageAdmission = stageContext?.messageAdmission?.boundary ?? (stageContext ? new WorkflowStageAdmissionBoundary : undefined);
+    this._workflowStageAdmission = stageContext?.messageAdmission?.boundary ?? (stageContext ? WorkflowStageAdmissionBoundary.restore(this.sessionManager.getBranch()) : undefined);
     if (this._workflowStageAdmission && stageContext && stageContext.messageAdmission === undefined) {
       stageContext.messageAdmission = {
         boundary: this._workflowStageAdmission,
@@ -45999,6 +46090,9 @@ class AuthStorage {
       this.data = this.parseStorageData(content);
     } catch {}
   }
+  peek(provider) {
+    return this.data[provider];
+  }
   async read(provider) {
     const credential = this.data[provider];
     if (credential?.type !== "api_key")
@@ -47052,6 +47146,10 @@ function getReloadableStore(store) {
   const reloadable = store;
   return typeof reloadable.reload === "function" ? reloadable : undefined;
 }
+function getSnapshotStore(store) {
+  const snapshotStore = store;
+  return typeof snapshotStore.peek === "function" ? snapshotStore : undefined;
+}
 
 class RuntimeCredentials {
   store;
@@ -47071,6 +47169,10 @@ class RuntimeCredentials {
   async reload() {
     await getReloadableStore(this.store)?.reload();
   }
+  peek(providerId) {
+    const override = this.overrides.get(providerId);
+    return override ? { type: "api_key", key: override } : getSnapshotStore(this.store)?.peek(providerId);
+  }
   async read(providerId, options) {
     const override = this.overrides.get(providerId);
     return override ? { type: "api_key", key: override } : this.store.read(providerId, options);
@@ -47506,6 +47608,9 @@ class ModelRuntime {
   hasConfiguredAuth(providerId) {
     return this.snapshot.configuredProviders.has(providerId);
   }
+  getCredentialSnapshot(providerId) {
+    return this.credentials.peek(providerId);
+  }
   async getAuth(providerOrModel, overrides = {}) {
     if (typeof providerOrModel === "string")
       return this.models.getAuth(providerOrModel, overrides);
@@ -55461,7 +55566,7 @@ async function createAgentSession(options = {}) {
     return filtered;
   };
   const extensionRunnerRef = {};
-  const isCodexFastModeEnabled = (requestModel) => shouldApplyCodexFastMode(requestModel, settingsManager.getCodexFastModeSettings(), options.orchestrationContext);
+  const isCodexFastModeEnabled = (requestModel) => shouldApplyCodexFastMode(requestModel, settingsManager.getCodexFastModeSettings(), options.orchestrationContext, modelRuntime.getCredentialSnapshot("github-copilot"));
   agent = new Agent2({
     initialState: {
       systemPrompt: "",
@@ -55497,7 +55602,7 @@ async function createAgentSession(options = {}) {
       const extensionProvider = modelRuntime.getRegisteredProviderConfig(requestModel.provider);
       const usesExtensionStream = extensionProvider?.streamSimple !== undefined && requestModel.api === extensionProvider.api;
       const transportHeaders = usesExtensionStream ? assembledHeaders : removeUnownedModelHeaders(assembledHeaders, model2.headers, requestHeaders);
-      if (fastModeEnabled && !usesExtensionStream && !authResult) {
+      if (fastModeEnabled && !isGitHubCopilotModel(model2) && !usesExtensionStream && !authResult) {
         throw new Error(`No API key found for "${model2.provider}"`);
       }
       const codexFastModeStreamOptions = withCodexFastModeStreamOptions(requestModel, {
@@ -55514,7 +55619,7 @@ async function createAgentSession(options = {}) {
       if (usesExtensionStream) {
         return modelRuntime.streamSimple(requestModel, context, codexFastModeStreamOptions);
       }
-      if (fastModeEnabled) {
+      if (fastModeEnabled && !isGitHubCopilotModel(requestModel)) {
         return streamWithCodexFastMode(requestModel, context, codexFastModeStreamOptions);
       }
       const transportOptions = usesChatGptCodexTransport(requestModel) && codexFastModeStreamOptions ? withChatGptCodexTransportRouting(requestModel, codexFastModeStreamOptions, false) : codexFastModeStreamOptions;
@@ -55522,7 +55627,7 @@ async function createAgentSession(options = {}) {
     },
     onPayload: async (payload, model2) => {
       const fastModeEnabled = isCodexFastModeEnabled(model2);
-      const guardedPayload = withCodexFastModePayload(payload, fastModeEnabled);
+      const guardedPayload = withCodexFastModePayload(payload, fastModeEnabled, model2);
       const sourceMessages = lastConvertedLlmMessages;
       const replayGuardedPayload = sourceMessages ? restoreAnthropicReplayThinkingBlocks(guardedPayload, sourceMessages, model2) : guardedPayload;
       const runner = extensionRunnerRef.current;
@@ -59987,6 +60092,31 @@ class RemoteQueuePause {
 var init_remote_queue_pause = () => {};
 
 // src/modes/interactive-engine/isolated-runtime.ts
+import { clampThinkingLevel as clampThinkingLevel5 } from "@bastani/pi-ai/compat";
+function applyPersistedModelDefault(session, model, alreadyInScope) {
+  session.settingsManager.setDefaultModelAndProvider(model.provider, model.id);
+  if (alreadyInScope || session.scopedModels.length === 0)
+    return;
+  const enabledModels = session.settingsManager.getEnabledModels();
+  if (!enabledModels?.length)
+    return;
+  const modelReference = `${model.provider}/${model.id}`;
+  if (enabledModels.some((pattern) => pattern.toLowerCase() === modelReference.toLowerCase()))
+    return;
+  session.settingsManager.setEnabledModels([...enabledModels, modelReference]);
+}
+function thinkingPersistTarget(result) {
+  if (!result.provider || !result.modelId)
+    return;
+  return { provider: result.provider, modelId: result.modelId };
+}
+function applyPersistedThinkingDefault(session, level, target) {
+  if (target) {
+    session.settingsManager.setModelThinkingLevel(target.provider, target.modelId, level);
+    return;
+  }
+  session.settingsManager.setDefaultThinkingLevel(level);
+}
 var IsolatedInteractiveRuntime;
 var init_isolated_runtime = __esm(() => {
   init_agent_session_runtime();
@@ -60005,6 +60135,7 @@ var init_isolated_runtime = __esm(() => {
     steeringMessages = [];
     followUpMessages = [];
     queueUpdateGeneration = 0;
+    thinkingEpoch = 0;
     pendingQueueClear;
     engineCallbackActive = false;
     queuePause;
@@ -60369,43 +60500,56 @@ var init_isolated_runtime = __esm(() => {
         },
         setModel: {
           configurable: true,
-          value: async (model) => {
-            const selected = await this.client.setModel(model.provider, model.id);
-            session.agent.state.model = session.modelRuntime.getModel(selected.provider, selected.id) ?? model;
+          value: async (model, options) => {
+            const selected = await this.client.setModel(model.provider, model.id, options);
+            const nextModel = session.modelRuntime.getModel(selected.provider, selected.id) ?? model;
+            session.agent.state.model = nextModel;
             this.resolveModelFallback();
+            if (options?.persist === true)
+              await this.syncPersistedModelCatalog(session, nextModel);
           }
         },
         setThinkingLevel: {
           configurable: true,
-          value: (level) => {
-            session.agent.state.thinkingLevel = level;
-            this.dispatchBestEffort("set thinking level", this.client.setThinkingLevel(level));
+          value: (level, options) => {
+            const availableLevels = session.getAvailableThinkingLevels();
+            const effectiveLevel = availableLevels.includes(level) ? level : session.model ? clampThinkingLevel5(session.model, level) : "off";
+            session.agent.state.thinkingLevel = effectiveLevel;
+            const epoch = ++this.thinkingEpoch;
+            this.dispatchBestEffort("set thinking level", this.client.setThinkingLevelAck(level, options).then((result) => {
+              this.applyThinkingAck(session, epoch, result, options?.persist === true);
+            }));
           }
         },
         cycleModel: {
           configurable: true,
-          value: async (direction) => {
+          value: async (direction, options) => {
             const previousModel = session.model;
-            const result = await this.client.cycleModel(direction);
+            const result = await this.client.cycleModel(direction, options);
             if (!result)
               return;
             const model = session.modelRuntime.getModel(result.model.provider, result.model.id) ?? result.model;
             session.agent.state.model = model;
             session.agent.state.thinkingLevel = result.thinkingLevel;
             this.resolveModelFallbackAfterExplicitModelSelection(previousModel, model);
+            if (options?.persist === true)
+              await this.syncPersistedModelCatalog(session, model);
             return { ...result, model };
           }
         },
         cycleThinkingLevel: {
           configurable: true,
-          value: () => {
+          value: (options) => {
             const levels = session.getAvailableThinkingLevels();
             if (levels.length <= 1)
               return;
             const current = levels.indexOf(session.thinkingLevel);
             const level = levels[(current + 1) % levels.length];
             session.agent.state.thinkingLevel = level;
-            this.dispatchBestEffort("cycle thinking level", this.client.setThinkingLevel(level));
+            const epoch = ++this.thinkingEpoch;
+            this.dispatchBestEffort("cycle thinking level", this.client.setThinkingLevelAck(level, options).then((result) => {
+              this.applyThinkingAck(session, epoch, result, options?.persist === true);
+            }));
             return level;
           }
         },
@@ -60449,6 +60593,14 @@ var init_isolated_runtime = __esm(() => {
         this.engineCallbackActive = false;
       }
     }
+    applyThinkingAck(session, epoch, result, persist) {
+      if (persist) {
+        applyPersistedThinkingDefault(session, result.level, thinkingPersistTarget(result));
+      }
+      if (epoch === this.thinkingEpoch) {
+        session.agent.state.thinkingLevel = result.level;
+      }
+    }
     dispatchBestEffort(label, operation) {
       operation.catch((error) => {
         if (this.health.isRecovering())
@@ -60489,6 +60641,12 @@ var init_isolated_runtime = __esm(() => {
         }
       });
     }
+    async syncPersistedModelCatalog(session, model) {
+      const alreadyInScope = session.scopedModels.some((scoped) => scoped.model.provider === model.provider && scoped.model.id === model.id);
+      const catalog = await this.client.requestInternal({ type: "get_available_models" });
+      this.remoteModelCatalog.apply(catalog);
+      applyPersistedModelDefault(session, model, alreadyInScope);
+    }
     refreshSessionView() {
       const session = super.session;
       const sessionFile = session.sessionFile;
@@ -60528,6 +60686,7 @@ var init_isolated_runtime = __esm(() => {
           session.agent.state.model = event.model;
           break;
         case "thinking_level_changed":
+          this.thinkingEpoch += 1;
           session.agent.state.thinkingLevel = event.level;
           break;
         case "session_info_changed":
@@ -61741,7 +61900,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 Codex fast mode for chat and workflows" },
+    { name: "fast", description: "Configure OpenAI fast mode for chat and workflows in 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" },
@@ -63203,7 +63362,7 @@ var init_interactive_autocomplete = __esm(() => {
     return [...this.session.modelRuntime.getAvailableSnapshot()];
   };
   InteractiveModeBase.prototype.hasCodexFastModeSupportedModels = function() {
-    return hasSupportedCodexFastModeModel(this.getCodexFastModeCandidateModels());
+    return hasSupportedCodexFastModeModel(this.getCodexFastModeCandidateModels(), this.session.modelRuntime.getCredentialSnapshot?.("github-copilot"));
   };
   InteractiveModeBase.prototype.buildRemoteSlashCommands = function(localCommands) {
     const remote = getInteractiveEngineRemoteCommands(this.runtimeHost);
@@ -63891,7 +64050,7 @@ var init_interactive_startup = __esm(() => {
     if (!model) {
       return modelLabel2;
     }
-    const fastModeEnabled = shouldApplyCodexFastMode(model, this.session.settingsManager.getCodexFastModeSettings(), this.session.orchestrationContext);
+    const fastModeEnabled = shouldApplyCodexFastMode(model, this.session.settingsManager.getCodexFastModeSettings(), this.session.orchestrationContext, this.session.modelRuntime.getCredentialSnapshot?.("github-copilot"));
     return formatCodexFastModeModelLabel(modelLabel2, fastModeEnabled);
   };
   InteractiveModeBase.prototype.getStartupIdentityText = function(maxWidth, gap = 0, manifestoPhase = 4) {
@@ -64817,7 +64976,7 @@ var init_interactive_extension_runtime = __esm(() => {
     if (shortcuts.size === 0)
       return;
     const createContext = () => ({
-      ui: this.createExtensionUIContext(),
+      ui: extensionRunner.getUIContext(),
       mode: "tui",
       hasUI: true,
       cwd: this.sessionManager.getCwd(),
@@ -68406,7 +68565,7 @@ var init_interactive_selectors = __esm(() => {
 });
 
 // src/modes/interactive/interactive-model-routing.ts
-import { clampThinkingLevel as clampThinkingLevel5 } from "@bastani/pi-ai/compat";
+import { clampThinkingLevel as clampThinkingLevel6 } from "@bastani/pi-ai/compat";
 function resolveThinkingSelectorDefault(rawDefault, availableLevels, model) {
   if (rawDefault === undefined)
     return;
@@ -68414,7 +68573,7 @@ function resolveThinkingSelectorDefault(rawDefault, availableLevels, model) {
     return rawDefault;
   if (!model)
     return availableLevels.includes("off") ? "off" : availableLevels[0];
-  const clamped = clampThinkingLevel5(model, rawDefault);
+  const clamped = clampThinkingLevel6(model, rawDefault);
   if (availableLevels.includes(clamped))
     return clamped;
   return availableLevels.includes("off") ? "off" : availableLevels[0];
@@ -70778,11 +70937,20 @@ class RpcClientApi {
   async getState() {
     return this.data(await this.request({ type: "get_state" }));
   }
-  async setModel(provider, modelId) {
-    return this.data(await this.request({ type: "set_model", provider, modelId }));
+  async setModel(provider, modelId, options) {
+    return this.data(await this.request({
+      type: "set_model",
+      provider,
+      modelId,
+      ...options?.persist === true ? { persist: true } : {}
+    }));
   }
-  async cycleModel(direction) {
-    return this.data(await this.request({ type: "cycle_model", direction }));
+  async cycleModel(direction, options) {
+    return this.data(await this.request({
+      type: "cycle_model",
+      direction,
+      ...options?.persist === true ? { persist: true } : {}
+    }));
   }
   async getAvailableModels() {
     return this.data(await this.request({ type: "get_available_models" })).models;
@@ -70816,6 +70984,20 @@ class RpcClientApi {
   async setThinkingLevel(level) {
     await this.request({ type: "set_thinking_level", level });
   }
+  async setThinkingLevelAck(level, options) {
+    const response = await this.request({
+      type: "set_thinking_level",
+      level,
+      ...options?.persist === true ? { persist: true } : {}
+    });
+    if (!response.success) {
+      return this.data(response);
+    }
+    if (response.command === "set_thinking_level" && "data" in response && response.data) {
+      return response.data;
+    }
+    return { level };
+  }
   async cycleThinkingLevel() {
     return this.data(await this.request({ type: "cycle_thinking_level" }));
   }
@@ -72834,13 +73016,13 @@ function createRpcCommandHandler({
         if (!model) {
           return createRpcErrorResponse(id, "set_model", `Model not found: ${command.provider}/${command.modelId}`);
         }
-        await session.setModel(model);
+        await session.setModel(model, command.persist === true ? { persist: true } : {});
         runtimeHost.resolveModelFallback();
         return createRpcSuccessResponse(id, "set_model", session.model ?? model);
       }
       case "cycle_model": {
         const previousModel = session.model;
-        const result = await session.cycleModel(command.direction);
+        const result = await session.cycleModel(command.direction, command.persist === true ? { persist: true } : {});
         runtimeHost.resolveModelFallbackAfterExplicitModelSelection(previousModel, result?.model);
         return createRpcSuccessResponse(id, "cycle_model", result ?? null);
       }
@@ -72903,8 +73085,12 @@ function createRpcCommandHandler({
         }
       }
       case "set_thinking_level": {
-        session.setThinkingLevel(command.level);
-        return createRpcSuccessResponse(id, "set_thinking_level");
+        session.setThinkingLevel(command.level, command.persist === true ? { persist: true } : {});
+        const model = session.model;
+        return createRpcSuccessResponse(id, "set_thinking_level", {
+          level: session.thinkingLevel,
+          ...model ? { provider: model.provider, modelId: model.id } : {}
+        });
       }
       case "cycle_thinking_level": {
         const level = session.cycleThinkingLevel();