@noir-ai/cli 1.14.0 → 1.15.0-beta.1

package/dist/tui/index.js

@@ -1,4 +1,7 @@
 import {
+  INTERRUPT_GRACE_MS,
+  RunInterrupt,
+  UsageReducer,
   buildPaletteCommandsForTui,
   describeContext,
   describeDaemon,
@@ -6,24 +9,37 @@ import {
   describeStore,
   describeWorkflow,
   gatherStatusPayload,
+  humanizeElapsed,
+  interruptedNotice,
   isDestructive,
-  resolveSections
-} from "./chunk-6LO4LXEH.js";
-import "./chunk-2RK6AFZQ.js";
+  loadRunConfig,
+  mergeEnv,
+  normalizeStreamEvent,
+  parseStreamLine,
+  performPostRunAction,
+  postRunActions,
+  resolveRunProfile,
+  resolveSections,
+  runHost,
+  runPromptFrom,
+  writeTranscript
+} from "./chunk-5KWETEMF.js";
+import "./chunk-TPNJEN4B.js";
 import {
   c,
   contentWidth,
   divider,
   useColor
-} from "./chunk-ESZTOQEC.js";
+} from "./chunk-KETMM3BA.js";
 
 // src/tui/index.tsx
-import { loadProjectInfo } from "@noir-ai/core";
+import { SUPPORTED_HOSTS } from "@noir-ai/adapters";
+import { loadProjectInfo, parseConfig } from "@noir-ai/core";
 import { render } from "ink";
 
 // src/tui/App.tsx
-import { Box as Box5, Text as Text8, useApp, useInput } from "ink";
-import { useEffect, useMemo, useState as useState2 } from "react";
+import { Box as Box8, Text as Text11, useApp, useInput as useInput3 } from "ink";
+import { useEffect as useEffect3, useMemo as useMemo2, useState as useState4 } from "react";
 
 // src/tui/CommandInput.tsx
 import { Box, Text } from "ink";
@@ -81,9 +97,13 @@ async function captureProcessOutput(fn) {
 import { Text as Text2 } from "ink";
 
 // src/tui/hints.ts
-var FOOTER_HINT = "?/h/Ctrl+K palette \xB7 Ctrl+F find \xB7 \u2191/\u2193 scroll \xB7 Enter run \xB7 q/Esc quit \xB7 Ctrl+C exit";
+var FOOTER_HINT = "?/h/Ctrl+K palette \xB7 Ctrl+F find \xB7 Ctrl+T transcripts \xB7 \u2191/\u2193 scroll \xB7 Enter run \xB7 q/Esc quit \xB7 Ctrl+C exit";
 var RUNNING_HINT = "running\u2026 (Ctrl+C to force exit)";
 var LIST_NAV_HINT = "\u2191/\u2193 navigate \xB7 Enter run \xB7 Esc close \xB7 Tab view";
+var RUN_HINT = "streaming \u2014 Esc cancels the host";
+var RUN_CANCEL_HINT = "cancelling\u2026";
+var TRANSCRIPT_LIST_HINT = "\u2191/\u2193 choose \xB7 Enter open \xB7 Esc back";
+var TRANSCRIPT_READ_HINT = "\u2191/\u2193 scroll \xB7 Esc back to list \xB7 read-only";
 var HELP_ENTRIES = [
   { keys: "/command", desc: "run a Noir sub-command (e.g. /status, /sync, /task next)" },
   { keys: "Enter", desc: "run the typed /command" },
@@ -94,8 +114,10 @@ var HELP_ENTRIES = [
   { keys: "h", desc: "palette \u2014 commands (quick actions + all commands)" },
   { keys: "Ctrl+K", desc: "palette \u2014 all commands (fuzzy search)" },
   { keys: "Ctrl+F", desc: "palette \u2014 find in the dispatched output" },
+  { keys: "Ctrl+T", desc: "transcripts \u2014 reopen a past run, read-only" },
   { keys: "Tab", desc: "switch between commands, output, and help" },
   { keys: "y / n", desc: "approve / decline a destructive command prompt" },
+  { keys: "Esc (in a run)", desc: "cancel the host and return to the dashboard" },
   { keys: "Ctrl+C", desc: "force exit" }
 ];
 
@@ -168,6 +190,10 @@ function useInputBuffer() {
   return { buffer, setBuffer, pushHistory, recall, clear, seed };
 }
 
+// src/tui/modes/run.tsx
+import { Box as Box4, Text as Text7, useInput } from "ink";
+import { useCallback as useCallback2, useEffect, useMemo, useRef as useRef2, useState as useState2 } from "react";
+
 // src/tui/OutputPane.tsx
 import { Text as Text4 } from "ink";
 import { Fragment, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
@@ -186,14 +212,15 @@ function OutputPane({
   lines,
   scrollOffset,
   height = 12,
-  title
+  title,
+  followTail = false
 }) {
   const width = contentWidth();
   if (lines.length === 0) {
     return /* @__PURE__ */ jsx4(Text4, { children: c.dim("(no output \u2014 type a /command, or ? for help)") });
   }
   const maxOffset = Math.max(0, lines.length - height);
-  const offset = Math.min(Math.max(0, scrollOffset), maxOffset);
+  const offset = followTail ? maxOffset : Math.min(Math.max(0, scrollOffset), maxOffset);
   const rows = toRows(lines.slice(offset, offset + height));
   return /* @__PURE__ */ jsxs3(Fragment, { children: [
     title !== void 0 ? /* @__PURE__ */ jsx4(Text4, { wrap: "truncate-end", children: c.dim(`\u2500\u2500 ${title} \u2500\u2500`) }) : null,
@@ -204,7 +231,7 @@ function OutputPane({
   ] });
 }
 
-// src/tui/overlays/ConfirmOverlay.tsx
+// src/tui/overlays/PostRunOverlay.tsx
 import { Box as Box3, Text as Text5 } from "ink";
 
 // src/tui/Panel.tsx
@@ -227,12 +254,665 @@ function Panel({ children, maxWidth }) {
   );
 }
 
-// src/tui/overlays/ConfirmOverlay.tsx
+// src/tui/overlays/PostRunOverlay.tsx
 import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var OVERLAY_WIDTH = 64;
+function truncate(text, max) {
+  return text.length > max ? `${text.slice(0, Math.max(1, max - 1))}\u2026` : text;
+}
+function PostRunOverlay({
+  options,
+  active,
+  value,
+  working = false,
+  result
+}) {
+  const listFocused = value === void 0 && !working && result === void 0;
+  const elements = [
+    /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsxs4(Text5, { children: [
+      c.bold("\u25B8 run finished "),
+      /* @__PURE__ */ jsx6(Text5, { children: c.dim("\xB7 what next?") })
+    ] }) }, "header")
+  ];
+  for (let i = 0; i < options.length; i++) {
+    const row = options[i];
+    if (!row) continue;
+    const focused = listFocused && i === active;
+    const body = focused ? `${truncate(row.label, 28).padEnd(30)}${truncate(row.hint, 30)}` : truncate(row.label, 60);
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: focused ? c.inverse(`\u25B8 ${body}`) : c.dim(listFocused ? `  ${body}` : `\u25B8 ${body}`) }) }, row.value)
+    );
+  }
+  if (value !== void 0) {
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsxs4(Text5, { children: [
+        c.accent("\u25B8 "),
+        value.value.length > 0 ? value.value : c.dim(value.placeholder),
+        /* @__PURE__ */ jsx6(Text5, { children: c.dim("\u258C") })
+      ] }) }, "value"),
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: c.dim(`${value.label} \u2014 Enter to continue \xB7 Esc to go back`) }) }, "value-label")
+    );
+  }
+  if (value?.notice !== void 0) {
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: c.warn(value.notice) }) }, "value-notice")
+    );
+  }
+  if (working) {
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: c.dim("working\u2026") }) }, "working")
+    );
+  }
+  if (result !== void 0) {
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: result.ok ? c.ok(result.message) : c.warn(result.message) }) }, "result")
+    );
+    elements.push(
+      /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx6(Text5, { children: c.dim("Enter or Esc to close") }) }, "result-hint")
+    );
+  }
+  return /* @__PURE__ */ jsxs4(Box3, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx6(Panel, { maxWidth: OVERLAY_WIDTH, children: elements }),
+    /* @__PURE__ */ jsx6(Text5, { children: c.dim(
+      result !== void 0 ? "Enter close" : value !== void 0 ? "type the value \xB7 Enter continue \xB7 Esc back" : "\u2191/\u2193 choose \xB7 Enter run \xB7 Esc dismiss"
+    ) })
+  ] });
+}
+
+// src/tui/run-stream.ts
+var TOOL_MARK = "\u25CF";
+var RunStream = class {
+  reducer = new UsageReducer();
+  /** The pane, in arrival order. */
+  rows = [];
+  sessionId;
+  model;
+  /** Fold one normalized host event in. */
+  apply(event) {
+    switch (event.kind) {
+      case "init":
+        if (event.sessionId !== void 0) this.sessionId = event.sessionId;
+        if (event.model !== void 0) this.model = event.model;
+        break;
+      case "assistant":
+        this.commitMessage(event);
+        break;
+      case "tool":
+        this.recordTool(event.name, event.messageId !== void 0);
+        break;
+      case "delta":
+        this.appendText(event.text);
+        break;
+      default:
+        break;
+    }
+    this.reducer.add(event);
+  }
+  /**
+   * Settle what is still provisional: called once the run has ended, so a run
+   * that stopped mid-block keeps the words it had already produced and the
+   * tools it had already started instead of losing them (and so a transcript
+   * read back from disk renders completely).
+   */
+  finalize() {
+    for (const row of this.rows) row.pending = false;
+  }
+  /** Everything the run screen renders, as of now. */
+  snapshot() {
+    const usage = this.reducer.snapshot();
+    const lines = [];
+    const answer = [];
+    let toolCount = 0;
+    for (const row of this.rows) {
+      if (row.kind === "tool") {
+        toolCount += 1;
+        lines.push(`${TOOL_MARK} ${row.text}`);
+        continue;
+      }
+      answer.push(row.text);
+      lines.push(...splitRows(row.text));
+    }
+    return {
+      lines,
+      // Provisional text counts: a cancelled run's answer is what it managed to
+      // say, and `finalize` will have committed it anyway.
+      answer: answer.join(""),
+      toolCount,
+      ...this.sessionId === void 0 ? {} : { sessionId: this.sessionId },
+      ...this.model === void 0 ? {} : { model: this.model },
+      inputTokens: usage.inputTokens,
+      outputTokens: usage.outputTokens
+    };
+  }
+  /**
+   * Commit a completed assistant message.
+   *
+   * Its text supersedes the deltas that spelled it out — the host reports the
+   * same words twice — and its tool calls are the authoritative word on the
+   * calls the incremental feed opened, each taking over the row its own
+   * announcement opened. The text lands where its deltas were, which is above
+   * the calls it went on to make: a message that says something and then calls
+   * a tool reads in that order, rather than the call floating above the
+   * sentence that introduced it.
+   */
+  commitMessage(event) {
+    const opened = this.rows.findIndex((row) => row.kind === "text" && row.pending);
+    const at = opened === -1 ? this.rows.length : opened;
+    for (let i = this.rows.length - 1; i >= 0; i--) {
+      const row = this.rows[i];
+      if (row !== void 0 && row.kind === "text" && row.pending) this.rows.splice(i, 1);
+    }
+    if (event.isError !== true && event.text !== void 0 && event.text.length > 0) {
+      this.rows.splice(at, 0, { kind: "text", text: event.text, pending: false });
+    }
+    for (const name of event.tools ?? []) this.recordTool(name, true);
+  }
+  /**
+   * Record a tool call, confirmed by a completed message or announced by the
+   * frame that opened its block. A confirmed call takes over the row the
+   * announcement left open; with nothing to take over — the first word on the
+   * call, which is all some hosts ever send — it opens a row of its own.
+   */
+  recordTool(name, confirmed) {
+    if (confirmed) {
+      const opened = this.rows.findIndex(
+        (row2) => row2.kind === "tool" && row2.pending && row2.text === name
+      );
+      const row = this.rows[opened];
+      if (row !== void 0) {
+        row.pending = false;
+        return;
+      }
+    }
+    this.rows.push({ kind: "tool", text: name, pending: !confirmed });
+  }
+  /** Extend the stretch of text the host is writing, or start a new one. */
+  appendText(text) {
+    const last = this.rows[this.rows.length - 1];
+    if (last !== void 0 && last.kind === "text" && last.pending) {
+      this.rows[this.rows.length - 1] = { kind: "text", text: last.text + text, pending: true };
+      return;
+    }
+    this.rows.push({ kind: "text", text, pending: true });
+  }
+};
+function splitRows(text) {
+  const rows = text.split("\n");
+  while (rows.length > 0 && rows[rows.length - 1] === "") rows.pop();
+  return rows;
+}
+function renderTranscript(rawLines) {
+  const stream = new RunStream();
+  for (const line of rawLines) {
+    const raw = parseStreamLine(line);
+    if (raw === null) continue;
+    const event = normalizeStreamEvent(raw);
+    if (event !== null) stream.apply(event);
+  }
+  stream.finalize();
+  return stream.snapshot().lines;
+}
+
+// src/tui/StatusBar.tsx
+import { Text as Text6 } from "ink";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+function Cell({
+  label,
+  value,
+  accent
+}) {
+  return /* @__PURE__ */ jsxs5(Text6, { children: [
+    /* @__PURE__ */ jsx7(Text6, { children: c.dim(`${label}:`) }),
+    " ",
+    /* @__PURE__ */ jsx7(Text6, { children: accent ? c.accent(value) : value })
+  ] });
+}
+function StatusBar({ payload, loading, run }) {
+  if (run !== void 0) {
+    const tools = run.tools !== void 0 && run.tools > 0 ? ` \xB7 ${run.tools} tool${run.tools === 1 ? "" : "s"}` : "";
+    return /* @__PURE__ */ jsx7(Text6, { children: /* @__PURE__ */ jsx7(Cell, { label: "run", value: `${run.model} \xB7 ${run.elapsed} \xB7 ${run.tokens}${tools}`, accent: true }) });
+  }
+  const host = payload?.host ?? "\u2014";
+  const mode = payload?.workflow?.mode ?? "\u2014";
+  const phase = payload?.workflow?.phase ?? (loading ? "\u2026" : "idle");
+  const daemonRunning = payload?.daemon.running === true;
+  const daemon = payload === null && loading ? "\u2026" : daemonRunning ? "up" : "down";
+  return /* @__PURE__ */ jsxs5(Text6, { children: [
+    /* @__PURE__ */ jsx7(Cell, { label: "host", value: host, accent: true }),
+    /* @__PURE__ */ jsx7(Text6, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx7(Cell, { label: "mode", value: mode }),
+    /* @__PURE__ */ jsx7(Text6, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsx7(Cell, { label: "phase", value: phase }),
+    /* @__PURE__ */ jsx7(Text6, { children: c.dim(" \xB7 ") }),
+    /* @__PURE__ */ jsxs5(Text6, { children: [
+      c.dim("daemon:"),
+      " ",
+      daemonRunning ? c.ok(daemon) : c.warn(daemon)
+    ] })
+  ] });
+}
+
+// src/tui/modes/run.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var EMPTY_STREAM = {
+  lines: [],
+  answer: "",
+  toolCount: 0,
+  inputTokens: 0,
+  outputTokens: 0
+};
+function tokenCell(input, output) {
+  return `\u2193${input.toLocaleString()}\u2191${output.toLocaleString()} tokens`;
+}
+function RunMode({
+  prompt,
+  deps,
+  onExit,
+  onQuit = onExit,
+  height = 14,
+  tickMs = 1e3,
+  now = Date.now,
+  graceMs = INTERRUPT_GRACE_MS
+}) {
+  const [stream, setStream] = useState2(EMPTY_STREAM);
+  const [binary, setBinary] = useState2("host");
+  const [phase, setPhase] = useState2({ kind: "running" });
+  const [elapsedMs, setElapsedMs] = useState2(0);
+  const [turn, setTurn] = useState2({ prompt });
+  const [valueBuffer, setValueBuffer] = useState2("");
+  const [valueNotice, setValueNotice] = useState2(null);
+  const [postRun, setPostRun] = useState2(null);
+  const [statusHint, setStatusHint] = useState2(null);
+  const interruptRef = useRef2(null);
+  const rawLinesRef = useRef2([]);
+  const startedAtRef = useRef2(now());
+  const exitRef = useRef2(onExit);
+  useEffect(() => {
+    exitRef.current = onExit;
+  }, [onExit]);
+  useEffect(() => {
+    const streamState = new RunStream();
+    const interrupt = new RunInterrupt({ graceMs });
+    interruptRef.current = interrupt;
+    rawLinesRef.current = [];
+    startedAtRef.current = now();
+    let live = true;
+    setStream(streamState.snapshot());
+    setElapsedMs(0);
+    setPostRun(null);
+    setPhase({ kind: "running" });
+    setStatusHint(null);
+    const tick = setInterval(() => {
+      if (live) setElapsedMs(now() - startedAtRef.current);
+    }, tickMs);
+    let session;
+    try {
+      session = deps.start(
+        turn.prompt,
+        {
+          onEvent: (event) => {
+            streamState.apply(event);
+            if (live) setStream(streamState.snapshot());
+          },
+          onLine: (line) => {
+            rawLinesRef.current.push(line);
+          },
+          signal: interrupt.signal,
+          onChild: (child) => interrupt.track(child)
+        },
+        turn.sessionId
+      );
+    } catch (err) {
+      clearInterval(tick);
+      setPhase({
+        kind: "ended",
+        ok: false,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return () => {
+        live = false;
+      };
+    }
+    setBinary(session.binary);
+    void session.done.then(async (result) => {
+      streamState.finalize();
+      const snapshot = streamState.snapshot();
+      const cancelled = interrupt.signal.aborted;
+      const transcript = await deps.transcripts?.write(rawLinesRef.current) ?? "(not persisted)";
+      if (!live) return;
+      setStream(snapshot);
+      if (cancelled) {
+        exitRef.current(interruptedNotice(transcript));
+        return;
+      }
+      if (result.isError || result.exitCode !== 0) {
+        setPhase({ kind: "ended", ok: false, message: failureText(result, session.binary) });
+        return;
+      }
+      setPostRun({
+        answer: snapshot.answer,
+        transcript,
+        host: session.binary,
+        ...snapshot.sessionId === void 0 ? {} : { sessionId: snapshot.sessionId },
+        canContinue: snapshot.sessionId !== void 0
+      });
+      setPhase({ kind: "menu", active: 0 });
+    }).catch((err) => {
+      if (!live) return;
+      setPhase({
+        kind: "ended",
+        ok: false,
+        message: `could not run ${session.binary}: ${err instanceof Error ? err.message : String(err)}`
+      });
+    });
+    return () => {
+      live = false;
+      clearInterval(tick);
+      interrupt.terminate();
+    };
+  }, [turn, deps, now, tickMs, graceMs]);
+  const options = useMemo(() => postRun === null ? [] : deps.actions(postRun), [postRun, deps]);
+  const choose = useCallback2(
+    (choice, value) => {
+      if (postRun === null) return;
+      const label = options.find((o) => o.value === choice)?.label ?? "That action";
+      if (choice === "dismiss") {
+        onExit("run finished");
+        return;
+      }
+      if (choice === "resume") {
+        const sessionId = postRun.sessionId;
+        if (sessionId === void 0 || value === void 0 || value.trim().length === 0) {
+          setValueNotice("a follow-up prompt is required");
+          return;
+        }
+        setValueBuffer("");
+        setValueNotice(null);
+        setTurn({ prompt: value.trim(), sessionId });
+        return;
+      }
+      setPhase({ kind: "working", message: label });
+      void (async () => {
+        let outcome = { ok: true, message: "" };
+        const captured = await captureProcessOutput(async () => {
+          outcome = await deps.perform(postRun, choice, value);
+        });
+        const written = `${captured.stdout}${captured.stderr}`.trim();
+        setPhase({
+          kind: "result",
+          ok: outcome.ok,
+          message: [outcome.message, outcome.detail, written].filter((part) => part !== void 0 && part.length > 0).join(" \u2014 ").replace(/\s+/g, " ")
+        });
+      })();
+    },
+    [deps, onExit, options, postRun]
+  );
+  const submitValue = useCallback2(
+    (option) => {
+      const value = valueBuffer;
+      if (option.needsValue !== void 0 && value.trim().length === 0 && option.value !== "save") {
+        setValueNotice(`a ${option.needsValue.label} is required`);
+        return;
+      }
+      setValueBuffer("");
+      setValueNotice(null);
+      choose(option.value, value);
+    },
+    [choose, valueBuffer]
+  );
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (phase.kind === "running") {
+        const interrupt = interruptRef.current;
+        if (interrupt === null) return;
+        if (interrupt.signal.aborted) {
+          interrupt.forceNow();
+          return;
+        }
+        interrupt.terminate();
+        setStatusHint(RUN_CANCEL_HINT);
+        return;
+      }
+      onQuit();
+      return;
+    }
+    if (phase.kind === "running") {
+      if (key.escape) {
+        interruptRef.current?.terminate();
+        setStatusHint(RUN_CANCEL_HINT);
+      }
+      return;
+    }
+    if (phase.kind === "ended") {
+      if (key.return || key.escape) onExit();
+      return;
+    }
+    if (phase.kind === "result") {
+      if (key.return || key.escape) setPhase({ kind: "menu", active: 0 });
+      return;
+    }
+    if (phase.kind === "working") return;
+    if (phase.kind === "value") {
+      if (key.escape) {
+        setValueBuffer("");
+        setValueNotice(null);
+        setPhase({ kind: "menu", active: 0 });
+        return;
+      }
+      if (key.return) {
+        submitValue(phase.option);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setValueBuffer((b) => b.slice(0, -1));
+        setValueNotice(null);
+        return;
+      }
+      if (key.ctrl || key.tab || key.upArrow || key.downArrow) return;
+      if (input.length > 0) {
+        setValueBuffer((b) => b + input);
+        setValueNotice(null);
+      }
+      return;
+    }
+    if (key.escape) {
+      onExit("run finished");
+      return;
+    }
+    if (key.return) {
+      const option = options[phase.active];
+      if (option === void 0) return;
+      if (option.needsValue === void 0) {
+        choose(option.value);
+        return;
+      }
+      setValueBuffer("");
+      setValueNotice(null);
+      setPhase({ kind: "value", option });
+      return;
+    }
+    if (key.upArrow) {
+      setPhase({ kind: "menu", active: Math.max(0, phase.active - 1) });
+      return;
+    }
+    if (key.downArrow) {
+      setPhase({
+        kind: "menu",
+        active: Math.min(Math.max(0, options.length - 1), phase.active + 1)
+      });
+    }
+  });
+  const valueStep = phase.kind === "value" && phase.option.needsValue !== void 0 ? {
+    label: phase.option.needsValue.label,
+    placeholder: phase.option.needsValue.placeholder,
+    value: valueBuffer,
+    ...valueNotice === null ? {} : { notice: valueNotice }
+  } : void 0;
+  const overlay = phase.kind === "menu" || phase.kind === "value" || phase.kind === "working" || phase.kind === "result" ? /* @__PURE__ */ jsx8(
+    PostRunOverlay,
+    {
+      options,
+      active: phase.kind === "menu" ? phase.active : 0,
+      ...valueStep === void 0 ? {} : { value: valueStep },
+      ...phase.kind === "working" ? { working: true } : {},
+      ...phase.kind === "result" ? { result: { ok: phase.ok, message: phase.message } } : {}
+    }
+  ) : null;
+  return /* @__PURE__ */ jsxs6(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Header, { tagline: "run" }),
+    /* @__PURE__ */ jsxs6(Panel, { children: [
+      /* @__PURE__ */ jsx8(Box4, { paddingX: 1, children: /* @__PURE__ */ jsx8(
+        StatusBar,
+        {
+          payload: null,
+          run: {
+            model: stream.model ?? binary,
+            elapsed: humanizeElapsed(elapsedMs),
+            tokens: tokenCell(stream.inputTokens, stream.outputTokens),
+            tools: stream.toolCount
+          }
+        }
+      ) }),
+      /* @__PURE__ */ jsx8(Box4, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text7, { children: divider() }) }),
+      /* @__PURE__ */ jsx8(Box4, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx8(
+        OutputPane,
+        {
+          lines: stream.lines,
+          scrollOffset: 0,
+          height,
+          title: prompt,
+          followTail: true
+        }
+      ) })
+    ] }),
+    phase.kind === "running" ? /* @__PURE__ */ jsx8(Text7, { children: c.dim(statusHint ?? RUN_HINT) }) : null,
+    phase.kind === "ended" ? /* @__PURE__ */ jsx8(Text7, { children: phase.ok ? c.ok(phase.message) : c.warn(phase.message) }) : null,
+    overlay
+  ] });
+}
+function failureText(result, binary) {
+  const reason = result.errorText !== void 0 && result.errorText.trim().length > 0 ? result.errorText.trim() : `exit code ${result.exitCode}`;
+  return `${binary} failed: ${reason}`;
+}
+
+// src/tui/modes/transcripts.tsx
+import { Box as Box5, Text as Text8, useInput as useInput2 } from "ink";
+import { useEffect as useEffect2, useState as useState3 } from "react";
+import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+function TranscriptPicker({
+  transcripts,
+  onExit,
+  height = 14
+}) {
+  const [entries, setEntries] = useState3([]);
+  const [loading, setLoading] = useState3(true);
+  const [active, setActive] = useState3(0);
+  const [view, setView] = useState3({ kind: "list" });
+  const [scroll, setScroll] = useState3(0);
+  useEffect2(() => {
+    let live = true;
+    void transcripts.list().then((found) => {
+      if (live) setEntries(found);
+    }).catch(() => {
+      if (live) setEntries([]);
+    }).finally(() => {
+      if (live) setLoading(false);
+    });
+    return () => {
+      live = false;
+    };
+  }, [transcripts]);
+  useInput2((_input, key) => {
+    if (loading) {
+      if (key.escape) onExit();
+      return;
+    }
+    if (view.kind === "list") {
+      if (key.escape) {
+        onExit();
+        return;
+      }
+      if (key.return) {
+        const entry = entries[active];
+        if (entry === void 0) return;
+        void transcripts.read(entry.path).then((lines) => {
+          setView({ kind: "open", name: entry.name, lines: renderTranscript(lines) });
+          setScroll(0);
+        }).catch(() => {
+        });
+        return;
+      }
+      if (key.upArrow) {
+        setActive((a) => Math.max(0, a - 1));
+        return;
+      }
+      if (key.downArrow) {
+        setActive((a) => Math.min(Math.max(0, entries.length - 1), a + 1));
+        return;
+      }
+      return;
+    }
+    if (key.escape) {
+      setView({ kind: "list" });
+      return;
+    }
+    if (key.upArrow) setScroll((s) => Math.max(0, s - 1));
+    if (key.downArrow) setScroll((s) => s + 1);
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Header, { tagline: "transcripts" }),
+      /* @__PURE__ */ jsx9(Panel, { children: /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx9(Text8, { children: c.dim("loading transcripts\u2026") }) }) }),
+      /* @__PURE__ */ jsx9(Text8, { children: c.dim("Esc back") })
+    ] });
+  }
+  if (view.kind === "open") {
+    return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Header, { tagline: `transcripts \xB7 ${view.name}` }),
+      /* @__PURE__ */ jsx9(Panel, { children: /* @__PURE__ */ jsx9(Box5, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx9(
+        OutputPane,
+        {
+          lines: view.lines.length > 0 ? view.lines : ["(empty transcript)"],
+          scrollOffset: scroll,
+          height,
+          title: view.name
+        }
+      ) }) }),
+      /* @__PURE__ */ jsx9(Text8, { children: c.dim(TRANSCRIPT_READ_HINT) })
+    ] });
+  }
+  if (entries.length === 0) {
+    return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx9(Header, { tagline: "transcripts" }),
+      /* @__PURE__ */ jsx9(Panel, { children: /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx9(Text8, { children: c.dim("no transcripts yet \u2014 a run leaves one here") }) }) }),
+      /* @__PURE__ */ jsx9(Text8, { children: c.dim("Esc back") })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx9(Header, { tagline: "transcripts" }),
+    /* @__PURE__ */ jsxs7(Panel, { children: [
+      /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsxs7(Text8, { children: [
+        c.bold("\u25B8 recent transcripts "),
+        /* @__PURE__ */ jsx9(Text8, { children: c.dim("\xB7 newest first") })
+      ] }) }),
+      entries.map((entry, i) => {
+        const focused = i === active;
+        const when = new Date(entry.mtimeMs).toISOString().replace("T", " ").slice(0, 19);
+        const row = `${entry.name} \xB7 ${when} \xB7 ${entry.sizeBytes} bytes`;
+        return /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx9(Text8, { children: focused ? c.inverse(`\u25B8 ${row}`) : c.dim(`  ${row}`) }) }, entry.path);
+      })
+    ] }),
+    /* @__PURE__ */ jsx9(Text8, { children: c.dim(TRANSCRIPT_LIST_HINT) })
+  ] });
+}
+
+// src/tui/overlays/ConfirmOverlay.tsx
+import { Box as Box6, Text as Text9 } from "ink";
+import { jsx as jsx10, jsxs as jsxs8 } from "react/jsx-runtime";
 function ConfirmOverlay({ argv }) {
-  return /* @__PURE__ */ jsx6(Panel, { children: /* @__PURE__ */ jsx6(Box3, { paddingX: 1, children: /* @__PURE__ */ jsxs4(Text5, { children: [
+  return /* @__PURE__ */ jsx10(Panel, { children: /* @__PURE__ */ jsx10(Box6, { paddingX: 1, children: /* @__PURE__ */ jsxs8(Text9, { children: [
     c.warn(`! run /${argv.join(" ")}? (y/N)`),
-    /* @__PURE__ */ jsx6(Text5, { children: c.dim("  [y approve \xB7 n/Esc back to palette]") })
+    /* @__PURE__ */ jsx10(Text9, { children: c.dim("  [y approve \xB7 n/Esc back to palette]") })
   ] }) }) });
 }
 
@@ -329,7 +1009,7 @@ var handRolledMatcher = {
 };
 
 // src/tui/palette/Palette.tsx
-import { Box as Box4, Text as Text6 } from "ink";
+import { Box as Box7, Text as Text10 } from "ink";
 
 // src/tui/palette/output.ts
 function computeMatches(lines, query) {
@@ -357,6 +1037,20 @@ function recentDeduped(recent, commands) {
   const known = new Set(commands.map((cmd) => cmd.id));
   return recent.filter((cmd) => known.has(cmd.id));
 }
+function argRequirements(commands, homeSections) {
+  const out = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    if (cmd.needsArg !== void 0) out.set(cmd.argv.join(" "), cmd.needsArg);
+  }
+  for (const { action } of flattenHome(homeSections)) {
+    const label = action.needsArg?.label;
+    if (label !== void 0) out.set((action.dispatch ?? [action.id]).join(" "), label);
+  }
+  return out;
+}
+function requirementFor(requirements, argv, id) {
+  return requirements.get(argv.join(" ")) ?? requirements.get(id);
+}
 function buildPaletteRows(input) {
   const { corpus, query, commands, matcher, recent, homeSections, outputLines } = input;
   if (corpus === "help") {
@@ -414,6 +1108,7 @@ function buildPaletteRows(input) {
       group: "matches"
     }));
   }
+  const args = argRequirements(commands, homeSections);
   if (query.length === 0) {
     const rows = [];
     const recents = recentDeduped(recent, commands);
@@ -425,7 +1120,8 @@ function buildPaletteRows(input) {
         secondary: cmd.description,
         argv: cmd.argv,
         destructive: cmd.destructive,
-        group: "recent"
+        group: "recent",
+        needsArg: requirementFor(args, cmd.argv, cmd.id)
       });
     }
     const homeIds = /* @__PURE__ */ new Set();
@@ -439,7 +1135,8 @@ function buildPaletteRows(input) {
         secondary: action.hint,
         argv,
         destructive: action.destructive ?? false,
-        group
+        group,
+        needsArg: requirementFor(args, argv, action.id)
       });
     }
     for (const cmd of commands) {
@@ -450,7 +1147,8 @@ function buildPaletteRows(input) {
         secondary: cmd.description,
         argv: cmd.argv,
         destructive: cmd.destructive,
-        group: cmd.category
+        group: cmd.category,
+        needsArg: requirementFor(args, cmd.argv, cmd.id)
       });
     }
     return rows;
@@ -461,12 +1159,13 @@ function buildPaletteRows(input) {
     secondary: m.item.description,
     argv: m.item.argv,
     destructive: m.item.destructive,
-    group: null
+    group: null,
+    needsArg: requirementFor(args, m.item.argv, m.item.id)
   }));
 }
 
 // src/tui/palette/Palette.tsx
-import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+import { jsx as jsx11, jsxs as jsxs9 } from "react/jsx-runtime";
 var PALETTE_WIDTH = 64;
 var ROW_TEXT_WIDTH = PALETTE_WIDTH - 6;
 var LABEL_WIDTH = 26;
@@ -495,22 +1194,31 @@ function placeholder(corpus) {
   if (corpus === "output") return "type to filter output";
   return "keybindings";
 }
-function Palette({ corpus, query, active, rows }) {
+function Palette({ corpus, query, active, rows, arg }) {
   const total = rows.length;
   const scroll = Math.max(0, Math.min(active - (VISIBLE_ROWS - 1), total - VISIBLE_ROWS));
   const visible = rows.slice(scroll, scroll + VISIBLE_ROWS);
   const activeIndex = Math.min(Math.max(active - scroll, 0), Math.max(0, visible.length - 1));
+  const input = arg === void 0 ? { marker: c.dim("> "), body: query.length > 0 ? query : c.dim(placeholder(corpus)) } : {
+    marker: c.accent("\u25B8 "),
+    body: arg.value.length > 0 ? arg.value : c.dim(arg.placeholder)
+  };
   const elements = [
-    /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsxs5(Text6, { children: [
+    /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsxs9(Text10, { children: [
       c.bold("\u25B8 palette "),
-      /* @__PURE__ */ jsx7(Text6, { children: c.dim(`\xB7 ${corpus}`) })
+      /* @__PURE__ */ jsx11(Text10, { children: c.dim(`\xB7 ${corpus}`) })
     ] }) }, "header"),
-    /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsxs5(Text6, { children: [
-      c.dim("> "),
-      query.length > 0 ? query : c.dim(placeholder(corpus)),
-      /* @__PURE__ */ jsx7(Text6, { children: c.dim("\u258C") })
+    /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsxs9(Text10, { children: [
+      input.marker,
+      input.body,
+      /* @__PURE__ */ jsx11(Text10, { children: c.dim("\u258C") })
     ] }) }, "query")
   ];
+  if (arg?.hint !== void 0) {
+    elements.push(
+      /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx11(Text10, { children: c.warn(arg.hint) }) }, "arg-hint")
+    );
+  }
   let lastGroup = null;
   for (let i = 0; i < visible.length; i++) {
     const row = visible[i];
@@ -518,27 +1226,32 @@ function Palette({ corpus, query, active, rows }) {
     if (row.group !== null && row.group !== lastGroup) {
       if (lastGroup !== null) {
         elements.push(
-          /* @__PURE__ */ jsx7(Box4, { children: /* @__PURE__ */ jsx7(Text6, { children: " " }) }, `gap:${row.group}`)
+          /* @__PURE__ */ jsx11(Box7, { children: /* @__PURE__ */ jsx11(Text10, { children: " " }) }, `gap:${row.group}`)
         );
       }
       elements.push(
-        /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsx7(Text6, { children: c.bold(`\u2500\u2500 ${row.group} \u2500\u2500`) }) }, `cat:${row.group}`)
+        /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx11(Text10, { children: c.bold(`\u2500\u2500 ${row.group} \u2500\u2500`) }) }, `cat:${row.group}`)
       );
       lastGroup = row.group;
     }
     const isActive = i === activeIndex;
-    const prefix = isActive ? "\u25B8 " : "  ";
+    const focused = isActive && arg === void 0;
+    const prefix = focused ? "\u25B8 " : "  ";
     const label = truncateLabel(row.primary);
     const labelCol = (prefix + label).padEnd(LABEL_WIDTH);
     const hintRaw = row.argv ? `/${row.argv.join(" ")}` : row.secondary;
     const hint = hintRaw.length > HINT_WIDTH ? `${hintRaw.slice(0, HINT_WIDTH - 1)}\u2026` : hintRaw;
-    if (isActive) {
+    if (focused) {
       elements.push(
-        /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsx7(Text6, { children: c.inverse(`${labelCol}${hint}`) }) }, row.key)
+        /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx11(Text10, { children: c.inverse(`${labelCol}${hint}`) }) }, row.key)
+      );
+    } else if (arg !== void 0) {
+      elements.push(
+        /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx11(Text10, { children: c.dim(`${labelCol}${hint}`) }) }, row.key)
       );
     } else {
       elements.push(
-        /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsxs5(Text6, { children: [
+        /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsxs9(Text10, { children: [
           c.bold(labelCol),
           hint.length > 0 ? c.dim(hint) : null
         ] }) }, row.key)
@@ -550,54 +1263,19 @@ function Palette({ corpus, query, active, rows }) {
         const line = detailLines[di] ?? "";
         const prefix2 = di === 0 ? "  \u21B3 " : "    ";
         elements.push(
-          /* @__PURE__ */ jsx7(Box4, { paddingX: 1, children: /* @__PURE__ */ jsx7(Text6, { children: c.dim(`${prefix2}${line}`) }) }, `${row.key}:d:${di}`)
+          /* @__PURE__ */ jsx11(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx11(Text10, { children: c.dim(`${prefix2}${line}`) }) }, `${row.key}:d:${di}`)
         );
       }
     }
   }
-  return /* @__PURE__ */ jsxs5(Box4, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx7(Panel, { maxWidth: PALETTE_WIDTH, children: elements }),
-    /* @__PURE__ */ jsx7(Text6, { children: c.dim(LIST_NAV_HINT) })
-  ] });
-}
-
-// src/tui/StatusBar.tsx
-import { Text as Text7 } from "ink";
-import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
-function Cell({
-  label,
-  value,
-  accent
-}) {
-  return /* @__PURE__ */ jsxs6(Text7, { children: [
-    /* @__PURE__ */ jsx8(Text7, { children: c.dim(`${label}:`) }),
-    " ",
-    /* @__PURE__ */ jsx8(Text7, { children: accent ? c.accent(value) : value })
-  ] });
-}
-function StatusBar({ payload, loading }) {
-  const host = payload?.host ?? "\u2014";
-  const mode = payload?.workflow?.mode ?? "\u2014";
-  const phase = payload?.workflow?.phase ?? (loading ? "\u2026" : "idle");
-  const daemonRunning = payload?.daemon.running === true;
-  const daemon = payload === null && loading ? "\u2026" : daemonRunning ? "up" : "down";
-  return /* @__PURE__ */ jsxs6(Text7, { children: [
-    /* @__PURE__ */ jsx8(Cell, { label: "host", value: host, accent: true }),
-    /* @__PURE__ */ jsx8(Text7, { children: c.dim(" \xB7 ") }),
-    /* @__PURE__ */ jsx8(Cell, { label: "mode", value: mode }),
-    /* @__PURE__ */ jsx8(Text7, { children: c.dim(" \xB7 ") }),
-    /* @__PURE__ */ jsx8(Cell, { label: "phase", value: phase }),
-    /* @__PURE__ */ jsx8(Text7, { children: c.dim(" \xB7 ") }),
-    /* @__PURE__ */ jsxs6(Text7, { children: [
-      c.dim("daemon:"),
-      " ",
-      daemonRunning ? c.ok(daemon) : c.warn(daemon)
-    ] })
+  return /* @__PURE__ */ jsxs9(Box7, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx11(Panel, { maxWidth: PALETTE_WIDTH, children: elements }),
+    /* @__PURE__ */ jsx11(Text10, { children: c.dim(LIST_NAV_HINT) })
   ] });
 }
 
 // src/tui/App.tsx
-import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
 function App({
   deps,
   initialPayload = null,
@@ -606,20 +1284,22 @@ function App({
 }) {
   const { exit } = useApp();
   const { buffer, setBuffer, pushHistory, recall, clear, seed } = useInputBuffer();
-  const [mode, setMode] = useState2(initialMode);
-  const [payload, setPayload] = useState2(initialPayload);
-  const [loading, setLoading] = useState2(initialPayload === null);
-  const [output, setOutput] = useState2(null);
-  const [searchLines, setSearchLines] = useState2([]);
-  const [scrollOffset, setScrollOffset] = useState2(0);
-  const [running, setRunning] = useState2(false);
-  const [notice, setNotice] = useState2(null);
-  const [pending, setPending] = useState2(null);
-  const [recent, setRecent] = useState2([]);
-  const [homeSections, setHomeSections] = useState2([]);
-  const [paletteQuery, setPaletteQuery] = useState2("");
-  const [paletteActive, setPaletteActive] = useState2(0);
-  useEffect(() => {
+  const [mode, setMode] = useState4(initialMode);
+  const [payload, setPayload] = useState4(initialPayload);
+  const [loading, setLoading] = useState4(initialPayload === null);
+  const [output, setOutput] = useState4(null);
+  const [searchLines, setSearchLines] = useState4([]);
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  const [running, setRunning] = useState4(false);
+  const [notice, setNotice] = useState4(null);
+  const [pending, setPending] = useState4(null);
+  const [recent, setRecent] = useState4([]);
+  const [homeSections, setHomeSections] = useState4([]);
+  const [paletteQuery, setPaletteQuery] = useState4("");
+  const [paletteActive, setPaletteActive] = useState4(0);
+  const [argBuffer, setArgBuffer] = useState4("");
+  const [argNotice, setArgNotice] = useState4(null);
+  useEffect3(() => {
     if (!deps.loadRecent) return;
     const loader = deps.loadRecent;
     let cancelled = false;
@@ -634,7 +1314,7 @@ function App({
       cancelled = true;
     };
   }, [deps.loadRecent, seed]);
-  useEffect(() => {
+  useEffect3(() => {
     let cancelled = false;
     void resolveSections(deps.commands ?? []).then((sections) => {
       if (!cancelled) setHomeSections(sections);
@@ -643,7 +1323,7 @@ function App({
       cancelled = true;
     };
   }, [deps.commands]);
-  useEffect(() => {
+  useEffect3(() => {
     if (running || mode.kind !== "dashboard") return;
     let cancelled = false;
     let inFlight = false;
@@ -668,7 +1348,7 @@ function App({
       clearInterval(id);
     };
   }, [running, mode.kind, refreshMs, deps.fetchStatus]);
-  useEffect(() => {
+  useEffect3(() => {
     if (pending === null) return;
     const argv = pending;
     let active = true;
@@ -700,6 +1380,14 @@ function App({
       setMode({ kind: "confirm", argv: [...argv] });
       return;
     }
+    enterRunOrDispatch(argv);
+  }
+  function enterRunOrDispatch(argv) {
+    const prompt = deps.run === void 0 ? null : runPromptFrom(argv);
+    if (prompt !== null) {
+      setMode({ kind: "run", prompt });
+      return;
+    }
     dispatchCmd([...argv]);
     void recordRuns([...argv]);
     pushHistory(`/${argv.join(" ")}`);
@@ -777,6 +1465,10 @@ function App({
         openOutputSearch();
         return;
       }
+      if (input === "t" && deps.run?.transcripts !== void 0) {
+        setMode({ kind: "transcripts" });
+        return;
+      }
       return;
     }
     if (input.length === 1) {
@@ -807,6 +1499,10 @@ function App({
   }
   function handlePaletteInput(input, key) {
     if (mode.kind !== "palette") return;
+    if (mode.collecting !== void 0) {
+      handleArgInput(input, key, mode.collecting);
+      return;
+    }
     if (key.escape) {
       setPaletteQuery("");
       setPaletteActive(0);
@@ -827,7 +1523,22 @@ function App({
     if (key.return) {
       if (mode.corpus === "commands") {
         const row = paletteRows[paletteActive];
-        if (row?.argv) handleRun(row.argv, row.destructive);
+        if (!row?.argv) return;
+        if (row.needsArg !== void 0) {
+          setArgBuffer("");
+          setArgNotice(null);
+          setMode({
+            kind: "palette",
+            corpus: mode.corpus,
+            collecting: {
+              argv: [...row.argv],
+              label: row.needsArg,
+              destructive: row.destructive
+            }
+          });
+          return;
+        }
+        handleRun(row.argv, row.destructive);
       } else {
         moveActive(1);
       }
@@ -852,6 +1563,37 @@ function App({
       setPaletteActive(0);
     }
   }
+  function handleArgInput(input, key, collecting) {
+    if (mode.kind !== "palette") return;
+    const corpus = mode.corpus;
+    if (key.escape) {
+      setArgBuffer("");
+      setArgNotice(null);
+      setMode({ kind: "palette", corpus });
+      return;
+    }
+    if (key.return) {
+      const value = argBuffer.trim();
+      if (value.length === 0) {
+        setArgNotice(`a ${collecting.label} is required`);
+        return;
+      }
+      setArgBuffer("");
+      setArgNotice(null);
+      handleRun([...collecting.argv, value], collecting.destructive);
+      return;
+    }
+    if (key.backspace || key.delete) {
+      setArgBuffer((b) => b.slice(0, -1));
+      setArgNotice(null);
+      return;
+    }
+    if (key.ctrl || key.tab) return;
+    if (input.length > 0) {
+      setArgBuffer((b) => b + input);
+      setArgNotice(null);
+    }
+  }
   function handleConfirmInput(input, key) {
     if (key.escape || input === "n" || input === "N") {
       setPaletteQuery("");
@@ -861,13 +1603,14 @@ function App({
     }
     if (input === "y" || input === "Y") {
       if (mode.kind !== "confirm") return;
-      dispatchCmd([...mode.argv]);
-      void recordRuns([...mode.argv]);
-      pushHistory(`/${mode.argv.join(" ")}`);
-      setMode({ kind: "dashboard" });
+      enterRunOrDispatch(mode.argv);
     }
   }
-  useInput((input, key) => {
+  useInput3((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (mode.kind !== "run") exit();
+      return;
+    }
     switch (mode.kind) {
       case "dashboard":
         handleDashboardInput(input, key);
@@ -878,6 +1621,9 @@ function App({
       case "confirm":
         handleConfirmInput(input, key);
         return;
+      case "run":
+      case "transcripts":
+        return;
     }
   });
   function submit() {
@@ -901,7 +1647,7 @@ function App({
     dispatchCmd(argv);
     void recordRuns(argv);
   }
-  const paletteRows = useMemo(
+  const paletteRows = useMemo2(
     () => buildPaletteRows({
       corpus: mode.kind === "palette" ? mode.corpus : "commands",
       query: paletteQuery,
@@ -914,40 +1660,64 @@ function App({
     [mode, paletteQuery, deps.commands, deps.matcher, recent, homeSections, searchLines]
   );
   if (mode.kind === "palette") {
-    return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(Header, { tagline: `palette \xB7 ${mode.corpus}` }),
-      /* @__PURE__ */ jsx9(
+    const collecting = mode.collecting;
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Header, { tagline: `palette \xB7 ${mode.corpus}` }),
+      /* @__PURE__ */ jsx12(
         Palette,
         {
           corpus: mode.corpus,
           query: paletteQuery,
           active: paletteActive,
-          rows: paletteRows
+          rows: paletteRows,
+          arg: collecting === void 0 ? void 0 : {
+            value: argBuffer,
+            placeholder: `${collecting.label} for ${collecting.argv.join(" ")}\u2026`,
+            hint: argNotice ?? void 0
+          }
         }
       ),
-      /* @__PURE__ */ jsx9(Footer, { running: false })
+      /* @__PURE__ */ jsx12(Footer, { running: false })
     ] });
   }
   if (mode.kind === "confirm") {
-    return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
-      /* @__PURE__ */ jsx9(Header, { tagline: "confirm" }),
-      /* @__PURE__ */ jsx9(ConfirmOverlay, { argv: mode.argv }),
-      /* @__PURE__ */ jsx9(Footer, { running: false })
+    return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx12(Header, { tagline: "confirm" }),
+      /* @__PURE__ */ jsx12(ConfirmOverlay, { argv: mode.argv }),
+      /* @__PURE__ */ jsx12(Footer, { running: false })
     ] });
   }
+  if (mode.kind === "run" && deps.run !== void 0) {
+    return /* @__PURE__ */ jsx12(
+      RunMode,
+      {
+        prompt: mode.prompt,
+        deps: deps.run,
+        onQuit: exit,
+        onExit: (notice2) => {
+          if (notice2 !== void 0) setNotice(notice2);
+          setMode({ kind: "dashboard" });
+        }
+      }
+    );
+  }
+  const transcripts = deps.run?.transcripts;
+  if (mode.kind === "transcripts" && transcripts !== void 0) {
+    return /* @__PURE__ */ jsx12(TranscriptPicker, { transcripts, onExit: () => setMode({ kind: "dashboard" }) });
+  }
   const snapshotLines = formatStatusPayload(payload);
   const paneLines = output?.lines ?? snapshotLines ?? [];
   const paneTitle = output?.title ?? "snapshot";
-  return /* @__PURE__ */ jsxs7(Box5, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx9(Header, { tagline: "dashboard" }),
-    /* @__PURE__ */ jsxs7(Panel, { children: [
-      /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx9(StatusBar, { payload, loading }) }),
-      /* @__PURE__ */ jsx9(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx9(Text8, { children: divider() }) }),
-      /* @__PURE__ */ jsx9(Box5, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx9(OutputPane, { lines: paneLines, scrollOffset, title: paneTitle }) })
+  return /* @__PURE__ */ jsxs10(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx12(Header, { tagline: "dashboard" }),
+    /* @__PURE__ */ jsxs10(Panel, { children: [
+      /* @__PURE__ */ jsx12(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx12(StatusBar, { payload, loading }) }),
+      /* @__PURE__ */ jsx12(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx12(Text11, { children: divider() }) }),
+      /* @__PURE__ */ jsx12(Box8, { flexDirection: "column", paddingX: 1, children: /* @__PURE__ */ jsx12(OutputPane, { lines: paneLines, scrollOffset, title: paneTitle }) })
     ] }),
-    /* @__PURE__ */ jsx9(CommandInput, { buffer, running }),
-    notice !== null ? /* @__PURE__ */ jsx9(Text8, { children: c.dim(notice) }) : null,
-    /* @__PURE__ */ jsx9(Footer, { running })
+    /* @__PURE__ */ jsx12(CommandInput, { buffer, running }),
+    notice !== null ? /* @__PURE__ */ jsx12(Text11, { children: c.dim(notice) }) : null,
+    /* @__PURE__ */ jsx12(Footer, { running })
   ] });
 }
 
@@ -1006,8 +1776,57 @@ function recordRecent(projectId, argv) {
   }
 }
 
+// src/tui/transcripts.ts
+import { readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { join as join2, resolve, sep } from "path";
+import { paths } from "@noir-ai/core";
+var TRANSCRIPT_LIST_LIMIT = 20;
+function transcriptDir(root = process.cwd()) {
+  return paths.transcriptsDir(root);
+}
+function createTranscriptStore(opts) {
+  const root = opts.root ?? process.cwd();
+  const dir = transcriptDir(root);
+  return {
+    list: async (limit = TRANSCRIPT_LIST_LIMIT) => {
+      let names;
+      try {
+        names = readdirSync(dir);
+      } catch {
+        return [];
+      }
+      const entries = [];
+      for (const name of names) {
+        if (!name.endsWith(".jsonl")) continue;
+        const path = join2(dir, name);
+        try {
+          const info = statSync(path);
+          if (!info.isFile()) continue;
+          entries.push({ path, name, sizeBytes: info.size, mtimeMs: info.mtimeMs });
+        } catch {
+        }
+      }
+      entries.sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
+      return entries.slice(0, Math.max(0, limit));
+    },
+    read: async (path) => {
+      const resolved = resolve(path);
+      if (resolved !== resolve(dir) && !resolved.startsWith(resolve(dir) + sep)) return [];
+      try {
+        return readFileSync2(resolved, "utf8").split("\n");
+      } catch {
+        return [];
+      }
+    },
+    write: async (lines) => {
+      return writeTranscript(opts.host, lines, root);
+    }
+  };
+}
+
 // src/tui/index.tsx
-import { jsx as jsx10 } from "react/jsx-runtime";
+import { jsx as jsx13 } from "react/jsx-runtime";
+var DEFAULT_RUN_HOST = "claude";
 function defaultFetchStatus(opts) {
   return async () => {
     try {
@@ -1017,17 +1836,68 @@ function defaultFetchStatus(opts) {
     }
   };
 }
+function startHostRun(prompt, handlers, resumeSessionId) {
+  const host = DEFAULT_RUN_HOST;
+  if (!SUPPORTED_HOSTS.includes(host)) {
+    throw new Error(`unknown host '${host}' (supported: ${SUPPORTED_HOSTS.join(", ")})`);
+  }
+  const profile = resolveProfile();
+  const extraArgs = resumeSessionId === void 0 ? profile.args : [...profile.args ?? [], "--resume", resumeSessionId];
+  const env = profile.env === void 0 ? void 0 : mergeEnv(process.env, profile.env);
+  const binary = profile.binary !== void 0 && profile.binary.length > 0 ? profile.binary : host;
+  return {
+    binary,
+    done: runHost({
+      host,
+      prompt,
+      ...profile.binary === void 0 ? {} : { customBinary: profile.binary },
+      ...extraArgs === void 0 ? {} : { extraArgs },
+      ...env === void 0 ? {} : { env },
+      onLine: handlers.onLine,
+      onEvent: handlers.onEvent,
+      signal: handlers.signal,
+      ...handlers.onChild === void 0 ? {} : { onChild: handlers.onChild }
+    })
+  };
+}
+function resolveProfile() {
+  const config = loadRunConfig(process.cwd()) ?? parseConfig({});
+  const resolved = resolveRunProfile(void 0, config, process.env);
+  if (!resolved.ok) throw new Error(resolved.message);
+  return resolved.profile;
+}
+function defaultRunDeps(opts) {
+  const toInput = (request) => ({
+    answer: request.answer,
+    transcript: request.transcript,
+    host: request.host,
+    opts,
+    ...request.sessionId === void 0 ? {} : { sessionId: request.sessionId },
+    ...request.canContinue === void 0 ? {} : { canContinue: request.canContinue }
+  });
+  return {
+    start: (prompt, handlers, resumeSessionId) => startHostRun(prompt, handlers, resumeSessionId),
+    actions: (request) => postRunActions(toInput(request)),
+    perform: (request, choice, value) => performPostRunAction(choice, toInput(request), value),
+    // Named by host, exactly as the CLI names its own transcripts, so a run
+    // started from the dashboard lands beside one started from a shell.
+    transcripts: createTranscriptStore({ host: DEFAULT_RUN_HOST })
+  };
+}
 async function runTui(opts, dispatch) {
   process.stdout.write("\x1B[2J\x1B[H");
   const deps = await buildTuiDeps(opts, dispatch);
-  const instance = render(/* @__PURE__ */ jsx10(App, { deps }));
+  const instance = render(/* @__PURE__ */ jsx13(App, { deps }), { exitOnCtrlC: false });
   await instance.waitUntilExit();
 }
 async function runPalette(opts, dispatch) {
   process.stdout.write("\x1B[2J\x1B[H");
   const deps = await buildTuiDeps(opts, dispatch);
   const instance = render(
-    /* @__PURE__ */ jsx10(App, { deps, initialMode: { kind: "palette", corpus: "commands" } })
+    /* @__PURE__ */ jsx13(App, { deps, initialMode: { kind: "palette", corpus: "commands" } }),
+    {
+      exitOnCtrlC: false
+    }
   );
   await instance.waitUntilExit();
 }
@@ -1041,9 +1911,13 @@ async function buildTuiDeps(opts, dispatch) {
   const deps = {
     dispatch,
     fetchStatus: defaultFetchStatus(opts),
-    // The palette source, derived from a fresh commander program at launch (B3).
+    // The live host-run screen. Present here (not optional in practice) is what
+    // routes a `run <prompt>` selection to the screen instead of dispatching it
+    // through the captured-command path — see `enterRunOrDispatch` in App.tsx.
+    run: defaultRunDeps(opts),
+    // The palette source, derived from a fresh commander program at launch.
     commands: buildPaletteCommandsForTui(),
-    // C3 — persistent recent commands (projectId-keyed). recordRecent is async
+    // Persistent recent commands (projectId-keyed). recordRecent is async
     // only to match the TuiDeps seam; it never rejects.
     record: (argv) => {
       if (projectId) recordRecent(projectId, argv);