@bastani/atomic 0.9.4 → 0.9.5-alpha.10

package/dist/builtin/workflows/src/shared/persistence-restore.ts

@@ -15,7 +15,7 @@ import {
 
 import type { Store } from "./store.js";
 import type { RunSnapshot } from "./store-types.js";
-import type { WorkflowInputValues } from "./types.js";
+import type { WorkflowInputValues, WorkflowSerializableValue } from "./types.js";
 
 // ---------------------------------------------------------------------------
 // Config option
@@ -32,7 +32,25 @@ export type ResumeInFlight = "ask" | "auto" | "never";
 export interface SessionEntry {
   readonly id: string;
   readonly type: string;
-  readonly payload: Record<string, unknown>;
+  readonly payload?: Record<string, WorkflowSerializableValue>;
+  readonly customType?: string;
+  readonly data?: Record<string, WorkflowSerializableValue>;
+}
+
+export interface NormalizedSessionEntry {
+  readonly id: string;
+  readonly type: string;
+  readonly payload: Record<string, WorkflowSerializableValue>;
+}
+
+export function normalizeSessionEntries(entries: readonly SessionEntry[]): readonly NormalizedSessionEntry[] {
+  return entries.flatMap((entry): readonly NormalizedSessionEntry[] => {
+    if (entry.type === "custom" && typeof entry.customType === "string" && entry.data !== undefined) {
+      return [{ id: entry.id, type: entry.customType, payload: entry.data }];
+    }
+    if (entry.payload !== undefined) return [{ id: entry.id, type: entry.type, payload: entry.payload }];
+    return [];
+  });
 }
 
 /** Structural type for pi's sessionManager (optional — degrades gracefully). */
@@ -69,7 +87,7 @@ export function scanInFlightRuns(entries: readonly SessionEntry[]): InFlightRun[
   const started = new Map<string, { name: string; inputs: WorkflowInputValues; startTs: number; stageIds: string[] }>();
   const ended = new Set<string>();
 
-  for (const entry of entries) {
+  for (const entry of normalizeSessionEntries(entries)) {
     if (entry.type === "workflow.run.start") {
       const runId = entry.payload["runId"];
       const name = entry.payload["name"];
@@ -168,8 +186,8 @@ export function restoreOnSessionStart(
   const getEntries = sessionManager.getEntries;
   if (typeof getEntries !== "function") return;
 
-  const entries = getEntries.call(sessionManager);
-  const sessionEntries = entries as readonly SessionEntry[];
+  const entries = getEntries.call(sessionManager) as readonly SessionEntry[];
+  const sessionEntries = normalizeSessionEntries(entries);
   restoreTerminalRuns(sessionEntries, store);
   const inFlight = scanInFlightRuns(sessionEntries);
   if (inFlight.length === 0) return;

package/dist/builtin/workflows/src/shared/persistence-session-entries.ts

@@ -112,6 +112,8 @@ export interface RunEndPayload {
   readonly failedStageId?: string;
   readonly resumable?: boolean;
   readonly retryAfterMs?: number;
+  readonly endedAt?: number;
+  readonly durationMs?: number;
   readonly ts: number;
 }
 
@@ -254,6 +256,8 @@ export function appendRunEnd(api: PersistenceAPI, payload: RunEndPayload): void
     ...(terminalPayload.failedStageId !== undefined ? { failedStageId: terminalPayload.failedStageId } : {}),
     ...(terminalPayload.resumable !== undefined ? { resumable: terminalPayload.resumable } : {}),
     ...(terminalPayload.retryAfterMs !== undefined ? { retryAfterMs: terminalPayload.retryAfterMs } : {}),
+    ...(terminalPayload.endedAt !== undefined ? { endedAt: terminalPayload.endedAt } : {}),
+    ...(terminalPayload.durationMs !== undefined ? { durationMs: terminalPayload.durationMs } : {}),
     ts: terminalPayload.ts,
   });
 }

package/dist/builtin/workflows/src/shared/resume-continuation.ts

@@ -0,0 +1,2 @@
+export const RESUME_CONTINUATION_PROMPT =
+  "Continue where you left off. If you believe you are finished with your original task (or a redefined task if the user told you), stop.";

package/dist/builtin/workflows/src/shared/returned-run-status.ts

@@ -0,0 +1,116 @@
+import type { RunEndMetadata } from "./store-public-types.js";
+import type { RunSnapshot, RunStatus, StageSnapshot, WorkflowFailureKind } from "./store-types.js";
+import type { WorkflowOutputValues } from "./types.js";
+
+const RETURNED_BLOCKED_STATUSES = new Set([
+  "blocked",
+  "needs_human",
+  "incomplete",
+  "auth_blocked",
+  "active",
+]);
+
+export interface StructuredRecoverableWorkflowFailure {
+  readonly error: string;
+  readonly metadata: RunEndMetadata;
+}
+
+export function normalizeReturnedWorkflowStatus(status: unknown): string | undefined {
+  if (typeof status !== "string") return undefined;
+  const normalized = status.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+export function isReturnedBlockedWorkflowStatus(status: string): boolean {
+  return RETURNED_BLOCKED_STATUSES.has(status);
+}
+
+export function isReturnedResumableBlockedWorkflowStatus(status: string): boolean {
+  return status !== "blocked" && isReturnedBlockedWorkflowStatus(status);
+}
+
+export function actionableReturnedStatusText(result: WorkflowOutputValues | undefined): string | undefined {
+  return stringResultField(result, "summary") ?? stringResultField(result, "remaining_work") ?? stringResultField(result, "result");
+}
+
+export function structuredRecoverableWorkflowFailure(
+  run: Pick<RunSnapshot,
+    | "error"
+    | "failureKind"
+    | "failureCode"
+    | "failureRecoverability"
+    | "failureDisposition"
+    | "failureMessage"
+    | "failedStageId"
+    | "retryAfterMs"
+    | "stages"
+  >,
+): StructuredRecoverableWorkflowFailure | undefined {
+  const runFailure = structuredRecoverableFailureFromSnapshot(run);
+  if (runFailure !== undefined) return runFailure;
+  if (run.failedStageId === undefined) return undefined;
+
+  const failedStage = run.stages.find((stage) => stage.id === run.failedStageId);
+  return failedStage === undefined
+    ? undefined
+    : structuredRecoverableFailureFromSnapshot(failedStage, failedStage.id);
+}
+
+export function structuredRecoverableWorkflowFailureText(
+  run: Pick<RunSnapshot,
+    | "error"
+    | "failureKind"
+    | "failureCode"
+    | "failureRecoverability"
+    | "failureDisposition"
+    | "failureMessage"
+    | "failedStageId"
+    | "retryAfterMs"
+    | "stages"
+  >,
+): string | undefined {
+  return structuredRecoverableWorkflowFailure(run)?.error;
+}
+
+export function effectiveRunStatus(run: RunSnapshot): RunStatus {
+  if (run.status !== "completed") return run.status;
+  if (structuredRecoverableWorkflowFailure(run) !== undefined) return "blocked";
+  const returnedStatus = normalizeReturnedWorkflowStatus(run.result?.["status"]);
+  if (returnedStatus === "failed") return "failed";
+  if (returnedStatus !== undefined && isReturnedBlockedWorkflowStatus(returnedStatus)) return "blocked";
+  return run.status;
+}
+
+function structuredRecoverableFailureFromSnapshot(
+  snapshot: Pick<RunSnapshot | StageSnapshot, "error" | "failureKind" | "failureCode" | "failureRecoverability" | "failureDisposition" | "failureMessage" | "retryAfterMs">,
+  failedStageId?: string,
+): StructuredRecoverableWorkflowFailure | undefined {
+  if (snapshot.failureDisposition !== "active_blocked") return undefined;
+  if (snapshot.failureRecoverability !== "recoverable") return undefined;
+  if (!isRecoverableProviderFailureKind(snapshot.failureKind)) return undefined;
+  const error = snapshot.error ?? snapshot.failureMessage ?? "Workflow is blocked by a recoverable provider failure.";
+  return {
+    error,
+    metadata: {
+      failureKind: snapshot.failureKind,
+      ...(snapshot.failureCode !== undefined ? { failureCode: snapshot.failureCode } : {}),
+      failureRecoverability: snapshot.failureRecoverability,
+      failureDisposition: snapshot.failureDisposition,
+      failureMessage: snapshot.failureMessage ?? error,
+      ...(failedStageId !== undefined ? { failedStageId } : {}),
+      resumable: true,
+      ...(snapshot.retryAfterMs !== undefined ? { retryAfterMs: snapshot.retryAfterMs } : {}),
+    },
+  };
+}
+
+function isRecoverableProviderFailureKind(kind: WorkflowFailureKind | undefined): kind is "auth" | "rate_limit" | "provider" {
+  return kind === "auth" || kind === "rate_limit" || kind === "provider";
+}
+
+
+
+function stringResultField(result: WorkflowOutputValues | undefined, key: string): string | undefined {
+  const value = result?.[key];
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}

package/dist/builtin/workflows/src/shared/workflow-failures-decisions.ts

@@ -186,6 +186,8 @@ const PROVIDER_UNAVAILABLE_PHRASES: readonly TokenMatch[] = [
   ["provider", "error"],
   ["model", "unavailable"],
   ["503"],
+  ["git", "command", "timed", "out"],
+  ["spawnsync", "git", "etimedout"],
 ];
 
 const AUTH_CONTEXT = new Set([

package/dist/builtin/workflows/src/tui/graph-view-render-helpers.ts

@@ -5,6 +5,7 @@ import {
   OVERLAY_LINE_COUNT,
   OVERLAY_VERTICAL_MARGIN_ROWS,
 } from "./graph-view-constants.js";
+import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
 import { GraphViewState } from "./graph-view-state.js";
 import { renderOutlinePill } from "./header.js";
 import { NODE_H, NODE_W } from "./layout.js";
@@ -78,12 +79,25 @@ export abstract class GraphViewRenderHelpers extends GraphViewState {
    * the header band: `backgroundPanel` chrome, outlined accent pill
    * flush-left, hints flowing right on the centre row.
    */
+  protected _externalStatusText(): string | null {
+    const entries = Array.from(this.footerData?.getExtensionStatuses() ?? [])
+      .filter(([key, value]) => (
+        value.trim().length > 0 &&
+        key !== WORKFLOW_STATUS_KEY &&
+        !key.startsWith(`${WORKFLOW_STATUS_KEY}:`)
+      ))
+      .sort(([a], [b]) => a.localeCompare(b));
+    if (entries.length === 0) return null;
+    return entries.map(([, value]) => value.trim()).join(" · ");
+  }
+
   protected _renderStatusline(width: number): string[] {
     const t = this.graphTheme;
     const chromeBg = hexBg(t.backgroundPanel);
     const text = hexToAnsi(t.text);
     const muted = hexToAnsi(t.textMuted);
     const dim = hexToAnsi(t.dim);
+    const accent = hexToAnsi(t.accent);
 
     const {
       top,
@@ -92,13 +106,17 @@ export abstract class GraphViewRenderHelpers extends GraphViewState {
       visibleWidth: pillW,
     } = renderOutlinePill(MODE_PILL_LABEL, t.accent, chromeBg);
 
-    // Hints — `<key> <label>` separated by `  ·  `.
+    // Hints — `<key> <label>` separated by `  ·  `. When other extensions
+    // publish status text (for example the async subagent widget), include it
+    // ahead of the controls so fullscreen workflow overlays do not hide it.
     const sep = `${chromeBg}  ${dim}·${RESET}${chromeBg}  `;
-    const segments = HINT_KEYS.map(
+    const statusText = this._externalStatusText();
+    const statusSegment = statusText ? [`${accent}${statusText}${RESET}${chromeBg}`] : [];
+    const hintSegments = HINT_KEYS.map(
       ({ key, label }) =>
         `${text}${BOLD}${key}${RESET}${chromeBg} ${muted}${label}${RESET}${chromeBg}`,
     );
-    const hintsStyledRaw = segments.join(sep);
+    const hintsStyledRaw = [...statusSegment, ...hintSegments].join(sep);
 
     const leftEdgePad = 1;
     const rightEdgePad = 2;

package/dist/builtin/workflows/src/tui/graph-view-state.ts

@@ -1,3 +1,4 @@
+import type { ReadonlyFooterDataProvider } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
 import type {
   PendingPrompt,
@@ -63,6 +64,7 @@ export abstract class GraphViewState {
   protected getViewportRows?: () => number | undefined;
   protected requestRender?: () => void;
   protected piKeybindings?: unknown;
+  protected footerData?: ReadonlyFooterDataProvider;
 
   /** Active HIL prompt state, set when `_rebuildLayout` sees a new prompt id. */
   protected promptState: PromptCardState | null = null;
@@ -102,6 +104,7 @@ export abstract class GraphViewState {
     this.getViewportRows = opts.getViewportRows;
     this.requestRender = opts.requestRender;
     this.piKeybindings = opts.piKeybindings;
+    this.footerData = opts.footerData;
 
     this._unsubscribe = this.store.subscribe((snap) => {
       this.currentSnapshot = snap;

package/dist/builtin/workflows/src/tui/graph-view-types.ts

@@ -1,3 +1,4 @@
+import type { ReadonlyFooterDataProvider } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
 import type { GraphTheme } from "./graph-theme.js";
 
@@ -66,4 +67,6 @@ export interface GraphViewOpts {
   requestRender?: () => void;
   /** Host Pi keybindings manager used by run-level prompt cards. */
   piKeybindings?: unknown;
+  /** Host footer/status provider used to surface non-workflow extension statuses inside the fullscreen graph overlay. */
+  footerData?: ReadonlyFooterDataProvider;
 }

package/dist/builtin/workflows/src/tui/stage-chat-view-archive-history.ts

@@ -24,7 +24,7 @@ export function renderReadOnlyArchiveBody(
   }
 
   const t = ctx.theme;
-  const calloutRows = 6;
+  const calloutRows = 5;
   const transcriptBudget = Math.max(1, budget - calloutRows);
   const lines = ctx.chatHost.renderBody(width, transcriptBudget);
   const callout: string[] = [];
@@ -46,17 +46,6 @@ export function renderReadOnlyArchiveBody(
       0,
     ).render(width),
   );
-  callout.push(
-    ...new Text(
-      paint("esc", t.accent, { bold: true }) +
-        paint(" close", t.textMuted) +
-        paint("  ·  ", t.dim) +
-        paint("ctrl+d", t.accent, { bold: true }) +
-        paint(" return to graph", t.textMuted),
-      2,
-      0,
-    ).render(width),
-  );
   lines.push(...callout);
   while (lines.length < budget) lines.push(blankLine(width));
   if (lines.length > budget) lines.length = budget;
@@ -111,17 +100,6 @@ function renderReadOnlyPromptArchiveBody(
   bodyLines.push(...new Text(paint("your response", t.textMuted, { bold: true }), 2, 0).render(innerWidth));
   bodyLines.push(...new Text(paint(answer, answer.startsWith("(") ? t.dim : t.text), 4, 0).render(innerWidth));
   bodyLines.push("");
-  bodyLines.push(
-    ...new Text(
-      paint("esc", t.accent, { bold: true }) +
-        paint(" close", t.textMuted) +
-        paint("  ·  ", t.dim) +
-        paint("ctrl+d", t.accent, { bold: true }) +
-        paint(" return to graph", t.textMuted),
-      2,
-      0,
-    ).render(innerWidth),
-  );
 
   const title = stage.status === "skipped" ? "QUESTION SKIPPED" : "QUESTION ASKED";
   const cardLines = renderRoundedBoxLines({

package/dist/builtin/workflows/src/tui/stage-chat-view-footer-status.ts

@@ -78,6 +78,19 @@ export function renderFooterWithOrchestratorReturnHint(
   );
   return lines;
 }
+export function renderReadOnlyArchiveFooter(
+  ctx: StageChatViewContext,
+  width: number,
+): string[] {
+  const closeHint =
+    paint("esc", ctx.theme.text, { bold: true }) +
+    paint(" to close", ctx.theme.textMuted);
+  return [
+    mergeOrchestratorReturnHintIntoLine(ctx, closeHint, width, {
+      minimumPrefixWidth: visibleWidth(closeHint) + 1,
+    }),
+  ];
+}
 
 export function embedOrchestratorReturnHintInWidget(
   ctx: StageChatViewContext,
@@ -102,21 +115,45 @@ function mergeOrchestratorReturnHintIntoLine(
   ctx: StageChatViewContext,
   line: string,
   width: number,
-  options: { preserveTrailingBorder?: boolean; rightMargin?: number } = {},
+  options: {
+    preserveTrailingBorder?: boolean;
+    rightMargin?: number;
+    minimumPrefixWidth?: number;
+  } = {},
 ): string {
   const copyModeState = ctx.mouseScrollCaptureEnabled ? "off" : "on";
-  const plain = `ctrl+d graph · ${STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL} copy mode ${copyModeState}`;
-  const styled =
-    paint("ctrl+d", ctx.theme.text, { bold: true }) +
-    paint(" graph · ", ctx.theme.textMuted) +
-    paint(STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL, ctx.theme.text, { bold: true }) +
-    paint(` copy mode ${copyModeState}`, ctx.theme.textMuted);
+  const fullHint = {
+    plain: `ctrl+d graph · ${STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL} copy mode ${copyModeState}`,
+    styled:
+      paint("ctrl+d", ctx.theme.text, { bold: true }) +
+      paint(" graph · ", ctx.theme.textMuted) +
+      paint(STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL, ctx.theme.text, { bold: true }) +
+      paint(` copy mode ${copyModeState}`, ctx.theme.textMuted),
+  };
+  const compactHint = {
+    plain: `ctrl+d · ${STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL} ${copyModeState}`,
+    styled:
+      paint("ctrl+d", ctx.theme.text, { bold: true }) +
+      paint(" · ", ctx.theme.textMuted) +
+      paint(STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL, ctx.theme.text, { bold: true }) +
+      paint(` ${copyModeState}`, ctx.theme.textMuted),
+  };
   const trailingBorder = options.preserveTrailingBorder === true
     ? trailingWidgetBorderChar(line)
     : "";
   const suffixWidth = visibleWidth(trailingBorder);
-  const hintWidth = visibleWidth(plain);
   const requestedRightMargin = Math.max(0, Math.floor(options.rightMargin ?? 0));
+  const minimumPrefixWidth = Math.max(
+    0,
+    Math.floor(options.minimumPrefixWidth ?? 0),
+  );
+  const fullRequiredWidth =
+    suffixWidth +
+    requestedRightMargin +
+    minimumPrefixWidth +
+    visibleWidth(fullHint.plain);
+  const hint = fullRequiredWidth <= width ? fullHint : compactHint;
+  const hintWidth = visibleWidth(hint.plain);
   const rightMargin = Math.min(
     requestedRightMargin,
     Math.max(0, width - suffixWidth - hintWidth),
@@ -124,7 +161,13 @@ function mergeOrchestratorReturnHintIntoLine(
   const hintStart = Math.max(0, width - suffixWidth - rightMargin - hintWidth);
   const prefix = truncateToWidth(line, hintStart, "", true);
   const gap = Math.max(0, hintStart - visibleWidth(prefix));
-  return prefix + " ".repeat(gap) + styled + " ".repeat(rightMargin) + trailingBorder;
+  return (
+    prefix +
+    " ".repeat(gap) +
+    hint.styled +
+    " ".repeat(rightMargin) +
+    trailingBorder
+  );
 }
 
 export function banner(
@@ -186,6 +229,8 @@ export function editorRuleColor(
       return ctx.theme.mauve;
     case "xhigh":
       return ctx.theme.error;
+    case "max":
+      return ctx.theme.error;
     case "off":
     default:
       return ctx.theme.border;

package/dist/builtin/workflows/src/tui/stage-chat-view-pending-tools.ts

@@ -0,0 +1,9 @@
+import type { AgentSessionEvent } from "@bastani/atomic";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+
+export function replayPendingToolExecutions(ctx: StageChatViewContext): void {
+  const events = ctx.handle?.isDisposed === true
+    ? []
+    : ctx.handle?.pendingToolExecutionEvents?.() ?? [];
+  for (const event of events) ctx.chatHost.applyAgentEvent(event as AgentSessionEvent);
+}

package/dist/builtin/workflows/src/tui/stage-chat-view-render-settings.ts

@@ -0,0 +1,27 @@
+import type { ChatMessageRenderOptions } from "@bastani/atomic";
+import type { StageChatViewContext, StageChatViewOpts } from "./stage-chat-view-types.js";
+
+type StageChatRenderSettings = Partial<Omit<ChatMessageRenderOptions, "ui" | "cwd">>;
+
+type MessageRendererHost = {
+  extensionRunner?: {
+    getMessageRenderer?: (customType: string) => ReturnType<NonNullable<StageChatRenderSettings["getCustomMessageRenderer"]>>;
+  };
+};
+
+export function stageChatRenderSettings(
+  ctx: StageChatViewContext,
+  opts: StageChatViewOpts,
+): StageChatRenderSettings | undefined {
+  const inherited = opts.getChatRenderSettings?.();
+  const stageSession = ctx.handle?.isDisposed === true ? undefined : ctx.handle?.agentSession;
+  if (!stageSession) return inherited;
+  const rendererHost = stageSession as MessageRendererHost;
+  return {
+    ...inherited,
+    getToolDefinition: (toolName) =>
+      stageSession.getToolDefinition(toolName) ?? inherited?.getToolDefinition?.(toolName),
+    getCustomMessageRenderer: (customType) =>
+      rendererHost.extensionRunner?.getMessageRenderer?.(customType) ?? inherited?.getCustomMessageRenderer?.(customType),
+  };
+}

package/dist/builtin/workflows/src/tui/stage-chat-view-state.ts

@@ -4,11 +4,7 @@ import type { PendingPrompt, RunSnapshot, StageSnapshot } from "../shared/store-
 import { stageUiBroker } from "../shared/stage-ui-broker.js";
 import { resolveStageChatViewportRows } from "./stage-chat-layout.js";
 import { createPromptCardState } from "./prompt-card.js";
-import {
-  hideMountedCustomUi,
-  releaseMountedCustomUi,
-  showCustomUi,
-} from "./stage-chat-view-custom-ui.js";
+import { hideMountedCustomUi, releaseMountedCustomUi, showCustomUi } from "./stage-chat-view-custom-ui.js";
 import { editorRuleColor } from "./stage-chat-view-footer-status.js";
 import {
   blankLine,
@@ -30,6 +26,8 @@ import {
 } from "./stage-chat-view-types.js";
 import { noticeRow, noticeSummary } from "./stage-chat-view-transcript.js";
 import { applyStageChatLiveHandleEvent } from "./stage-chat-view-live-events.js";
+import { replayPendingToolExecutions } from "./stage-chat-view-pending-tools.js";
+import { stageChatRenderSettings } from "./stage-chat-view-render-settings.js";
 import { hexToAnsi, RESET } from "./color-utils.js";
 import {
   isTerminalOrNonStreamingStageChatStatus,
@@ -89,6 +87,7 @@ export function initializeStageChatView(
   });
 
   snapshotMessagesFromHandle(ctx);
+  replayPendingToolExecutions(ctx);
   const initialRun = currentRun(ctx);
   const initialStage = initialRun?.stages.find((s) => s.id === ctx.stageId);
   ctx.lastObservedRunStatus = initialRun?.status;
@@ -187,7 +186,7 @@ function createChatHost(
     keybindings: opts.piKeybindings,
     editorFactory: opts.piEditorFactory,
     editorTheme: editorThemeFromGraphTheme(ctx.theme),
-    getChatRenderSettings: opts.getChatRenderSettings,
+    getChatRenderSettings: () => stageChatRenderSettings(ctx, opts),
     footerData: opts.footerData,
     renderExtraEntry: (entry) => noticeRow(entry, ctx.theme),
   });

package/dist/builtin/workflows/src/tui/stage-chat-view.ts

@@ -35,6 +35,7 @@ import { renderCustomUi } from "./stage-chat-view-custom-ui.js";
 import {
   renderFooterWithOrchestratorReturnHint,
   renderHeader,
+  renderReadOnlyArchiveFooter,
   sepRule,
 } from "./stage-chat-view-footer-status.js";
 import { handleStageChatInput } from "./stage-chat-view-input.js";
@@ -127,9 +128,11 @@ export class StageChatView implements Component, Focusable {
     const workingLines = chatChromeHidden ? [] : this.chatHost.renderWorkingStatus(w);
     const usageLines = chatChromeHidden ? [] : this.chatHost.renderUsage(w);
     const editorLines = chatChromeHidden ? [] : this.chatHost.renderEditor(w);
-    const footerLines = chatChromeHidden
+    const footerLines = customUiActive || promptActive
       ? []
-      : renderFooterWithOrchestratorReturnHint(ctx, w, this.chatHost.renderFooter(w));
+      : readOnlyArchive
+        ? renderReadOnlyArchiveFooter(ctx, w)
+        : renderFooterWithOrchestratorReturnHint(ctx, w, this.chatHost.renderFooter(w));
 
     const totalRows = viewLineCount(ctx);
     const plan = planStageChatFrame({

package/dist/builtin/workflows/src/tui/status-list.ts

@@ -27,6 +27,7 @@
  */
 
 import type { RunSnapshot, StageSnapshot, StageStatus } from "../shared/store-types.js";
+import { effectiveRunStatus } from "../shared/returned-run-status.js";
 import { elapsedRunMs, elapsedStageMs } from "../shared/timing.js";
 import type { GraphTheme } from "./graph-theme.js";
 import { fmtDuration } from "./status-helpers.js";
@@ -162,7 +163,7 @@ function renderRunEntry(
 function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
   if (!theme) return "#000000";
   if (isQuitRun(run)) return theme.warning;
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return theme.success;
     case "running":   return theme.warning;
     case "paused":    return theme.warning;
@@ -178,7 +179,7 @@ function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
 
 function runTrailing(run: RunSnapshot, theme?: GraphTheme): { text: string; fg?: string } | undefined {
   if (isQuitRun(run)) return { text: "○ quit", fg: theme?.warning };
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return { text: "✓ completed", fg: theme?.success };
     case "running":   return { text: "● running", fg: theme?.warning };
     case "paused":    return { text: "❚❚ paused", fg: theme?.warning };
@@ -212,7 +213,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
       : undefined;
 
   if (isQuitRun(run)) return "resumable via /workflow resume";
-  if (run.status === "running") {
+  if (effectiveRunStatus(run) === "running") {
     if (isChain) parts.push(`${done}/${total}`);
     const labels = runningStageLabels(run);
     if (labels) parts.push(labels);
@@ -220,7 +221,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "paused") {
+  if (effectiveRunStatus(run) === "paused") {
     if (isChain) parts.push(`${done}/${total}`);
     const labels = pausedStageLabels(run);
     if (labels) parts.push(labels);
@@ -228,7 +229,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "failed" || run.status === "killed") {
+  if (effectiveRunStatus(run) === "failed" || effectiveRunStatus(run) === "killed") {
     const failed = run.stages.find((s) => s.status === "failed");
     if (failed && isChain) parts.push(`failed at ${failed.name}`);
     else if (failed) parts.push(failed.name);
@@ -239,7 +240,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
     return parts.join(" · ");
   }
 
-  if (run.status === "completed" || run.status === "skipped" || run.status === "cancelled" || run.status === "blocked") {
+  if (["completed", "skipped", "cancelled", "blocked"].includes(effectiveRunStatus(run))) {
     if (run.exitReason !== undefined && run.exitReason.length > 0) parts.push(run.exitReason);
     if (!isChain && run.stages[0]) parts.push(run.stages[0].name);
     const dur = lastStageDuration(run, now);
@@ -292,7 +293,7 @@ function stageCells(run: RunSnapshot): Array<{ status: StageStatus }> {
 }
 
 function stageStatusFromRun(run: RunSnapshot): StageStatus {
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return "completed";
     case "skipped":   return "skipped";
     case "cancelled": return "skipped";
@@ -324,22 +325,26 @@ interface Counts {
   paused: number;
   quit: number;
   completed: number;
+  blocked: number;
   failed: number;
   pending: number;
 }
 
 function countBuckets(runs: readonly RunSnapshot[]): Counts {
-  const c: Counts = { active: 0, paused: 0, quit: 0, completed: 0, failed: 0, pending: 0 };
+  const c: Counts = { active: 0, paused: 0, quit: 0, completed: 0, blocked: 0, failed: 0, pending: 0 };
   for (const r of runs) {
+    const status = effectiveRunStatus(r);
     if (isQuitRun(r)) c.quit++;
     else if (r.endedAt === undefined) {
-      if (r.status === "pending") c.pending++;
-      else if (r.status === "paused") c.paused++;
-      else if (r.status === "running") c.active++;
-      else if (r.status === "completed") c.completed++;
+      if (status === "pending") c.pending++;
+      else if (status === "paused") c.paused++;
+      else if (status === "running") c.active++;
+      else if (status === "completed") c.completed++;
+      else if (status === "blocked") c.blocked++;
       else c.failed++;
-    } else if (r.status === "completed") c.completed++;
-    else if (r.status === "skipped" || r.status === "cancelled" || r.status === "blocked") c.completed++;
+    } else if (status === "completed") c.completed++;
+    else if (status === "blocked") c.blocked++;
+    else if (status === "skipped" || status === "cancelled") c.completed++;
     else c.failed++;
   }
   return c;
@@ -348,6 +353,7 @@ function countBuckets(runs: readonly RunSnapshot[]): Counts {
 function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}`, fg: theme.success });
+  if (c.blocked > 0) out.push({ text: `↑ ${c.blocked} blocked`, fg: theme.warning });
   if (c.active > 0) out.push({ text: `● ${c.active}`, fg: theme.warning });
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
@@ -361,6 +367,7 @@ function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
 function plainBadges(c: Counts): FlatBandBadge[] {
   const out: FlatBandBadge[] = [];
   if (c.completed > 0) out.push({ text: `✓ ${c.completed}` });
+  if (c.blocked > 0) out.push({ text: `↑ ${c.blocked} blocked` });
   if (c.active > 0) out.push({ text: `● ${c.active}` });
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
@@ -393,7 +400,7 @@ function emptyStateLine(theme?: GraphTheme): string {
 
 function statusIconForRun(run: RunSnapshot): string {
   if (isQuitRun(run)) return "○";
-  switch (run.status) {
+  switch (effectiveRunStatus(run)) {
     case "completed": return "✓";
     case "skipped": return "⊘";
     case "cancelled": return "⊘";