@bastani/atomic 0.9.2 → 0.9.3-alpha.2

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);
+}

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

@@ -11,7 +11,7 @@ import type {
   MountedStageCustomUi,
   StageUiBroker,
 } from "../shared/stage-ui-broker.js";
-import type { StageNotice, StageStatus } from "../shared/store-types.js";
+import type { RunStatus, StageNotice, StageStatus } from "../shared/store-types.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { PromptCardState } from "./prompt-card.js";
 
@@ -19,6 +19,7 @@ export const VIEW_LINE_COUNT = 32;
 export const PROMPT_SCROLL_STEP_ROWS = 4;
 export const HEADER_ROWS = 1;
 export const SEP_ROWS = 1;
+export const STAGE_CHAT_MOUSE_SCROLL_TOGGLE_LABEL = "ctrl+t";
 
 export function isReadOnlyArchiveStatus(status: StageStatus): boolean {
   return status === "completed" || status === "failed" || status === "skipped";
@@ -144,6 +145,9 @@ export interface StageChatViewContext {
   promptScrollOffset: number;
   promptMaxScroll: number;
   localPaused: boolean;
+  mouseScrollCaptureEnabled: boolean;
+  lastObservedStageStatus: StageStatus | undefined;
+  lastObservedRunStatus: RunStatus | undefined;
   seenNoticeIds: Set<string>;
   _unsubscribeStore: (() => void) | null;
   _unsubscribeHandle: (() => void) | null;

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

@@ -95,6 +95,7 @@ export class StageChatView implements Component, Focusable {
   private promptScrollOffset!: StageChatViewContext["promptScrollOffset"];
   private promptMaxScroll!: StageChatViewContext["promptMaxScroll"];
   private localPaused!: StageChatViewContext["localPaused"];
+  private mouseScrollCaptureEnabled!: StageChatViewContext["mouseScrollCaptureEnabled"];
   private seenNoticeIds!: StageChatViewContext["seenNoticeIds"];
   private _unsubscribeStore!: StageChatViewContext["_unsubscribeStore"];
   private _unsubscribeHandle!: StageChatViewContext["_unsubscribeHandle"];
@@ -177,7 +178,7 @@ export class StageChatView implements Component, Focusable {
   }
 
   wantsMouseScrollTracking(): boolean {
-    return true;
+    return this.mouseScrollCaptureEnabled;
   }
 
   handleInput(data: string): boolean {
@@ -220,6 +221,7 @@ export class StageChatView implements Component, Focusable {
     void this.promptEditorSubmitFromEnter;
     void this.promptScrollOffset;
     void this.promptMaxScroll;
+    void this.mouseScrollCaptureEnabled;
     void this.seenNoticeIds;
     void this._unsubscribeStore;
     void this._unsubscribeHandle;

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

@@ -56,6 +56,10 @@ export interface RenderStatusListOpts {
   width?: number;
 }
 
+function isQuitRun(run: RunSnapshot): boolean {
+  return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
+}
+
 /**
  * Render a list of run snapshots as the canonical rounded `BACKGROUND`
  * surface: one panel plus one card per run.
@@ -157,6 +161,7 @@ function renderRunEntry(
 
 function runAccent(run: RunSnapshot, theme?: GraphTheme): string {
   if (!theme) return "#000000";
+  if (isQuitRun(run)) return theme.warning;
   switch (run.status) {
     case "completed": return theme.success;
     case "running":   return theme.warning;
@@ -172,6 +177,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) {
     case "completed": return { text: "✓ completed", fg: theme?.success };
     case "running":   return { text: "● running", fg: theme?.warning };
@@ -205,6 +211,7 @@ function runCardMeta(run: RunSnapshot, now: number): string {
       ? fmtDuration(elapsedRunMs(run, now))
       : undefined;
 
+  if (isQuitRun(run)) return "resumable via /workflow resume";
   if (run.status === "running") {
     if (isChain) parts.push(`${done}/${total}`);
     const labels = runningStageLabels(run);
@@ -315,15 +322,17 @@ function effectiveWidth(width?: number): number {
 interface Counts {
   active: number;
   paused: number;
+  quit: number;
   completed: number;
   failed: number;
   pending: number;
 }
 
 function countBuckets(runs: readonly RunSnapshot[]): Counts {
-  const c: Counts = { active: 0, paused: 0, completed: 0, failed: 0, pending: 0 };
+  const c: Counts = { active: 0, paused: 0, quit: 0, completed: 0, failed: 0, pending: 0 };
   for (const r of runs) {
-    if (r.endedAt === undefined) {
+    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++;
@@ -343,6 +352,7 @@ function themedBadges(c: Counts, theme: GraphTheme): FlatBandBadge[] {
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
   if (c.paused > 0) out.push({ text: `❚❚ ${c.paused} paused`, fg: theme.warning });
+  if (c.quit > 0) out.push({ text: `${c.quit} quit`, fg: theme.warning });
   if (c.pending > 0) out.push({ text: `○ ${c.pending}`, fg: theme.dim });
   if (c.failed > 0) out.push({ text: `⊘ ${c.failed}`, fg: theme.error });
   return out;
@@ -355,6 +365,7 @@ function plainBadges(c: Counts): FlatBandBadge[] {
   // Keep the word label: the pause glyph is less familiar than the other
   // status glyphs, so this intentional asymmetry improves scanability.
   if (c.paused > 0) out.push({ text: `❚❚ ${c.paused} paused` });
+  if (c.quit > 0) out.push({ text: `${c.quit} quit` });
   if (c.pending > 0) out.push({ text: `○ ${c.pending}` });
   if (c.failed > 0) out.push({ text: `⊘ ${c.failed}` });
   return out;
@@ -381,6 +392,7 @@ function emptyStateLine(theme?: GraphTheme): string {
 }
 
 function statusIconForRun(run: RunSnapshot): string {
+  if (isQuitRun(run)) return "○";
   switch (run.status) {
     case "completed": return "✓";
     case "skipped": return "⊘";

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

@@ -73,9 +73,14 @@ function recentlyEnded(run: RunSnapshot, now: number): boolean {
   return run.endedAt !== undefined && now - run.endedAt <= RECENT_ENDED_WINDOW_MS;
 }
 
+function isQuitRun(run: RunSnapshot): boolean {
+  return run.endedAt === undefined && run.status === "paused" && run.exitReason === "quit";
+}
+
 interface RunCounts {
   active: number;
   paused: number;
+  quit: number;
   done: number;
   failed: number;
   /** Runs with a pending HIL prompt — surfaced as a separate badge so the
@@ -106,9 +111,10 @@ function countRuns(
   runs: readonly RunSnapshot[],
   allRuns: readonly RunSnapshot[] = runs,
 ): RunCounts {
-  const counts: RunCounts = { active: 0, paused: 0, done: 0, failed: 0, awaiting: 0 };
+  const counts: RunCounts = { active: 0, paused: 0, quit: 0, done: 0, failed: 0, awaiting: 0 };
   for (const r of runs) {
-    if (r.endedAt === undefined && r.status === "paused") counts.paused++;
+    if (isQuitRun(r)) counts.quit++;
+    else if (r.endedAt === undefined && r.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++;
@@ -165,6 +171,7 @@ function shortId(run: RunSnapshot): string {
 }
 
 function statusGlyph(run: RunSnapshot): string {
+  if (isQuitRun(run)) return "○";
   switch (run.status) {
     case "running":
       return "●";
@@ -188,6 +195,7 @@ function statusGlyph(run: RunSnapshot): string {
 }
 
 function statusFg(run: RunSnapshot, theme: GraphTheme): string {
+  if (isQuitRun(run)) return theme.warning;
   switch (run.status) {
     case "running":
     case "paused":
@@ -237,6 +245,7 @@ function metaLine(run: RunSnapshot, now: number): string {
   if (run.endedAt !== undefined) {
     return elapsedLabel(run, now);
   }
+  if (isQuitRun(run)) return "quit · resumable via /workflow resume";
   const parts: string[] = [modeLabel(run)];
   const prog = progressLabel(run);
   if (prog) parts.push(prog);
@@ -257,6 +266,9 @@ function countBadges(counts: RunCounts, theme: GraphTheme): FlatBandBadge[] {
   if (counts.paused > 0) {
     badges.push({ text: `❚❚ ${counts.paused} paused`, fg: theme.warning });
   }
+  if (counts.quit > 0) {
+    badges.push({ text: `${counts.quit} quit`, fg: theme.warning });
+  }
   // Awaiting input is shown in Sky per DESIGN.md status semantics: a live
   // human-in-the-loop request that requires attention. Mirror the graph node's
   // question-mark status glyph, then keep ↵ as the attach/respond action hint.
@@ -332,16 +344,18 @@ function themedCollapsed(
   const dim = hexToAnsi(theme.dim);
   const muted = hexToAnsi(theme.textMuted);
   const warning = hexToAnsi(theme.warning);
-  const total = counts.active + counts.paused + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
   const active = counts.active;
   const paused = counts.paused > 0 ? `${dim} · ${RESET}${warning}${counts.paused} ❚❚${RESET}` : "";
-  return ` ${mauve}▾${RESET}  ${muted}${total} background${RESET}${dim} · ${RESET}${warning}${active} ●${RESET}${paused}`;
+  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}`;
 }
 
 function plainCollapsed(counts: RunCounts): string {
-  const total = counts.active + counts.paused + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
   const paused = counts.paused > 0 ? ` · ${counts.paused} ❚❚` : "";
-  return ` ▾  ${total} background · ${counts.active} ●${paused}`;
+  const quit = counts.quit > 0 ? ` · ${counts.quit} quit` : "";
+  return ` ▾  ${total} background · ${counts.active} ●${paused}${quit}`;
 }
 
 // ---------------------------------------------------------------------------
@@ -372,7 +386,8 @@ export function buildThemedWidgetLines(
   // 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").length,
+    paused: display.filter((r) => r.endedAt === undefined && r.status === "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,
     awaiting: counts.awaiting,
@@ -386,7 +401,7 @@ export function buildThemedWidgetLines(
     return [themed ? themedCollapsed(visibleCounts, graphTheme) : plainCollapsed(visibleCounts)];
   }
 
-  const total = counts.active + counts.paused + counts.done + counts.failed;
+  const total = counts.active + counts.paused + counts.quit + counts.done + counts.failed;
   const subtitle = `${total} run${total === 1 ? "" : "s"}`;
 
   const badgeList = countBadges(visibleCounts, graphTheme);

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

@@ -29,8 +29,8 @@ export interface WorkflowAttachPaneOpts {
   onClose: () => void;
   /** Called when the user requests the host to hide the popup. */
   onHide?: () => void;
-  /** Called when the user kills the active run (q in graph mode). */
-  onKill?: (runId: string) => 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. */
@@ -73,8 +73,9 @@ export interface WorkflowAttachPaneOpts {
   requestFocus?: () => void;
   /**
    * Host hook for terminal mouse reporting. Graph mode uses wheel input
-   * for canvas scrolling; stage-chat mode uses it for transcript history
-   * scrolling and drops non-wheel mouse bytes before they reach the editor.
+   * for canvas scrolling. Stage-chat mode captures wheel input by default so
+   * transcript/prompt scrolling stays inside the active workflow chat; ctrl+t
+   * toggles copy mode, which disables capture for terminal text selection.
    */
   setMouseScrollTracking?: (enabled: boolean) => void;
   /** Optional clock injection for deterministic transition-quarantine tests. */

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

@@ -19,7 +19,6 @@
  *  - src/tui/stage-chat-view.ts (chat mode Component)
  *  - src/runs/foreground/stage-control-registry.ts (live handles)
  */
-
 import type { Component, EditorComponent, EditorTheme, TUI } from "@earendil-works/pi-tui";
 import type { ChatMessageRenderOptions, ReadonlyFooterDataProvider } from "@bastani/atomic";
 import type { Store } from "../shared/store.js";
@@ -39,7 +38,6 @@ 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";
-
 /**
  * Surface used to write Pi's footer/status tag while the attach pane is
  * mounted. Passing `undefined` clears the slot — required on dispose so
@@ -50,7 +48,6 @@ import { WORKFLOW_STATUS_KEY } from "./workflow-status.js";
  */
 import type { AttachUiStatusSurface, WorkflowAttachPaneMode, WorkflowAttachPaneOpts } from "./workflow-attach-pane-types.js";
 const ENTER_TRANSITION_QUARANTINE_MS = 200;
-
 export class WorkflowAttachPane implements Component {
   private store: Store;
   private theme: GraphTheme;
@@ -60,7 +57,7 @@ export class WorkflowAttachPane implements Component {
   private uiStatus: AttachUiStatusSurface | undefined;
   private onClose: () => void;
   private onHide?: () => void;
-  private onKill?: (runId: string) => void;
+  private onQuit?: (runId: string) => void;
   private onPromptResolve?: (runId: string, promptId: string, response: unknown) => void;
   private getViewportRows?: () => number | undefined;
   private hostRequestRender?: () => void;
@@ -73,7 +70,6 @@ export class WorkflowAttachPane implements Component {
   private getChatRenderSettings?: () => Partial<Omit<ChatMessageRenderOptions, "ui" | "cwd">> | undefined;
   private footerData?: ReadonlyFooterDataProvider;
   private now: () => number;
-
   private mode: WorkflowAttachPaneMode = "graph";
   private visible = true;
   private graphView: GraphView;
@@ -97,7 +93,7 @@ export class WorkflowAttachPane implements Component {
     this.uiStatus = opts.uiStatus;
     this.onClose = opts.onClose;
     this.onHide = opts.onHide;
-    this.onKill = opts.onKill;
+    this.onQuit = opts.onQuit;
     this.onPromptResolve = opts.onPromptResolve;
     this.getViewportRows = opts.getViewportRows;
     this.hostRequestRender = opts.requestRender;
@@ -130,7 +126,7 @@ export class WorkflowAttachPane implements Component {
       graphTheme: this.theme,
       onClose: this.onClose,
       onHide: this.onHide,
-      onKill: this.onKill,
+      onQuit: this.onQuit,
       onPromptResolve: this.onPromptResolve,
       onStageAttach: (runId, stageId) => this._attachToStage(runId, stageId, {
         suppressInitialPromptSubmit: true,
@@ -366,7 +362,11 @@ export class WorkflowAttachPane implements Component {
     if (!this.visible) return false;
     if (this.mode === "stage-chat" && this.chatView) {
       if (this._shouldQuarantineStagePromptEnter(data)) return true;
-      return this.chatView.handleInput(data);
+      const beforeMouseTracking = this.chatView.wantsMouseScrollTracking();
+      const handled = this.chatView.handleInput(data);
+      const afterMouseTracking = this.chatView?.wantsMouseScrollTracking();
+      if (afterMouseTracking !== undefined && afterMouseTracking !== beforeMouseTracking) this._syncMouseScrollTracking();
+      return handled;
     }
     if (this._shouldQuarantineGraphEnter(data)) return true;
     return this.graphView.handleInput(data);