@bastani/atomic 0.8.20-0 → 0.8.21-0

package/dist/builtin/workflows/src/shared/store.ts

@@ -7,6 +7,7 @@ import type {
   PendingPrompt,
   PromptKind,
   RunSnapshot,
+  StageInputRequest,
   StageSnapshot,
   StageNotice,
   StoreSnapshot,
@@ -177,6 +178,16 @@ export interface Store {
    * or restore it to running after the tool resolves.
    */
   recordStageAwaitingInput(runId: string, stageId: string, awaiting: boolean, ts?: number): boolean;
+  /**
+   * Record the serializable descriptor of a brokered structured prompt
+   * (`ask_user_question` / readiness gate) awaiting an answer on a stage.
+   * Surfaces the questions/options on the snapshot so `workflow send` and
+   * status inspection can answer the prompt headlessly. Resolution itself lives
+   * in `StageUiBroker`. Returns `true` when the descriptor changed.
+   */
+  recordStageInputRequest(runId: string, stageId: string, request: StageInputRequest): boolean;
+  /** Clear a stage's brokered structured-prompt descriptor. Returns `true` when one was present. */
+  clearStageInputRequest(runId: string, stageId: string): boolean;
   /**
    * Mark a stage as `paused` and record `pausedAt`. Returns `true` when
    * the stage transitioned (was not already paused, blocked, or terminal).
@@ -373,6 +384,7 @@ export function createStore(): Store {
       if (stage.replayedFromStageId !== undefined) existing.replayedFromStageId = stage.replayedFromStageId;
       if (stage.replayed !== undefined) existing.replayed = stage.replayed;
       delete existing.awaitingInputSince;
+      delete existing.inputRequest;
       rejectStagePrompt(existing, `pi-workflows: stage ${stage.id} ended before prompt resolved`);
       _version++;
       notify();
@@ -697,6 +709,31 @@ export function createStore(): Store {
       return true;
     },
 
+    recordStageInputRequest(runId: string, stageId: string, request: StageInputRequest): boolean {
+      const run = findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      const stage = findStage(run, stageId);
+      if (!stage) return false;
+      if (isTerminalStageStatus(stage.status)) return false;
+      if (stage.inputRequest?.id === request.id) return false;
+      stage.inputRequest = { ...request };
+      _version++;
+      notify();
+      return true;
+    },
+
+    clearStageInputRequest(runId: string, stageId: string): boolean {
+      const run = findRun(runId);
+      if (!run) return false;
+      const stage = findStage(run, stageId);
+      if (!stage || stage.inputRequest === undefined) return false;
+      delete stage.inputRequest;
+      _version++;
+      notify();
+      return true;
+    },
+
     recordStageBlocked(runId: string, stageId: string, blockedBy: string): boolean {
       const run = findRun(runId);
       if (!run) return false;

package/dist/builtin/workflows/src/tui/chat-surface-message.ts

@@ -60,7 +60,9 @@ export interface DispatchPayload {
 /**
  * Status list after `/workflow status`. The snapshot is captured (and
  * `--all`-filtered) at emit time — scrollback entries don't live-update
- * (the orchestrator widget owns live state).
+ * (the orchestrator widget owns live state). The wall-clock used for the
+ * `elapsed` / `running` labels is likewise frozen once per chat entry; see
+ * {@link makeComponent}.
  */
 export interface StatusPayload {
   kind: "status";
@@ -186,12 +188,27 @@ function makeComponent(
   payload: ChatSurfacePayload,
   theme: GraphTheme,
 ): CardComponent {
+  // Capture wall-clock ONCE, when the chat entry's component is created. The
+  // render() lambda below re-runs on every TUI frame: pi-tui's Container.render
+  // fans out to every child on each doRender, and the workflow/subagent live
+  // widgets call requestRender() ~12x/sec while runs are active. Without a
+  // frozen `now`, renderStatusList / renderRunDetail fall through to Date.now()
+  // on each frame, ticking the `elapsed` / `running` labels. Once the entry has
+  // scrolled above the viewport fold, that off-screen change pushes pi-tui's
+  // doRender() into the full-redraw branch (CSI 2J + CSI H + CSI 3J), which
+  // reads as a whole-screen flicker on terminals without synchronized-output
+  // support (notably mosh). Freezing here is also semantically right: these are
+  // point-in-time scrollback snapshots — the orchestrator widget owns live
+  // state. requestRender() never invalidates, so makeComponent runs once per
+  // entry; this mirrors the tool-result renderResult slot fix in
+  // src/extension/index.ts (capture `now` once, reuse it across renders).
+  const capturedNow = Date.now();
   return {
     render(width: number): string[] {
       // pi passes the real chat content width; thread it down to every
       // primitive so band fillers and card gaps land exactly on the
       // right-edge cell. No `process.stdout.columns` heuristic needed.
-      return renderPayload(payload, theme, width).split("\n");
+      return renderPayload(payload, theme, width, capturedNow).split("\n");
     },
     invalidate() {
       /* renders are pure of stored state; nothing to drop. */
@@ -203,6 +220,7 @@ function renderPayload(
   payload: ChatSurfacePayload,
   theme: GraphTheme,
   width: number,
+  now: number,
 ): string {
   switch (payload.kind) {
     case "dispatch":
@@ -214,11 +232,11 @@ function renderPayload(
         width,
       });
     case "status":
-      return renderStatusList(payload.runs, { theme, width });
+      return renderStatusList(payload.runs, { theme, width, now });
     case "list":
       return renderWorkflowList(payload.entries, { theme, width });
     case "detail":
-      return renderRunDetail(payload.detail, { theme, width });
+      return renderRunDetail(payload.detail, { theme, width, now });
     case "killed":
       return renderWorkflowKilledNotice({
         width,

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

@@ -191,6 +191,7 @@ export class GraphView implements Component {
   private graphScrollOffset = 0;
   private graphScrollColOffset = 0;
   private pendingEnsureFocusedVisible = true;
+  private lastAutoFocusedAwaitingInputKey: string | null = null;
 
   private _intervalId: ReturnType<typeof setInterval> | null = null;
   private _lastGTime: number | null = null;
@@ -278,6 +279,17 @@ export class GraphView implements Component {
       }
     }
 
+    const awaitingTarget = this._awaitingInputFocusTarget();
+    if (awaitingTarget) {
+      if (awaitingTarget.key !== this.lastAutoFocusedAwaitingInputKey) {
+        this.focusedIndex = awaitingTarget.index;
+        focusNeedsReveal = true;
+        this.lastAutoFocusedAwaitingInputKey = awaitingTarget.key;
+      }
+    } else {
+      this.lastAutoFocusedAwaitingInputKey = null;
+    }
+
     if (this.cachedLayout.length === 0) {
       this.focusedIndex = 0;
       this.graphScrollOffset = 0;
@@ -290,6 +302,41 @@ export class GraphView implements Component {
     this._syncPromptState(run.pendingPrompt);
   }
 
+  private _awaitingInputFocusTarget(): { index: number; key: string } | null {
+    let newest: { index: number; key: string; createdAt: number } | null = null;
+    for (let index = 0; index < this.cachedLayout.length; index++) {
+      const stage = this.cachedLayout[index]!.stage;
+      const target = this._awaitingInputKey(stage);
+      if (!target) continue;
+      if (!newest || target.createdAt >= newest.createdAt) {
+        newest = { index, key: target.key, createdAt: target.createdAt };
+      }
+    }
+    return newest ? { index: newest.index, key: newest.key } : null;
+  }
+
+  private _awaitingInputKey(stage: StageSnapshot): { key: string; createdAt: number } | null {
+    if (stage.pendingPrompt) {
+      return {
+        key: `prompt:${stage.id}:${stage.pendingPrompt.id}`,
+        createdAt: stage.pendingPrompt.createdAt,
+      };
+    }
+    if (stage.inputRequest) {
+      return {
+        key: `input-request:${stage.id}:${stage.inputRequest.id}`,
+        createdAt: stage.inputRequest.createdAt,
+      };
+    }
+    if (stage.status === "awaiting_input") {
+      return {
+        key: `awaiting:${stage.id}:${stage.awaitingInputSince ?? "active"}`,
+        createdAt: stage.awaitingInputSince ?? stage.startedAt ?? 0,
+      };
+    }
+    return null;
+  }
+
   private _graphStages(run: RunSnapshot): StageSnapshot[] {
     const hasStagePrompt = run.stages.some((stage) => stage.pendingPrompt !== undefined);
     if (!hasStagePrompt) return [...run.stages];

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

@@ -16,6 +16,7 @@
  */
 
 import type { Store } from "../shared/store.js";
+import type { StoreSnapshot } from "../shared/store-types.js";
 import type { ChatMessageRenderOptions, ReadonlyFooterDataProvider } from "@bastani/atomic";
 import { WorkflowAttachPane } from "./workflow-attach-pane.js";
 import { deriveGraphThemeFromPiTheme } from "./graph-theme.js";
@@ -176,12 +177,31 @@ export function buildGraphOverlayAdapter(
     }
   }
 
+  function snapshotHasAwaitingInput(snapshot: StoreSnapshot): boolean {
+    return snapshot.runs.some(
+      (run) => run.pendingPrompt !== undefined || run.stages.some(
+        (stage) => stage.status === "awaiting_input"
+          || stage.pendingPrompt !== undefined
+          || stage.inputRequest !== undefined,
+      ),
+    );
+  }
+
+  function refocusVisibleOverlayForAwaitingInput(snapshot: StoreSnapshot): void {
+    if (!snapshotHasAwaitingInput(snapshot)) return;
+    if (currentHandle === null) return;
+    if (currentHandle.isHidden()) return;
+    if (currentHandle.isFocused()) return;
+    currentHandle.focus();
+  }
+
   function makeComponent(
     view: WorkflowAttachPane,
     tui: PiCustomOverlayFactoryTui,
   ): PiCustomComponent {
-    const onStoreUpdate = (): void => {
+    const onStoreUpdate = (snapshot: StoreSnapshot): void => {
       view.invalidate();
+      refocusVisibleOverlayForAwaitingInput(snapshot);
       tui.requestRender?.();
     };
     const unsubscribe = store.subscribe(onStoreUpdate);
@@ -217,6 +237,13 @@ export function buildGraphOverlayAdapter(
     if (mounted) {
       currentView?.retarget(runId, stageId);
       setMouseScrollTracking(currentView?.wantsMouseScrollTracking() ?? true);
+      // Restore keyboard focus to the visible overlay after retargeting.
+      // pi-tui dispatches key events only to the focused component, so a
+      // mounted-but-visible overlay that is retargeted (e.g. to a stage-scoped
+      // HIL prompt / readiness gate) would otherwise appear frozen — arrows,
+      // Enter, Ctrl+D and `q` all dead — if focus stayed on an underlying or
+      // previously-focused pane (issue #1120).
+      currentHandle?.focus();
       return;
     }
 
@@ -275,6 +302,21 @@ export function buildGraphOverlayAdapter(
           if (currentHandle?.isHidden() === true) return;
           tui.requestRender?.();
         },
+        // Re-assert overlay keyboard focus on demand. The attached stage chat
+        // calls this when it shows a broker custom UI (e.g. the readiness gate)
+        // so the gate receives input even if focus drifted off the overlay
+        // while the agent's turn was streaming (#1120).
+        requestFocus: () => {
+          if (currentHandle?.isHidden() === true) return;
+          // Idempotent: only grab focus if the overlay does not already own it.
+          // A redundant focus() while already focused re-runs pi-tui's focus
+          // transition mid-stream and stalls the agent's continuation (#1120,
+          // the "ac" freeze). Skipping the no-op case lets callers ask for focus
+          // freely — e.g. when showing a mid-turn ask_user_question — without a
+          // fragile "only when not streaming" guard at every call site.
+          if (currentHandle?.isFocused() === true) return;
+          currentHandle?.focus();
+        },
         setMouseScrollTracking,
       } as ConstructorParameters<typeof WorkflowAttachPane>[0] & {
         piTui?: PiCustomOverlayFactoryTui;

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

@@ -202,7 +202,7 @@ function artifactRowsFor(detail: RunDetail): Array<[string, string]> {
 function stageLinePlain(stage: StageSnapshot, now: number, width: number): string {
   const icon = statusIcon(stage.status);
   const dur = stageDurationString(stage, now);
-  const activity = stageActivityString(stage);
+  const activity = stageActivityString(stage, now);
   const name = truncateToWidth(`${icon} ${stage.name}`, STAGE_NAME_COL + 2, "…");
   const activityText = activity ? truncateToWidth(activity, 16, "…") : undefined;
   const parts = [
@@ -222,7 +222,7 @@ function stageLineThemed(stage: StageSnapshot, now: number, theme: GraphTheme, w
   const dim = hexToAnsi(theme.dim);
   const stateFg = hexToAnsi(statusColor(stage.status, theme));
 
-  const activity = stageActivityString(stage);
+  const activity = stageActivityString(stage, now);
   const dur = stageDurationString(stage, now);
 
   const nameText = truncateToWidth(stage.name, STAGE_NAME_COL, "…");
@@ -268,7 +268,13 @@ function stageDurationString(stage: StageSnapshot, now: number): string | undefi
   return elapsed === undefined ? undefined : fmtDuration(elapsed);
 }
 
-function stageActivityString(stage: StageSnapshot): string | undefined {
+// `now` is the stable, capture-once clock threaded down from renderRunDetail
+// (opts.now). Using it — not a fresh Date.now() — keeps a running stage's active
+// tool-activity label (e.g. `bash · 6s`) byte-stable across host re-renders so a
+// scrollback run-detail card that has scrolled above the viewport fold does not
+// retrigger pi-tui's full-screen redraw (CSI 2J/H/3J) every render tick. The
+// companion below-editor widget owns the live, ticking view.
+function stageActivityString(stage: StageSnapshot, now: number): string | undefined {
   if (stage.status !== "running") return undefined;
   const last = stage.toolEvents.at(-1);
   if (!last) return undefined;
@@ -276,7 +282,7 @@ function stageActivityString(stage: StageSnapshot): string | undefined {
     return `${last.name} · ${fmtDuration(last.endedAt - last.startedAt)}`;
   }
   if (last.startedAt !== undefined) {
-    return `${last.name} · ${fmtDuration(Date.now() - last.startedAt)}`;
+    return `${last.name} · ${fmtDuration(now - last.startedAt)}`;
   }
   return last.name;
 }

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

@@ -109,6 +109,12 @@ export interface StageChatViewOpts {
   onClose: () => void;
   /** Request a host TUI repaint after SDK events mutate local chat state. */
   requestRender?: () => void;
+  /**
+   * Re-assert overlay keyboard focus. Showing a stage custom UI (e.g. the
+   * readiness gate) must make the overlay the focused pi-tui component again,
+   * otherwise key events keep going elsewhere and the UI looks frozen (#1120).
+   */
+  requestFocus?: () => void;
   /** Live pi-tui host objects. When present, stage input uses pi's editor UI. */
   piTui?: TUI;
   piTheme?: unknown;
@@ -190,6 +196,8 @@ export class StageChatView implements Component, Focusable {
   private onDetach: () => void;
   private onClose: () => void;
   private requestRender: (() => void) | undefined;
+  private requestFocus: (() => void) | undefined;
+  private focusHoldTimer: ReturnType<typeof setInterval> | undefined;
   private getViewportRows?: () => number | undefined;
   private piTui?: TUI;
   private piTheme?: unknown;
@@ -198,6 +206,7 @@ export class StageChatView implements Component, Focusable {
   private chatHost: ChatSessionHost<NoticeEntry>;
   private stageUiBroker: StageUiBroker;
   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;
@@ -227,6 +236,25 @@ export class StageChatView implements Component, Focusable {
     this.onDetach = opts.onDetach;
     this.onClose = opts.onClose;
     this.requestRender = opts.requestRender;
+    this.requestFocus = opts.requestFocus;
+    // Hold overlay keyboard focus against host focus-steals. pi-tui overlays
+    // capture focus on show, but any tui.setFocus() elsewhere (the host editor
+    // during background workflow activity) steals it, leaving the gate/composer
+    // input-dead. Re-claim it on a short interval — only while NOT streaming, so
+    // a mid-turn ask_user_question never refocuses during the agent's
+    // continuation (which would stall the stream).
+    if (opts.requestFocus) {
+      this.focusHoldTimer = setInterval(() => {
+        // Hold focus on the overlay whenever there is something to interact
+        // with: a mounted custom UI (ask_user_question / readiness gate) must
+        // stay answerable even mid-turn, and an idle composer should keep focus.
+        // During a pure streaming continuation (no custom UI mounted) we leave
+        // focus alone so we never reclaim it out from under the agent's live
+        // output. requestFocus is idempotent, so this is a no-op whenever the
+        // overlay already owns focus.
+        if (this.mountedCustomUi !== null || !this._isStreaming()) this.requestFocus?.();
+      }, 150);
+    }
     this.getViewportRows = opts.getViewportRows;
     this.piTui = opts.piTui;
     this.piTheme = opts.piTheme;
@@ -367,7 +395,15 @@ export class StageChatView implements Component, Focusable {
   private async _showCustomUi(request: StageCustomUiRequest): Promise<void> {
     this.mountedCustomUi?.component.dispose?.();
     this.mountedCustomUi = null;
+    // Track the request currently being mounted. `mountStageCustomUi` is async,
+    // so the broker can resolve/reject/abort the request (clearing it via
+    // `_hideMountedCustomUi`) before we finish awaiting. Without this guard the
+    // post-await assignment below would strand a settled gate as a permanent
+    // `mountedCustomUi`, hiding the transcript and crashing on the next
+    // keystroke routed into the dead component (readiness gate #1099).
+    this.mountingRequestId = request.id;
     if (!this.piTui || this.piTheme === undefined || this.piKeybindings === undefined) {
+      this.mountingRequestId = null;
       this.stageUiBroker.reject(
         request,
         new Error("pi-workflows: stage custom UI cannot mount without attached TUI host"),
@@ -375,7 +411,7 @@ export class StageChatView implements Component, Focusable {
       return;
     }
     try {
-      this.mountedCustomUi = await mountStageCustomUi(
+      const mounted = await mountStageCustomUi(
         request,
         this.piTui,
         this.piTheme,
@@ -390,8 +426,25 @@ export class StageChatView implements Component, Focusable {
           this.requestRender?.();
         },
       );
+      // Settled or superseded while mounting: drop the freshly-built component
+      // instead of showing a gate the broker has already torn down.
+      if (this.mountingRequestId !== request.id) {
+        mounted.component.dispose?.();
+        return;
+      }
+      this.mountingRequestId = null;
+      this.mountedCustomUi = mounted;
+      // A freshly-shown custom UI (ask_user_question / readiness gate) must own
+      // keyboard focus to be answerable — including a question mounted mid-turn
+      // while the agent is "streaming" (it is blocked on this very question, and
+      // host focus may have drifted off the overlay during the turn, e.g. after a
+      // stay-loop composer submit). requestFocus is idempotent (a no-op when the
+      // overlay already owns focus), so this never re-runs a redundant focus
+      // transition that would stall the stream (#1120).
+      this.requestFocus?.();
       this.requestRender?.();
     } catch (error) {
+      if (this.mountingRequestId === request.id) this.mountingRequestId = null;
       this.stageUiBroker.reject(request, error);
     }
   }
@@ -579,6 +632,13 @@ export class StageChatView implements Component, Focusable {
     this._syncPromptState(stage?.pendingPrompt);
     const promptActive = !customUiActive && this.promptState !== null;
     const readOnlyArchive = this._isReadOnlyArchive(stage);
+
+    // ask_user_question / readiness-gate custom UI renders as a bottom panel
+    // (in the high-priority composer slot) so the live transcript stays visible
+    // and scrollable above it — matching the standalone ask_user_question tool.
+    // Structured prompt nodes and read-only archives keep their full-body
+    // treatment below.
+    const customUiLines = customUiActive ? this._renderCustomUi(w) : [];
     const chatChromeHidden = customUiActive || promptActive || readOnlyArchive;
     const pendingLines = chatChromeHidden ? [] : this.chatHost.renderPendingMessages(w);
     const workingLines = chatChromeHidden ? [] : this.chatHost.renderWorkingStatus(w);
@@ -594,27 +654,32 @@ export class StageChatView implements Component, Focusable {
       pendingRows: pendingLines.length,
       workingRows: workingLines.length,
       usageRows: usageLines.length,
-      editorRows: editorLines.length,
+      // The custom UI question takes the reserved bottom (composer) slot so the
+      // transcript above keeps as much room as possible and the question never
+      // clips below the overlay boundary.
+      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 = editorLines.slice(0, plan.editorRows);
+    const visibleEditorLines = customUiActive
+      ? customUiLines.slice(0, plan.editorRows)
+      : editorLines.slice(0, plan.editorRows);
     const visibleFooterLines = footerLines.slice(0, plan.footerRows);
     const bodyBudget = plan.bodyRows;
     if (blocked) this.chatHost.scrollToBottom();
 
     let bodyLines: string[];
-    if (customUiActive) {
-      bodyLines = this._renderCustomUiBody(w, bodyBudget);
-    } else if (promptActive) {
+    if (promptActive) {
       bodyLines = this._renderPromptBody(w, bodyBudget);
     } else if (blocked) {
       bodyLines = this._renderBlockedBody(w, bodyBudget, stage);
     } else if (readOnlyArchive) {
       bodyLines = this._renderReadOnlyArchiveBody(w, bodyBudget, stage);
     } else {
+      // Live transcript. When a custom UI question is active it renders in the
+      // composer slot above; the transcript here stays visible and scrollable.
       bodyLines = this.chatHost.renderBody(w, bodyBudget);
     }
 
@@ -844,11 +909,13 @@ export class StageChatView implements Component, Focusable {
     return lines;
   }
 
-  private _renderCustomUiBody(width: number, budget: number): string[] {
+  // Natural-height render of the mounted custom UI (no body padding): it is
+  // placed in the composer slot so the transcript stays scrollable above it.
+  private _renderCustomUi(width: number): string[] {
     const component = this.mountedCustomUi?.component;
-    if (component) setComponentFocused(component, this.focused);
-    const lines = component ? component.render(width) : [];
-    return this._fitBodyLines(lines, width, budget);
+    if (!component) return [];
+    setComponentFocused(component, this.focused);
+    return component.render(width);
   }
 
   private _renderPromptBody(width: number, budget: number): string[] {
@@ -1041,16 +1108,30 @@ export class StageChatView implements Component, Focusable {
   handleInput(data: string): boolean {
     if (this.mountedCustomUi) {
       if (matchesKey(data, Key.ctrl("d"))) {
-        this._rejectMountedCustomUi("stage custom UI detached");
+        // Detach stops *viewing* the stage; it does not cancel a pending
+        // human-input request. Release the local display only — the request
+        // stays pending (the stage remains awaiting_input) and is re-displayed
+        // when the user re-attaches.
+        this._releaseMountedCustomUi();
         if (this._isPaused()) this.onClose();
         else this.onDetach();
         return true;
       }
       if (matchesKey(data, Key.ctrl("c"))) {
-        this._rejectMountedCustomUi("stage custom UI closed");
+        // Close hides the overlay; the background run — and its pending
+        // human-input request — keep living. Release the local display only.
+        this._releaseMountedCustomUi();
         this.onClose();
         return true;
       }
+      // Let scroll input (mouse wheel / pageUp / pageDown / home / end) reach
+      // the transcript so history stays scrollable while the question is shown,
+      // matching the standalone ask_user_question tool. Navigation keys
+      // (arrows / enter / typing) fall through to the question component.
+      if (this.chatHost.handleScrollInput(data)) {
+        this.requestRender?.();
+        return true;
+      }
       setComponentFocused(this.mountedCustomUi.component, this.focused);
       this.mountedCustomUi.component.handleInput?.(data);
       this.requestRender?.();
@@ -1165,11 +1246,15 @@ export class StageChatView implements Component, Focusable {
   }
 
   dispose(): void {
+    if (this.focusHoldTimer !== undefined) {
+      clearInterval(this.focusHoldTimer);
+      this.focusHoldTimer = undefined;
+    }
     this._unsubscribeStore?.();
     this._unsubscribeStore = null;
     this._unsubscribeHandle?.();
     this._unsubscribeHandle = null;
-    this._rejectMountedCustomUi("stage chat view disposed");
+    this._releaseMountedCustomUi();
     this._disposePromptEditor();
     this._unregisterStageUiHost?.();
     this._unregisterStageUiHost = null;
@@ -1177,20 +1262,37 @@ export class StageChatView implements Component, Focusable {
   }
 
   private _hideMountedCustomUi(request: StageCustomUiRequest): void {
+    // Signal any in-flight `_showCustomUi` mount for this request to drop its
+    // component when it finishes — the broker is already tearing it down.
+    if (this.mountingRequestId === request.id) this.mountingRequestId = null;
     const mounted = this.mountedCustomUi;
     if (!mounted || mounted.request.id !== request.id) return;
     this.mountedCustomUi = null;
     mounted.component.dispose?.();
     this.chatHost.focused = this.focused;
     this.chatHost.scrollToBottom();
+    // Returning to the composer after a custom UI resolves (e.g. the readiness
+    // gate -> "stay") must re-assert overlay focus so the composer accepts
+    // input. Guarded for streaming so an answered mid-turn ask_user_question
+    // does not refocus during the agent's continuation (would stall it).
+    if (!this._isStreaming()) this.requestFocus?.();
     this.requestRender?.();
   }
 
-  private _rejectMountedCustomUi(message: string): void {
+  /**
+   * Stop displaying the mounted stage custom UI locally, WITHOUT settling its
+   * broker request. Detaching / closing / disposing the attached chat stops
+   * viewing the stage; it never cancels a pending human-input request. The
+   * request stays pending (the stage remains awaiting_input) so re-attaching
+   * re-displays it. The request is settled only by the user answering (broker
+   * resolve) or the run aborting (its AbortSignal -> broker reject) — those are
+   * the single chokepoints for ending a human-input request.
+   */
+  private _releaseMountedCustomUi(): void {
+    this.mountingRequestId = null;
     const mounted = this.mountedCustomUi;
     if (!mounted) return;
     this.mountedCustomUi = null;
-    this.stageUiBroker.reject(mounted.request, new Error(`pi-workflows: ${message}`));
     mounted.component.dispose?.();
   }
 

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

@@ -100,6 +100,12 @@ export interface WorkflowAttachPaneOpts {
    * visibility so a hidden pane stays cheap.
    */
   requestRender?: () => void;
+  /**
+   * Host hook to re-assert overlay keyboard focus. Threaded into the attached
+   * stage chat so showing a broker custom UI (e.g. the readiness gate) refocuses
+   * the overlay and the UI is not left input-dead (#1120).
+   */
+  requestFocus?: () => void;
   /**
    * Host hook for terminal mouse reporting. Graph mode uses wheel input
    * for canvas scrolling; stage-chat mode uses it for transcript history
@@ -125,6 +131,7 @@ export class WorkflowAttachPane implements Component {
   private onPromptResolve?: (runId: string, promptId: string, response: unknown) => void;
   private getViewportRows?: () => number | undefined;
   private hostRequestRender?: () => void;
+  private hostRequestFocus?: () => void;
   private setMouseScrollTracking?: (enabled: boolean) => void;
   private piTui?: TUI;
   private piTheme?: unknown;
@@ -152,6 +159,7 @@ export class WorkflowAttachPane implements Component {
     this.onPromptResolve = opts.onPromptResolve;
     this.getViewportRows = opts.getViewportRows;
     this.hostRequestRender = opts.requestRender;
+    this.hostRequestFocus = opts.requestFocus;
     this.setMouseScrollTracking = opts.setMouseScrollTracking;
     this.piTui = opts.piTui;
     this.piTheme = opts.piTheme;
@@ -233,6 +241,7 @@ export class WorkflowAttachPane implements Component {
       onDetach: () => this._detachFromStage(),
       onClose: this.onClose,
       requestRender: this.hostRequestRender,
+      requestFocus: this.hostRequestFocus,
       piTui: this.piTui,
       piTheme: this.piTheme,
       piKeybindings: this.piKeybindings,