@bastani/atomic 0.8.21 → 0.8.22-0

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

@@ -10,7 +10,7 @@
  *  - input reuses the host's custom editor factory when one is installed,
  *    otherwise `CustomEditor`; tests/headless fall back to the historical
  *    one-line editor
- *  - workflow notices remain lightweight workflow-specific rows because they
+ *  - workflow notices render as compact workflow-specific cards because they
  *    are not coding-agent chat messages
  *
  * Behaviour:
@@ -66,8 +66,9 @@ import {
 import type { PendingPrompt, StageNotice, StageSnapshot, StageStatus } from "../shared/store-types.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { StageControlHandle } from "../runs/foreground/stage-control-registry.js";
-import { isKeybindingsLike } from "./keybindings-adapter.js";
+import { isKeybindingsLike, type KeybindingsLike } from "./keybindings-adapter.js";
 import { BOLD, RESET, hexBg, hexToAnsi, lerpColor } from "./color-utils.js";
+import { renderWorkflowNoticeCard, type WorkflowNoticeTone } from "./workflow-notice-card.js";
 import { Key, matchesKey, visibleWidth } from "./text-helpers.js";
 import {
   fitStageChatFrame,
@@ -78,6 +79,7 @@ import {
   createPromptCardState,
   defaultResponseFor,
   handlePromptCardInput,
+  isPromptEscapeInput,
   renderPromptCard,
   type PromptCardState,
 } from "./prompt-card.js";
@@ -104,7 +106,7 @@ export interface StageChatViewOpts {
    */
   handle?: StageControlHandle;
   /** Called when the user presses Ctrl+D outside a paused stage (back to graph). */
-  onDetach: () => void;
+  onDetach: (reason?: StageChatDetachReason, metadata?: StageChatDetachMetadata) => void;
   /** Called when the user presses Escape (close the whole popup). */
   onClose: () => void;
   /** Request a host TUI repaint after SDK events mutate local chat state. */
@@ -141,6 +143,12 @@ export interface StageChatViewOpts {
   getViewportRows?: () => number | undefined;
   /** Broker that routes stage-local custom UI, such as ask_user_question, into this node. */
   stageUiBroker?: StageUiBroker;
+  /**
+   * Ownership guard for prompt submission. The attach shell uses this to ensure
+   * stale/hidden/non-active stage-chat instances cannot settle a prompt unless
+   * the user is currently attached to this exact workflow node.
+   */
+  canSubmitPrompt?: (runId: string, stageId: string, promptId: string) => boolean;
 }
 
 /**
@@ -148,6 +156,12 @@ export interface StageChatViewOpts {
  * that read `_transcript` (tests, future serialisers) can recover the
  * canonical user-visible string without knowing about the Pi-box payload.
  */
+export type StageChatDetachReason = "user" | "prompt-resolved";
+
+export interface StageChatDetachMetadata {
+  readonly suppressNextGraphSubmit?: boolean;
+}
+
 interface NoticeEntry {
   readonly role: "notice";
   readonly text: string;
@@ -158,7 +172,6 @@ interface NoticeEntry {
   readonly meta?: string;
 }
 type TranscriptEntry = NoticeEntry | ChatMessageEntry;
-type AgentSnapshotMessage = AgentSession["messages"][number];
 
 // ---------------------------------------------------------------------------
 // Frame budget
@@ -193,7 +206,7 @@ export class StageChatView implements Component, Focusable {
   private stageId: string;
   private workflowName: string;
   private handle: StageControlHandle | undefined;
-  private onDetach: () => void;
+  private onDetach: (reason?: StageChatDetachReason, metadata?: StageChatDetachMetadata) => void;
   private onClose: () => void;
   private requestRender: (() => void) | undefined;
   private requestFocus: (() => void) | undefined;
@@ -205,17 +218,15 @@ export class StageChatView implements Component, Focusable {
   private piEditorFactory?: StageChatViewOpts["piEditorFactory"];
   private chatHost: ChatSessionHost<NoticeEntry>;
   private stageUiBroker: StageUiBroker;
+  private canSubmitPrompt?: (runId: string, stageId: string, promptId: string) => boolean;
   private mountedCustomUi: MountedStageCustomUi | null = null;
   private mountingRequestId: string | null = null;
   private promptState: PromptCardState | null = null;
   private promptEditor: EditorComponent | null = null;
   private promptEditorPromptId: string | null = null;
+  private promptEditorSubmitFromEnter = false;
   private promptScrollOffset = 0;
   private promptMaxScroll = 0;
-  private getChatRenderSettings?: () =>
-    | Partial<Omit<ChatMessageRenderOptions, "ui" | "cwd">>
-    | undefined;
-  private footerData?: ReadonlyFooterDataProvider;
 
   /** True while a pending pause request is in flight (between ctrl+p and resolve). */
   private localPaused = false;
@@ -260,9 +271,8 @@ export class StageChatView implements Component, Focusable {
     this.piTheme = opts.piTheme;
     this.piKeybindings = opts.piKeybindings;
     this.piEditorFactory = opts.piEditorFactory;
-    this.getChatRenderSettings = opts.getChatRenderSettings;
-    this.footerData = opts.footerData;
     this.stageUiBroker = opts.stageUiBroker ?? stageUiBroker;
+    this.canSubmitPrompt = opts.canSubmitPrompt;
     this.chatHost = new ChatSessionHost<NoticeEntry>({
       style: this._chatHostStyle(),
       commands: {
@@ -364,7 +374,11 @@ export class StageChatView implements Component, Focusable {
       // `stage.setModel`, `stage.compact`, …) so they thread through the
       // transcript without a special render path.
       changed = this._absorbStageNotices(stage) || changed;
-      changed = this._syncPromptState(stage?.pendingPrompt) || changed;
+      const promptChanged = this._syncPromptState(stage?.pendingPrompt);
+      changed = promptChanged || changed;
+      if (promptChanged && this.promptState && this._canSubmitPrompt(this.promptState.prompt.id)) {
+        this.requestFocus?.();
+      }
       this.chatHost.syncAnimationTick();
       if (changed) this.requestRender?.();
     });
@@ -406,7 +420,7 @@ export class StageChatView implements Component, Focusable {
       this.mountingRequestId = null;
       this.stageUiBroker.reject(
         request,
-        new Error("pi-workflows: stage custom UI cannot mount without attached TUI host"),
+        new Error("atomic-workflows: stage custom UI cannot mount without attached TUI host"),
       );
       return;
     }
@@ -425,6 +439,7 @@ export class StageChatView implements Component, Focusable {
           this.chatHost.scrollToBottom();
           this.requestRender?.();
         },
+        () => this._canSubmitPrompt(request.id),
       );
       // Settled or superseded while mounting: drop the freshly-built component
       // instead of showing a gate the broker has already torn down.
@@ -494,23 +509,30 @@ export class StageChatView implements Component, Focusable {
 
   private _syncPromptState(prompt: PendingPrompt | undefined): boolean {
     if (!prompt) {
-      const changed = this.promptState !== null;
+      const hadLivePrompt =
+        this.promptState !== null ||
+        this.promptEditor !== null ||
+        this.promptEditorPromptId !== null;
+      if (!hadLivePrompt) return false;
       this.promptState = null;
       this._disposePromptEditor();
-      this.promptScrollOffset = 0;
-      this.promptMaxScroll = 0;
-      return changed;
+      this._resetPromptScroll();
+      return true;
     }
     if (!this.promptState || this.promptState.prompt.id !== prompt.id) {
       this.promptState = createPromptCardState(prompt);
       this._resetPromptEditor(prompt);
-      this.promptScrollOffset = 0;
-      this.promptMaxScroll = 0;
+      this._resetPromptScroll();
       return true;
     }
     return false;
   }
 
+  private _resetPromptScroll(): void {
+    this.promptScrollOffset = 0;
+    this.promptMaxScroll = 0;
+  }
+
   private _resetPromptEditor(prompt: PendingPrompt): void {
     this._disposePromptEditor();
     if ((prompt.kind !== "input" && prompt.kind !== "editor") || !this.piTui) return;
@@ -527,7 +549,9 @@ export class StageChatView implements Component, Focusable {
       this.requestRender?.();
     };
     editor.onSubmit = (text: string) => {
-      this._resolvePromptResponse(prompt.id, text);
+      this._resolvePromptResponse(prompt.id, text, {
+        suppressNextGraphSubmit: this.promptEditorSubmitFromEnter,
+      });
     };
     this.promptEditor = editor;
     this.promptEditorPromptId = prompt.id;
@@ -541,17 +565,27 @@ export class StageChatView implements Component, Focusable {
     disposable?.dispose?.();
   }
 
-  private _resolvePromptResponse(promptId: string, response: unknown): void {
+  private _resolvePromptResponse(
+    promptId: string,
+    response: unknown,
+    metadata: StageChatDetachMetadata = {},
+  ): void {
     const prompt = this.promptState?.prompt;
     if (!prompt || prompt.id !== promptId) return;
+    if (!this._canSubmitPrompt(promptId)) {
+      this.requestRender?.();
+      return;
+    }
     this.promptState = null;
     this._disposePromptEditor();
+    this._resetPromptScroll();
     // A false return means the prompt was already resolved/removed (for
     // example by run abort). The local UI is already stale, so clearing it is
-    // the least surprising recovery path.
-    this.store.resolveStagePendingPrompt(this.runId, this.stageId, prompt.id, response);
+    // the least surprising recovery path, but it must not trigger graph-mode
+    // transition side effects for a prompt this view did not actually settle.
+    const resolved = this.store.resolveStagePendingPrompt(this.runId, this.stageId, prompt.id, response);
     this.requestRender?.();
-    this.onDetach();
+    if (resolved) this.onDetach("prompt-resolved", metadata);
   }
 
   // -------------------------------------------------------------------------
@@ -660,13 +694,12 @@ export class StageChatView implements Component, Focusable {
       editorRows: customUiActive ? customUiLines.length : editorLines.length,
       footerRows: footerLines.length,
     });
-    const visiblePendingLines = pendingLines.slice(0, plan.pendingRows);
-    const visibleWorkingLines = workingLines.slice(0, plan.workingRows);
-    const visibleUsageLines = usageLines.slice(0, plan.usageRows);
-    const visibleEditorLines = customUiActive
-      ? customUiLines.slice(0, plan.editorRows)
-      : editorLines.slice(0, plan.editorRows);
-    const visibleFooterLines = footerLines.slice(0, plan.footerRows);
+    const visiblePendingLines = takeRows(pendingLines, plan.pendingRows);
+    const visibleWorkingLines = takeRows(workingLines, plan.workingRows);
+    const visibleUsageLines = takeRows(usageLines, plan.usageRows);
+    const editorSlotLines = customUiActive ? customUiLines : editorLines;
+    const visibleEditorLines = takeRows(editorSlotLines, plan.editorRows);
+    const visibleFooterLines = takeRows(footerLines, plan.footerRows);
     const bodyBudget = plan.bodyRows;
     if (blocked) this.chatHost.scrollToBottom();
 
@@ -675,6 +708,8 @@ export class StageChatView implements Component, Focusable {
       bodyLines = this._renderPromptBody(w, bodyBudget);
     } else if (blocked) {
       bodyLines = this._renderBlockedBody(w, bodyBudget, stage);
+    } else if (!readOnlyArchive && this._isPaused(stage)) {
+      bodyLines = this._renderPausedBody(w, bodyBudget);
     } else if (readOnlyArchive) {
       bodyLines = this._renderReadOnlyArchiveBody(w, bodyBudget, stage);
     } else {
@@ -829,6 +864,7 @@ export class StageChatView implements Component, Focusable {
     bodyLines.push("");
     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) +
@@ -867,6 +903,36 @@ export class StageChatView implements Component, Focusable {
     }
   }
 
+  private _renderPausedBody(width: number, budget: number): string[] {
+    const t = this.theme;
+    const callout: string[] = [];
+    callout.push(this._blank(width));
+    callout.push(
+      ...this._bannerLines(
+        width,
+        "warning",
+        "❚❚",
+        "PAUSED",
+        "enter resumes · ctrl+d close",
+      ),
+    );
+    callout.push(
+      ...new Text(
+        paint("This workflow stage is paused. Type a message below and press Enter to resume.", t.textMuted),
+        2,
+        0,
+      ).render(width),
+    );
+
+    const calloutRows = Math.min(callout.length, Math.max(0, budget - 1));
+    const transcriptBudget = Math.max(1, budget - calloutRows);
+    const lines = this.chatHost.renderBody(width, transcriptBudget);
+    lines.push(...callout.slice(0, calloutRows));
+    while (lines.length < budget) lines.push(this._blank(width));
+    if (lines.length > budget) lines.length = budget;
+    return lines;
+  }
+
   private _renderBlockedBody(
     width: number,
     budget: number,
@@ -977,17 +1043,20 @@ export class StageChatView implements Component, Focusable {
   }
 
   private _noticeRow(entry: NoticeEntry): Component {
-    const t = this.theme;
-    const fromPart = entry.from ? paint(` (was ${entry.from})`, t.dim) : "";
-    const metaPart = entry.meta ? "  " + paint(entry.meta, t.dim) : "";
-    const line =
-      paint("~ ", t.borderDim) +
-      paint(entry.kind, t.mauve, { bold: true }) +
-      paint(" → ", t.borderDim) +
-      paint(entry.value, t.text) +
-      fromPart +
-      metaPart;
-    return new Text(line, 2, 0);
+    const theme = this.theme;
+    return {
+      render(width: number): string[] {
+        return renderWorkflowNoticeCard({
+          ...stageNoticeCard(entry),
+          fallbackText: entry.text,
+          width,
+          theme,
+        });
+      },
+      invalidate() {
+        /* notice entries are immutable */
+      },
+    };
   }
 
   // -------------------------------------------------------------------------
@@ -1072,24 +1141,39 @@ export class StageChatView implements Component, Focusable {
     return true;
   }
 
+  private _promptKeybindings(): KeybindingsLike | undefined {
+    return isKeybindingsLike(this.piKeybindings) ? this.piKeybindings : undefined;
+  }
+
+  private _canSubmitPrompt(promptId: string): boolean {
+    return this.canSubmitPrompt?.(this.runId, this.stageId, promptId) ?? true;
+  }
+
   private _handlePromptInput(data: string): void {
     const state = this.promptState;
     if (!state) return;
     if (this.promptEditor && this.promptEditorPromptId === state.prompt.id) {
-      if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
-        this._resolvePromptResponse(state.prompt.id, defaultResponseFor(state.prompt));
+      if (matchesKey(data, Key.ctrl("c"))) {
+        this._resolvePromptResponse(state.prompt.id, defaultResponseFor(state.prompt), {
+          suppressNextGraphSubmit: false,
+        });
+        return;
+      }
+      if (isPromptEscapeInput(data)) {
+        this.requestRender?.();
         return;
       }
       setEditorFocused(this.promptEditor, this.focused);
-      this.promptEditor.handleInput(data);
+      this.promptEditorSubmitFromEnter = matchesKey(data, Key.enter);
+      try {
+        this.promptEditor.handleInput(data);
+      } finally {
+        this.promptEditorSubmitFromEnter = false;
+      }
       this.requestRender?.();
       return;
     }
-    const action = handlePromptCardInput(
-      data,
-      state,
-      isKeybindingsLike(this.piKeybindings) ? this.piKeybindings : undefined,
-    );
+    const action = handlePromptCardInput(data, state, this._promptKeybindings());
     if (action.kind === "noop") {
       this.requestRender?.();
       return;
@@ -1098,7 +1182,9 @@ export class StageChatView implements Component, Focusable {
     const response = action.kind === "submit"
       ? action.response
       : defaultResponseFor(prompt);
-    this._resolvePromptResponse(prompt.id, response);
+    this._resolvePromptResponse(prompt.id, response, {
+      suppressNextGraphSubmit: action.kind === "submit" && matchesKey(data, Key.enter),
+    });
   }
 
   // -------------------------------------------------------------------------
@@ -1107,6 +1193,10 @@ export class StageChatView implements Component, Focusable {
 
   handleInput(data: string): boolean {
     if (this.mountedCustomUi) {
+      if (!this._canSubmitPrompt(this.mountedCustomUi.request.id)) {
+        this.requestRender?.();
+        return true;
+      }
       if (matchesKey(data, Key.ctrl("d"))) {
         // Detach stops *viewing* the stage; it does not cancel a pending
         // human-input request. Release the local display only — the request
@@ -1137,7 +1227,10 @@ export class StageChatView implements Component, Focusable {
       this.requestRender?.();
       return true;
     }
-    this._syncPromptState(this._currentStage()?.pendingPrompt);
+    const stage = this._currentStage();
+    this._syncPromptState(stage?.pendingPrompt);
+    const readOnlyArchive = this._isReadOnlyArchive(stage);
+    const readOnlyPromptArchive = readOnlyArchive && stage?.promptFootprint !== undefined;
     if (matchesKey(data, Key.ctrl("d"))) {
       if (!this.promptState && this.chatHost.hasInputText()) return this.chatHost.handleInput(data);
       if (this._isPaused()) this.onClose();
@@ -1149,6 +1242,9 @@ export class StageChatView implements Component, Focusable {
       this._handlePromptInput(data);
       return true;
     }
+    if (readOnlyPromptArchive && this._handlePromptScrollInput(data, true)) {
+      return true;
+    }
     if (this.chatHost.handleScrollInput(data)) {
       return true;
     }
@@ -1167,7 +1263,6 @@ export class StageChatView implements Component, Focusable {
       this.onClose();
       return true;
     }
-    const readOnlyArchive = this._isReadOnlyArchive();
     if (readOnlyArchive) return true;
     const blocked = this._isBlocked();
     if (matchesKey(data, Key.ctrl("f"))) {
@@ -1502,6 +1597,78 @@ function noticeSummary(n: StageNotice): string {
   return n.from ? `${base} (was ${n.from})` : base;
 }
 
+function stageNoticeCard(entry: NoticeEntry): {
+  title: string;
+  glyph: string;
+  headline: string;
+  tone: WorkflowNoticeTone;
+  fields: Array<{ label: string; value: string | undefined; tone?: WorkflowNoticeTone | "text" | "muted" }>;
+} {
+  switch (entry.kind) {
+    case "abort":
+      return {
+        title: "STAGE ABORTED",
+        glyph: "✗",
+        headline: "Stage received an abort notice",
+        tone: "error",
+        fields: stageNoticeFields(entry, "error"),
+      };
+    case "compaction":
+      return {
+        title: "STAGE COMPACTION",
+        glyph: "✓",
+        headline: "Stage context was compacted",
+        tone: "success",
+        fields: stageNoticeFields(entry, "muted"),
+      };
+    case "model":
+      return {
+        title: "STAGE MODEL",
+        glyph: "→",
+        headline: "Stage model changed",
+        tone: "info",
+        fields: stageNoticeFields(entry),
+      };
+    case "thinking":
+      return {
+        title: "STAGE THINKING",
+        glyph: "→",
+        headline: "Stage thinking level changed",
+        tone: "mauve",
+        fields: stageNoticeFields(entry),
+      };
+    case "tree":
+      return {
+        title: "STAGE TREE",
+        glyph: "◆",
+        headline: "Stage branch tree changed",
+        tone: "info",
+        fields: stageNoticeFields(entry, "muted"),
+      };
+    case "mcp":
+    default:
+      return {
+        title: "STAGE NOTICE",
+        glyph: "◆",
+        headline: "Workflow stage notice",
+        tone: "info",
+        fields: stageNoticeFields(entry, "muted"),
+      };
+  }
+}
+
+function stageNoticeFields(
+  entry: NoticeEntry,
+  valueTone: WorkflowNoticeTone | "text" | "muted" = "text",
+): Array<{ label: string; value: string | undefined; tone?: WorkflowNoticeTone | "text" | "muted" }> {
+  return [
+    { label: "kind", value: entry.kind, tone: "muted" },
+    { label: "value", value: entry.value, tone: valueTone },
+    { label: "from", value: entry.from, tone: "muted" },
+    { label: "meta", value: entry.meta, tone: "muted" },
+  ];
+}
+
 function shortenId(id: string): string {
   return id.length > 10 ? id.slice(0, 8) : id;
 }
@@ -1528,6 +1695,10 @@ function editorThemeFromGraphTheme(t: GraphTheme): EditorTheme {
   } as EditorTheme;
 }
 
+function takeRows(lines: readonly string[], rows: number): string[] {
+  return lines.slice(0, rows);
+}
+
 interface PaintOpts {
   bold?: boolean;
   italic?: boolean;
@@ -1545,9 +1716,9 @@ function paint(text: string, fg: string, opts: PaintOpts = {}): string {
 
 function renderHintsForPrompt(kind: PendingPrompt["kind"], theme: GraphTheme): string {
   if (kind === "input" || kind === "editor") {
-    return `${paint("enter", theme.textMuted, { bold: true })} Submit · ${paint("esc/ctrl+c", theme.textMuted, { bold: true })} Skip`;
+    return `${paint("enter", theme.textMuted, { bold: true })} Submit · ${paint("ctrl+c", theme.textMuted, { bold: true })} Skip`;
   }
-  return `${paint("enter", theme.textMuted, { bold: true })} Select · ${paint("esc/ctrl+c", theme.textMuted, { bold: true })} Skip`;
+  return `${paint("enter", theme.textMuted, { bold: true })} Select · ${paint("ctrl+c", theme.textMuted, { bold: true })} Skip`;
 }
 
 /**

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

@@ -41,6 +41,8 @@ export function statusIcon(status: StageStatus | RunStatus): string {
   switch (status) {
     case "pending":
       return "○";
+    case "awaiting_input":
+      return "？";
     case "blocked":
       return "↑";
     case "skipped":