@bastani/atomic 0.9.9 → 0.9.10-alpha.1

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

@@ -55,7 +55,6 @@ export abstract class GraphViewState {
   protected store: Store;
   protected graphTheme: GraphTheme;
   protected onClose?: () => 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;
@@ -95,7 +94,6 @@ export abstract class GraphViewState {
     this.store = opts.store;
     this.graphTheme = opts.graphTheme;
     this.onClose = opts.onClose;
-    this.onQuit = opts.onQuit;
     this.onHide = opts.onHide;
     this.onPromptResolve = opts.onPromptResolve;
     this.onStageAttach = opts.onStageAttach;

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

@@ -10,12 +10,6 @@ export interface GraphViewOpts {
   store: Store;
   graphTheme: GraphTheme;
   onClose?: () => void;
-  /**
-   * 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.
-   */
-  onQuit?: (runId: string) => void;
   /**
    * Invoked when the user presses `h` inside the pane. Hides without
    * unmounting (overlay-adapter calls `setHidden(true)`). Re-open via
@@ -35,9 +29,9 @@ export interface GraphViewOpts {
    */
   onStageAttach?: (runId: string, stageId: string) => void;
   /**
-   * Invoked when the user presses `Ctrl+D` while in graph mode. Mirrors
-   * the in-chat back affordance: detaches the whole popup (host calls
-   * `setHidden(true)`). Falls back to `onHide` when unset.
+   * Invoked when the user presses `Ctrl+X` in graph mode. Returns to main
+   * chat by hiding the popup with `setHidden(true)`. Falls back to `onHide`
+   * when unset.
    */
   onDetach?: () => void;
   /**

package/dist/builtin/workflows/src/tui/host-input-form.ts

@@ -0,0 +1,62 @@
+import type { WorkflowInputEntry } from "../extension/render-result.js";
+import type {
+  PiHostInputFormField,
+  PiHostInputFormFunction,
+} from "../extension/ui-surface.js";
+import type { WorkflowInputValues } from "../shared/types.js";
+import { coerceValues } from "./inputs-picker.js";
+import type { InputsPickerResult } from "./inputs-overlay.js";
+
+export interface HostInputsFormUi {
+  hostInputForm?: PiHostInputFormFunction;
+}
+
+function supportedType(type: string): PiHostInputFormField["type"] {
+  switch (type) {
+    case "text":
+    case "number":
+    case "integer":
+    case "boolean":
+    case "select":
+      return type;
+    default:
+      return "string";
+  }
+}
+
+function initialValue(field: WorkflowInputEntry, prefilled: WorkflowInputValues): string {
+  if (prefilled[field.name] !== undefined) return String(prefilled[field.name]);
+  if (field.default !== undefined) return String(field.default);
+  if (field.type === "select" && field.choices && field.choices.length > 0) return field.choices[0]!;
+  if (field.type === "boolean") return "false";
+  return "";
+}
+
+/** Adapt workflow schemas to the host-owned, raw-string form capability. */
+export async function openHostInputsForm(
+  ui: HostInputsFormUi,
+  options: {
+    workflowName: string;
+    fields: readonly WorkflowInputEntry[];
+    prefilled?: WorkflowInputValues;
+  },
+): Promise<InputsPickerResult | { kind: "unsupported" }> {
+  const open = ui.hostInputForm;
+  if (typeof open !== "function") return { kind: "unsupported" };
+  const prefilled = options.prefilled ?? {};
+  const fields: PiHostInputFormField[] = options.fields.map((field) => ({
+    name: field.name,
+    type: supportedType(field.type),
+    initialValue: initialValue(field, prefilled),
+    ...(field.description !== undefined ? { description: field.description } : {}),
+    ...(field.required !== undefined ? { required: field.required } : {}),
+    ...(field.choices !== undefined ? { choices: [...field.choices] } : {}),
+    ...(field.placeholder !== undefined ? { placeholder: field.placeholder } : {}),
+  }));
+  try {
+    const raw = await open.call(ui, { title: options.workflowName, fields });
+    return raw === undefined ? { kind: "cancel" } : { kind: "run", values: coerceValues(options.fields, raw) };
+  } catch {
+    return { kind: "unsupported" };
+  }
+}

package/dist/builtin/workflows/src/tui/mouse-input.ts

@@ -0,0 +1,63 @@
+export type TerminalMouseProtocol = "sgr" | "x10";
+export type TerminalMouseAction = "press" | "release";
+export type TerminalMouseWheelDirection = "up" | "down" | "left" | "right";
+
+export interface TerminalMouseEvent {
+  readonly protocol: TerminalMouseProtocol;
+  readonly action: TerminalMouseAction;
+  readonly buttonCode: number;
+  /** Zero-based terminal column. */
+  readonly col: number;
+  /** Zero-based terminal row. */
+  readonly row: number;
+}
+
+/** Parse one complete SGR or legacy X10 terminal mouse sequence. */
+export function parseTerminalMouseInput(data: string): TerminalMouseEvent | null {
+  const sgr = data.match(/^\x1b\[<(\d+);(\d+);(\d+)([Mm])$/);
+  if (sgr) {
+    const oneBasedCol = Number.parseInt(sgr[2]!, 10);
+    const oneBasedRow = Number.parseInt(sgr[3]!, 10);
+    if (oneBasedCol < 1 || oneBasedRow < 1) return null;
+    return {
+      protocol: "sgr",
+      action: sgr[4] === "M" ? "press" : "release",
+      buttonCode: Number.parseInt(sgr[1]!, 10),
+      col: oneBasedCol - 1,
+      row: oneBasedRow - 1,
+    };
+  }
+
+  if (!data.startsWith("\x1b[M") || data.length !== 6) return null;
+  const buttonCode = data.charCodeAt(3) - 32;
+  const col = data.charCodeAt(4) - 33;
+  const row = data.charCodeAt(5) - 33;
+  if (buttonCode < 0 || col < 0 || row < 0) return null;
+  return {
+    protocol: "x10",
+    action: (buttonCode & (64 | 32)) === 0 && (buttonCode & 3) === 3
+      ? "release"
+      : "press",
+    buttonCode,
+    col,
+    row,
+  };
+}
+
+export function terminalMouseWheelDirection(
+  event: TerminalMouseEvent,
+): TerminalMouseWheelDirection | null {
+  if (event.action !== "press" || (event.buttonCode & 64) === 0) return null;
+  const direction = event.buttonCode & 3;
+  if (direction === 0) return "up";
+  if (direction === 1) return "down";
+  if (direction === 2) return "left";
+  return "right";
+}
+
+export function isTerminalLeftMousePress(event: TerminalMouseEvent): boolean {
+  return event.action === "press"
+    && (event.buttonCode & 64) === 0
+    && (event.buttonCode & 32) === 0
+    && (event.buttonCode & 3) === 0;
+}

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

@@ -119,6 +119,7 @@ function durationText(stage: StageSnapshot): string {
 }
 
 function metaText(stage: StageSnapshot): string {
+  if (stage.topologyState === "unavailable") return "topology unavailable";
   const deps = stage.parentIds.length;
   const dependencyText = deps === 0 ? "root" : deps === 1 ? "1 dep" : `${deps} deps`;
   return stage.fastMode === true ? `${dependencyText} · fast` : dependencyText;

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

@@ -21,10 +21,16 @@ 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 { 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";
+import type { PostMortemHandleResolution } from "./workflow-attach-pane-types.js";
+import {
+  remoteTerminalControlFrom,
+  setMouseScrollTracking,
+  setTerminalAutowrap,
+} from "./overlay-terminal-modes.js";
+import type { OverlayTerminalOutput } from "./overlay-terminal-modes.js";
 import type {
   PiCustomComponent,
   PiCustomOverlayFactoryTui,
@@ -36,11 +42,14 @@ import type {
   PiKeybindings,
   PiOverlayHandle,
   PiOverlayOptions,
+  PiRemoteTerminalControl,
   PiTheme,
 } from "../extension/wiring.js";
 
 export type OverlayChatRenderSettings = Partial<Omit<ChatMessageRenderOptions, "ui" | "cwd">>;
 
+export type { OverlayTerminalOutput } from "./overlay-terminal-modes.js";
+
 export interface OverlayUISurface {
   custom?: PiCustomOverlayFunction;
   getHostCustomUiState?: () => PiHostCustomUiState;
@@ -64,12 +73,12 @@ export interface OverlayPiSurface {
  * `toggle(runId)`— show if hidden, hide if visible, create if absent.
  * `close()`      — permanently dismiss.
  *
- * Optional `stageId` (on `open`) opens directly on the stage-chat
- * surface for that node — used by `/workflow attach <runId> <stageId>`
+ * Optional `stageId` and owning `stageRunId` (on `open`) open directly on
+ * that exact stage-chat node — used by `/workflow attach <runId> <stageId>`
  * and the picker overlay's connect-to-stage flow.
  */
 export interface GraphOverlayPort {
-  open(runId: string | null, surface?: OverlayPiSurface, stageId?: string): void;
+  open(runId: string | null, surface?: OverlayPiSurface, stageId?: string, stageRunId?: string): void;
   toggle(runId: string | null, surface?: OverlayPiSurface): void;
   close(): void;
 }
@@ -101,42 +110,25 @@ const FULLSCREEN_OVERLAY_OPTIONS: PiOverlayOptions = {
   margin: 0,
 };
 
-const MOUSE_SCROLL_TRACKING_ON = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
-const MOUSE_SCROLL_TRACKING_OFF = "\x1b[?1006l\x1b[?1002l\x1b[?1000l";
-const TERMINAL_AUTOWRAP_ON = "\x1b[?7h";
-const TERMINAL_AUTOWRAP_OFF = "\x1b[?7l";
 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.";
 
-export interface OverlayTerminalOutput {
-  platform: NodeJS.Platform;
-  isTTY: boolean | undefined;
-  write(data: string): void;
-}
-
-function setMouseScrollTracking(enabled: boolean, output: OverlayTerminalOutput): void {
-  if (!output.isTTY) return;
-  output.write(enabled ? MOUSE_SCROLL_TRACKING_ON : MOUSE_SCROLL_TRACKING_OFF);
-}
-
-function setTerminalAutowrap(enabled: boolean, output: OverlayTerminalOutput): void {
-  if (output.platform !== "win32" || !output.isTTY) return;
-  output.write(enabled ? TERMINAL_AUTOWRAP_ON : TERMINAL_AUTOWRAP_OFF);
-}
-
 export interface BuildGraphOverlayAdapterOpts {
   /**
    * Live stage-control registry threaded through to the attach shell.
    * Defaults to the singleton registry registered alongside the store.
    */
   stageControlRegistry?: StageControlRegistry;
-  /** Broker used to route stage-local custom UI into attached stage chats. */
-  stageUiBroker?: StageUiBroker;
   /**
-   * Quit hook used by graph-mode `q`. This is intentionally distinct from
-   * `/workflow kill`: panel quit leaves durable-progress runs resumable.
+   * Resolver that revives a post-mortem chat handle for an eligible terminal
+   * agent stage with a valid retained session but no process-local handle.
+   * Threaded into every `WorkflowAttachPane` so generic attach/connect and
+   * restored/replayed durable snapshots open as interactive follow-up chats;
+   * unavailable results provide the pane's actionable read-only reason.
    */
-  onQuitRun?: (runId: string) => void;
+  resolvePostMortemHandle?: (runId: string, stageId: string) => PostMortemHandleResolution;
+  /** Broker used to route stage-local custom UI into attached stage chats. */
+  stageUiBroker?: StageUiBroker;
   /** Optional clock injection for deterministic attach-pane transition tests. */
   now?: () => number;
   /** Terminal output seam used to test raw overlay control sequences. */
@@ -149,6 +141,7 @@ export function buildGraphOverlayAdapter(
   buildOpts: BuildGraphOverlayAdapterOpts = {},
 ): GraphOverlayPort {
   const registry = buildOpts.stageControlRegistry ?? defaultStageControlRegistry;
+  const resolvePostMortemHandle = buildOpts.resolvePostMortemHandle;
   const stageUiBroker = buildOpts.stageUiBroker;
   const terminalOutput = buildOpts.terminalOutput ?? {
     platform: process.platform,
@@ -157,12 +150,14 @@ export function buildGraphOverlayAdapter(
       process.stdout.write(data);
     },
   };
+  // Isolated interactive mode exposes a remote terminal-control capability;
+  // prefer it so the real host TTY (not the child's non-TTY JSONL stdout) gets
+  // the modes. Otherwise fall back to the local process.stdout seam.
+  let remoteTerminalControl: PiRemoteTerminalControl | null = null;
   const updateMouseScrollTracking = (enabled: boolean): void => {
-    setMouseScrollTracking(enabled, terminalOutput);
+    if (remoteTerminalControl) remoteTerminalControl.setMouseScrollTracking(enabled);
+    else setMouseScrollTracking(enabled, terminalOutput);
   };
-  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
   // it so toggle() can flip `setHidden` rather than remounting the
@@ -171,6 +166,11 @@ export function buildGraphOverlayAdapter(
   let currentHandle: PiOverlayHandle | null = null;
   let mounted = false;
   let finishMounted: (() => void) | null = null;
+  // Repaints the mounted overlay through its factory TUI. Needed on the
+  // hidden→visible flip: store updates while hidden intentionally skip
+  // `requestRender` (#1856), so reopening must explicitly render the
+  // invalidated view from the current snapshot.
+  let requestMountedRender: (() => void) | null = null;
   let observedUi: OverlayUISurface | undefined;
   let unsubscribeHostCustomUi: (() => void) | null = null;
   let hostInlineCustomUiActive = false;
@@ -179,6 +179,10 @@ export function buildGraphOverlayAdapter(
   function updateTerminalAutowrap(visible: boolean): void {
     if (overlayVisible === visible) return;
     overlayVisible = visible;
+    if (remoteTerminalControl) {
+      if (terminalOutput.platform === "win32") remoteTerminalControl.setAutowrap(!visible);
+      return;
+    }
     setTerminalAutowrap(!visible, terminalOutput);
   }
 
@@ -231,11 +235,13 @@ export function buildGraphOverlayAdapter(
     finishMounted = null;
     currentView = null;
     mounted = false;
+    remoteTerminalControl = null;
+    requestMountedRender = null;
     clearHostCustomUiObservation();
   }
 
   /**
-   * Non-destructive close path used by graph-mode `Ctrl+D` / `h`. Goes
+   * Non-destructive return path used by graph-mode `Ctrl+X` / `h`. Goes
    * through Pi/pi public primitives in priority order:
    *   1. `OverlayHandle.setHidden(true)` when the host exposed an
    *      overlay handle via `options.onHandle`. Keeps the overlay
@@ -246,9 +252,8 @@ export function buildGraphOverlayAdapter(
    *      component, hides the overlay if present, restores focus to
    *      the editor, and resolves the custom() promise.
    *
-   * Critically: this never touches `killRun`, `cancellationRegistry`,
-   * or any run-cancellation surface — the backing workflow keeps
-   * running and can be re-attached.
+   * This is UI-only: the backing workflow keeps running unchanged and the
+   * same mounted overlay can be reopened later.
    */
   function hideMounted(): void {
     updateMouseScrollTracking(false);
@@ -279,8 +284,15 @@ export function buildGraphOverlayAdapter(
     view: WorkflowAttachPane,
     tui: PiCustomOverlayFactoryTui,
   ): PiCustomComponent {
+    requestMountedRender = () => tui.requestRender?.();
     const onStoreUpdate = (snapshot: StoreSnapshot): void => {
+      // Always invalidate retained view state so a later reopen renders the
+      // current snapshot — but while the overlay is hidden, never ask the
+      // host to render (#1856): each hidden-overlay render request became
+      // terminal writes that flickered main chat and could snap native
+      // scrollback to the bottom.
       view.invalidate();
+      if (currentHandle?.isHidden() === true) return;
       refocusVisibleOverlayForAwaitingInput(snapshot);
       tui.requestRender?.();
     };
@@ -295,6 +307,8 @@ export function buildGraphOverlayAdapter(
       dispose: () => {
         updateTerminalAutowrap(false);
         updateMouseScrollTracking(false);
+        remoteTerminalControl = null;
+        requestMountedRender = null;
         unsubscribe();
         view.dispose();
       },
@@ -305,29 +319,31 @@ export function buildGraphOverlayAdapter(
     runId: string | null,
     surface?: OverlayPiSurface,
     stageId?: string,
+    stageRunId?: string,
   ): void {
     const ui = surface?.ui ?? pi.ui;
     observeHostCustomUi(ui);
 
     // Already mounted but hidden — flip visibility without remounting.
     if (mounted && currentHandle?.isHidden()) {
-      currentView?.retarget(runId, stageId);
+      currentView?.retarget(runId, stageId, stageRunId);
       currentView?.setVisible(true);
       updateTerminalAutowrap(true);
       updateMouseScrollTracking(currentView?.wantsMouseScrollTracking() ?? true);
       currentHandle.setHidden(false);
       currentHandle.focus();
+      requestMountedRender?.();
       return;
     }
     if (mounted) {
-      currentView?.retarget(runId, stageId);
+      currentView?.retarget(runId, stageId, stageRunId);
       updateTerminalAutowrap(true);
       updateMouseScrollTracking(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
+      // Enter and Ctrl+X all dead — if focus stayed on an underlying or
       // previously-focused pane (issue #1120).
       currentHandle?.focus();
       return;
@@ -344,6 +360,9 @@ export function buildGraphOverlayAdapter(
       keybindings: PiKeybindings,
       done: (result: undefined) => void,
     ): PiCustomComponent => {
+      // Prefer the host's remote terminal-control capability (isolated mode);
+      // stays null for non-isolated hosts, keeping the local process.stdout seam.
+      remoteTerminalControl = remoteTerminalControlFrom(tui);
       const finish = (): void => {
         if (settled) return;
         settled = true;
@@ -355,11 +374,13 @@ export function buildGraphOverlayAdapter(
         currentHandle = null;
         finishMounted = null;
         mounted = false;
+        requestMountedRender = null;
         clearHostCustomUiObservation();
         try {
           done(undefined);
         } finally {
           updateTerminalAutowrap(false);
+          remoteTerminalControl = null;
         }
       };
       const view = new WorkflowAttachPane({
@@ -367,12 +388,13 @@ export function buildGraphOverlayAdapter(
         graphTheme: deriveGraphThemeFromPiTheme(theme),
         runId,
         stageControlRegistry: registry,
+        resolvePostMortemHandle,
         stageUiBroker,
         uiStatus,
         onClose: finish,
         onHide: hideMounted,
-        onQuit: quitRun,
         initialAttachStageId: stageId,
+        initialAttachRunId: stageRunId,
         piTui: tui,
         piTheme: theme,
         piKeybindings: keybindings,
@@ -452,7 +474,10 @@ export function buildGraphOverlayAdapter(
       );
       currentHandle.setHidden(nowHidden);
       if (nowHidden) updateTerminalAutowrap(false);
-      else currentHandle.focus();
+      else {
+        currentHandle.focus();
+        requestMountedRender?.();
+      }
       return;
     }
     if (mounted) {

package/dist/builtin/workflows/src/tui/overlay-terminal-modes.ts

@@ -0,0 +1,49 @@
+/**
+ * Terminal-mode seams for the workflow graph overlay: raw mouse-scroll
+ * reporting and autowrap (DECAWM) escape sequences for the local TTY, plus
+ * extraction of the isolated host's remote terminal-control capability.
+ *
+ * cross-ref: src/tui/overlay-adapter.ts (sole consumer)
+ */
+
+import type {
+  PiCustomOverlayFactoryTui,
+  PiRemoteTerminalControl,
+} from "../extension/wiring.js";
+
+const MOUSE_SCROLL_TRACKING_ON = "\x1b[?1000h\x1b[?1002h\x1b[?1006h";
+const MOUSE_SCROLL_TRACKING_OFF = "\x1b[?1006l\x1b[?1002l\x1b[?1000l";
+const TERMINAL_AUTOWRAP_ON = "\x1b[?7h";
+const TERMINAL_AUTOWRAP_OFF = "\x1b[?7l";
+
+export interface OverlayTerminalOutput {
+  platform: NodeJS.Platform;
+  isTTY: boolean | undefined;
+  write(data: string): void;
+}
+
+export function setMouseScrollTracking(enabled: boolean, output: OverlayTerminalOutput): void {
+  if (!output.isTTY) return;
+  output.write(enabled ? MOUSE_SCROLL_TRACKING_ON : MOUSE_SCROLL_TRACKING_OFF);
+}
+
+export function setTerminalAutowrap(enabled: boolean, output: OverlayTerminalOutput): void {
+  if (output.platform !== "win32" || !output.isTTY) return;
+  output.write(enabled ? TERMINAL_AUTOWRAP_ON : TERMINAL_AUTOWRAP_OFF);
+}
+
+/**
+ * Extract the host's remote terminal-control capability from the factory TUI —
+ * present in isolated interactive mode (drives the real host TTY over the
+ * allowlisted engine protocol); `null` for non-isolated hosts and test seams.
+ */
+export function remoteTerminalControlFrom(tui: PiCustomOverlayFactoryTui): PiRemoteTerminalControl | null {
+  const terminal = tui.terminal;
+  if (terminal === undefined || typeof terminal.setMouseScrollTracking !== "function" || typeof terminal.setAutowrap !== "function") {
+    return null;
+  }
+  return {
+    setMouseScrollTracking: terminal.setMouseScrollTracking.bind(terminal),
+    setAutowrap: terminal.setAutowrap.bind(terminal),
+  };
+}

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

@@ -1,11 +1,6 @@
 /**
- * Mount adapters for the session picker and kill-confirmation overlays.
+ * Mount adapter for the workflow session picker.
  *
- * Both overlays use Pi / pi's real `ctx.ui.custom(factory, options)`
- * primitive. There is no legacy object-shaped fallback — when the host
- * doesn't expose `pi.ui.custom` the picker resolves with `close` and the
- * kill-confirm falls back to `pi.ui.confirm` (or `false` when even that
- * is absent, since the action is destructive).
  *
  * Mount mode
  * ----------
@@ -20,9 +15,6 @@
  * chrome wedged between command and picker (those rows are owned by
  * the editor area we just replaced).
  *
- * The kill-confirm intentionally stays on `{ overlay: true }` — it is a
- * destructive modal and reads better as a centered popup over the
- * editor, not as an inline replacement.
  *
  * cross-ref:
  *  - src/tui/session-picker.ts (state machine + render)
@@ -35,7 +27,6 @@ import type {
   PiCustomComponent,
   PiCustomOverlayFactoryTui,
   PiCustomOverlayFunction,
-  PiOverlayOptions,
 } from "../extension/wiring.js";
 import type { Store } from "../shared/store.js";
 import type { GraphTheme } from "./graph-theme.js";
@@ -45,34 +36,16 @@ import {
   renderSessionPicker,
   selectRunsForPicker,
 } from "./session-picker.js";
-import {
-  createKillConfirmState,
-  handleKillConfirmInput,
-  renderKillConfirm,
-} from "./session-confirm.js";
-import type { RunSnapshot } from "../shared/store-types.js";
 
-/**
- * Aspirational confirm-modal geometry. Current pi interactive
- * `custom()` does not forward `overlayOptions` to pi-tui's overlay
- * layout (it always uses `{ anchor: "bottom-center", width: "100%",
- * maxHeight: "100%", margin: 0 }`); the value is retained for future
- * hosts that honour the option bag and for the test seam.
- */
-const CONFIRM_OVERLAY: PiOverlayOptions = {
-  anchor: "center",
-  width: "60%",
-};
 
 export interface UiSurface {
   custom?: PiCustomOverlayFunction;
 }
 
-export type SessionPickerIntent = "connect" | "kill" | "pause" | "resume";
+export type SessionPickerIntent = "connect" | "pause" | "resume";
 
 export type SessionPickerResult =
   | { kind: "connect"; runId: string }
-  | { kind: "kill"; runId: string }
   | { kind: "pause"; runId: string }
   | { kind: "resume"; runId: string }
   | { kind: "close" };
@@ -82,9 +55,6 @@ export type SessionPickerResult =
  *
  * `intent` (default `"connect"`) determines what Enter does on a row:
  *   - `connect`: resolve with `{ kind: "connect", runId }`.
- *   - `kill`: resolve with `{ kind: "kill", runId }` (caller still
- *     owns the destructive confirm — `x` on a row preserves the
- *     legacy fast-kill path).
  *   - `pause`: resolve with `{ kind: "pause", runId }`.
  *   - `resume`: resolve with `{ kind: "resume", runId }`.
  */
@@ -94,13 +64,11 @@ export function openSessionPicker(
   theme: GraphTheme,
   intent: SessionPickerIntent = "connect",
 ): Promise<SessionPickerResult> {
-  function toResult(action: { kind: "connect" | "kill"; runId: string }): SessionPickerResult {
-    if (action.kind === "kill") return { kind: "kill", runId: action.runId };
+  function toResult(action: { kind: "connect"; runId: string }): SessionPickerResult {
     // Enter action arrives as `connect` from the picker; remap based on
     // caller intent so a pause/resume picker doesn't open the graph.
     if (intent === "pause") return { kind: "pause", runId: action.runId };
     if (intent === "resume") return { kind: "resume", runId: action.runId };
-    if (intent === "kill") return { kind: "kill", runId: action.runId };
     return { kind: "connect", runId: action.runId };
   }
   return new Promise<SessionPickerResult>((resolve) => {
@@ -168,72 +136,3 @@ export function openSessionPicker(
     void custom(factory, { overlay: false });
   });
 }
-
-/**
- * Mount the kill-confirmation overlay. Resolves with `true` when the user
- * confirms, `false` otherwise. When `pi.ui.custom` is unavailable, falls
- * back to `pi.ui.confirm` if present, else returns `false` (safe default
- * for a destructive action).
- */
-export interface ConfirmUiSurface extends UiSurface {
-  confirm?: (title: string, message: string) => Promise<boolean>;
-}
-
-export function openKillConfirm(
-  ui: ConfirmUiSurface,
-  run: RunSnapshot,
-  theme: GraphTheme,
-): Promise<boolean> {
-  return new Promise<boolean>((resolve) => {
-    const custom = ui.custom;
-    if (typeof custom !== "function") {
-      // Fall back to plain confirm dialog when available.
-      if (typeof ui.confirm === "function") {
-        ui.confirm(
-          "Kill workflow run?",
-          `Abort ${run.name} (${run.id.slice(0, 8)})? Active stage work will be discarded.`,
-        ).then(resolve, () => resolve(false));
-        return;
-      }
-      resolve(false);
-      return;
-    }
-
-    const state = createKillConfirmState();
-    let settled = false;
-
-    const factory = (
-      tui: PiCustomOverlayFactoryTui,
-      _theme: unknown,
-      _keys: unknown,
-      done: (r: undefined) => void,
-    ): PiCustomComponent => {
-      const finish = (result: boolean): void => {
-        if (settled) return;
-        settled = true;
-        done(undefined);
-        resolve(result);
-      };
-      return {
-        render: (width: number) => renderKillConfirm({ width, theme, run, state }),
-        handleInput: (data: string) => {
-          const action = handleKillConfirmInput(data, state);
-          if (action.kind === "noop") {
-            tui.requestRender?.();
-            return;
-          }
-          finish(action.kind === "confirm");
-        },
-        invalidate: () => tui.requestRender?.(),
-        dispose: () => {
-          if (!settled) {
-            settled = true;
-            resolve(false);
-          }
-        },
-      };
-    };
-
-    void custom(factory, { overlay: true, overlayOptions: CONFIRM_OVERLAY });
-  });
-}