@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/src/extension/extension-lifecycle.ts

@@ -3,22 +3,24 @@ import { quitAllRuns } from "../runs/background/quit.js";
 import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
 import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import { store } from "../shared/store.js";
-import { restoreOnSessionStart } from "../shared/persistence-restore.js";
-import { findResumableWorkflowNotices } from "../shared/resumable-workflow-notices.js";
 import { installCompactionHook } from "../shared/persistence-compaction-policy.js";
 import { clearForms } from "../tui/inline-form-store.js";
 import { installStoreWidget } from "../tui/store-widget-installer.js";
-import { registerIntercomParentSession } from "../intercom/intercom-bridge.js";
-import {
-  resetWorkflowLifecycleNotificationState,
-  seedWorkflowLifecycleNotificationState,
-  withWorkflowLifecycleNotificationsSuppressed,
-} from "./lifecycle-notifications.js";
+import { resetWorkflowLifecycleNotificationState } from "./lifecycle-notifications.js";
 import { resetWorkflowHilAnswerNotificationState } from "./hil-answer-notifications.js";
 import type { ExtensionAPI } from "./public-types.js";
 import type { WorkflowExtensionRuntimeState } from "./extension-runtime-state.js";
 import { deAdvertiseAskUserQuestionWhenHeadless, formatStartupDiagnostics } from "./workflow-command-surfaces.js";
 import { inFlightRunCount } from "./workflow-targets.js";
+import { shutdownDbos } from "../durable/dbos-lifecycle.js";
+
+let processShutdownInstalled = false;
+
+function installDbosProcessShutdown(): void {
+  if (processShutdownInstalled) return;
+  processShutdownInstalled = true;
+  process.once("beforeExit", () => shutdownDbos());
+}
 
 export interface WorkflowLifecycleRegistrationDeps {
   runtimeState: WorkflowExtensionRuntimeState;
@@ -31,6 +33,7 @@ export function registerWorkflowLifecycleHandlers(
   deps: WorkflowLifecycleRegistrationDeps,
 ): void {
   if (typeof pi.on !== "function") return;
+  installDbosProcessShutdown();
   const { runtimeState } = deps;
   pi.on("session_before_switch", async (event, ctx) => {
     const reason = typeof event === "object" && event !== null && "reason" in event
@@ -58,7 +61,7 @@ export function registerWorkflowLifecycleHandlers(
     return { cancel: true };
   });
 
-  pi.on("session_start", async (event, ctx) => {
+  pi.on("session_start", async (_event, ctx) => {
     runtimeState.resetWorkflowDiscoveryForSession();
     deAdvertiseAskUserQuestionWhenHeadless(pi, ctx?.hasUI);
     await runtimeState.ensureWorkflowConfigLoaded();
@@ -68,7 +71,7 @@ export function registerWorkflowLifecycleHandlers(
     resetWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState);
     resetWorkflowHilAnswerNotificationState(runtimeState.hilAnswerNotificationState);
     stageControlRegistry.clear();
-    runtimeState.setIntercomParentSession(registerIntercomParentSession(pi));
+    // Named workflows publish lifecycle notices through the normal notification path.
     runtimeState.setNotificationsActive(true);
     runtimeState.startWorkflowDiscoveryWarmup(() => {
       if (!ctx?.ui) return;
@@ -81,70 +84,45 @@ export function registerWorkflowLifecycleHandlers(
       deps.storeWidgetRef.current?.();
       deps.storeWidgetRef.current = installStoreWidget({ ui: ctx.ui }, store);
     }
-    const sessionManager = ctx?.sessionManager ?? pi.sessionManager;
-    runtimeState.updateHostStageSessionDir(sessionManager);
-    if (sessionManager) {
-      const cfg = runtimeState.configLoadRef.current?.config;
-      withWorkflowLifecycleNotificationsSuppressed(runtimeState.lifecycleNotificationState, () => {
-        try {
-          restoreOnSessionStart(
-            sessionManager,
-            {
-              resumeInFlight: cfg?.resumeInFlight ?? "ask",
-              persistRuns: cfg?.persistRuns ?? true,
-            },
-            store,
-          );
-        } catch {
-          // Host session-entry failures must not prevent the session from starting.
-        }
-        seedWorkflowLifecycleNotificationState(runtimeState.lifecycleNotificationState, store.snapshot());
-      });
-      const reason = typeof event === "object" && event !== null && "reason" in event
-        ? (event as { readonly reason?: string }).reason
-        : undefined;
-      if (reason === "startup" || reason === "resume") {
-        const getEntries = sessionManager.getEntries;
-        if (typeof getEntries === "function") {
-          let authoritativeCatalog: Awaited<ReturnType<typeof runtimeState.runtimeProxy.prepareDurableResumable>> = [];
-          try {
-            authoritativeCatalog = await runtimeState.runtimeProxy.prepareDurableResumable();
-          } catch {
-            // A resume-catalog failure must not prevent the host session from starting.
-          }
-          try {
-            const resumable = findResumableWorkflowNotices(getEntries.call(sessionManager), authoritativeCatalog);
-            if (resumable.length > 0) {
-              const commands = resumable
-                .map((workflow) => `\`${workflow.name}\` (${workflow.workflowId.slice(0, 8)}): /workflow resume ${workflow.workflowId}`)
-                .join("\n");
-              ctx?.ui?.notify?.(`This session has resumable workflows:\n${commands}`, "info");
-            }
-          } catch {
-            // Host session-entry failures must not prevent the session from starting.
-          }
-        }
-      }
-    }
+    // Session JSONL contains chat transcripts only. Workflow state is loaded
+    // from DBOS on the first workflow command or run, never during startup.
+    runtimeState.updateHostStageSessionDir(ctx?.sessionManager ?? pi.sessionManager);
   });
 
   installCompactionHook(pi, store);
-  pi.on("session_shutdown", (event) => {
+  pi.on("session_shutdown", async (event) => {
     const reason = typeof event === "object" && event !== null && "reason" in event
       ? (event as { readonly reason?: string }).reason
       : undefined;
     deps.intercomControlRef.current?.();
     deps.intercomControlRef.current = null;
     if (reason === "quit") {
-      // CLI/orchestrator quit is a resumable process boundary, not explicit
-      // `/workflow kill`. Durable-progress workflows stay available through
+      // CLI/orchestrator quit is a resumable process boundary, not destructive
+      // cancellation. Durable-progress workflows stay available through
       // `/workflow resume`; stage handles are disposed after being paused.
-      quitAllRuns({ store, stageControlRegistry });
+      try {
+        const results = await quitAllRuns({ store, stageControlRegistry });
+        const failures = results.filter((result) => !result.ok);
+        if (failures.length > 0) {
+          console.error(
+            "atomic-workflows: session shutdown could not gracefully quit every run:",
+            failures.map((result) =>
+              `${result.runId}: ${result.reason}${"message" in result ? ` (${result.message})` : ""}`
+            ).join(", "),
+          );
+        }
+      } finally {
+        stageControlRegistry.clear();
+      }
+    } else {
+      // Every non-quit host-session boundary invalidates detached lazy handles
+      // synchronously, before they can attach to the replacement session.
       stageControlRegistry.clear();
     }
     deps.storeWidgetRef.current?.();
     deps.storeWidgetRef.current = null;
     runtimeState.resetWorkflowDiscoveryForSession();
     runtimeState.setNotificationsActive(false);
+    await shutdownDbos();
   });
 }

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

@@ -58,13 +58,15 @@ export interface WorkflowExtensionRuntimeState {
   startWorkflowDiscoveryWarmup(onSettled?: () => void): void;
   runWithLifecycleSuppressedForPolicy<T>(policy: WorkflowExecutionPolicy, fn: () => Promise<T>): Promise<T>;
   setNotificationsActive(active: boolean): void;
-  setIntercomParentSession(session: string | null): void;
   updateHostStageSessionDir(sessionManager: SessionManager | undefined): void;
+  /** Current default stage session directory, when the host set a non-default one. */
+  resolveDefaultStageSessionDir(): string | undefined;
 }
 
 export function createWorkflowExtensionRuntimeState(
   pi: ExtensionAPI,
   adapters: StageAdapters,
+  resolveCwd: () => string = () => pi.sessionManager?.getCwd?.() ?? process.cwd(),
 ): WorkflowExtensionRuntimeState {
   const persistenceRef = { current: makePersistencePort(pi, WORKFLOW_CONFIG_DEFAULTS.persistRuns) };
   const mcpPort = makeMcpPort(pi);
@@ -75,6 +77,7 @@ export function createWorkflowExtensionRuntimeState(
       persistRuns: WORKFLOW_CONFIG_DEFAULTS.persistRuns,
       statusFile: WORKFLOW_CONFIG_DEFAULTS.statusFile,
       resumeInFlight: WORKFLOW_CONFIG_DEFAULTS.resumeInFlight,
+      worktree: WORKFLOW_CONFIG_DEFAULTS.worktree,
     },
   };
   let statusWriterRef: StatusWriter = createStatusWriter(store, runtimeConfigRef.current);
@@ -119,25 +122,17 @@ export function createWorkflowExtensionRuntimeState(
     });
   };
 
-  let intercomParentSession: string | null = null;
-  const intercomPort = {
-    emit: typeof pi.events?.emit === "function"
-      ? (event: string, payload: Record<string, unknown>) => pi.events!.emit!(event, payload)
-      : undefined,
-    parentSession: () => intercomParentSession ?? undefined,
-  };
   const hostStageSessionDir: { current: string | undefined } = { current: undefined };
   const resolveDefaultStageSessionDir = (): string | undefined => hostStageSessionDir.current;
   const startupDiscovery = discoverStartupWorkflowsSync();
   const runtimeRef: { current: ExtensionRuntime } = {
     current: createExtensionRuntime({
       registry: startupDiscovery.registry,
-      cwd: process.cwd(),
+      cwd: resolveCwd(),
       adapters,
       cancellation: cancellationRegistry,
       persistence: persistenceRef.current,
       mcp: mcpPort,
-      intercom: intercomPort,
       config: runtimeConfigRef.current,
       resolveDefaultStageSessionDir,
     }),
@@ -147,11 +142,15 @@ export function createWorkflowExtensionRuntimeState(
   const runtimeProxy: ExtensionRuntime = {
     get registry() { return runtimeRef.current.registry; },
     dispatch(args, options) { return runtimeRef.current.dispatch(args, options); },
-    runDirect(args, options) { return runtimeRef.current.runDirect(args, options); },
     resumeFailedRun(sourceRunId, stageId, options) { return runtimeRef.current.resumeFailedRun(sourceRunId, stageId, options); },
     resumeDurableWorkflow(workflowIdOrPrefix, options) { return runtimeRef.current.resumeDurableWorkflow(workflowIdOrPrefix, options); },
-    listDurableResumable(sessionDir) { return runtimeRef.current.listDurableResumable(sessionDir); },
-    prepareDurableResumable(workflowIdOrPrefix, sessionDir) { return runtimeRef.current.prepareDurableResumable(workflowIdOrPrefix, sessionDir); },
+    listDurableResumable() { return runtimeRef.current.listDurableResumable(); },
+    prepareDurableResumable(workflowIdOrPrefix) { return runtimeRef.current.prepareDurableResumable(workflowIdOrPrefix); },
+    prepareDurableResumableForIds(workflowIds) {
+      const targeted = runtimeRef.current.prepareDurableResumableForIds;
+      if (targeted !== undefined) return targeted.call(runtimeRef.current, workflowIds);
+      return runtimeRef.current.prepareDurableResumable();
+    },
     prepareCompletedDurable() {
       return runtimeRef.current.prepareCompletedDurable?.() ?? Promise.resolve([]);
     },
@@ -190,12 +189,11 @@ export function createWorkflowExtensionRuntimeState(
     if (models === undefined) return runtimeProxy;
     return createExtensionRuntime({
       registry: runtimeRef.current.registry,
-      cwd: process.cwd(),
+      cwd: resolveCwd(),
       adapters,
       cancellation: cancellationRegistry,
       persistence: persistenceRef.current,
       mcp: mcpPort,
-      intercom: intercomPort,
       config: runtimeConfigRef.current,
       models,
       resolveDefaultStageSessionDir,
@@ -218,6 +216,7 @@ export function createWorkflowExtensionRuntimeState(
       persistRuns: effectiveConfig.persistRuns,
       statusFile: effectiveConfig.statusFile,
       resumeInFlight: effectiveConfig.resumeInFlight,
+      worktree: effectiveConfig.worktree,
     };
     lifecycleNotificationConfigRef.current = effectiveConfig.workflowNotifications;
     reinstallLifecycleNotifications();
@@ -229,12 +228,11 @@ export function createWorkflowExtensionRuntimeState(
   function rebuildRuntime(registry = runtimeRef.current.registry): void {
     runtimeRef.current = createExtensionRuntime({
       registry,
-      cwd: process.cwd(),
+      cwd: resolveCwd(),
       adapters,
       cancellation: cancellationRegistry,
       persistence: persistenceRef.current,
       mcp: mcpPort,
-      intercom: intercomPort,
       config: runtimeConfigRef.current,
       resolveDefaultStageSessionDir,
     });
@@ -432,7 +430,6 @@ export function createWorkflowExtensionRuntimeState(
       reinstallLifecycleNotifications();
       reinstallHilAnswerNotifications();
     },
-    setIntercomParentSession(session) { intercomParentSession = session; },
     updateHostStageSessionDir(sessionManager) {
       try {
         hostStageSessionDir.current = sessionManager?.usesDefaultSessionDir?.() === false
@@ -442,5 +439,6 @@ export function createWorkflowExtensionRuntimeState(
         hostStageSessionDir.current = undefined;
       }
     },
+    resolveDefaultStageSessionDir,
   };
 }

package/dist/builtin/workflows/src/extension/lifecycle-notification-delivery.ts

@@ -0,0 +1,83 @@
+import type {
+  WorkflowLifecycleNotificationState,
+  WorkflowLifecycleNoticeDetails,
+} from "./lifecycle-notifications.js";
+
+interface LifecycleNoticeDeliveryOptions {
+  readonly state: WorkflowLifecycleNotificationState;
+  readonly emit: (details: WorkflowLifecycleNoticeDetails) => boolean | Promise<boolean>;
+  /** Whether this installation is configured to deliver the given notice kind. */
+  readonly eligible: (details: WorkflowLifecycleNoticeDetails) => boolean;
+}
+
+/**
+ * Owns terminal-notice admission with capped-backoff retry. Delivery state lives
+ * on the shared notification state, so a pending admission started under one
+ * configuration installation is not re-sent by a later reinstall: the shared
+ * pending token remains authoritative until its original send settles. If that
+ * send later fails, the failed payload is handed to whichever installation is
+ * currently active through the shared retry-observer set, preserving exactly
+ * once main-chat delivery across config reload and session-preserving reinstall.
+ */
+export function createLifecycleNoticeDelivery(options: LifecycleNoticeDeliveryOptions): {
+  deliver(key: string, details: WorkflowLifecycleNoticeDetails): void;
+  dispose(): void;
+} {
+  const retryTimers = new Set<ReturnType<typeof setTimeout>>();
+  const attempts = new Map<string, number>();
+  let active = true;
+
+  const deliver = (key: string, details: WorkflowLifecycleNoticeDetails): void => {
+    // A disposed installation never starts a new send; an active one refuses to
+    // duplicate an already-delivered or still-pending admission.
+    if (!active) return;
+    if (options.state.deliveredTerminalRuns.has(key) || options.state.pendingTerminalRuns.has(key)) return;
+    const token = Symbol(key);
+    options.state.pendingTerminalRuns.set(key, token);
+    const attempt = (attempts.get(key) ?? 0) + 1;
+    attempts.set(key, attempt);
+    const settle = (delivered: boolean): void => {
+      // Another installation may have superseded this pending admission.
+      if (options.state.pendingTerminalRuns.get(key) !== token) return;
+      options.state.pendingTerminalRuns.delete(key);
+      if (delivered) {
+        options.state.deliveredTerminalRuns.add(key);
+        options.state.retryableTerminalRuns.delete(key);
+        options.state.retryableTerminalNotices.delete(key);
+        return;
+      }
+      options.state.retryableTerminalRuns.add(key);
+      options.state.retryableTerminalNotices.set(key, details);
+      if (active) {
+        const timer = setTimeout(() => {
+          retryTimers.delete(timer);
+          if (active) deliver(key, details);
+        }, Math.min(20 * (2 ** (attempt - 1)), 1_000));
+        retryTimers.add(timer);
+        return;
+      }
+      // This installation was disposed while its admission was in flight; hand
+      // the failed payload to a currently-active installation, if any.
+      for (const observer of options.state.retryObservers) observer(key, details);
+    };
+    const result = options.emit(details);
+    if (typeof result === "boolean") settle(result);
+    else void result.then(settle);
+  };
+
+  const retryObserver = (key: string, details: WorkflowLifecycleNoticeDetails): void => {
+    if (active && options.eligible(details)) deliver(key, details);
+  };
+  options.state.retryObservers.add(retryObserver);
+
+  return {
+    deliver,
+    dispose() {
+      active = false;
+      options.state.retryObservers.delete(retryObserver);
+      for (const timer of retryTimers) clearTimeout(timer);
+      // Do not clear pending tokens or mark them retryable: an in-flight
+      // admission remains authoritative and settles into the shared state.
+    },
+  };
+}

package/dist/builtin/workflows/src/extension/lifecycle-notifications.ts

@@ -24,6 +24,7 @@ import {
 } from "../shared/returned-run-status.js";
 import { deriveGraphThemeFromPiTheme, type GraphTheme } from "../tui/graph-theme.js";
 import { renderWorkflowNoticeCard, type WorkflowNoticeTone } from "../tui/workflow-notice-card.js";
+import { createLifecycleNoticeDelivery } from "./lifecycle-notification-delivery.js";
 
 export const LIFECYCLE_NOTICE_CUSTOM_TYPE = "workflows:lifecycle-notice";
 export const LIFECYCLE_NOTICE_SNIPPET_LIMIT = 240;
@@ -56,11 +57,16 @@ export interface WorkflowLifecycleNoticeDetails {
   readonly error?: string;
   readonly failedStageId?: string;
   readonly durationMs?: number;
+  readonly active?: boolean;
   readonly createdAt: number;
 }
 
 export interface WorkflowLifecycleNotificationState {
   readonly deliveredTerminalRuns: Set<string>;
+  readonly retryableTerminalNotices: Map<string, WorkflowLifecycleNoticeDetails>;
+  readonly pendingTerminalRuns: Map<string, symbol>;
+  readonly retryableTerminalRuns: Set<string>;
+  readonly retryObservers: Set<(key: string, details: WorkflowLifecycleNoticeDetails) => void>;
   readonly deliveredInputPrompts: Set<string>;
   suppressionDepth: number;
 }
@@ -76,23 +82,28 @@ export interface WorkflowLifecycleNotificationOptions {
 }
 
 type RawRenderer = PiMessageRenderer;
-
-// Process-lifetime registration dedupe: extension hosts are object identities
-// and may be garbage-collected, but renderer registrations are not unregistered.
 const rendererRegisteredHosts = new WeakSet<object>();
-
 export function createWorkflowLifecycleNotificationState(): WorkflowLifecycleNotificationState {
   return {
     deliveredTerminalRuns: new Set<string>(),
+    pendingTerminalRuns: new Map<string, symbol>(),
+    retryableTerminalNotices: new Map<string, WorkflowLifecycleNoticeDetails>(),
+    retryableTerminalRuns: new Set<string>(),
+    retryObservers: new Set<(key: string, details: WorkflowLifecycleNoticeDetails) => void>(),
     deliveredInputPrompts: new Set<string>(),
     suppressionDepth: 0,
   };
 }
 
+/** Reset all prior-session lifecycle delivery and dedupe state. */
 export function resetWorkflowLifecycleNotificationState(
   state: WorkflowLifecycleNotificationState,
 ): void {
   state.deliveredTerminalRuns.clear();
+  state.pendingTerminalRuns.clear();
+  state.retryableTerminalRuns.clear();
+  state.retryableTerminalNotices.clear();
+  state.retryObservers.clear();
   state.deliveredInputPrompts.clear();
   state.suppressionDepth = 0;
 }
@@ -104,8 +115,11 @@ export function seedWorkflowLifecycleNotificationState(
   for (const run of snapshot.runs) {
     if (!isTopLevelWorkflowRun(run)) continue;
     const noticeKind = terminalNoticeKind(run);
-    if (noticeKind !== undefined && run.endedAt !== undefined) {
-      state.deliveredTerminalRuns.add(terminalRunKey(noticeKind, run.id));
+    if (noticeKind !== undefined && lifecycleOccurrenceAt(run, noticeKind) !== undefined) {
+      const key = terminalRunKey(noticeKind, run);
+      if (!state.pendingTerminalRuns.has(key) && !state.retryableTerminalRuns.has(key)) {
+        state.deliveredTerminalRuns.add(key);
+      }
     }
     if (run.pendingPrompt !== undefined) {
       state.deliveredInputPrompts.add(runAwaitingInputKey(run.id, run.pendingPrompt));
@@ -166,30 +180,25 @@ export function installWorkflowLifecycleNotifications(
 
   const notifyOn = new Set<WorkflowLifecycleNoticeKind>(options.config.notifyOn);
   const state = options.state ?? createWorkflowLifecycleNotificationState();
-  if (options.seedExisting !== false) {
-    seedWorkflowLifecycleNotificationState(state, options.store.snapshot());
-  }
+  let delivery!: ReturnType<typeof createLifecycleNoticeDelivery>;
+  if (options.seedExisting !== false) seedWorkflowLifecycleNotificationState(state, options.store.snapshot());
 
-  const emit = (details: WorkflowLifecycleNoticeDetails): void => {
-    const content = formatWorkflowLifecycleNoticeText(details);
-    const deliveryOptions = { triggerTurn: true, deliverAs: "steer" as const };
+  const emit = (details: WorkflowLifecycleNoticeDetails): boolean | Promise<boolean> => {
     try {
-      // Store subscribers are notified in a tight loop. A lifecycle notice
-      // failure must never abort sibling subscribers such as status writers.
-      void Promise.resolve(
-        send(
-          {
-            customType: LIFECYCLE_NOTICE_CUSTOM_TYPE,
-            content,
-            display: true,
-            details,
-          },
-          deliveryOptions,
-        ),
-      ).catch((error: unknown) => warnLifecycleSendFailure(error));
+      const result = send({
+        customType: LIFECYCLE_NOTICE_CUSTOM_TYPE,
+        content: formatWorkflowLifecycleNoticeText(details),
+        display: true,
+        details,
+      }, { triggerTurn: true, deliverAs: "steer", persistWhenStreaming: true });
+      if (result === undefined) return true;
+      return Promise.resolve(result).then(() => true, (error: unknown) => {
+        warnLifecycleSendFailure(error);
+        return false;
+      });
     } catch (error) {
       warnLifecycleSendFailure(error);
-      // Best-effort notification only; keep store delivery isolated.
+      return false;
     }
   };
 
@@ -198,16 +207,19 @@ export function installWorkflowLifecycleNotifications(
     kind: "completed" | "failed" | "blocked",
   ): void => {
     const noticeKind = terminalNoticeKind(run);
-    if (noticeKind !== kind || run.endedAt === undefined || !notifyOn.has(kind)) {
+    if (noticeKind !== kind || lifecycleOccurrenceAt(run, kind) === undefined || !notifyOn.has(kind)) {
       return;
     }
 
-    const key = terminalRunKey(kind, run.id);
-    if (state.deliveredTerminalRuns.has(key)) return;
-
-    state.deliveredTerminalRuns.add(key);
-    if (state.suppressionDepth > 0) return;
-    emit(makeTerminalNotice(run, kind));
+    const key = terminalRunKey(kind, run);
+    if (state.deliveredTerminalRuns.has(key) || state.pendingTerminalRuns.has(key)) return;
+    if (state.suppressionDepth > 0) {
+      state.deliveredTerminalRuns.add(key);
+      state.retryableTerminalRuns.delete(key);
+      state.retryableTerminalNotices.delete(key);
+      return;
+    }
+    delivery.deliver(key, makeTerminalNotice(run, kind));
   };
 
   const emitStageAwaitingInputNoticeOnce = (
@@ -250,8 +262,17 @@ export function installWorkflowLifecycleNotifications(
       }
     }
   };
+  delivery = createLifecycleNoticeDelivery({ state, emit, eligible: (details) => notifyOn.has(details.kind) });
+  for (const [key, details] of state.retryableTerminalNotices) {
+    if (notifyOn.has(details.kind)) delivery.deliver(key, details);
+  }
 
-  return options.store.subscribe(inspect);
+  const unsubscribe = options.store.subscribe(inspect);
+  inspect(options.store.snapshot());
+  return () => {
+    unsubscribe();
+    delivery.dispose();
+  };
 }
 
 export function registerLifecycleNoticeRenderer(
@@ -286,7 +307,8 @@ export function formatWorkflowLifecycleNoticeText(details: WorkflowLifecycleNoti
   }
   if (details.kind === "blocked") {
     const errorText = details.error ? `: ${details.error}` : "";
-    return `! Workflow "${workflowName}" ended blocked (run ${details.runId})${errorText}. Inspect: /workflow status ${details.runId}`;
+    const stateText = details.active === true ? "is blocked" : "ended blocked";
+    return `! Workflow "${workflowName}" ${stateText} (run ${details.runId})${errorText}. Inspect: /workflow status ${details.runId}`;
   }
   const prompt = details.promptMessage ? ` Prompt: ${details.promptMessage}` : "";
   if (details.scope === "run") {
@@ -306,19 +328,22 @@ function makeTerminalNotice(
   const failedStage = run.failedStageId
     ? run.stages.find((stage) => stage.id === run.failedStageId)
     : undefined;
-  const error = run.error ?? returnedNoticeError(run, kind) ?? (kind === "blocked" ? run.exitReason : undefined);
+  const activeBlocked = kind === "blocked" && isActiveRecoverableBlockedRun(run);
+  const error = activeBlocked
+    ? run.failureMessage ?? structuredRecoverableWorkflowFailureText(run) ?? run.error
+    : run.error ?? returnedNoticeError(run, kind) ?? (kind === "blocked" ? run.exitReason : undefined);
   return {
     kind,
     scope: "run",
     runId: run.id,
     workflowName: run.name,
     status: effectiveRunStatus(run),
+    ...(activeBlocked ? { active: true } : {}),
     ...(error ? { error: truncateSnippet(error) } : {}),
     ...(run.failedStageId ? { failedStageId: run.failedStageId } : {}),
     ...(failedStage ? { stageId: failedStage.id, stageName: failedStage.name } : {}),
     ...(run.durationMs !== undefined ? { durationMs: run.durationMs } : {}),
-    // Normal store paths stamp endedAt; Date.now() is defensive for malformed restored snapshots.
-    createdAt: run.endedAt ?? Date.now(),
+    createdAt: lifecycleOccurrenceAt(run, kind) ?? Date.now(),
   };
 }
 
@@ -337,12 +362,25 @@ function jsonString(value: string): string {
 }
 
 function terminalNoticeKind(run: RunSnapshot): "completed" | "failed" | "blocked" | undefined {
+  if (isActiveRecoverableBlockedRun(run)) return "blocked";
   const status = effectiveRunStatus(run);
   if (status === "failed" || status === "blocked") return status;
   if (status !== "completed") return undefined;
   return "completed";
 }
 
+function isActiveRecoverableBlockedRun(run: RunSnapshot): boolean {
+  return run.blockedAt !== undefined && structuredRecoverableWorkflowFailureText(run) !== undefined;
+}
+
+function lifecycleOccurrenceAt(
+  run: RunSnapshot,
+  kind: "completed" | "failed" | "blocked",
+): number | undefined {
+  if (kind === "blocked" && isActiveRecoverableBlockedRun(run)) return run.blockedAt;
+  return run.endedAt;
+}
+
 function returnedNoticeError(run: RunSnapshot, kind: "completed" | "failed" | "blocked"): string | undefined {
   const structuredFailureText = structuredRecoverableWorkflowFailureText(run);
   if (kind === "blocked" && structuredFailureText !== undefined) return structuredFailureText;
@@ -353,8 +391,9 @@ function returnedNoticeError(run: RunSnapshot, kind: "completed" | "failed" | "b
   return undefined;
 }
 
-function terminalRunKey(kind: "completed" | "failed" | "blocked", runId: string): string {
-  return `${kind}:${runId}`;
+function terminalRunKey(kind: "completed" | "failed" | "blocked", run: RunSnapshot): string {
+  const occurrence = kind === "blocked" ? run.blockedAt ?? lifecycleOccurrenceAt(run, kind) : "";
+  return occurrence === undefined ? `${kind}:${run.id}` : `${kind}:${run.id}:${occurrence}`;
 }
 
 function awaitingInputKey(runId: string, stage: StageSnapshot): string {
@@ -413,7 +452,7 @@ function renderLifecycleNoticeCard(
     : details.kind === "awaiting_input"
       ? `Workflow "${details.workflowName}" needs input`
       : details.kind === "blocked"
-        ? `Workflow "${details.workflowName}" ended blocked`
+        ? `Workflow "${details.workflowName}" ${details.active === true ? "is blocked" : "ended blocked"}`
         : `Workflow "${details.workflowName}" completed`;
   return renderWorkflowNoticeCard({
     title,

package/dist/builtin/workflows/src/extension/postmortem-deps.ts

@@ -0,0 +1,73 @@
+/**
+ * Extension-side wiring for the shared post-mortem stage-chat resolver.
+ *
+ * Builds `PostMortemStageChatDeps` from live extension runtime surfaces
+ * (stage adapters, durable per-run cwd, and the default stage session dir after
+ * a host restart) so both the TUI attach pane and `workflow send` revive an
+ * eligible terminal agent stage through the same detached, single-flight
+ * resolver instead of process-local handle presence alone.
+ *
+ * cross-ref:
+ *   - src/runs/foreground/postmortem-stage-chat.ts (resolver)
+ *   - src/tui/overlay-adapter.ts (attach pane wiring)
+ *   - src/extension/workflow-tool-send.ts (send parity)
+ */
+import { store } from "../shared/store.js";
+import { getDurableBackend } from "../durable/factory.js";
+import {
+  ensurePostMortemStageHandle,
+  type EnsurePostMortemStageHandleResult,
+  type PostMortemStageChatDeps,
+} from "../runs/foreground/postmortem-stage-chat.js";
+import { stageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import type { StageAdapters } from "../runs/foreground/stage-runner.js";
+
+export interface PostMortemResolverDeps {
+  readonly adapters: StageAdapters;
+  readonly resolveDefaultStageSessionDir: () => string | undefined;
+}
+
+/** Persisted original/resolved cwd for a durable run tree, when still available. */
+function resolveStageCwd(runId: string): string | undefined {
+  try {
+    const backend = getDurableBackend();
+    const owningHandle = backend.getWorkflow(runId);
+    const run = store.snapshot().runs.find((candidate) => candidate.id === runId);
+    const rootRunId = run?.rootRunId ?? owningHandle?.rootWorkflowId;
+    const cwdHandle = rootRunId === undefined
+      ? owningHandle
+      : backend.getWorkflow(rootRunId) ?? owningHandle;
+    return cwdHandle?.workflowCwd ?? cwdHandle?.invocationCwd ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Resolver deps for a specific run, keyed so revived handles use the real run cwd. */
+export function postMortemDepsForRun(
+  runId: string,
+  deps: PostMortemResolverDeps,
+): PostMortemStageChatDeps {
+  return {
+    registry: stageControlRegistry,
+    adapters: deps.adapters,
+    cwd: resolveStageCwd(runId),
+    defaultSessionDir: deps.resolveDefaultStageSessionDir(),
+  };
+}
+
+/**
+ * Build a `(runId, stageId) => result | undefined` resolver for the attach pane.
+ * Unknown stages return `undefined`; known but non-revivable stages retain the
+ * resolver's explicit reason so the pane can explain why chat is unavailable.
+ */
+export function createPostMortemHandleResolver(
+  deps: PostMortemResolverDeps,
+): (runId: string, stageId: string) => EnsurePostMortemStageHandleResult | undefined {
+  return (runId, stageId) => {
+    const run = store.snapshot().runs.find((candidate) => candidate.id === runId);
+    const stage = run?.stages.find((candidate) => candidate.id === stageId);
+    if (stage === undefined) return undefined;
+    return ensurePostMortemStageHandle(runId, stage, postMortemDepsForRun(runId, deps));
+  };
+}