@bastani/atomic 0.9.9 → 0.9.10-alpha.1

package/dist/builtin/workflows/src/tui/widget.ts

@@ -28,6 +28,7 @@ import type {
 } from "../shared/store-types.js";
 import { elapsedRunMs } from "../shared/timing.js";
 import { topLevelWorkflowRuns } from "../shared/run-visibility.js";
+import { effectiveRunStatus } from "../shared/returned-run-status.js";
 import type { PiTheme } from "./store-widget-installer.js";
 import { renderRoundedBoxLines } from "./chat-surface.js";
 import type { FlatBandBadge } from "./chat-surface.js";
@@ -43,7 +44,6 @@ import { statusIcon } from "./status-helpers.js";
 const SHORT_ID_LEN = 6;
 const MAX_VISIBLE_RUNS = 4;
 export const RECENT_ENDED_WINDOW_MS = 30_000;
-const WIDGET_CLOCK_REFRESH_MS = 1_000;
 const COLLAPSED_BREAKPOINT_COLS = 80;
 
 // ---------------------------------------------------------------------------
@@ -82,6 +82,7 @@ interface RunCounts {
   paused: number;
   quit: number;
   done: number;
+  blocked: number;
   failed: number;
   /** Runs with a pending HIL prompt — surfaced as a separate badge so the
    *  user knows to attach via F2 before more progress is possible. */
@@ -111,25 +112,27 @@ function countRuns(
   runs: readonly RunSnapshot[],
   allRuns: readonly RunSnapshot[] = runs,
 ): RunCounts {
-  const counts: RunCounts = { active: 0, paused: 0, quit: 0, done: 0, failed: 0, awaiting: 0 };
+  const counts: RunCounts = { active: 0, paused: 0, quit: 0, done: 0, blocked: 0, failed: 0, awaiting: 0 };
   for (const r of runs) {
+    const status = effectiveRunStatus(r);
     if (isQuitRun(r)) counts.quit++;
-    else if (r.endedAt === undefined && r.status === "paused") counts.paused++;
+    else if (status === "blocked") counts.blocked++;
+    else if (r.endedAt === undefined && status === "paused") counts.paused++;
     else if (r.endedAt === undefined) counts.active++;
-    else if (r.status === "completed" || r.status === "skipped" || r.status === "cancelled" || r.status === "blocked") counts.done++;
-    else if (r.status === "failed" || r.status === "killed") counts.failed++;
-    if (r.endedAt === undefined && subtreeAwaitsInput(r, allRuns)) {
-      counts.awaiting++;
-    }
+    else if (status === "completed" || status === "skipped" || status === "cancelled") counts.done++;
+    else if (status === "failed" || status === "killed") counts.failed++;
+    if (r.endedAt === undefined && subtreeAwaitsInput(r, allRuns)) counts.awaiting++;
   }
   return counts;
 }
 
-function msUntilNextClockTick(now: number): number {
-  const remainder = now % WIDGET_CLOCK_REFRESH_MS;
-  return remainder === 0 ? WIDGET_CLOCK_REFRESH_MS : WIDGET_CLOCK_REFRESH_MS - remainder;
-}
-
+/**
+ * Returns the next wall-clock boundary that can change the visible widget.
+ * Running elapsed labels tick on exact one-second boundaries; paused runs stay
+ * frozen. Recently ended cards retain their independent one-shot expiry.
+ * Reactive-widget updates the existing mounted component in place, so these
+ * ticks repaint the visible panel without disposing or remounting it.
+ */
 export function nextWidgetRefreshDelayMs(
   snap: StoreSnapshot,
   now = Date.now(),
@@ -137,12 +140,14 @@ export function nextWidgetRefreshDelayMs(
   const display = selectDisplayRuns(snap, now);
   if (display.length === 0) return undefined;
 
-  const hasLiveClock = display.some((run) => run.endedAt === undefined && run.status !== "paused");
-  const clockDelay = hasLiveClock ? msUntilNextClockTick(now) : undefined;
-  const expiryDelays = display
+  const delays: number[] = display
     .filter((run) => run.endedAt !== undefined)
     .map((run) => Math.max(1, run.endedAt! + RECENT_ENDED_WINDOW_MS - now + 1));
-  const delays = [clockDelay, ...expiryDelays].filter((delay): delay is number => delay !== undefined);
+  for (const run of display) {
+    if (run.endedAt !== undefined || effectiveRunStatus(run) !== "running" || run.pausedAt !== undefined) continue;
+    const remainder = elapsedRunMs(run, now) % 1_000;
+    delays.push(remainder === 0 ? 1_000 : 1_000 - remainder);
+  }
   return delays.length === 0 ? undefined : Math.min(...delays);
 }
 
@@ -172,7 +177,7 @@ function shortId(run: RunSnapshot): string {
 
 function statusGlyph(run: RunSnapshot): string {
   if (isQuitRun(run)) return "○";
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "running":
       return "●";
     case "paused":
@@ -196,7 +201,7 @@ function statusGlyph(run: RunSnapshot): string {
 
 function statusFg(run: RunSnapshot, theme: GraphTheme): string {
   if (isQuitRun(run)) return theme.warning;
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "running":
     case "paused":
       return theme.warning;
@@ -232,10 +237,11 @@ function progressLabel(run: RunSnapshot): string | undefined {
 function elapsedLabel(run: RunSnapshot, now: number): string {
   if (run.endedAt !== undefined) {
     const elapsed = formatDuration(elapsedRunMs(run, run.endedAt));
-    if (run.status === "completed") return `complete · ${elapsed}`;
-    if (run.status === "failed") return `failed · ${elapsed}`;
-    if (run.status === "killed") return `killed · ${elapsed}`;
-    return `${run.status} · ${elapsed}`;
+    const status = effectiveRunStatus(run);
+    if (status === "completed") return `complete · ${elapsed}`;
+    if (status === "failed") return `failed · ${elapsed}`;
+    if (status === "killed") return `killed · ${elapsed}`;
+    return `${status} · ${elapsed}`;
   }
   if (run.startedAt != null) return formatDuration(elapsedRunMs(run, now));
   return "";
@@ -246,6 +252,7 @@ function metaLine(run: RunSnapshot, now: number): string {
     return elapsedLabel(run, now);
   }
   if (isQuitRun(run)) return "quit · resumable via /workflow resume";
+  if (effectiveRunStatus(run) === "blocked") return "blocked · resumable via /workflow resume";
   const parts: string[] = [modeLabel(run)];
   const prog = progressLabel(run);
   if (prog) parts.push(prog);
@@ -275,6 +282,9 @@ function countBadges(counts: RunCounts, theme: GraphTheme): FlatBandBadge[] {
   if (counts.awaiting > 0) {
     badges.push({ text: `${statusIcon("awaiting_input")} ↵ ${counts.awaiting} needs attention (attach to workflow with \`/workflow connect\`)`, fg: theme.info });
   }
+  if (counts.blocked > 0) {
+    badges.push({ text: `↑ ${counts.blocked} blocked`, fg: theme.warning });
+  }
   if (counts.done > 0) {
     badges.push({ text: `✓ ${counts.done} complete`, fg: theme.success });
   }
@@ -321,7 +331,7 @@ function themedRunLines(
   const meta = metaLine(run, now);
   // Render the meta line in muted while running so the elapsed-time
   // gradient stays readable; dim it once the run has terminated.
-  const metaFg = run.status === "running" ? muted : dim;
+  const metaFg = effectiveRunStatus(run) === "running" ? muted : dim;
   const line2 = `     ${metaFg}${meta}${RESET}`;
   return [line1, line2];
 }
@@ -344,18 +354,20 @@ function themedCollapsed(
   const dim = hexToAnsi(theme.dim);
   const muted = hexToAnsi(theme.textMuted);
   const warning = hexToAnsi(theme.warning);
-  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.blocked + counts.failed;
   const active = counts.active;
   const paused = counts.paused > 0 ? `${dim} · ${RESET}${warning}${counts.paused} ❚❚${RESET}` : "";
   const quit = counts.quit > 0 ? `${dim} · ${RESET}${warning}${counts.quit} quit${RESET}` : "";
-  return ` ${mauve}▾${RESET}  ${muted}${total} background${RESET}${dim} · ${RESET}${warning}${active} ●${RESET}${paused}${quit}`;
+  const blocked = counts.blocked > 0 ? `${dim} · ${RESET}${warning}${counts.blocked} ↑${RESET}` : "";
+  return ` ${mauve}▾${RESET}  ${muted}${total} background${RESET}${dim} · ${RESET}${warning}${active} ●${RESET}${paused}${quit}${blocked}`;
 }
 
 function plainCollapsed(counts: RunCounts): string {
-  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.blocked + counts.failed;
   const paused = counts.paused > 0 ? ` · ${counts.paused} ❚❚` : "";
   const quit = counts.quit > 0 ? ` · ${counts.quit} quit` : "";
-  return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}`;
+  const blocked = counts.blocked > 0 ? ` · ${counts.blocked} ↑` : "";
+  return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}${blocked}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -385,11 +397,12 @@ export function buildThemedWidgetLines(
   // Active + recently-ended dominate the badge counts so a finished run
   // visually persists for a beat before dropping off.
   const visibleCounts: RunCounts = {
-    active: display.filter((r) => r.endedAt === undefined && r.status !== "paused").length,
-    paused: display.filter((r) => r.endedAt === undefined && r.status === "paused" && !isQuitRun(r)).length,
+    active: display.filter((r) => r.endedAt === undefined && effectiveRunStatus(r) === "running").length,
+    paused: display.filter((r) => r.endedAt === undefined && effectiveRunStatus(r) === "paused" && !isQuitRun(r)).length,
     quit: display.filter(isQuitRun).length,
-    done: display.filter((r) => r.endedAt !== undefined && (r.status === "completed" || r.status === "skipped" || r.status === "cancelled" || r.status === "blocked")).length,
-    failed: display.filter((r) => r.endedAt !== undefined && (r.status === "failed" || r.status === "killed")).length,
+    done: display.filter((r) => r.endedAt !== undefined && ["completed", "skipped", "cancelled"].includes(effectiveRunStatus(r))).length,
+    blocked: display.filter((r) => effectiveRunStatus(r) === "blocked").length,
+    failed: display.filter((r) => r.endedAt !== undefined && ["failed", "killed"].includes(effectiveRunStatus(r))).length,
     awaiting: counts.awaiting,
   };
 
@@ -401,7 +414,7 @@ export function buildThemedWidgetLines(
     return [themed ? themedCollapsed(visibleCounts, graphTheme) : plainCollapsed(visibleCounts)];
   }
 
-  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.blocked + counts.failed;
   const subtitle = `${total} run${total === 1 ? "" : "s"}`;
 
   const badgeList = countBadges(visibleCounts, graphTheme);

package/dist/builtin/workflows/src/tui/workflow-attach-pane-handle.ts

@@ -0,0 +1,26 @@
+import type { PostMortemUnavailableReason } from "../runs/foreground/postmortem-stage-chat.js";
+import type {
+  StageControlHandle,
+  StageControlRegistry,
+} from "../runs/foreground/stage-control-registry.js";
+import type { PostMortemHandleResolution } from "./workflow-attach-pane-types.js";
+
+interface AttachedStageHandleResolution {
+  readonly handle?: StageControlHandle;
+  readonly postMortemUnavailableReason?: PostMortemUnavailableReason;
+}
+
+export function resolveAttachedStageHandle(
+  registry: StageControlRegistry | undefined,
+  resolvePostMortemHandle: ((runId: string, stageId: string) => PostMortemHandleResolution) | undefined,
+  runId: string,
+  stageId: string,
+): AttachedStageHandleResolution {
+  const liveHandle = registry?.get(runId, stageId);
+  if (liveHandle !== undefined) return { handle: liveHandle };
+  const postMortem = resolvePostMortemHandle?.(runId, stageId);
+  if (postMortem?.ok === true) return { handle: postMortem.handle };
+  return postMortem?.ok === false
+    ? { postMortemUnavailableReason: postMortem.reason }
+    : {};
+}

package/dist/builtin/workflows/src/tui/workflow-attach-pane-types.ts

@@ -4,11 +4,14 @@ import type { Store } from "../shared/store.js";
 import type { StageUiBroker } from "../shared/stage-ui-broker.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import type { EnsurePostMortemStageHandleResult } from "../runs/foreground/postmortem-stage-chat.js";
 
 export interface AttachUiStatusSurface {
   setStatus?: (key: string, value: string | undefined) => void;
 }
 
+export type PostMortemHandleResolution = EnsurePostMortemStageHandleResult | undefined;
+
 export interface WorkflowAttachPaneOpts {
   store: Store;
   graphTheme: GraphTheme;
@@ -18,6 +21,15 @@ export interface WorkflowAttachPaneOpts {
    * the user attaches to a node. Defaults to the singleton registry.
    */
   stageControlRegistry?: StageControlRegistry;
+  /**
+   * Resolver that revives an interactive post-mortem chat handle for an
+   * eligible terminal agent stage that has a valid retained session but no
+   * process-local handle (generic attach/connect, restored/replayed durable
+   * snapshots). Unavailable results retain their reason so the pane can render
+   * a truthful actionable read-only fallback. Called only after a live
+   * `stageControlRegistry.get()` miss.
+   */
+  resolvePostMortemHandle?: (runId: string, stageId: string) => PostMortemHandleResolution;
   /** Broker used to route stage-local custom UI such as ask_user_question into attached chats. */
   stageUiBroker?: StageUiBroker;
   /**
@@ -29,8 +41,6 @@ export interface WorkflowAttachPaneOpts {
   onClose: () => void;
   /** Called when the user requests the host to hide the popup. */
   onHide?: () => void;
-  /** Called when the user quits/detaches the active run (q in graph mode). */
-  onQuit?: (runId: string) => void;
   /** Called when the user resolves a HIL prompt via the graph view. */
   onPromptResolve?: (runId: string, promptId: string, response: unknown) => void;
   /** Live pi-tui host objects used by attached stage chat to reuse coding-agent editor UI. */
@@ -53,6 +63,8 @@ export interface WorkflowAttachPaneOpts {
    * directly on the node's chat.
    */
   initialAttachStageId?: string;
+  /** Owning nested run for `initialAttachStageId`; omitted stages resolve through the root graph. */
+  initialAttachRunId?: string;
   /**
    * Optional accessor returning the current terminal row count. Threaded
    * into both `GraphView` and `StageChatView` so the overlay renders a

package/dist/builtin/workflows/src/tui/workflow-attach-pane.ts

@@ -1,23 +1,11 @@
 /**
- * WorkflowAttachPane — outer in-place attach shell.
+ * In-place shell that swaps one `pi.ui.custom` overlay between the workflow
+ * graph and a stage chat without remounting the outer popup. Enter attaches
+ * the focused graph node; Ctrl+X returns to the graph with focus preserved,
+ * including for paused stages.
  *
- * Wraps a single `pi.ui.custom` overlay popup whose interior swaps
- * between the orchestrator `GraphView` and a stage-scoped
- * `StageChatView`. Pressing Enter on a graph node attaches the popup
- * to that node's chat; Ctrl+D in chat mode swaps back to graph mode
- * with the same node still focused (see ui/attach-mockup.html), including
- * paused stage chats.
- *
- * The shell never remounts the overlay — it only flips a `mode`
- * field and re-renders, so the popup stays in pi-tui's overlay layer
- * across attach/detach cycles. This matches the mockup contract
- * (`only the popup interior swapped — outer chrome is unchanged`).
- *
- * cross-ref:
- *  - src/tui/overlay-adapter.ts (host mount glue)
- *  - src/tui/graph-view.ts (graph mode Component)
- *  - src/tui/stage-chat-view.ts (chat mode Component)
- *  - src/runs/foreground/stage-control-registry.ts (live handles)
+ * Related host and view wiring lives in `overlay-adapter.ts`, `graph-view.ts`,
+ * `stage-chat-view.ts`, and `stage-control-registry.ts`.
  */
 import type { Component, EditorComponent, EditorTheme, TUI } from "@earendil-works/pi-tui";
 import type { ChatMessageRenderOptions, ReadonlyFooterDataProvider } from "@bastani/atomic";
@@ -25,12 +13,14 @@ import type { Store } from "../shared/store.js";
 import type { GraphTheme } from "./graph-theme.js";
 import { GraphView } from "./graph-view.js";
 import { StageChatView, type StageChatDetachMetadata, type StageChatDetachReason } from "./stage-chat-view.js";
+import { StageChatComposerDrafts } from "./stage-chat-composer-drafts.js";
 import { Key, matchesKey } from "./text-helpers.js";
-import type { StageControlHandle, StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
+import type { StageControlRegistry } from "../runs/foreground/stage-control-registry.js";
 import type { StageUiBroker } from "../shared/stage-ui-broker.js";
 import type { StageSnapshot, StoreSnapshot } from "../shared/store-types.js";
 import { expandWorkflowGraph } from "../shared/expanded-workflow-graph.js";
 import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
+import { resolveAttachedStageHandle } from "./workflow-attach-pane-handle.js";
 /**
  * Surface for the overlay footer/status tag. Passing `undefined` on dispose
  * prevents `pi-workflows/<workflow>[/<stage>]` from lingering in later chat
@@ -45,11 +35,11 @@ export class WorkflowAttachPane implements Component {
   private theme: GraphTheme;
   private runId: string | null;
   private registry: StageControlRegistry | undefined;
+  private resolvePostMortemHandle?: WorkflowAttachPaneOpts["resolvePostMortemHandle"];
   private stageUiBroker: StageUiBroker | undefined;
   private uiStatus: AttachUiStatusSurface | undefined;
   private onClose: () => void;
   private onHide?: () => void;
-  private onQuit?: (runId: string) => void;
   private onPromptResolve?: (runId: string, promptId: string, response: unknown) => void;
   private getViewportRows?: () => number | undefined;
   private hostRequestRender?: () => void;
@@ -73,6 +63,7 @@ export class WorkflowAttachPane implements Component {
   private attachedRunId: string | null = null;
   /** Stage id the user most recently attached to (used to seed focus). */
   private lastAttachedStageId: string | null = null;
+  private composerDrafts = new StageChatComposerDrafts();
   /** Time-boxed guard for Enter leaking into graph mode during connect/detach transitions. */
   private graphEnterQuarantineUntil = 0;
   private stagePromptEnterQuarantineUntil = 0;
@@ -82,12 +73,11 @@ export class WorkflowAttachPane implements Component {
     this.store = opts.store;
     this.theme = opts.graphTheme;
     this.runId = opts.runId;
-    this.registry = opts.stageControlRegistry;
+    this.registry = opts.stageControlRegistry; this.resolvePostMortemHandle = opts.resolvePostMortemHandle;
     this.stageUiBroker = opts.stageUiBroker;
     this.uiStatus = opts.uiStatus;
     this.onClose = opts.onClose;
     this.onHide = opts.onHide;
-    this.onQuit = opts.onQuit;
     this.onPromptResolve = opts.onPromptResolve;
     this.getViewportRows = opts.getViewportRows;
     this.hostRequestRender = opts.requestRender;
@@ -105,7 +95,7 @@ export class WorkflowAttachPane implements Component {
     this.unsubscribeStore = this.store.subscribe((snapshot) => this._handleStoreUpdate(snapshot));
     this.graphView = this._buildGraphView();
     if (opts.initialAttachStageId !== undefined && this.runId) {
-      const target = this._resolveGraphStageTarget(this.runId, opts.initialAttachStageId);
+      const target = opts.initialAttachRunId === undefined ? this._resolveGraphStageTarget(this.runId, opts.initialAttachStageId) : { runId: opts.initialAttachRunId, stageId: opts.initialAttachStageId };
       this._attachToStage(target.runId, target.stageId);
     } else {
       this._syncAwaitingInputKeys(this.store.snapshot());
@@ -122,7 +112,6 @@ export class WorkflowAttachPane implements Component {
       graphTheme: this.theme,
       onClose: this.onClose,
       onHide: this.onHide,
-      onQuit: this.onQuit,
       onPromptResolve: this.onPromptResolve,
       onStageAttach: (runId, stageId) => this._attachToStage(runId, stageId, {
         suppressInitialPromptSubmit: true,
@@ -175,7 +164,7 @@ export class WorkflowAttachPane implements Component {
         : 0;
     this.attachedRunId = runId;
     this.lastAttachedStageId = stageId;
-    const handle: StageControlHandle | undefined = this.registry?.get(runId, stageId);
+    const { handle, postMortemUnavailableReason } = resolveAttachedStageHandle(this.registry, this.resolvePostMortemHandle, runId, stageId);
     this.chatView?.dispose();
     let chatView!: StageChatView;
     chatView = new StageChatView({
@@ -185,6 +174,8 @@ export class WorkflowAttachPane implements Component {
       stageId,
       workflowName: this._workflowName(runId),
       handle,
+      initialComposerDraft: this.composerDrafts.get(runId, stageId),
+      postMortemUnavailableReason,
       onDetach: (reason, metadata) => this._detachFromStage(reason, metadata),
       onClose: this.onClose,
       requestRender: this.hostRequestRender,
@@ -218,6 +209,11 @@ export class WorkflowAttachPane implements Component {
     reason: StageChatDetachReason = "user",
     metadata: StageChatDetachMetadata = {},
   ): void {
+    this.composerDrafts.capture(
+      this.attachedRunId,
+      this.lastAttachedStageId,
+      this.chatView?._inputBuffer,
+    );
     if (this.chatView && this.attachedRunId && this.lastAttachedStageId) {
       this.store.recordStageAttached(this.attachedRunId, this.lastAttachedStageId, false);
     }
@@ -237,7 +233,7 @@ export class WorkflowAttachPane implements Component {
     this._setBaseStatus();
     this._syncMouseScrollTracking();
   }
-  retarget(runId: string | null, stageId?: string): void {
+  retarget(runId: string | null, stageId?: string, stageRunId?: string): void {
     if (this.chatView && this.attachedRunId && this.lastAttachedStageId) {
       this.store.recordStageAttached(this.attachedRunId, this.lastAttachedStageId, false);
     }
@@ -253,7 +249,7 @@ export class WorkflowAttachPane implements Component {
     this.graphView = this._buildGraphView();
     this._syncAwaitingInputKeys(this.store.snapshot());
     if (stageId !== undefined && runId) {
-      const target = this._resolveGraphStageTarget(runId, stageId);
+      const target = stageRunId === undefined ? this._resolveGraphStageTarget(runId, stageId) : { runId: stageRunId, stageId };
       this._attachToStage(target.runId, target.stageId);
       return;
     }
@@ -493,6 +489,9 @@ export class WorkflowAttachPane implements Component {
   get _hasChatView(): boolean {
     return this.chatView !== null;
   }
+  get _chatInputBuffer(): string | undefined {
+    return this.chatView?._inputBuffer;
+  }
   get _runId(): string | null {
     return this.runId;
   }