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

package/dist/builtin/intercom/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/intercom",
-  "version": "0.9.16-alpha.7",
+  "version": "0.9.16-alpha.8",
   "private": true,
   "description": "Atomic extension providing a private coordination channel between parent and child agent sessions. Fork of: https://github.com/nicobailon/pi-intercom",
   "contributors": [

package/dist/builtin/intercom/session-target.ts

@@ -0,0 +1,54 @@
+import type { SessionInfo } from "./types.js";
+
+export type SessionTargetResolution =
+  | { kind: "resolved"; session: SessionInfo }
+  | { kind: "ambiguous_name"; matches: readonly SessionInfo[] }
+  | { kind: "not_found" };
+
+/** Resolve an Intercom session by exact ID or exact case-insensitive name. */
+export function resolveSessionTarget(
+  sessions: readonly SessionInfo[],
+  nameOrId: string,
+): SessionTargetResolution {
+  const target = nameOrId.trim();
+  const exactId = sessions.find((session) => session.id === target);
+  if (exactId !== undefined) return { kind: "resolved", session: exactId };
+
+  const lowerTarget = target.toLowerCase();
+  const exactNames = sessions.filter(
+    (session) => session.name?.toLowerCase() === lowerTarget,
+  );
+  if (exactNames.length === 1) {
+    return { kind: "resolved", session: exactNames[0]! };
+  }
+  if (exactNames.length > 1) {
+    return { kind: "ambiguous_name", matches: exactNames };
+  }
+
+  return { kind: "not_found" };
+}
+
+export function sessionTargetFailureReason(
+  target: string,
+  resolution: Exclude<SessionTargetResolution, { kind: "resolved" }>,
+): string {
+  if (resolution.kind === "ambiguous_name") {
+    return `Multiple sessions named "${target}" are connected. Use the session ID instead.`;
+  }
+  return "Session not found";
+}
+
+export interface SessionListingClient {
+  listSessions(): Promise<SessionInfo[]>;
+}
+
+/** Resolve a target through the broker's current session list. */
+export async function resolveSessionTargetId(
+  client: SessionListingClient,
+  nameOrId: string,
+): Promise<string | null> {
+  const resolution = resolveSessionTarget(await client.listSessions(), nameOrId);
+  if (resolution.kind === "resolved") return resolution.session.id;
+  if (resolution.kind === "not_found") return null;
+  throw new Error(sessionTargetFailureReason(nameOrId, resolution));
+}

package/dist/builtin/intercom/skills/intercom/SKILL.md

@@ -75,7 +75,22 @@ intercom({ action: "list" })
 intercom({ action: "ask", to: "6332faab-1111-4222-8333-123456789abc", message: "Which option should I use?" })
 ```
 
-Intercom accepts only an exact full session ID or an exact case-insensitive session name. Use the full ID printed by `list` or the session's exact name.
+Live sessions accept an exact full session ID or exact case-insensitive name. Ordinary `send` to a known workflow stage whose session has not initialized uses the exact `<runId>:<stageKey>` identity. Unknown runs and stages retain the ordinary unknown-target failure.
+
+### Deliver to workflow stages that have not started
+
+Send material updates through Intercom to every affected workflow stage, including stages that have not started. Atomic queues messages for known pending stages and delivers them when their sessions initialize:
+
+```typescript
+intercom({
+  action: "send",
+  to: "<runId>:reviewer",
+  message: "Scope changed: preserve raw amendment text in the verification oracle."
+})
+// → queued, distinct from live-session delivered, with the FIFO position
+```
+
+The stage receives the ordinary inbound Intercom message before its first model turn under **Messages received before you started**, with real sender identity and a `Sent:` timestamp. Only same-workflow-group sessions may queue messages. Each exact run/stage key holds at most 50 queued messages; the next send is refused rather than evicting one. Resume/replay, broker restart, and stage-attempt restart preserve exactly-once delivery. If the stage is skipped, cancelled, or becomes terminal before its session initializes, the message becomes undeliverable and acknowledgment-requesting senders receive a correlated failure. Do not use `ask`: Atomic returns `pending_stage_ask_unsupported` and recommends ordinary `send` instead of holding an unbounded waiter.
 
 ### Runtime named groups
 
@@ -230,8 +245,8 @@ In Atomic workflows, each invocation has its own Intercom group, and parallel st
 |--------|----------|----------|
 | `join` | Joins or creates a named group in place | Two plain chat sessions need a private group |
 | `leave` | Returns to the resolved home group | Restore the session's startup group |
-| `send` | Fire-and-forget | You don't need a response |
-| `ask` | Blocks until reply (10 min timeout) | You need an answer to continue |
+| `send` | Fire-and-forget to a live session, or durable `queued` delivery to `<runId>:<stageKey>` before a workflow stage starts | You don't need a response |
+| `ask` | Blocks until a live recipient replies (10 min timeout); refused for an unstarted stage | You need an answer to continue |
 | `reply` | Responds to the active or pending inbound ask; `to` accepts an exact full session ID or exact session name | You were asked something and need to answer naturally |
 | `pending` | Lists unresolved inbound asks | You need to see who is waiting before replying |
 | `list` | Returns all sessions in the current group with full session IDs and live status | You need to discover targets or choose an idle peer |

package/dist/builtin/intercom/source-ownership.ts

@@ -0,0 +1,31 @@
+import { type SubagentChildPolicy } from "@bastani/atomic";
+import type { Message } from "./types.js";
+
+export function buildSubagentMessageSource(
+  runIdValue: string | undefined,
+  agentValue: string | undefined,
+  indexValue: string | undefined,
+): Message["source"] | undefined {
+  const subagentRunId = runIdValue?.trim();
+  if (!subagentRunId) return undefined;
+  const subagentAgent = agentValue?.trim();
+  const rawIndex = indexValue?.trim();
+  const parsedIndex = rawIndex === undefined ? undefined : Number(rawIndex);
+  const subagentIndex = parsedIndex !== undefined && Number.isInteger(parsedIndex) && parsedIndex >= 0
+    ? parsedIndex : undefined;
+  return {
+    subagentRunId,
+    ...(subagentAgent ? { subagentAgent } : {}),
+    ...(subagentIndex !== undefined ? { subagentIndex } : {}),
+  };
+}
+
+export function readSubagentMessageSource(policy?: SubagentChildPolicy): Message["source"] | undefined {
+	const identity = policy?.intercom;
+	if (!identity) return undefined;
+	return {
+		subagentRunId: identity.runId,
+		subagentAgent: identity.agent,
+		subagentIndex: identity.index,
+	};
+}

package/dist/builtin/intercom/types.ts

@@ -0,0 +1,115 @@
+export interface SessionInfo {
+  id: string;
+  name?: string;
+  cwd: string;
+  model: string;
+  pid: number;
+  startedAt: number;
+  lastActivity: number;
+  status?: string;
+  /** Session's intercom group; undefined is treated as the shared "default" group. */
+  group?: string;
+}
+
+export interface Message {
+  id: string;
+  timestamp: number;
+  replyTo?: string;
+  expectsReply?: boolean;
+  /** Actionable remote failure for a correlated ask reply. */
+  replyError?: string;
+  source?: {
+    subagentRunId: string;
+    subagentAgent?: string;
+    subagentIndex?: number;
+  };
+  content: {
+    text: string;
+    attachments?: Attachment[];
+  };
+}
+
+export interface Attachment {
+  type: "file" | "snippet" | "context";
+  name: string;
+  content: string;
+  language?: string;
+}
+/** Broker capability metadata binding a child registration to its supervisor. */
+export interface SupervisorRegistration {
+  capability: string;
+  supervisorSessionId: string;
+}
+
+
+export type ClientMessage =
+	| {
+			type: "register";
+			session: Omit<SessionInfo, "id">;
+			/** Internal host-owned identity retained across broker reconnects. */
+			returnAddress?: string;
+			supervisor?: SupervisorRegistration;
+			supervisorOwnerToken?: string;
+	  }
+	| { type: "unregister" }
+  | { type: "list"; requestId: string; group?: string }
+  | { type: "authorize_supervisor"; requestId: string; childName: string; capability?: string }
+  | { type: "send" | "supervisor_send"; to: string; message: Message; attemptId?: string }
+	| {
+			type: "send_pending_stage_notification";
+			runId: string;
+			capability: string;
+			to: string;
+			senderRegistrationName?: string;
+			senderReturnAddress?: string;
+			message: Message;
+			attemptId?: string;
+	  }
+	| { type: "pending_stage_notification_result"; requestId: string; delivered: boolean }
+  | { type: "register_pending_stage_route"; runId: string; group: string; capability: string }
+  | {
+      type: "register_live_workflow_stage_route";
+      requestId: string;
+      runId: string;
+      stageKeys: string[];
+      capability: string;
+    }
+	| {
+		type: "pending_stage_message_result";
+		requestId: string;
+		outcome: "queued" | "delivered" | "forward" | "refused";
+		position?: number;
+		reason?: string;
+		reasonCode?: "message_id_conflict";
+	  }
+  | { type: "presence"; name?: string; status?: string; model?: string; group?: string; requestId?: string };
+
+export type BrokerMessage =
+  | { type: "registered"; sessionId: string; supervisorSessionId?: string }
+  | { type: "registration_failed"; reason: string }
+  | { type: "sessions"; requestId: string; sessions: SessionInfo[] }
+  | { type: "supervisor_authorized"; requestId: string; capability: string; supervisorSessionId: string; childName: string }
+  | { type: "message"; from: SessionInfo; message: Message; channel?: "supervisor" }
+	| { type: "pending_stage_notification"; requestId: string; from: SessionInfo; message: Message }
+	| {
+			type: "pending_stage_message";
+			requestId: string;
+			from: SessionInfo;
+			senderRegistrationName?: string;
+			senderReturnAddress?: string;
+			runId: string;
+			stageKey: string;
+			message: Message;
+			live?: boolean;
+	  }
+  | { type: "live_workflow_stage_route_registered"; requestId: string }
+  | { type: "presence_update"; session: SessionInfo }
+  | { type: "session_joined"; session: SessionInfo }
+  | { type: "session_left"; sessionId: string }
+  | { type: "peer_disconnected"; replyTo: string; peerSessionId: string; peerName?: string }
+  | { type: "presence_ack"; requestId: string; group: string }
+  | { type: "presence_failed"; requestId: string; reason: string }
+  | { type: "error"; error: string }
+  | { type: "delivered"; messageId: string; attemptId?: string }
+  | { type: "queued"; messageId: string; attemptId?: string; runId: string; stageKey: string; position: number }
+	| { type: "delivery_failed"; messageId: string; reason: string; reasonCode?: "message_id_conflict"; attemptId?: string };

package/dist/builtin/mcp/index.bundle.mjs

@@ -3854,10 +3854,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;
@@ -9925,6 +9925,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 };
 }
@@ -10150,12 +10152,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) {
@@ -10169,20 +10176,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) {
@@ -10205,7 +10212,7 @@ async function commitAdmittedCustomMessage(session, appMessage, options) {
       self._continueQueuedAgentMessages().catch(() => {});
     }
   } else {
-    self._appendCustomMessage(appMessage);
+    appendDurableStageAdmission(self, appMessage);
   }
 }
 function _commitAdmittedCustomMessage(appMessage, options) {
@@ -21607,11 +21614,20 @@ import {
 function isCodexFastModeSupportedProvider(provider) {
   return provider === "openai" || provider === "openai-codex";
 }
-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";
@@ -21622,11 +21638,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 formatCodexFastModeModelLabel(modelName, enabled) {
   return enabled ? `${modelName} fast` : modelName;
@@ -21767,7 +21783,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";
@@ -39355,14 +39371,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) {
@@ -39601,7 +39621,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,
@@ -46699,6 +46719,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();
@@ -46717,6 +46762,7 @@ var init_isolated_runtime = __esm(() => {
     steeringMessages = [];
     followUpMessages = [];
     queueUpdateGeneration = 0;
+    thinkingEpoch = 0;
     pendingQueueClear;
     engineCallbackActive = false;
     queuePause;
@@ -47081,43 +47127,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;
           }
         },
@@ -47161,6 +47220,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())
@@ -47201,6 +47268,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;
@@ -47240,6 +47313,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":
@@ -48453,7 +48527,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" },
@@ -49905,7 +49979,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);
@@ -50593,7 +50667,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) {
@@ -55108,7 +55182,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;
@@ -55116,7 +55190,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];

package/dist/builtin/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/mcp",
-  "version": "0.9.16-alpha.7",
+  "version": "0.9.16-alpha.8",
   "private": true,
   "description": "Atomic extension that adapts MCP (Model Context Protocol) servers into the coding agent. Fork of: https://github.com/nicobailon/pi-mcp-adapter",
   "contributors": [

package/dist/builtin/subagents/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bastani/subagents",
-  "version": "0.9.16-alpha.7",
+  "version": "0.9.16-alpha.8",
   "private": true,
   "description": "Atomic extension for delegating tasks to subagents with parallel execution. Fork of: https://github.com/nicobailon/pi-subagents",
   "contributors": [