@bastani/atomic 0.9.3-alpha.1 → 0.9.3-alpha.2

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

@@ -16,6 +16,8 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
   protected _renderGraph(width: number): string[] {
     const run = this._getCurrentRun();
     if (!run || this.cachedLayout.length === 0) {
+      this.lastGraphViewport = null;
+      this.graphNodeHitRects = [];
       const dim = hexToAnsi(this.graphTheme.dim);
       return [
         this._centerCanvasContent(
@@ -40,6 +42,7 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
     );
     const viewportWidth = Math.max(1, width - leftMargin);
     const fullCanvasWidth = Math.max(canvasWidth, viewportWidth);
+    this.lastGraphViewport = { leftMargin, viewportWidth };
     this._clampGraphHorizontalScroll(fullCanvasWidth, viewportWidth);
     if (this.pendingEnsureFocusedVisible) {
       this._scrollFocusedColumnIntoView(viewportWidth, fullCanvasWidth);
@@ -129,6 +132,44 @@ export abstract class GraphViewGraphRenderer extends GraphViewRenderHelpers {
     });
   }
 
+  protected _recordGraphNodeHitRects(
+    graphStartRow: number,
+    visibleRowCount: number,
+  ): void {
+    const viewport = this.lastGraphViewport;
+    if (!viewport || visibleRowCount <= 0) {
+      this.graphNodeHitRects = [];
+      return;
+    }
+
+    const visibleTop = graphStartRow;
+    const visibleBottom = graphStartRow + visibleRowCount;
+    const viewportLeft = viewport.leftMargin;
+    const viewportRight = viewport.leftMargin + viewport.viewportWidth;
+    const rects: typeof this.graphNodeHitRects = [];
+
+    for (let index = 0; index < this.cachedLayout.length; index++) {
+      const node = this.cachedLayout[index]!;
+      const top = graphStartRow + node.y - this.graphScrollOffset;
+      const bottom = top + NODE_H;
+      const left = viewport.leftMargin + node.x - this.graphScrollColOffset;
+      const right = left + NODE_W;
+      const clippedTop = Math.max(visibleTop, top);
+      const clippedBottom = Math.min(visibleBottom, bottom);
+      const clippedLeft = Math.max(viewportLeft, left);
+      const clippedRight = Math.min(viewportRight, right);
+      if (clippedTop >= clippedBottom || clippedLeft >= clippedRight) continue;
+      rects.push({
+        index,
+        top: clippedTop,
+        bottom: clippedBottom,
+        left: clippedLeft,
+        right: clippedRight,
+      });
+    }
+    this.graphNodeHitRects = rects;
+  }
+
   protected _visibleGraphLines(
     graphLines: string[],
     frameWidth: number,

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

@@ -11,6 +11,13 @@ import {
 import { filterStages, type SwitcherState } from "./switcher.js";
 import { Key, matchesKey } from "./text-helpers.js";
 
+interface SgrMouseEvent {
+  buttonCode: number;
+  col: number;
+  row: number;
+  final: "M" | "m";
+}
+
 /** Keyboard, mouse, switcher, prompt, and focus navigation handling. */
 export abstract class GraphViewInputController extends GraphViewRenderer {
   /** Returns true if consumed. */
@@ -80,6 +87,15 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
       return true;
     }
 
+    const clickedNodeIndex = this._graphNodeIndexForClick(data);
+    if (clickedNodeIndex !== undefined) {
+      if (clickedNodeIndex !== null) {
+        this._setFocusedIndex(clickedNodeIndex);
+        this._activateFocusedNode();
+      }
+      return true;
+    }
+
     // Vertical-graph navigation: up/down step between depth levels
     // (col), left/right step between siblings at the same depth (row).
     // j/k preserved as a flat-order fallback for muscle memory.
@@ -115,12 +131,7 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
       return true;
     }
     if (matchesKey(data, Key.enter)) {
-      // Enter attaches the popup interior to the focused stage. The
-      // attach shell swaps in the stage-chat view without remounting
-      // the overlay; without a callback, fall back to the legacy
-      // expand/collapse toggle so non-attach hosts still work.
-      if (this._attachFocusedStage()) return true;
-      this.detailsExpanded = !this.detailsExpanded;
+      this._activateFocusedNode();
       return true;
     }
     // `ctrl+d` detaches the whole popup (host hides the overlay). This
@@ -133,16 +144,13 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
       }
       return true;
     }
-    // `q` kills the active run (no confirm). `h` hides the pane via
-    // the overlay's setHidden() flag (not unmount); Escape/Ctrl+C closes.
+    // `q` quits/detaches the orchestrator view without authoritatively
+    // killing the workflow. The workflow remains resumable via
+    // `/workflow resume`; use `/workflow kill` for non-resumable disposal.
     if (matchesKey(data, "q")) {
       const run = this._getCurrentRun();
-      const targetRunId = this._focusedStageTarget()?.runId ?? run?.id;
-      const targetRun = targetRunId !== undefined
-        ? this.currentSnapshot?.runs.find((candidate) => candidate.id === targetRunId)
-        : undefined;
-      if (targetRun && targetRun.endedAt === undefined && this.onKill) {
-        this.onKill(targetRun.id);
+      if (run && run.endedAt === undefined && this.onQuit) {
+        this.onQuit(run.id);
       }
       this.onClose?.();
       return true;
@@ -265,6 +273,15 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
     return true;
   }
 
+  private _activateFocusedNode(): void {
+    // Enter and direct node clicks attach the popup interior to the focused
+    // stage. The attach shell swaps in the stage-chat view without remounting
+    // the overlay; without a callback, fall back to the legacy expand/collapse
+    // toggle so non-attach hosts still work.
+    if (this._attachFocusedStage()) return;
+    this.detailsExpanded = !this.detailsExpanded;
+  }
+
   private _attachFocusedStage(): boolean {
     if (!this.onStageAttach) return false;
     const node = this.cachedLayout[this.focusedIndex];
@@ -278,13 +295,6 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
     return true;
   }
 
-  private _focusedStageTarget(): { runId: string; stageId: string } | undefined {
-    const node = this.cachedLayout[this.focusedIndex];
-    if (!node) return undefined;
-    const target = expandedStageTarget(this.expandedGraph, node.stage.id);
-    return target ? { runId: target.runId, stageId: target.stageId } : undefined;
-  }
-
   private _setFocusedIndex(index: number): void {
     const max = Math.max(0, this.cachedLayout.length - 1);
     const next = Math.max(0, Math.min(index, max));
@@ -298,10 +308,55 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
     this.graphScrollOffset = Math.max(0, this.graphScrollOffset + deltaRows);
   }
 
+  private _graphNodeIndexForClick(data: string): number | null | undefined {
+    const click = this._sgrLeftMousePress(data);
+    if (!click) return undefined;
+    if (this.mode !== "overlay") return undefined;
+    if (this.cachedLayout.length === 0) return null;
+
+    for (const rect of this.graphNodeHitRects) {
+      if (
+        click.row >= rect.top &&
+        click.row < rect.bottom &&
+        click.col >= rect.left &&
+        click.col < rect.right
+      ) {
+        return rect.index;
+      }
+    }
+    return null;
+  }
+
+  private _parseSgrMouse(data: string): SgrMouseEvent | null {
+    const sgr = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
+    if (!sgr) return null;
+    const oneBasedCol = Number.parseInt(sgr[2]!, 10);
+    const oneBasedRow = Number.parseInt(sgr[3]!, 10);
+    const final = sgr[4];
+    if (oneBasedCol < 1 || oneBasedRow < 1) return null;
+    if (final !== "M" && final !== "m") return null;
+    return {
+      buttonCode: Number.parseInt(sgr[1]!, 10),
+      col: oneBasedCol - 1,
+      row: oneBasedRow - 1,
+      final,
+    };
+  }
+
+  private _sgrLeftMousePress(data: string): { col: number; row: number } | null {
+    const sgr = this._parseSgrMouse(data);
+    if (!sgr || sgr.final !== "M") return null;
+    const buttonCode = sgr.buttonCode;
+    if ((buttonCode & 64) !== 0 || (buttonCode & 32) !== 0 || (buttonCode & 3) !== 0) {
+      return null;
+    }
+    return { col: sgr.col, row: sgr.row };
+  }
+
   private _mouseWheelDeltaRows(data: string): number {
-    const sgr = data.match(/^\x1b\[<(\d+);\d+;\d+M$/);
-    if (sgr) {
-      return this._wheelDeltaForButtonCode(Number.parseInt(sgr[1]!, 10));
+    const sgr = this._parseSgrMouse(data);
+    if (sgr && sgr.final === "M") {
+      return this._wheelDeltaForButtonCode(sgr.buttonCode);
     }
     if (data.startsWith("\x1b[M") && data.length >= 6) {
       return this._wheelDeltaForButtonCode(data.charCodeAt(3) - 32);
@@ -330,4 +385,7 @@ export abstract class GraphViewInputController extends GraphViewRenderer {
   get _graphScrollOffset(): number {
     return this.graphScrollOffset;
   }
+  get _graphScrollColOffset(): number {
+    return this.graphScrollColOffset;
+  }
 }

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

@@ -37,6 +37,7 @@ export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
 
   protected _renderOverlay(width: number): string[] {
     const frameWidth = Math.max(40, width);
+    this.lastOverlayFrameWidth = frameWidth;
     const lines: string[] = [];
     const run = this._getCurrentRun();
 
@@ -58,6 +59,10 @@ export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
       frameWidth,
       bodyTarget,
     );
+    this._recordGraphNodeHitRects(
+      this._overlayVerticalMarginRows() + 3 + visibleGraph.topPad,
+      visibleGraph.lines.length,
+    );
     for (let i = 0; i < visibleGraph.topPad; i++)
       lines.push(this._blankRow(frameWidth));
     for (const line of visibleGraph.lines) {
@@ -78,6 +83,8 @@ export abstract class GraphViewRenderer extends GraphViewGraphRenderer {
   }
 
   protected _renderEmptyState(width: number): string[] {
+    this.graphNodeHitRects = [];
+    this.lastGraphViewport = null;
     const t = this.graphTheme;
     const muted = hexToAnsi(t.textMuted);
     const dim = hexToAnsi(t.dim);

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

@@ -34,6 +34,19 @@ export interface GraphStageCounts {
   skipped: number;
 }
 
+interface GraphNodeHitRect {
+  index: number;
+  top: number;
+  bottom: number;
+  left: number;
+  right: number;
+}
+
+interface GraphViewportGeometry {
+  leftMargin: number;
+  viewportWidth: number;
+}
+
 /** Expansion, focus, prompt, and store-backed layout state for GraphView. */
 export abstract class GraphViewState {
   protected mode: GraphViewMode;
@@ -41,7 +54,7 @@ export abstract class GraphViewState {
   protected store: Store;
   protected graphTheme: GraphTheme;
   protected onClose?: () => void;
-  protected onKill?: (runId: string) => void;
+  protected onQuit?: (runId: string) => void;
   protected onHide?: () => void;
   protected onPromptResolve?: (runId: string, promptId: string, response: unknown) => void;
   protected onStageAttach?: (runId: string, stageId: string) => void;
@@ -64,6 +77,9 @@ export abstract class GraphViewState {
   protected currentSnapshot: StoreSnapshot | null = null;
   protected graphScrollOffset = 0;
   protected graphScrollColOffset = 0;
+  protected graphNodeHitRects: GraphNodeHitRect[] = [];
+  protected lastGraphViewport: GraphViewportGeometry | null = null;
+  protected lastOverlayFrameWidth = 80;
   protected pendingEnsureFocusedVisible = true;
   protected lastAutoFocusedAwaitingInputKey: string | null = null;
 
@@ -77,7 +93,7 @@ export abstract class GraphViewState {
     this.store = opts.store;
     this.graphTheme = opts.graphTheme;
     this.onClose = opts.onClose;
-    this.onKill = opts.onKill;
+    this.onQuit = opts.onQuit;
     this.onHide = opts.onHide;
     this.onPromptResolve = opts.onPromptResolve;
     this.onStageAttach = opts.onStageAttach;
@@ -121,6 +137,8 @@ export abstract class GraphViewState {
       this.focusedIndex = 0;
       this.graphScrollOffset = 0;
       this.graphScrollColOffset = 0;
+      this.graphNodeHitRects = [];
+      this.lastGraphViewport = null;
       this.pendingEnsureFocusedVisible = true;
       this.promptState = null;
       return;
@@ -130,6 +148,8 @@ export abstract class GraphViewState {
     const graphStages = this._graphStages(run);
     const nextLayout = computeLayout(graphStages, { orientation: "vertical" });
     this.cachedLayout = nextLayout;
+    this.graphNodeHitRects = [];
+    this.lastGraphViewport = null;
 
     let focusNeedsReveal = this.pendingEnsureFocusedVisible;
     // One-shot: if the host passed `initialFocusedStageId`, snap the

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

@@ -10,12 +10,11 @@ export interface GraphViewOpts {
   graphTheme: GraphTheme;
   onClose?: () => void;
   /**
-   * Invoked when the user presses `q` inside the pane on an in-flight
-   * run. Fires immediately (no confirm) per the toggle-driven UX:
-   * `h` hides without quitting; `q` is reserved for terminating the
-   * current run.
+   * Invoked when the user presses `q` inside the pane. This quits/detaches
+   * the orchestrator view and leaves the workflow resumable; it must not use
+   * the `/workflow kill` terminal path.
    */
-  onKill?: (runId: string) => void;
+  onQuit?: (runId: string) => void;
   /**
    * Invoked when the user presses `h` inside the pane. Hides without
    * unmounting (overlay-adapter calls `setHidden(true)`). Re-open via

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

@@ -21,8 +21,7 @@ import type { ChatMessageRenderOptions, ReadonlyFooterDataProvider } from "@bast
 import { WorkflowAttachPane } from "./workflow-attach-pane.js";
 import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
 import { deriveGraphThemeFromPiTheme } from "./graph-theme.js";
-import { killRun as defaultKillRun } from "../runs/background/status.js";
-import { cancellationRegistry } from "../runs/background/cancellation-registry.js";
+import { quitRun as defaultQuitRun } from "../runs/background/quit.js";
 import { stageControlRegistry as defaultStageControlRegistry } 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";
@@ -100,8 +99,8 @@ const FULLSCREEN_OVERLAY_OPTIONS: PiOverlayOptions = {
   margin: 0,
 };
 
-const MOUSE_SCROLL_TRACKING_ON = "\x1b[?1000h\x1b[?1006h";
-const MOUSE_SCROLL_TRACKING_OFF = "\x1b[?1006l\x1b[?1000l";
+const MOUSE_SCROLL_TRACKING_ON = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+const MOUSE_SCROLL_TRACKING_OFF = "\x1b[?1006l\x1b[?1002l\x1b[?1000l";
 const MAIN_CHAT_INPUT_STATUS_KEY = `${WORKFLOW_STATUS_KEY}:main-chat-input`;
 const MAIN_CHAT_INPUT_STATUS = "Main chat needs input — exit graph to answer.";
 
@@ -119,11 +118,10 @@ export interface BuildGraphOverlayAdapterOpts {
   /** Broker used to route stage-local custom UI into attached stage chats. */
   stageUiBroker?: StageUiBroker;
   /**
-   * Kill hook used by graph-mode `q`. The extension factory supplies this so
-   * persistence can record a terminal event while retaining the run for
-   * inspection.
+   * Quit hook used by graph-mode `q`. This is intentionally distinct from
+   * `/workflow kill`: panel quit leaves durable-progress runs resumable.
    */
-  onKillRun?: (runId: string) => void;
+  onQuitRun?: (runId: string) => void;
   /** Optional clock injection for deterministic attach-pane transition tests. */
   now?: () => number;
 }
@@ -135,8 +133,8 @@ export function buildGraphOverlayAdapter(
 ): GraphOverlayPort {
   const registry = buildOpts.stageControlRegistry ?? defaultStageControlRegistry;
   const stageUiBroker = buildOpts.stageUiBroker;
-  const killRun = buildOpts.onKillRun ?? ((id: string): void => {
-    defaultKillRun(id, { store, cancellation: cancellationRegistry });
+  const quitRun = buildOpts.onQuitRun ?? ((id: string): void => {
+    defaultQuitRun(id, { store, stageControlRegistry: registry });
   });
   let currentView: WorkflowAttachPane | null = null;
   // pi-tui returns an OverlayHandle via `options.onHandle`. We hold onto
@@ -329,7 +327,7 @@ export function buildGraphOverlayAdapter(
         uiStatus,
         onClose: finish,
         onHide: hideMounted,
-        onKill: killRun,
+        onQuit: quitRun,
         initialAttachStageId: stageId,
         piTui: tui,
         piTheme: theme,

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

@@ -10,7 +10,10 @@ import {
   trailingWidgetBorderChar,
   widgetHintTargetLineIndex,
 } from "./stage-chat-view-render-helpers.js";
-import type { StageChatViewContext } from "./stage-chat-view-types.js";
+import {
+  STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL,
+  type StageChatViewContext,
+} from "./stage-chat-view-types.js";
 import type { StageSnapshot } from "../shared/store-types.js";
 import { truncateToWidth, visibleWidth } from "./text-helpers.js";
 
@@ -101,10 +104,13 @@ function mergeOrchestratorReturnHintIntoLine(
   width: number,
   options: { preserveTrailingBorder?: boolean; rightMargin?: number } = {},
 ): string {
-  const plain = "ctrl+d returns to orchestrator panel";
+  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(" returns to orchestrator panel", ctx.theme.textMuted);
+    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 trailingBorder = options.preserveTrailingBorder === true
     ? trailingWidgetBorderChar(line)
     : "";

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

@@ -17,9 +17,9 @@ import { releaseMountedCustomUi } from "./stage-chat-view-custom-ui.js";
 import {
   canSubmitPrompt,
   currentStage,
+  isAbortableStreamingSession,
   isBlocked,
   isReadOnlyArchive,
-  isStreaming,
   promptPageSize,
   recordCurrentPromptDraft,
   resolvePromptResponse,
@@ -30,6 +30,11 @@ export function handleStageChatInput(
   ctx: StageChatViewContext,
   data: string,
 ): boolean {
+  if (matchesKey(data, Key.ctrl("t"))) {
+    ctx.mouseScrollCaptureEnabled = !ctx.mouseScrollCaptureEnabled;
+    ctx.requestRender?.();
+    return true;
+  }
   if (ctx.mountedCustomUi) {
     return handleMountedCustomUiInput(ctx, data);
   }
@@ -54,12 +59,16 @@ export function handleStageChatInput(
   if (ctx.chatHost.handleScrollInput(data)) return true;
   if (matchesKey(data, Key.escape)) {
     if (
-      isStreaming(ctx) ||
+      ctx.chatHost.isCompacting() ||
       ctx.chatHost.isBashRunning() ||
       ctx.chatHost.isEditingBashCommand()
     ) {
       return ctx.chatHost.handleInput(data);
     }
+    if (isAbortableStreamingSession(ctx)) {
+      void ctx.chatHost.interrupt();
+      return true;
+    }
     ctx.onClose();
     return true;
   }

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

@@ -0,0 +1,35 @@
+import type { AgentSessionEvent } from "@bastani/atomic";
+import type { StageChatViewContext } from "./stage-chat-view-types.js";
+import { isTerminalStageChatState } from "./stage-chat-view-status.js";
+
+export function applyStageChatLiveHandleEvent(
+  ctx: StageChatViewContext,
+  event: AgentSessionEvent,
+): void {
+  ctx.chatHost.applyAgentEvent(event);
+  if (!shouldCleanupAfterLiveEvent(ctx, event)) return;
+  const hadAnimationTick = ctx.chatHost.hasAnimationTick();
+  ctx.chatHost.clearBusyForTerminalWorkflowStage();
+  if (hadAnimationTick !== ctx.chatHost.hasAnimationTick()) ctx.requestRender?.();
+}
+
+function shouldCleanupAfterLiveEvent(
+  ctx: StageChatViewContext,
+  event: AgentSessionEvent,
+): boolean {
+  if (!isToolExecutionLiveEvent(event)) return false;
+  if (ctx.chatHost.isStreaming()) return false;
+  return isCurrentRunOrStageTerminal(ctx);
+}
+
+function isCurrentRunOrStageTerminal(ctx: StageChatViewContext): boolean {
+  return (
+    isTerminalStageChatState(ctx.lastObservedRunStatus) ||
+    isTerminalStageChatState(ctx.lastObservedStageStatus)
+  );
+}
+
+function isToolExecutionLiveEvent(event: AgentSessionEvent): boolean {
+  const type = String((event as { type?: unknown }).type ?? "");
+  return type === "tool_execution_start" || type === "tool_execution_update";
+}

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

@@ -1,10 +1,6 @@
-import {
-  ChatSessionHost,
-  type ChatSessionHostStyle,
-} from "@bastani/atomic";
-import { Editor } from "@earendil-works/pi-tui";
-import type { EditorComponent } from "@earendil-works/pi-tui";
-import type { PendingPrompt, StageSnapshot } from "../shared/store-types.js";
+import { ChatSessionHost, type ChatSessionHostStyle } 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";
@@ -33,7 +29,13 @@ import {
   type StageChatViewOpts,
 } 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 { hexToAnsi, RESET } from "./color-utils.js";
+import {
+  isTerminalOrNonStreamingStageChatStatus,
+  isTerminalStageChatState,
+  isTerminalStageChatTransition,
+} from "./stage-chat-view-status.js";
 
 export function initializeStageChatView(
   ctx: StageChatViewContext,
@@ -66,6 +68,9 @@ export function initializeStageChatView(
   ctx.promptScrollOffset = 0;
   ctx.promptMaxScroll = 0;
   ctx.localPaused = false;
+  ctx.mouseScrollCaptureEnabled = true;
+  ctx.lastObservedStageStatus = undefined;
+  ctx.lastObservedRunStatus = undefined;
   ctx.seenNoticeIds = new Set<string>();
   ctx._unsubscribeStore = null;
   ctx._unsubscribeHandle = null;
@@ -82,16 +87,18 @@ export function initializeStageChatView(
   });
 
   snapshotMessagesFromHandle(ctx);
-  const initialStage = currentStage(ctx);
+  const initialRun = currentRun(ctx);
+  const initialStage = initialRun?.stages.find((s) => s.id === ctx.stageId);
+  ctx.lastObservedRunStatus = initialRun?.status;
+  ctx.lastObservedStageStatus = initialStage?.status;
   snapshotMessagesFromSessionFile(ctx, initialStage);
   absorbStageNotices(ctx, initialStage);
   syncPromptState(ctx, initialStage?.pendingPrompt);
+  if (isTerminalStageChatState(initialRun?.status) || isTerminalStageChatState(initialStage?.status)) ctx.chatHost.clearBusyForTerminalWorkflowStage();
   ctx._unsubscribeStore = ctx.store.subscribe(() => handleStoreUpdate(ctx));
 
   if (ctx.handle) {
-    ctx._unsubscribeHandle = ctx.handle.subscribe((event) => {
-      ctx.chatHost.applyAgentEvent(event);
-    });
+    ctx._unsubscribeHandle = ctx.handle.subscribe((event) => applyStageChatLiveHandleEvent(ctx, event));
   }
   ctx.chatHost.syncAnimationTick();
 }
@@ -171,7 +178,7 @@ function createChatHost(
     isBashRunning: () => liveHandle(ctx)?.agentSession?.isBashRunning === true,
     requestRender: opts.requestRender,
     getAgentSession: () => liveHandle(ctx)?.agentSession,
-    isStreaming: () => liveHandle(ctx)?.isStreaming === true,
+    isStreaming: () => isLiveHandleStreaming(ctx),
     isPaused: () => isPaused(ctx),
     isDisabled: () => isBlocked(ctx) || !liveHandle(ctx),
     tui: opts.piTui,
@@ -200,7 +207,10 @@ function chatHostStyle(ctx: StageChatViewContext): ChatSessionHostStyle {
 }
 
 function handleStoreUpdate(ctx: StageChatViewContext): void {
-  const stage = currentStage(ctx);
+  const run = currentRun(ctx);
+  const stage = run?.stages.find((s) => s.id === ctx.stageId);
+  const currentRunStatus = run?.status;
+  const currentStageStatus = stage?.status;
   let changed = false;
   if (stage && stage.status === "paused" && !ctx.localPaused) {
     ctx.localPaused = true;
@@ -215,8 +225,15 @@ function handleStoreUpdate(ctx: StageChatViewContext): void {
   if (promptChanged && ctx.promptState && canSubmitPrompt(ctx, ctx.promptState.prompt.id)) {
     ctx.requestFocus?.();
   }
+  if (isTerminalStageChatTransition(ctx.lastObservedStageStatus, currentStageStatus) || isTerminalStageChatTransition(ctx.lastObservedRunStatus, currentRunStatus)) {
+    ctx.chatHost.clearBusyForTerminalWorkflowStage();
+    changed = true;
+  }
+  ctx.lastObservedRunStatus = currentRunStatus;
+  ctx.lastObservedStageStatus = currentStageStatus;
+  const hadAnimationTick = ctx.chatHost.hasAnimationTick();
   ctx.chatHost.syncAnimationTick();
-  if (changed) ctx.requestRender?.();
+  if (changed || hadAnimationTick !== ctx.chatHost.hasAnimationTick()) ctx.requestRender?.();
 }
 
 function snapshotMessagesFromHandle(ctx: StageChatViewContext): void {
@@ -256,10 +273,12 @@ function absorbStageNotices(
   return changed;
 }
 
+export function currentRun(ctx: StageChatViewContext): RunSnapshot | undefined {
+  return ctx.store.snapshot().runs.find((r) => r.id === ctx.runId);
+}
+
 export function currentStage(ctx: StageChatViewContext): StageSnapshot | undefined {
-  const snap = ctx.store.snapshot();
-  const run = snap.runs.find((r) => r.id === ctx.runId);
-  return run?.stages.find((s) => s.id === ctx.stageId);
+  return currentRun(ctx)?.stages.find((s) => s.id === ctx.stageId);
 }
 
 export function syncPromptState(
@@ -386,14 +405,29 @@ export function viewLineCount(ctx: StageChatViewContext): number {
   return resolveStageChatViewportRows(reported, VIEW_LINE_COUNT);
 }
 
+export { isTerminalOrNonStreamingStageChatStatus } from "./stage-chat-view-status.js";
+
 export function liveHandle(ctx: StageChatViewContext) {
   return ctx.handle?.isDisposed === true ? undefined : ctx.handle;
 }
 
+export function isLiveHandleStreaming(ctx: StageChatViewContext): boolean {
+  const handle = liveHandle(ctx);
+  if (!handle) return false;
+  if (isTerminalOrNonStreamingStageChatStatus(currentRun(ctx)?.status)) return false;
+  if (isTerminalOrNonStreamingStageChatStatus(currentStage(ctx)?.status)) return false;
+  if (isTerminalOrNonStreamingStageChatStatus(handle.status)) return false;
+  return handle.isStreaming === true;
+}
+
 export function isStreaming(ctx: StageChatViewContext): boolean {
   return ctx.chatHost.isStreaming();
 }
 
+export function isAbortableStreamingSession(ctx: StageChatViewContext): boolean {
+  return isLiveHandleStreaming(ctx) || liveHandle(ctx)?.agentSession?.isStreaming === true;
+}
+
 export function isBlocked(ctx: StageChatViewContext): boolean {
   return currentStage(ctx)?.status === "blocked";
 }

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

@@ -0,0 +1,36 @@
+const TERMINAL_OR_NON_STREAMING_STAGE_CHAT_STATUSES = new Set<string>([
+  "success",
+  "complete",
+  "completed",
+  "failure",
+  "failed",
+  "error",
+  "cancellation",
+  "cancelled",
+  "canceled",
+  "paused",
+  "detached",
+  "killed",
+  "stopped",
+  "no-longer-running",
+  "skipped",
+  "blocked",
+]);
+
+export function isTerminalOrNonStreamingStageChatStatus(
+  status: string | undefined,
+): boolean {
+  return status !== undefined && TERMINAL_OR_NON_STREAMING_STAGE_CHAT_STATUSES.has(status);
+}
+
+export function isTerminalStageChatTransition(
+  previousStatus: string | undefined,
+  currentStatus: string | undefined,
+): boolean {
+  return !isTerminalOrNonStreamingStageChatStatus(previousStatus) &&
+    isTerminalOrNonStreamingStageChatStatus(currentStatus);
+}
+
+export function isTerminalStageChatState(status: string | undefined): boolean {
+  return isTerminalOrNonStreamingStageChatStatus(status);
+}