@bastani/atomic 0.9.11-alpha.5 → 0.9.11-alpha.7

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

@@ -11,6 +11,7 @@ import {
   expandWorkflowGraph,
   type ExpandedWorkflowGraph,
   type ExpandedWorkflowStage,
+  type ExpandedWorkflowStageTarget,
 } from "../shared/expanded-workflow-graph.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { LayoutNode } from "./layout.js";
@@ -60,6 +61,7 @@ export abstract class GraphViewState {
   protected onStageAttach?: (runId: string, stageId: string) => void;
   protected onDetach?: () => void;
   protected initialFocusedStageId?: string;
+  protected initialFocusedRunId?: string;
   protected getViewportRows?: () => number | undefined;
   protected requestRender?: () => void;
   protected piKeybindings?: unknown;
@@ -74,7 +76,7 @@ export abstract class GraphViewState {
   protected toastManager = createToastManager();
   protected detailsExpanded = true;
   protected cachedLayout: LayoutNode[] = [];
-  protected expandedGraph: ExpandedWorkflowGraph = { stages: [], targets: new Map() };
+  protected expandedGraph: ExpandedWorkflowGraph = { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
   protected currentSnapshot: StoreSnapshot | null = null;
   protected graphScrollOffset = 0;
   protected graphScrollColOffset = 0;
@@ -99,6 +101,7 @@ export abstract class GraphViewState {
     this.onStageAttach = opts.onStageAttach;
     this.onDetach = opts.onDetach;
     this.initialFocusedStageId = opts.initialFocusedStageId;
+    this.initialFocusedRunId = opts.initialFocusedRunId;
     this.getViewportRows = opts.getViewportRows;
     this.requestRender = opts.requestRender;
     this.piKeybindings = opts.piKeybindings;
@@ -134,7 +137,7 @@ export abstract class GraphViewState {
     const run = this._getCurrentRun();
     if (!run) {
       this.cachedLayout = [];
-      this.expandedGraph = { stages: [], targets: new Map() };
+      this.expandedGraph = { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
       this.focusedIndex = 0;
       this.graphScrollOffset = 0;
       this.graphScrollColOffset = 0;
@@ -158,16 +161,19 @@ export abstract class GraphViewState {
     // uses this when swapping back from chat mode so the focus lands on
     // the same node the user just attached to.
     if (this.initialFocusedStageId !== undefined) {
-      const idx = this.cachedLayout.findIndex(
-        (n) =>
-          n.stage.id === this.initialFocusedStageId ||
-          expandedStageTarget(this.expandedGraph, n.stage.id)?.stageId === this.initialFocusedStageId,
-      );
+      const idx = this.cachedLayout.findIndex((node) => {
+        const target = expandedStageTarget(this.expandedGraph, node.stage.id);
+        if (this.initialFocusedRunId === undefined) {
+          return node.stage.id === this.initialFocusedStageId || target?.stageId === this.initialFocusedStageId;
+        }
+        return target !== undefined && target.stageId === this.initialFocusedStageId && target.runId === this.initialFocusedRunId;
+      });
       if (idx >= 0 && idx !== this.focusedIndex) {
         this.focusedIndex = idx;
         focusNeedsReveal = true;
       }
       this.initialFocusedStageId = undefined;
+      this.initialFocusedRunId = undefined;
     } else if (previousFocusedStageId !== undefined) {
       const idx = this.cachedLayout.findIndex(
         (n) => n.stage.id === previousFocusedStageId,
@@ -241,8 +247,8 @@ export abstract class GraphViewState {
   protected _graphStages(run: RunSnapshot): ExpandedWorkflowStage[] {
     this.expandedGraph = this.currentSnapshot
       ? expandWorkflowGraph(this.currentSnapshot, run.id)
-      : { stages: [], targets: new Map() };
-    const stages = [...this.expandedGraph.stages];
+      : { stages: [], renderStages: [], tools: [], nodes: [], targets: new Map() };
+    const stages = [...this.expandedGraph.renderStages];
     const hasStagePrompt = stages.some((stage) =>
       stage.pendingPrompt !== undefined ||
       (stage.status === "awaiting_input" && stage.promptFootprint?.kind === "custom")
@@ -275,6 +281,18 @@ export abstract class GraphViewState {
     }
   }
 
+  /** Stage-only control target shared by hints and activation. */
+  protected _stageChatTarget(
+    stage: StageSnapshot | undefined,
+  ): ExpandedWorkflowStageTarget | undefined {
+    if (!stage || stage.nodeKind === "tool") return undefined;
+    return expandedStageTarget(this.expandedGraph, stage.id);
+  }
+
+  protected _focusedStageChatTarget(): ExpandedWorkflowStageTarget | undefined {
+    return this._stageChatTarget(this.cachedLayout[this.focusedIndex]?.stage);
+  }
+
   protected _getCurrentRun(): RunSnapshot | null {
     if (!this.currentSnapshot) return null;
     // Pin to the first run we see so a completed run stays visible after

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

@@ -35,11 +35,12 @@ export interface GraphViewOpts {
    */
   onDetach?: () => void;
   /**
-   * When provided, GraphView restores focus to this stage on construction
-   * — used by the attach shell so returning from the chat lands the
-   * cursor on the same node the user just attached to.
+   * When provided, GraphView restores focus to this stage on construction.
+   * `initialFocusedRunId` disambiguates identical local stage IDs in nested runs.
+   * The attach shell uses the pair when returning from stage chat.
    */
   initialFocusedStageId?: string;
+  initialFocusedRunId?: string;
   /**
    * Optional accessor returning the current terminal row count. When
    * present in overlay mode the renderer expands the frame to roughly

package/dist/builtin/workflows/src/tui/node-card.ts

@@ -278,12 +278,13 @@ export function renderNodeCard(stage: StageSnapshot, opts: NodeCardOpts): string
   // body row for the child workflow identity and the final row for a
   // terse child-run summary. This keeps the graph dense while making
   // the boundary explain what actually ran.
-  const bodyText =
-    stage.status === "blocked"
+  const bodyText = stage.nodeKind === "tool"
+    ? (stage.error ?? stage.result ?? "durable tool")
+    : stage.status === "blocked"
       ? blockedBadgeText(stage, opts.stages, innerWidth)
       : workflowChildSummaryText(stage);
   const bodyHex = durationColor(stage.status, theme);
-  const statusText = `${statusIcon(stage.status)} ${statusLabel(stage.status)}`;
+  const statusText = `${statusIcon(stage.status)} ${stage.toolStatus ?? statusLabel(stage.status)}`;
   const statusLine =
     `${bg}${bc}│${RESET}` +
     centreColored(statusText, innerWidth, bodyHex, bg, {

package/dist/builtin/workflows/src/tui/overlay-adapter.ts

@@ -228,7 +228,6 @@ export function buildGraphOverlayAdapter(
     currentHandle?.hide();
     updateTerminalAutowrap(false);
     finishMounted?.();
-    observedUi?.setStatus?.(WORKFLOW_STATUS_KEY, undefined);
     observedUi?.setStatus?.(MAIN_CHAT_INPUT_STATUS_KEY, undefined);
     currentView?.dispose();
     currentHandle = null;
@@ -351,7 +350,6 @@ export function buildGraphOverlayAdapter(
 
     const custom = ui?.custom;
     if (typeof custom !== "function") return;
-    const uiStatus = ui;
 
     let settled = false;
     const factory = (
@@ -367,7 +365,6 @@ export function buildGraphOverlayAdapter(
         if (settled) return;
         settled = true;
         updateMouseScrollTracking(false);
-        observedUi?.setStatus?.(WORKFLOW_STATUS_KEY, undefined);
         observedUi?.setStatus?.(MAIN_CHAT_INPUT_STATUS_KEY, undefined);
         currentView?.dispose();
         currentView = null;
@@ -390,7 +387,6 @@ export function buildGraphOverlayAdapter(
         stageControlRegistry: registry,
         resolvePostMortemHandle,
         stageUiBroker,
-        uiStatus,
         onClose: finish,
         onHide: hideMounted,
         initialAttachStageId: stageId,

package/dist/builtin/workflows/src/tui/run-detail.ts

@@ -18,7 +18,7 @@
  */
 
 import type { RunDetail } from "../runs/background/status.js";
-import type { StageSnapshot } from "../shared/store-types.js";
+import type { StageSnapshot, ToolNodeSnapshot, ToolNodeStatus } from "../shared/store-types.js";
 import { elapsedRunMs, elapsedStageMs } from "../shared/timing.js";
 import type { GraphTheme } from "./graph-theme.js";
 import { renderRoundedBox } from "./chat-surface.js";
@@ -70,15 +70,18 @@ function renderPlain(detail: RunDetail, now: number, width: number): string {
   }
   out.push("");
 
-  out.push(" STAGES ");
-  if (detail.stages.length === 0) {
-    out.push("  (no stages recorded yet) ");
-  } else {
-    for (const stage of detail.stages) {
-      out.push(...renderStageRowsPlain(stage, now, width - 4));
-    }
+  const tools = detail.tools ?? [];
+  if (detail.stages.length > 0 || tools.length === 0) {
+    out.push(" STAGES ");
+    if (detail.stages.length === 0) out.push("  (no stages recorded yet) ");
+    else for (const stage of detail.stages) out.push(...renderStageRowsPlain(stage, now, width - 4));
+    out.push("");
+  }
+  if (tools.length > 0) {
+    out.push(" TOOLS ");
+    for (const tool of tools) out.push(...renderToolRowsPlain(tool, now, width - 4));
+    out.push("");
   }
-  out.push("");
 
   const artifactRows = artifactRowsFor(detail);
   if (artifactRows.length > 0) {
@@ -126,15 +129,18 @@ function renderThemed(detail: RunDetail, now: number, theme: GraphTheme, width:
   }
   out.push("");
 
-  out.push(` ${muted}${BOLD}STAGES${RESET} `);
-  if (detail.stages.length === 0) {
-    out.push(`  ${dim}(no stages recorded yet)${RESET} `);
-  } else {
-    for (const stage of detail.stages) {
-      out.push(...renderStageRowsThemed(stage, now, theme, width - 4));
-    }
+  const tools = detail.tools ?? [];
+  if (detail.stages.length > 0 || tools.length === 0) {
+    out.push(` ${muted}${BOLD}STAGES${RESET} `);
+    if (detail.stages.length === 0) out.push(`  ${dim}(no stages recorded yet)${RESET} `);
+    else for (const stage of detail.stages) out.push(...renderStageRowsThemed(stage, now, theme, width - 4));
+    out.push("");
+  }
+  if (tools.length > 0) {
+    out.push(` ${muted}${BOLD}TOOLS${RESET} `);
+    for (const tool of tools) out.push(...renderToolRowsThemed(tool, now, theme, width - 4));
+    out.push("");
   }
-  out.push("");
 
   const artifactRows = artifactRowsFor(detail);
   if (artifactRows.length > 0) {
@@ -270,6 +276,36 @@ function renderStageRowsThemed(
   return rows;
 }
 
+function toolDisplayStatus(status: ToolNodeStatus): "pending" | "running" | "completed" | "failed" | "cancelled" {
+  return status === "cached" ? "completed" : status;
+}
+
+function toolDurationString(tool: ToolNodeSnapshot, now: number): string | undefined {
+  if (tool.startedAt === undefined) return undefined;
+  return fmtDuration(Math.max(0, (tool.endedAt ?? now) - tool.startedAt));
+}
+
+function renderToolRowsPlain(tool: ToolNodeSnapshot, now: number, width: number): string[] {
+  const icon = statusIcon(toolDisplayStatus(tool.status));
+  const duration = toolDurationString(tool, now);
+  const line = ` ${pad(`${icon} ${tool.name}`, STAGE_NAME_COL + 2)}${pad(tool.status, 10)}${duration ?? ""} `;
+  const rows = [truncateToWidth(line, width, "…")];
+  if (tool.error) rows.push(`   error  ${truncateToWidth(tool.error.split("\n")[0] ?? "", Math.max(1, width - 10), "…")} `);
+  return rows;
+}
+
+function renderToolRowsThemed(tool: ToolNodeSnapshot, now: number, theme: GraphTheme, width: number): string[] {
+  const displayStatus = toolDisplayStatus(tool.status);
+  const stateFg = hexToAnsi(statusColor(displayStatus, theme));
+  const text = hexToAnsi(theme.text);
+  const dim = hexToAnsi(theme.dim);
+  const duration = toolDurationString(tool, now);
+  const line = ` ${stateFg}${statusIcon(displayStatus)}${RESET} ${text}${pad(tool.name, STAGE_NAME_COL)}${RESET}  ${stateFg}${pad(tool.status, 10)}${RESET}${duration ? `${dim}${duration}${RESET}` : ""} `;
+  const rows = [truncateToWidth(line, width, "…")];
+  if (tool.error) rows.push(`   ${hexToAnsi(theme.textMuted)}error${RESET}  ${hexToAnsi(theme.error)}${truncateToWidth(tool.error.split("\n")[0] ?? "", Math.max(1, width - 12), "…")}${RESET} `);
+  return rows;
+}
+
 function stageDurationString(stage: StageSnapshot, now: number): string | undefined {
   const elapsed = elapsedStageMs(stage, now);
   return elapsed === undefined ? undefined : fmtDuration(elapsed);

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

@@ -29,9 +29,13 @@ export function renderSessionList(
   const now = opts.now ?? Date.now();
   const rows = selectRunsForPicker(runs, "", opts.includeAll, now);
   const snapshot: StoreSnapshot = { runs, notices: [], version: 0 };
-  const filtered = rows.map((row) => ({
-    ...row.run,
-    stages: expandWorkflowGraph(snapshot, row.run.id).stages.map((stage) => structuredClone(stage)),
-  }));
+  const filtered = rows.map((row) => {
+    const graph = expandWorkflowGraph(snapshot, row.run.id);
+    return {
+      ...row.run,
+      stages: graph.stages.map((stage) => structuredClone(stage)),
+      toolNodes: graph.tools.map((tool) => structuredClone(tool)),
+    };
+  });
   return renderStatusList(filtered, { theme: opts.theme, now });
 }

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

@@ -0,0 +1,121 @@
+/**
+ * Maps workflow-owned stage delivery lifecycle facts onto the attached chat's
+ * existing Working lifecycle.
+ *
+ * A workflow definition that auto-sends to its own retained stage starts a real
+ * backend turn well before the public `agent_start` reaches this view. Without
+ * this bridge the pane sits with `sdkBusy=false` and no requested render while
+ * the model is already running, so it looks idle.
+ *
+ * Starting the host's ordinary lifecycle here — rather than synthesising an SDK
+ * event — keeps `agent_start`, `turn_start`, `turn_end`, `agent_end`, retry,
+ * fallback, compaction, and terminal cleanup in charge of everything after
+ * startup, and lets a settled delivery that never produced a turn clean up.
+ *
+ * cross-ref: src/runs/foreground/stage-delivery-activity.ts
+ */
+import type { StageDeliveryActivityEvent } from "../runs/foreground/stage-delivery-activity.js";
+import { isTerminalStageChatState } from "./stage-chat-view-status.js";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+
+export function subscribeStageChatDeliveryActivity(
+  ctx: StageChatViewContext,
+): (() => void) | null {
+  const handle = ctx.handle;
+  if (!handle?.subscribeDeliveryActivity) return null;
+  return handle.subscribeDeliveryActivity((event) => {
+    applyStageChatDeliveryActivityEvent(ctx, event);
+  });
+}
+
+export function applyStageChatDeliveryActivityEvent(
+  ctx: StageChatViewContext,
+  event: StageDeliveryActivityEvent,
+): void {
+  if (event.type === "delivery_start") {
+    // Replaces any lifecycle this same delivery id already owned; the map keeps
+    // one live token per delivery so settlement stays correlated. A start that
+    // arrives after terminal cleanup is fresh authorization for a retained
+    // post-mortem turn, so it also lifts the stale-start fence.
+    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);
+  // A pre-turn compaction reasserts one lifecycle and hands the same token to
+  // every lease still open, so several deliveries can alias one generation.
+  // Only the last owner may settle it; otherwise the first lease to finish
+  // would stop Working while another accepted delivery is still running.
+  // Distinct generations — including stale ones — keep reaching the host's own
+  // generation fence exactly as before.
+  if (!ownsStageChatLifecycleGeneration(ctx, generation)) {
+    ctx.chatHost.settleExternalPromptLifecycle(generation);
+  }
+  // The map is the reference count: overlapping leases keep authorization open,
+  // and the last one to settle on a finished stage restores stale-start
+  // suppression. Otherwise the fence stayed open forever after the first
+  // post-terminal delivery and a late start could repaint a settled chat.
+  if (!hasActiveStageChatDelivery(ctx) && isStageChatContextTerminal(ctx)) {
+    ctx.terminalLifecycleFenced = true;
+  }
+}
+
+/** True while another still-active delivery references this exact lifecycle token. */
+function ownsStageChatLifecycleGeneration(
+  ctx: StageChatViewContext,
+  generation: number | undefined,
+): boolean {
+  for (const active of ctx.deliveryLifecycles.values()) {
+    if (active === generation) return true;
+  }
+  return false;
+}
+
+/** True while at least one admitted delivery still owns this chat's Working period. */
+export function hasActiveStageChatDelivery(ctx: StageChatViewContext): boolean {
+  return ctx.deliveryLifecycles.size > 0;
+}
+
+/** True when the last observed run or stage status is terminal. */
+export function isStageChatContextTerminal(ctx: StageChatViewContext): boolean {
+  return (
+    isTerminalStageChatState(ctx.lastObservedRunStatus) ||
+    isTerminalStageChatState(ctx.lastObservedStageStatus)
+  );
+}
+
+/**
+ * Restore delivery-owned Working after a temporary overlay ended.
+ *
+ * A pre-turn `compaction_end` clears busy state and the Working lifecycle even
+ * though the accepted delivery has not started its turn yet, so the pane would
+ * sit idle until the public `agent_start`. Reassertion preserves factual status
+ * text, so a compaction error still outranks ordinary Working.
+ */
+export function reconcileStageChatDeliveryLifecycle(ctx: StageChatViewContext): void {
+  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);
+  }
+}
+
+/**
+ * Drop every delivery lease admitted before a workflow terminal transition and
+ * arm the stale-start fence.
+ *
+ * Those turns can no longer authorize activity on this chat, and keeping them
+ * would let a queued late `agent_start` restart Working on a finished stage. A
+ * settlement for a dropped id is then an ordinary unknown settlement.
+ *
+ * The fence is armed only by an observed transition. A chat that mounts onto an
+ * already-terminal stage never cleaned up in-flight work, so a later
+ * `agent_start` there is genuine retained-session work and stays visible.
+ */
+export function invalidateStageChatDeliveryLifecycles(ctx: StageChatViewContext): void {
+  ctx.deliveryLifecycles.clear();
+  ctx.terminalLifecycleFenced = true;
+}

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

@@ -1,18 +1,60 @@
 import type { AgentSessionEvent } from "@bastani/atomic";
 import type { StageChatViewContext } from "./stage-chat-view-types.js";
 import { isTerminalStageChatState } from "./stage-chat-view-status.js";
+import {
+  hasActiveStageChatDelivery,
+  reconcileStageChatDeliveryLifecycle,
+} from "./stage-chat-view-delivery-activity.js";
 
 export function applyStageChatLiveHandleEvent(
   ctx: StageChatViewContext,
   event: AgentSessionEvent,
 ): void {
+  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: StageChatViewContext): void {
   const hadAnimationTick = ctx.chatHost.hasAnimationTick();
   ctx.chatHost.clearBusyForTerminalWorkflowStage();
   if (hadAnimationTick !== ctx.chatHost.hasAnimationTick()) ctx.requestRender?.();
 }
 
+/**
+ * A turn start queued before the stage finished must not repaint Working on a
+ * settled stage.
+ *
+ * The fence is armed only when this chat actually observed a terminal
+ * transition and cleaned up in-flight work. Work admitted after that carries
+ * its own authorization and is left alone: a live workflow delivery lease
+ * (including one replayed at attach time), or a prompt this chat submitted
+ * itself, which is already busy by the time its `agent_start` arrives.
+ * `turn_start` is guarded too, otherwise it would restart the lifecycle a
+ * suppressed `agent_start` just stopped.
+ */
+function isStaleTerminalLifecycleStart(
+  ctx: StageChatViewContext,
+  event: AgentSessionEvent,
+): boolean {
+  if (!ctx.terminalLifecycleFenced) return false;
+  const type = String((event as { type?: unknown }).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: AgentSessionEvent): boolean {
+  return String((event as { type?: unknown }).type ?? "") === "compaction_end";
+}
+
 function shouldCleanupAfterLiveEvent(
   ctx: StageChatViewContext,
   event: AgentSessionEvent,

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

@@ -138,6 +138,18 @@ export function blendBg(baseHex: string, tintHex: string, alpha: number): string
   return lerpColor(baseHex, tintHex, Math.max(0, Math.min(1, alpha)));
 }
 
+export function workingIndicatorPalette(theme: GraphTheme) {
+  const { selection: dark, accent, text: peak } = theme;
+  return {
+    dark,
+    lift: lerpColor(dark, accent, 0.25),
+    muted: lerpColor(dark, accent, 0.6),
+    accent,
+    bright: lerpColor(accent, peak, 0.55),
+    peak,
+  };
+}
+
 export function renderHintsForPrompt(
   kind: PendingPrompt["kind"],
   theme: GraphTheme,

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

@@ -1,5 +1,8 @@
-import type { ChatMessageRenderOptions } from "@bastani/atomic";
+import type { ChatMessageRenderOptions, ChatSessionHostStyle } from "@bastani/atomic";
+import { editorRuleColor } from "./stage-chat-view-footer-status.js";
+import { blankLine, cursorBlock, paint, workingIndicatorPalette } from "./stage-chat-view-render-helpers.js";
 import type { StageChatViewContext, StageChatViewOpts } from "./stage-chat-view-types.js";
+import { hexToAnsi, RESET } from "./color-utils.js";
 
 type StageChatRenderSettings = Partial<Omit<ChatMessageRenderOptions, "ui" | "cwd">>;
 
@@ -25,3 +28,20 @@ export function stageChatRenderSettings(
       rendererHost.extensionRunner?.getMessageRenderer?.(customType) ?? inherited?.getCustomMessageRenderer?.(customType),
   };
 }
+
+export function chatHostStyle(ctx: StageChatViewContext): ChatSessionHostStyle {
+  return {
+    dim: (text) => paint(text, ctx.theme.dim),
+    text: (text) => paint(text, ctx.theme.text),
+    textMuted: (text) => paint(text, ctx.theme.textMuted),
+    accent: (text) => paint(text, ctx.theme.accent),
+    accentBold: (text) => paint(text, ctx.theme.accent, { bold: true }),
+    workingIndicatorPalette: ctx.piTheme === undefined ? () => workingIndicatorPalette(ctx.theme) : undefined,
+    workingIndicatorUseGlobalTheme: ctx.piTheme !== undefined,
+    rule: (hex, text) => hexToAnsi(hex) + text + RESET,
+    cursor: () => cursorBlock(),
+    blank: (width) => blankLine(width),
+    editorRuleColor: (disabled, agentSession, state) =>
+      editorRuleColor(ctx, disabled, agentSession, state),
+  };
+}

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

@@ -1,12 +1,11 @@
-import { ChatSessionHost, type ChatSessionHostStyle } from "@bastani/atomic";
+import { ChatSessionHost } from "@bastani/atomic";
 import { Editor, type EditorComponent } from "@earendil-works/pi-tui";
 import type { PendingPrompt, RunSnapshot, StageSnapshot } from "../shared/store-types.js";
 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 { editorRuleColor } from "./stage-chat-view-footer-status.js";
-import { blankLine, cursorBlock, editorThemeFromGraphTheme, paint, setEditorBorderColor, setEditorPlaceholder } from "./stage-chat-view-render-helpers.js";
+import { editorThemeFromGraphTheme, setEditorBorderColor, setEditorPlaceholder } from "./stage-chat-view-render-helpers.js";
 import {
   HEADER_ROWS,
   SEP_ROWS,
@@ -19,8 +18,12 @@ 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 {
+  invalidateStageChatDeliveryLifecycles,
+  subscribeStageChatDeliveryActivity,
+} from "./stage-chat-view-delivery-activity.js";
 import { replayPendingToolExecutions } from "./stage-chat-view-pending-tools.js";
-import { stageChatRenderSettings } from "./stage-chat-view-render-settings.js";
+import { chatHostStyle, stageChatRenderSettings } from "./stage-chat-view-render-settings.js";
 import { hexToAnsi, RESET } from "./color-utils.js";
 import {
   isTerminalOrNonStreamingStageChatStatus,
@@ -67,8 +70,11 @@ export function initializeStageChatView(
   ctx.lastObservedStageStatus = undefined;
   ctx.lastObservedRunStatus = undefined;
   ctx.seenNoticeIds = new Set<string>();
+  ctx.deliveryLifecycles = new Map<number, number | undefined>();
+  ctx.terminalLifecycleFenced = false;
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity = null;
   ctx._unsubscribeFooterData = null;
   ctx._unregisterStageUiHost = null;
   installFocusHold(ctx);
@@ -99,6 +105,10 @@ export function initializeStageChatView(
   ctx._unsubscribeFooterData = ctx.footerData?.onBranchChange(() => ctx.requestRender?.()) ?? null;
 
   if (ctx.handle) {
+    // Delivery activity first: its replay must be in place before the SDK
+    // stream, so a synchronously replayed `agent_start` on a retained terminal
+    // stage can see that a live delivery authorizes it.
+    ctx._unsubscribeDeliveryActivity = subscribeStageChatDeliveryActivity(ctx);
     ctx._unsubscribeHandle = ctx.handle.subscribe((event) => applyStageChatLiveHandleEvent(ctx, event));
   }
   ctx.chatHost.syncAnimationTick();
@@ -189,21 +199,6 @@ function createChatHost(
   });
 }
 
-function chatHostStyle(ctx: StageChatViewContext): ChatSessionHostStyle {
-  return {
-    dim: (text) => paint(text, ctx.theme.dim),
-    text: (text) => paint(text, ctx.theme.text),
-    textMuted: (text) => paint(text, ctx.theme.textMuted),
-    accent: (text) => paint(text, ctx.theme.accent),
-    accentBold: (text) => paint(text, ctx.theme.accent, { bold: true }),
-    rule: (hex, text) => hexToAnsi(hex) + text + RESET,
-    cursor: () => cursorBlock(),
-    blank: (width) => blankLine(width),
-    editorRuleColor: (disabled, agentSession, state) =>
-      editorRuleColor(ctx, disabled, agentSession, state),
-  };
-}
-
 function handleStoreUpdate(ctx: StageChatViewContext): void {
   const run = currentRun(ctx);
   const stage = run?.stages.find((s) => s.id === ctx.stageId);
@@ -225,6 +220,8 @@ function handleStoreUpdate(ctx: StageChatViewContext): void {
   }
   if (isTerminalStageChatTransition(ctx.lastObservedStageStatus, currentStageStatus) || isTerminalStageChatTransition(ctx.lastObservedRunStatus, currentRunStatus)) {
     ctx.chatHost.clearBusyForTerminalWorkflowStage();
+    // Leases admitted before this transition can no longer authorize activity.
+    invalidateStageChatDeliveryLifecycles(ctx);
     changed = true;
   }
   ctx.lastObservedRunStatus = currentRunStatus;
@@ -484,6 +481,9 @@ export function disposeStageChatView(ctx: StageChatViewContext): void {
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle?.();
   ctx._unsubscribeHandle = null;
+  ctx._unsubscribeDeliveryActivity?.();
+  ctx._unsubscribeDeliveryActivity = null;
+  ctx.deliveryLifecycles.clear();
   ctx._unsubscribeFooterData?.();
   ctx._unsubscribeFooterData = null;
   releaseMountedCustomUi(ctx);

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

@@ -162,8 +162,12 @@ export interface StageChatViewContext {
   lastObservedStageStatus: StageStatus | undefined;
   lastObservedRunStatus: RunStatus | undefined;
   seenNoticeIds: Set<string>;
+  deliveryLifecycles: Map<number, number | undefined>;
+  /** True once this chat observed a terminal transition and cleaned up in-flight work. */
+  terminalLifecycleFenced: boolean;
   _unsubscribeStore: (() => void) | null;
   _unsubscribeHandle: (() => void) | null;
+  _unsubscribeDeliveryActivity: (() => void) | null;
   _unsubscribeFooterData: (() => void) | null;
   _unregisterStageUiHost: (() => void) | null;
 }

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

@@ -126,7 +126,7 @@ export class StageChatView implements Component, Focusable {
     const readOnlyArchive = isReadOnlyArchive(ctx, stage);
 
     const customUiLines = customUiActive ? renderCustomUi(ctx, w) : [];
-    const chatChromeHidden = customUiActive || promptActive || readOnlyArchive;
+    const chatChromeHidden = customUiActive || promptActive || readOnlyArchive || blocked;
     const pendingLines = chatChromeHidden ? [] : this.chatHost.renderPendingMessages(w);
     const workingLines = chatChromeHidden ? [] : this.chatHost.renderWorkingStatus(w);
     const usageLines = chatChromeHidden ? [] : this.chatHost.renderUsage(w);
@@ -149,7 +149,9 @@ export class StageChatView implements Component, Focusable {
       footerRows: footerLines.length,
     });
     const visiblePendingLines = takeRows(pendingLines, plan.pendingRows);
-    const visibleWorkingLines = takeRows(workingLines, plan.workingRows);
+    const visibleWorkingLines = workingLines.slice(
+      Math.max(0, workingLines.length - plan.workingRows),
+    );
     const visibleUsageLines = takeRows(usageLines, plan.usageRows);
     const editorSlotLines = customUiActive ? customUiLines : editorLines;
     const visibleEditorLines = takeRows(editorSlotLines, plan.editorRows);