@bastani/atomic 0.9.11-alpha.6 → 0.9.11-alpha.8

package/dist/builtin/workflows/skills/impeccable/scripts/surface-brief.mjs

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { resolveProjectRoot } from './context.mjs';
+import {
+  listSurfaceBriefs,
+  resolveSurfaceBrief,
+  surfaceBriefPathForTarget,
+  writeSurfaceBrief,
+} from './lib/surface-briefs.mjs';
+
+function summary(brief, projectRoot) {
+  return {
+    slug: brief.slug,
+    path: path.relative(projectRoot, brief.path).split(path.sep).join('/'),
+    primaryTarget: brief.primaryTarget,
+    relatedTargets: brief.relatedTargets,
+  };
+}
+
+function main(argv) {
+  const [command, target, bodyFile, ...relatedTargets] = argv;
+  const projectRoot = resolveProjectRoot(process.cwd(), target ? { targetPath: target } : {});
+  if (command === 'path') {
+    const filePath = surfaceBriefPathForTarget(target, { projectRoot });
+    if (!filePath) throw new Error('surface brief path requires a concrete target');
+    process.stdout.write(`${path.relative(process.cwd(), filePath) || filePath}\n`);
+    return;
+  }
+  if (command === 'list') {
+    process.stdout.write(`${JSON.stringify(listSurfaceBriefs(projectRoot).map((brief) => summary(brief, projectRoot)), null, 2)}\n`);
+    return;
+  }
+  if (command === 'read') {
+    const result = resolveSurfaceBrief(projectRoot, target || null);
+    if (result.brief) {
+      process.stdout.write(result.brief.text);
+      return;
+    }
+    if (result.candidates.length) process.stderr.write(`${JSON.stringify(result.candidates.map((brief) => summary(brief, projectRoot)), null, 2)}\n`);
+    process.exit(2);
+  }
+  if (command === 'write') {
+    if (!target || !bodyFile) throw new Error('usage: surface-brief.mjs write <primary-target> <body-file>');
+    const filePath = writeSurfaceBrief({
+      projectRoot,
+      primaryTarget: target,
+      relatedTargets,
+      body: fs.readFileSync(bodyFile, 'utf-8'),
+    });
+    process.stdout.write(`${path.relative(process.cwd(), filePath) || filePath}\n`);
+    return;
+  }
+  throw new Error('usage: surface-brief.mjs <path|list|read|write> [target] [body-file] [related-target ...]');
+}
+
+function isMainModule() {
+  if (!process.argv[1]) return false;
+  try {
+    return fs.realpathSync(fileURLToPath(import.meta.url)) === fs.realpathSync(process.argv[1]);
+  } catch {
+    return import.meta.url === pathToFileURL(process.argv[1]).href;
+  }
+}
+
+if (isMainModule()) {
+  try {
+    main(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${error?.message || error}\n`);
+    process.exit(1);
+  }
+}

package/dist/builtin/workflows/src/extension/extension-runtime-state.ts

@@ -1,12 +1,9 @@
-import type { CreateAgentSessionOptions } from "@bastani/atomic";
 import type { StageAdapters } from "../runs/foreground/stage-runner.js";
 import type { SessionManager } from "../shared/persistence-restore.js";
 import type { RunSnapshot } from "../shared/store-types.js";
 import type {
   WorkflowExecutionPolicy,
   WorkflowMcpPort,
-  WorkflowModelCatalogPort,
-  WorkflowModelInfo,
   WorkflowPersistencePort,
   WorkflowRuntimeConfig,
 } from "../shared/types.js";
@@ -43,6 +40,7 @@ import {
   workflowReloadDiagnostics,
   type WorkflowReloadReport,
 } from "./workflow-reload-report.js";
+import { workflowModelCatalogFromContext } from "./workflow-model-catalog.js";
 
 export interface WorkflowExtensionRuntimeState {
   persistenceRef: { current: WorkflowPersistencePort | undefined };
@@ -171,27 +169,6 @@ export function createWorkflowExtensionRuntimeState(
     },
   };
 
-  function workflowModelCatalogFromContext(ctx?: PiModelContext): WorkflowModelCatalogPort | undefined {
-    if (ctx?.modelRegistry === undefined && ctx?.model === undefined) return undefined;
-    return {
-      listModels: async (): Promise<readonly WorkflowModelInfo[]> => {
-        const available = ctx.modelRegistry?.getAvailable() ?? (ctx.model === undefined ? [] : [ctx.model]);
-        return available.map((model) => ({
-          provider: String(model.provider),
-          id: model.id,
-          fullId: `${String(model.provider)}/${model.id}`,
-          model: model as NonNullable<CreateAgentSessionOptions["model"]>,
-        }));
-      },
-      ...(ctx.model !== undefined
-        ? {
-            currentModel: ctx.model as NonNullable<CreateAgentSessionOptions["model"]>,
-            preferredProvider: String(ctx.model.provider),
-          }
-        : {}),
-    };
-  }
-
   function runtimeForContext(ctx?: PiModelContext): ExtensionRuntime {
     const models = workflowModelCatalogFromContext(ctx);
     if (models === undefined) return runtimeProxy;

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

@@ -41452,16 +41452,95 @@ function isTerminalStageChatState(status) {
   return isTerminalOrNonStreamingStageChatStatus(status);
 }
 
+// dist/builtin/workflows/src/tui/stage-chat-view-delivery-activity.ts
+function subscribeStageChatDeliveryActivity(ctx) {
+  const handle = ctx.handle;
+  if (!handle?.subscribeDeliveryActivity)
+    return null;
+  return handle.subscribeDeliveryActivity((event) => {
+    applyStageChatDeliveryActivityEvent(ctx, event);
+  });
+}
+function applyStageChatDeliveryActivityEvent(ctx, event) {
+  if (event.type === "delivery_start") {
+    ctx.terminalLifecycleFenced = false;
+    ctx.deliveryLifecycles.set(event.deliveryId, ctx.chatHost.beginExternalPromptLifecycle());
+    return;
+  }
+  if (!ctx.deliveryLifecycles.has(event.deliveryId))
+    return;
+  const generation = ctx.deliveryLifecycles.get(event.deliveryId);
+  ctx.deliveryLifecycles.delete(event.deliveryId);
+  if (!ownsStageChatLifecycleGeneration(ctx, generation)) {
+    ctx.chatHost.settleExternalPromptLifecycle(generation);
+  }
+  if (!hasActiveStageChatDelivery(ctx) && isStageChatContextTerminal(ctx)) {
+    ctx.terminalLifecycleFenced = true;
+  }
+}
+function ownsStageChatLifecycleGeneration(ctx, generation) {
+  for (const active of ctx.deliveryLifecycles.values()) {
+    if (active === generation)
+      return true;
+  }
+  return false;
+}
+function hasActiveStageChatDelivery(ctx) {
+  return ctx.deliveryLifecycles.size > 0;
+}
+function isStageChatContextTerminal(ctx) {
+  return isTerminalStageChatState(ctx.lastObservedRunStatus) || isTerminalStageChatState(ctx.lastObservedStageStatus);
+}
+function reconcileStageChatDeliveryLifecycle(ctx) {
+  if (!hasActiveStageChatDelivery(ctx))
+    return;
+  if (ctx.chatHost.isStreaming() && ctx.chatHost.hasAnimationTick())
+    return;
+  const generation = ctx.chatHost.reassertExternalPromptLifecycle();
+  for (const deliveryId of [...ctx.deliveryLifecycles.keys()]) {
+    ctx.deliveryLifecycles.set(deliveryId, generation);
+  }
+}
+function invalidateStageChatDeliveryLifecycles(ctx) {
+  ctx.deliveryLifecycles.clear();
+  ctx.terminalLifecycleFenced = true;
+}
+
 // dist/builtin/workflows/src/tui/stage-chat-view-live-events.ts
 function applyStageChatLiveHandleEvent(ctx, event) {
+  const staleTerminalStart = isStaleTerminalLifecycleStart(ctx, event);
   ctx.chatHost.applyAgentEvent(event);
+  if (staleTerminalStart) {
+    retainTerminalCleanup(ctx);
+    return;
+  }
+  if (isCompactionEndEvent(event))
+    reconcileStageChatDeliveryLifecycle(ctx);
   if (!shouldCleanupAfterLiveEvent(ctx, event))
     return;
+  retainTerminalCleanup(ctx);
+}
+function retainTerminalCleanup(ctx) {
   const hadAnimationTick = ctx.chatHost.hasAnimationTick();
   ctx.chatHost.clearBusyForTerminalWorkflowStage();
   if (hadAnimationTick !== ctx.chatHost.hasAnimationTick())
     ctx.requestRender?.();
 }
+function isStaleTerminalLifecycleStart(ctx, event) {
+  if (!ctx.terminalLifecycleFenced)
+    return false;
+  const type = String(event.type ?? "");
+  if (type !== "agent_start" && type !== "turn_start")
+    return false;
+  if (hasActiveStageChatDelivery(ctx))
+    return false;
+  if (ctx.chatHost.isStreaming())
+    return false;
+  return isCurrentRunOrStageTerminal(ctx);
+}
+function isCompactionEndEvent(event) {
+  return String(event.type ?? "") === "compaction_end";
+}
 function shouldCleanupAfterLiveEvent(ctx, event) {
   if (!isToolExecutionLiveEvent(event))
     return false;
@@ -41550,8 +41629,11 @@ function initializeStageChatView(ctx, opts) {
   ctx.lastObservedStageStatus = undefined;
   ctx.lastObservedRunStatus = undefined;
   ctx.seenNoticeIds = new Set;
+  ctx.deliveryLifecycles = new Map;
+  ctx.terminalLifecycleFenced = false;
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity = null;
   ctx._unsubscribeFooterData = null;
   ctx._unregisterStageUiHost = null;
   installFocusHold(ctx);
@@ -41581,6 +41663,7 @@ function initializeStageChatView(ctx, opts) {
   ctx._unsubscribeStore = ctx.store.subscribe(() => handleStoreUpdate(ctx));
   ctx._unsubscribeFooterData = ctx.footerData?.onBranchChange(() => ctx.requestRender?.()) ?? null;
   if (ctx.handle) {
+    ctx._unsubscribeDeliveryActivity = subscribeStageChatDeliveryActivity(ctx);
     ctx._unsubscribeHandle = ctx.handle.subscribe((event) => applyStageChatLiveHandleEvent(ctx, event));
   }
   ctx.chatHost.syncAnimationTick();
@@ -41693,6 +41776,7 @@ function handleStoreUpdate(ctx) {
   }
   if (isTerminalStageChatTransition(ctx.lastObservedStageStatus, currentStageStatus) || isTerminalStageChatTransition(ctx.lastObservedRunStatus, currentRunStatus)) {
     ctx.chatHost.clearBusyForTerminalWorkflowStage();
+    invalidateStageChatDeliveryLifecycles(ctx);
     changed = true;
   }
   ctx.lastObservedRunStatus = currentRunStatus;
@@ -41918,6 +42002,9 @@ function disposeStageChatView(ctx) {
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle?.();
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity?.();
+  ctx._unsubscribeDeliveryActivity = null;
+  ctx.deliveryLifecycles.clear();
   ctx._unsubscribeFooterData?.();
   ctx._unsubscribeFooterData = null;
   releaseMountedCustomUi(ctx);
@@ -48440,7 +48527,7 @@ function asAgentSession(activeSession) {
   if (!activeSession)
     return;
   const candidate = activeSession;
-  if (candidate.state !== undefined && candidate.sessionManager !== undefined && candidate.modelRegistry !== undefined && typeof candidate.getContextUsage === "function") {
+  if (candidate.state !== undefined && candidate.sessionManager !== undefined && candidate.modelRuntime !== undefined && typeof candidate.getContextUsage === "function") {
     return candidate;
   }
   return;
@@ -48550,8 +48637,8 @@ function buildStageSessionOptions(input) {
     options.context = undefined;
     options.forkFromSessionFile = undefined;
   }
-  if (input.sharedModelRegistry !== undefined && options.modelRegistry === undefined) {
-    options.modelRegistry = input.sharedModelRegistry;
+  if (input.sharedModelRuntime !== undefined && options.modelRuntime === undefined) {
+    options.modelRuntime = input.sharedModelRuntime;
   }
   return Object.keys(options).length === 0 ? undefined : options;
 }
@@ -48600,7 +48687,7 @@ function coordinatedPromptOwnershipObserver(turn) {
 function unsupportedContentError() {
   return new Error("atomic-workflows: this stage session adapter does not support non-string sendUserMessage content; provide a runtime sendUserMessage implementation for text/image blocks.");
 }
-async function sendStageUserMessage(activeSession, content, options, beforeDelivery, promptStarted, admission) {
+async function sendStageUserMessage(activeSession, content, options, beforeDelivery, promptStarted, admission, activity) {
   const streaming = activeSession.isStreaming || admission?.isOwned(activeSession) === true;
   const deliverAs = streaming ? options?.deliverAs ?? "followUp" : options?.deliverAs;
   if (activeSession.sendUserMessage !== undefined) {
@@ -48608,6 +48695,7 @@ async function sendStageUserMessage(activeSession, content, options, beforeDeliv
     let reportedAction;
     const ownership2 = streaming ? undefined : admission === undefined ? createLocalPromptOwnershipObserver(activeSession, promptStarted) : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
     ownership2?.arm();
+    const deliveryId2 = streaming ? undefined : activity?.start();
     try {
       const delivery = activeSession.sendUserMessage(content, {
         ...deliverAs === undefined ? {} : { deliverAs },
@@ -48628,6 +48716,7 @@ async function sendStageUserMessage(activeSession, content, options, beforeDeliv
       throw error;
     } finally {
       ownership2?.dispose();
+      activity?.settle(deliveryId2);
     }
   }
   if (typeof content !== "string")
@@ -48642,6 +48731,7 @@ async function sendStageUserMessage(activeSession, content, options, beforeDeliv
   }
   const ownership = admission === undefined ? createLocalPromptOwnershipObserver(activeSession, promptStarted) : coordinatedPromptOwnershipObserver(admission.startTurn(activeSession, promptStarted ?? (() => {})));
   ownership.arm();
+  const deliveryId = activity?.start();
   try {
     const turn = activeSession.prompt(content);
     ownership.observeStreaming();
@@ -48653,6 +48743,7 @@ async function sendStageUserMessage(activeSession, content, options, beforeDeliv
     throw error;
   } finally {
     ownership.dispose();
+    activity?.settle(deliveryId);
   }
 }
 
@@ -48839,6 +48930,52 @@ class StageMessageAdmission {
   }
 }
 
+// dist/builtin/workflows/src/runs/foreground/stage-delivery-activity.ts
+class StageDeliveryActivity {
+  listeners = new Set;
+  active = new Set;
+  nextDeliveryId = 0;
+  subscribe(listener) {
+    this.listeners.add(listener);
+    for (const deliveryId of [...this.active]) {
+      if (!this.listeners.has(listener))
+        break;
+      listener({ type: "delivery_start", deliveryId });
+    }
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  start() {
+    const deliveryId = ++this.nextDeliveryId;
+    this.active.add(deliveryId);
+    this.emit({ type: "delivery_start", deliveryId });
+    return deliveryId;
+  }
+  async runWithLease(operation) {
+    const deliveryId = this.start();
+    try {
+      return await operation();
+    } finally {
+      this.settle(deliveryId);
+    }
+  }
+  settle(deliveryId) {
+    if (deliveryId === undefined || !this.active.delete(deliveryId))
+      return;
+    this.emit({ type: "delivery_settled", deliveryId });
+  }
+  dispose() {
+    for (const deliveryId of [...this.active])
+      this.settle(deliveryId);
+    this.listeners.clear();
+  }
+  emit(event) {
+    for (const listener of [...this.listeners])
+      listener(event);
+  }
+}
+
 // dist/builtin/workflows/src/runs/foreground/stage-runner-unresolved-overflow.ts
 function unresolvedContextOverflowMessage(event) {
   if (event === null || typeof event !== "object")
@@ -49095,7 +49232,7 @@ class StageSessionController {
   candidatesPromise;
   activeCandidateIndex;
   selectedModel;
-  sharedModelRegistry;
+  sharedModelRuntime;
   sharedOrchestrationContext;
   resumeCurrentSession = false;
   modelAttempts = [];
@@ -49105,6 +49242,7 @@ class StageSessionController {
   sessionSettingsManager;
   replacement = new StageSessionReplacement;
   messageAdmission = new StageMessageAdmission;
+  deliveryActivity = new StageDeliveryActivity;
   constructor(opts, meta, effectiveStageOptions, structuredOutputCapture) {
     this.opts = opts;
     this.meta = meta;
@@ -49168,16 +49306,24 @@ class StageSessionController {
     await session.closeWorkflowStageGeneration?.();
     return session;
   }
-  async sendUserMessage(content, options, beforeDelivery) {
+  async sendUserMessage(content, options, beforeDelivery, preparation) {
     return this.messageAdmission.run(async (release) => {
-      const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(() => this.sendUserMessage(content, options, beforeDelivery));
+      const pausedDelivery = this.pauseControl.deferRunnerOwnedDelivery(() => this.sendUserMessage(content, options, beforeDelivery, preparation));
       if (pausedDelivery !== undefined) {
         release();
         return pausedDelivery;
       }
-      return sendStageUserMessage(await this.ensureSession("prompt"), content, options, beforeDelivery, release, this.messageAdmission);
+      preparation?.beforePreparation?.();
+      const sessionFile = preparation?.sessionFile;
+      const deliver = async (activity) => sendStageUserMessage(sessionFile === undefined ? await this.ensureSession("prompt") : await this.ensureSessionFromFile(sessionFile, "prompt"), content, options, beforeDelivery, release, this.messageAdmission, activity);
+      if (this.session === undefined || sessionFile !== undefined)
+        return this.deliveryActivity.runWithLease(() => deliver());
+      return deliver(this.deliveryActivity);
     });
   }
+  subscribeDeliveryActivity(listener) {
+    return this.deliveryActivity.subscribe(listener);
+  }
   sealGeneration() {
     this.generationSealed = true;
     this.sharedOrchestrationContext?.messageAdmission?.boundary.seal();
@@ -49252,6 +49398,7 @@ class StageSessionController {
     this.unsubscribeTerminateWatcher = undefined;
     this.terminatingToolCallIds.clear();
     this.messageAdmission.dispose();
+    this.deliveryActivity.dispose();
     await this.replacement.dispose();
     await disposeStageSession(this.session);
   }
@@ -49339,7 +49486,7 @@ class StageSessionController {
       candidate,
       restoreSavedModel: resumeOptions?.restoreSavedModel,
       reattachSessionFile: this.reattachSessionFile,
-      sharedModelRegistry: this.sharedModelRegistry
+      sharedModelRuntime: this.sharedModelRuntime
     });
     const created = this.opts.adapters.agentSession ? await this.opts.adapters.agentSession.create(stripWorkflowOnlyOptions2(stageOptions, this.opts.defaultSessionDir, this.meta), {
       ...this.meta,
@@ -49358,10 +49505,10 @@ class StageSessionController {
       result.session.sealWorkflowStageGeneration?.();
     this.replacement.adopt(result.session);
     this.session = result.session;
-    if (this.sharedModelRegistry === undefined) {
+    if (this.sharedModelRuntime === undefined) {
       const withRegistry = result.session;
-      if (withRegistry.modelRegistry !== undefined)
-        this.sharedModelRegistry = withRegistry.modelRegistry;
+      if (withRegistry.modelRuntime !== undefined)
+        this.sharedModelRuntime = withRegistry.modelRuntime;
     }
     this.sessionSettingsManager = result.settingsManager ?? result.session.settingsManager;
     if (this.pendingThinkingLevel !== undefined)
@@ -49739,8 +49886,8 @@ function createStageContext(opts) {
     async sendUserMessage(text, options) {
       await controller.sendUserMessage(text, options);
     },
-    async __sendUserMessage(text, options, beforeDelivery) {
-      return controller.sendUserMessage(text, options, beforeDelivery);
+    async __sendUserMessage(text, options, beforeDelivery, preparation) {
+      return controller.sendUserMessage(text, options, beforeDelivery, preparation);
     },
     async steer(text) {
       await (await controller.ensureSession()).steer(text);
@@ -49751,6 +49898,9 @@ function createStageContext(opts) {
     subscribe(listener) {
       return controller.subscribe(listener);
     },
+    __subscribeDeliveryActivity(listener) {
+      return controller.subscribeDeliveryActivity(listener);
+    },
     get sessionFile() {
       return controller.currentSession?.sessionFile;
     },
@@ -51274,6 +51424,7 @@ function createReplayStageContext(input) {
     steer: async () => rejectReplayMutation("steer"),
     followUp: async () => rejectReplayMutation("follow up"),
     subscribe: () => () => {},
+    __subscribeDeliveryActivity: () => () => {},
     get sessionFile() {
       return replaySource.sessionFile;
     },
@@ -51371,18 +51522,28 @@ class StageToolExecutionBuffer {
 
 // dist/builtin/workflows/src/runs/foreground/executor-stage-control.ts
 function createStageControlHandle(runtime) {
-  const ensureMessagingSession = async () => {
+  const messagePreparation = () => {
     const meta = runtime.innerCtx.__sessionMeta();
-    if (meta.sessionId !== undefined || meta.sessionFile !== undefined)
-      return;
+    if (meta.sessionId !== undefined || meta.sessionFile !== undefined) {
+      return { beforePreparation: runtime.throwIfStageMutationBlocked };
+    }
     if (runtime.stageSnapshot.sessionFile !== undefined) {
-      await runtime.innerCtx.__ensureSessionFromFile(runtime.stageSnapshot.sessionFile);
-      runtime.captureStageSessionMeta();
-      return;
+      return {
+        sessionFile: runtime.stageSnapshot.sessionFile,
+        beforePreparation: runtime.throwIfStageMutationBlocked
+      };
     }
     if (isTerminalStage(runtime.stageSnapshot)) {
       throw new Error(`atomic-workflows: cannot message stage "${runtime.name}" because no retained session metadata is available.`);
     }
+    return { beforePreparation: runtime.throwIfStageMutationBlocked };
+  };
+  const ensureMessagingSession = async () => {
+    const sessionFile = messagePreparation().sessionFile;
+    if (sessionFile === undefined)
+      return;
+    await runtime.innerCtx.__ensureSessionFromFile(sessionFile);
+    runtime.captureStageSessionMeta();
   };
   const toolExecutions = new StageToolExecutionBuffer;
   const unsubscribeToolExecutions = runtime.innerCtx.subscribe((event) => toolExecutions.record(event));
@@ -51423,14 +51584,13 @@ function createStageControlHandle(runtime) {
     },
     async sendUserMessage(text, options, beforeDelivery) {
       runtime.throwIfStageMutationBlocked();
-      await ensureMessagingSession();
-      runtime.throwIfStageMutationBlocked();
+      const preparation = messagePreparation();
       const admitDelivery = () => {
         runtime.throwIfStageMutationBlocked();
         beforeDelivery?.();
       };
       try {
-        const action = await runtime.innerCtx.__sendUserMessage(text, options, admitDelivery);
+        const action = await runtime.innerCtx.__sendUserMessage(text, options, admitDelivery, preparation);
         if (action === "steer" || action === "followUp") {
           runtime.state.resumeContinuationPending = "queued-user-message";
         }
@@ -51441,10 +51601,10 @@ function createStageControlHandle(runtime) {
     },
     async prompt(text) {
       runtime.throwIfStageMutationBlocked();
-      await ensureMessagingSession();
+      const preparation = messagePreparation();
       let action;
       try {
-        action = await runtime.innerCtx.__sendUserMessage(text, undefined, runtime.throwIfStageMutationBlocked);
+        action = await runtime.innerCtx.__sendUserMessage(text, undefined, runtime.throwIfStageMutationBlocked, preparation);
       } finally {
         runtime.captureStageSessionMeta();
       }
@@ -51540,6 +51700,9 @@ function createStageControlHandle(runtime) {
     subscribe(listener) {
       return runtime.innerCtx.subscribe(listener);
     },
+    subscribeDeliveryActivity(listener) {
+      return runtime.innerCtx.__subscribeDeliveryActivity(listener);
+    },
     async dispose() {
       unsubscribeToolExecutions();
       toolExecutions.clear();
@@ -61765,11 +61928,19 @@ function createPostMortemStageHandle(runId, stage, sessionFile, adapters, cwd, d
     ...defaultSessionDir !== undefined ? { defaultSessionDir } : {}
   });
   let disposed = false;
-  const ensureAttached = async () => {
+  const throwIfClosed = () => {
     if (disposed)
       throw new Error(`Post-mortem stage chat "${stage.name}" is closed.`);
-    if (context.__sessionMeta().sessionFile === undefined) {
-      await context.__ensureSessionFromFile(sessionFile);
+  };
+  const messagePreparation = () => ({
+    ...context.__sessionMeta().sessionFile === undefined ? { sessionFile } : {},
+    beforePreparation: throwIfClosed
+  });
+  const ensureAttached = async () => {
+    throwIfClosed();
+    const sessionFileToRestore = messagePreparation().sessionFile;
+    if (sessionFileToRestore !== undefined) {
+      await context.__ensureSessionFromFile(sessionFileToRestore);
     }
   };
   return {
@@ -61799,8 +61970,13 @@ function createPostMortemStageHandle(runId, stage, sessionFile, adapters, cwd, d
       await ensureAttached();
     },
     async sendUserMessage(text, options, beforeDelivery) {
-      await ensureAttached();
-      return context.__sendUserMessage(text, options, beforeDelivery);
+      throwIfClosed();
+      const preparation = messagePreparation();
+      const admitDelivery = () => {
+        throwIfClosed();
+        beforeDelivery?.();
+      };
+      return context.__sendUserMessage(text, options, admitDelivery, preparation);
     },
     async prompt(text) {
       await ensureAttached();
@@ -61823,6 +61999,9 @@ function createPostMortemStageHandle(runId, stage, sessionFile, adapters, cwd, d
     subscribe(listener) {
       return context.subscribe(listener);
     },
+    subscribeDeliveryActivity(listener) {
+      return context.__subscribeDeliveryActivity(listener);
+    },
     async dispose() {
       if (disposed)
         return;
@@ -68529,6 +68708,27 @@ function workflowReloadDiagnostics(configDiagnostics, discoveryDiagnostics) {
   ];
 }
 
+// dist/builtin/workflows/src/extension/workflow-model-catalog.ts
+function workflowModelCatalogFromContext(ctx) {
+  if (ctx?.modelRegistry === undefined && ctx?.model === undefined)
+    return;
+  return {
+    listModels: async () => {
+      const available = ctx.modelRegistry?.getAvailable() ?? (ctx.model === undefined ? [] : [ctx.model]);
+      return available.map((model) => ({
+        provider: String(model.provider),
+        id: model.id,
+        fullId: `${String(model.provider)}/${model.id}`,
+        model
+      }));
+    },
+    ...ctx.model !== undefined ? {
+      currentModel: ctx.model,
+      preferredProvider: String(ctx.model.provider)
+    } : {}
+  };
+}
+
 // dist/builtin/workflows/src/extension/extension-runtime-state.ts
 function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi.sessionManager?.getCwd?.() ?? process.cwd()) {
   const persistenceRef = { current: makePersistencePort(pi, WORKFLOW_CONFIG_DEFAULTS.persistRuns) };
@@ -68639,25 +68839,6 @@ function createWorkflowExtensionRuntimeState(pi, adapters, resolveCwd = () => pi
       return open(workflowIdOrPrefix, catalog);
     }
   };
-  function workflowModelCatalogFromContext(ctx) {
-    if (ctx?.modelRegistry === undefined && ctx?.model === undefined)
-      return;
-    return {
-      listModels: async () => {
-        const available = ctx.modelRegistry?.getAvailable() ?? (ctx.model === undefined ? [] : [ctx.model]);
-        return available.map((model) => ({
-          provider: String(model.provider),
-          id: model.id,
-          fullId: `${String(model.provider)}/${model.id}`,
-          model
-        }));
-      },
-      ...ctx.model !== undefined ? {
-        currentModel: ctx.model,
-        preferredProvider: String(ctx.model.provider)
-      } : {}
-    };
-  }
   function runtimeForContext(ctx) {
     const models = workflowModelCatalogFromContext(ctx);
     if (models === undefined)
@@ -72054,7 +72235,7 @@ var WorkflowParametersSchema = Type21.Object({
 }, { additionalProperties: false });
 
 // dist/builtin/workflows/src/extension/workflow-prompts.ts
-var WORKFLOW_TOOL_DESCRIPTION = "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " + "when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; " + "discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " + "send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " + "For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " + "For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " + "quote the exact path without rewriting separators (Windows backslashes are valid), " + "then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " + "Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " + "When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
+var WORKFLOW_TOOL_DESCRIPTION = "Run named builtin, project, user, or package workflows; custom definitions may import reusable project/package workflows or builtin definitions from @bastani/workflows/builtin and nest them with ctx.workflow(...), including deeper composition within the configured maxDepth; " + "when workflow execution fits but another shape would better achieve the task, author a custom TypeScript workflow({...}) inline with normal coding tools, reload it, and run it; after successfully creating and reloading a newly authored custom workflow, report the folder containing its generated code as 'Custom workflow created. You can inspect its code at: <workflow-folder-path>'; do this only for newly created custom workflows, never builtin or pre-existing workflows; " + "discover with list/get/inputs/models, list session runs with status (no runId; statusFilter narrows the list), inspect status/stages/stage details, " + "send prompt answers or steering only while the root workflow is nonterminal, pause/resume/interrupt/quit runs, and reload workflow resources. " + "For large stage handoffs, write context to files/artifacts, pass paths via reads, and prompt downstream agents to 'Read the file at <path>...' instead of injecting large previous text. " + "For transcripts, prefer status/stages/stage to get sessionFile/transcriptPath, " + "quote the exact path without rewriting separators (Windows backslashes are valid), " + "then search it with rg/grep and read small ranges; transcript is path-only by default when sessionFile/transcriptPath exists, explicit tail/limit returns bounded previews, and missing transcript paths fall back to a small preview. " + "Use action 'models' to inspect models in the configured catalog; the result is a configured-auth snapshot showing what's present in the registry with configured authentication, not proof of credentials, entitlements, OAuth freshness, or live provider access. " + "When authoring a workflow that should dynamically select a model, first call workflow({ action: 'models' }) to inspect the configured catalog, then select from the returned provider/id entries considering the isCurrent marker and available thinking levels.";
 var DEFAULT_PROMPT_GUIDANCE = [
   `**Workflows**: Treat workflows as the default execution path for any non-trivial task and for any request that has inherent structure plus an objective you can make verifiable. Use the \`workflow\` tool for existing named workflows; when the task needs a graph that is not installed, author a custom TypeScript \`workflow({...})\` inline with normal coding tools, reload workflow resources, and run it.
   - Workflow fit check: prefer a workflow for implementation, build, debug/diagnosis, bug-fix, migration, new-feature, scoped multi-file, or docs/code changes with validation; and whenever there are multiple steps, dependencies, handoffs, uncertainty, review/validation needs, long-running work, measurable done criteria, or an outcome that needs evidence.
@@ -72089,6 +72270,7 @@ var DEFAULT_PROMPT_GUIDANCE = [
   - For transcripts, avoid whole-file reads. Get \`sessionFile\`/\`transcriptPath\` from \`stages\` or \`stage\`, preserve the exact path and platform separators, search with \`rg\`/\`grep\`, and read small relevant ranges; use explicit \`tail\` or \`limit\` only for a bounded preview.`,
   `**Workflow authoring and handoffs**:
   - When a user asks to create or edit a workflow, clarify only unresolved requirements that materially affect its purpose, inputs, stages, handoffs, validation, success criteria, or starter pattern. Read the workflow docs/examples, implement the TypeScript definition with normal coding tools, reload it, and run representative test inputs before presenting it. Use the create-spec skill when it adds value; it is not mandatory when context is already sufficient.
+  - After creating and reloading a newly authored custom workflow, close the loop by stating the folder containing the workflow file just written, for example \`.atomic/workflows/\`, in this shape: \`Custom workflow created. You can inspect its code at: <workflow-folder-path>\`. Do this only for newly created custom workflows, never builtin or pre-existing workflows.
   - When creating or editing a workflow that pins an explicit stage \`model\` or \`fallbackModels\`, consult \`packages/coding-agent/docs/models/model-selection.md\` for role-based recommendations, then call \`workflow({ action: "models" })\` to see the models actually present in the user's configured catalog. Use only the catalog's returned \`fullId\` values as model strings, and append a thinking suffix only when that exact level appears in the entry's \`availableThinkingLevels\`; treat an absent or empty \`availableThinkingLevels\` as no suffix support rather than inferring one. If a guide-recommended model for the role is unavailable, try another guide-recommended model that is present in the catalog. If no recommendation intersects with the catalog, leave the stage unpinned rather than inventing a substitute, and mention the limitation, asking the user only if the workflow requires an explicit model choice. If the catalog is empty, continue with unpinned stages, state that no configured models were returned, and do not fabricate model IDs. Do not inspect or infer credentials, environment variables, auth files, token validity, entitlements, or the reason a model is absent; \`isCurrent\` marks the active selection, not a quality recommendation.
   - Consult docs/workflows.md and its starter patterns (Classify-and-act, Fan-out-and-synthesize, Adversarial verification, Generate-and-filter, Tournament, and Loop until done) when designing a stage graph.
   - Treat workflow composition as a first-class authoring option. Before duplicating stages, inspect reusable workflow modules and builtin exports; import their definitions and invoke them with \`ctx.workflow(...)\`, mapping typed inputs and consuming only declared outputs. Nested workflows can themselves import children, so combine small reusable graphs into a richer parent while respecting \`maxDepth\`.