@buildaharness/aielia 0.3.4 → 0.3.6

package/dist/{tui-app-DeyZ4Pr9.js → tui-app-CJq6YaiP.js}

@@ -3,11 +3,11 @@ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { en
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { jsxs, jsx } from "react/jsx-runtime";
 import { Readable, Writable } from "node:stream";
-import { useState, useRef, useCallback, useSyncExternalStore, useEffect } from "react";
+import { useState, useRef, useEffect, useMemo, useCallback, useSyncExternalStore } from "react";
 import { useWindowSize, usePaste, useInput, Box, Text, render, Static } from "ink";
-import { r as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-CdVTAe7j.js";
+import { s as sanitizeLabel, r as renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-BYRl4xXM.js";
 import { format } from "node:util";
-import { j as DIFF_INDENT } from "./provider-setup-CPbB5y_V.js";
+import { n as DIFF_INDENT, bL as stripTerminalControls } from "./provider-setup-CV3S_TAS.js";
 function classify(raw, stream) {
   if (raw.startsWith("\r")) {
     return { type: "progress", text: raw.replace(/\r/g, "").trimEnd() };
@@ -99,6 +99,15 @@ function TuiInput(props) {
   const [history, setHistory] = useState([]);
   const [historyIndex, setHistoryIndex] = useState(null);
   const [pendingDraft, setPendingDraft] = useState("");
+  const previousPromptLabel = useRef(promptLabel);
+  useEffect(() => {
+    if (previousPromptLabel.current === promptLabel) return;
+    previousPromptLabel.current = promptLabel;
+    setValue("");
+    setCursor(0);
+    setHistoryIndex(null);
+    setPendingDraft("");
+  }, [promptLabel]);
   const windowSize = useWindowSize();
   const terminalColumns = props.columns ?? windowSize.columns;
   const wrapWidth = Math.max(1, terminalColumns - BOX_CHROME_WIDTH);
@@ -212,10 +221,20 @@ function TuiInput(props) {
   ] });
 }
 function SelectPrompt(props) {
-  const { question, options, onSubmit, isActive = true } = props;
+  const { question, options, onSubmit, isActive = true, armDelayMs = 0 } = props;
   const [highlighted, setHighlighted] = useState(0);
+  const armed = useRef(armDelayMs <= 0);
+  useEffect(() => {
+    if (armDelayMs <= 0) return;
+    armed.current = false;
+    const timer = setTimeout(() => {
+      armed.current = true;
+    }, armDelayMs);
+    return () => clearTimeout(timer);
+  }, [armDelayMs, question, options]);
   useInput(
     (input, key) => {
+      if (!armed.current) return;
       if (key.upArrow) {
         setHighlighted((h) => (h - 1 + options.length) % options.length);
         return;
@@ -244,6 +263,195 @@ function SelectPrompt(props) {
     ] }, option.key)) })
   ] });
 }
+function navModelFrom(nodes, boxes) {
+  const byId = new Map(boxes.map((b) => [b.id, b]));
+  const ids = nodes.map((n) => n.id).filter((id) => byId.has(id));
+  const dependents = Object.fromEntries(ids.map((id) => [id, []]));
+  for (const n of nodes) if (byId.has(n.id)) {
+    for (const d of n.deps) if (dependents[d]) dependents[d].push(n.id);
+  }
+  return {
+    ids,
+    taskOrder: ids,
+    x: Object.fromEntries(ids.map((id) => [id, byId.get(id).x + byId.get(id).w / 2])),
+    y: Object.fromEntries(ids.map((id) => [id, byId.get(id).y])),
+    deps: Object.fromEntries(nodes.map((n) => [n.id, n.deps.filter((d) => byId.has(d))])),
+    dependents
+  };
+}
+const cmp = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+const byX = (m, ids) => [...ids].sort((a, b) => m.x[a] - m.x[b] || cmp(a, b));
+const planNavigator = {
+  start: (_m, id) => ({ cur: id, k: 0 }),
+  press(m, st, key) {
+    if (key === "tab" || key === "shiftTab") {
+      const n = m.taskOrder.length;
+      if (!n) return st;
+      const i2 = m.taskOrder.indexOf(st.cur);
+      return { cur: m.taskOrder[(i2 + (key === "tab" ? 1 : -1) + n) % n], k: 0 };
+    }
+    if (key === "up" || key === "down") {
+      let origin = st.lastKey === key && st.lastFrom !== void 0 ? st.lastFrom : st.cur;
+      let cands = byX(m, (key === "up" ? m.deps[origin] : m.dependents[origin]) ?? []);
+      let repeating = st.lastKey === key;
+      if (repeating && cands.length < 2) {
+        origin = st.cur;
+        cands = byX(m, (key === "up" ? m.deps[origin] : m.dependents[origin]) ?? []);
+        repeating = false;
+      }
+      if (!cands.length) return st;
+      const nearest = [...cands].sort((a, b) => Math.abs(m.x[a] - m.x[origin]) - Math.abs(m.x[b] - m.x[origin]) || cmp(a, b))[0];
+      const k = repeating ? (st.k + 1) % cands.length : 0;
+      return { cur: cands[(cands.indexOf(nearest) + k) % cands.length], lastKey: key, lastFrom: origin, k };
+    }
+    const rank = byX(m, m.ids.filter((id) => m.y[id] === m.y[st.cur]));
+    const i = rank.indexOf(st.cur);
+    if (i < 0) return st;
+    return { cur: rank[(i + (key === "left" ? -1 : 1) + rank.length) % rank.length], lastKey: key, k: 0 };
+  }
+};
+function followSelection(prev, box, grid, term) {
+  const width = Math.min(term.cols, grid.width);
+  const height = Math.min(term.rows, grid.height);
+  const fit = (start, size, bStart, bSize, total) => {
+    let s = start;
+    if (bStart < s) s = bStart;
+    if (bStart + bSize > s + size) s = bStart + bSize - size;
+    return Math.max(0, Math.min(s, total - size));
+  };
+  return { width, height, left: fit(prev.left, width, box.x, box.w, grid.width), top: fit(prev.top, height, box.y, box.h, grid.height) };
+}
+function scrollIndicators(v, grid) {
+  return { up: v.top > 0, down: v.top + v.height < grid.height, left: v.left > 0, right: v.left + v.width < grid.width };
+}
+const STATUS_WORD = {
+  pending: "pending",
+  ready: "ready to run",
+  running: "running",
+  done: "done",
+  failed: "failed",
+  awaiting_user: "waiting for you",
+  awaiting_input: "blocked, waiting for input",
+  cancelled: "cancelled"
+};
+function wrap(text, width) {
+  const out = [];
+  let line = "";
+  for (const word of text.split(/\s+/).filter(Boolean)) {
+    let w = word;
+    while (w.length > width) {
+      if (line) {
+        out.push(line);
+        line = "";
+      }
+      out.push(w.slice(0, width));
+      w = w.slice(width);
+    }
+    if (!line) line = w;
+    else if (line.length + 1 + w.length <= width) line += ` ${w}`;
+    else {
+      out.push(line);
+      line = w;
+    }
+  }
+  if (line) out.push(line);
+  return out;
+}
+function planDetailLines(nodes, id, width) {
+  const node = nodes.find((n) => n.id === id);
+  if (!node) return ["No task selected."];
+  const w = Math.max(10, width);
+  const name = (i) => {
+    var _a;
+    return sanitizeLabel(((_a = nodes.find((n) => n.id === i)) == null ? void 0 : _a.id) ?? i);
+  };
+  const dependents = nodes.filter((n) => n.deps.includes(node.id)).map((n) => n.id);
+  return [
+    ...wrap(sanitizeLabel(node.id), w),
+    "",
+    ...wrap(sanitizeLabel(node.label), w),
+    "",
+    `Status: ${STATUS_WORD[node.status] ?? node.status}`,
+    ...wrap(`Depends on: ${node.deps.length ? node.deps.map(name).join(", ") : "nothing"}`, w),
+    ...wrap(`Needed by: ${dependents.length ? dependents.map(sanitizeLabel).join(", ") : "nothing"}`, w)
+  ];
+}
+const DRAWER_DOCK_COLUMNS = 120;
+const DRAWER_WIDTH = 36;
+function PlanGraphPane({ nodes, columns, rows, active = true, color = true, ascii = false, onClose }) {
+  const docked = columns >= DRAWER_DOCK_COLUMNS;
+  const [drawerOpen, setDrawerOpen] = useState(false);
+  const showDrawer = docked || drawerOpen;
+  const graphCols = showDrawer ? Math.max(20, columns - DRAWER_WIDTH - 1) : columns;
+  const graphRows = Math.max(3, rows - 2);
+  const [nav, setNav] = useState(void 0);
+  const lastIndex = useRef(0);
+  const viewport = useRef({ left: 0, top: 0, width: 0, height: 0 });
+  const base = useMemo(() => renderPlan(nodes, { maxCols: graphCols, ascii, color: false }), [nodes, graphCols, ascii]);
+  const model = useMemo(() => base.ok ? navModelFrom(nodes, base.boxes) : void 0, [nodes, base]);
+  let selectedId;
+  if (model && model.ids.length) {
+    if (nav && model.ids.includes(nav.cur)) selectedId = nav.cur;
+    else selectedId = model.taskOrder[Math.min(lastIndex.current, model.taskOrder.length - 1)];
+  }
+  if (model && selectedId) lastIndex.current = model.taskOrder.indexOf(selectedId);
+  const detail = useMemo(() => planDetailLines(nodes, selectedId, DRAWER_WIDTH - 2), [nodes, selectedId]);
+  const [scroll, setScroll] = useState({ id: void 0, offset: 0 });
+  const drawerRows = graphRows;
+  const maxScroll = Math.max(0, detail.length - drawerRows);
+  const drawerOffset = scroll.id === selectedId ? Math.min(scroll.offset, maxScroll) : 0;
+  const scrollDrawer = (delta) => setScroll({ id: selectedId, offset: Math.max(0, Math.min(maxScroll, drawerOffset + delta)) });
+  useInput(
+    (input, key) => {
+      if (key.escape || input === "q") return onClose();
+      if (key.return || input === "d") return setDrawerOpen((open) => !open);
+      if (showDrawer) {
+        if (input === "j") return scrollDrawer(1);
+        if (input === "k") return scrollDrawer(-1);
+        if (key.pageDown) return scrollDrawer(drawerRows);
+        if (key.pageUp) return scrollDrawer(-drawerRows);
+      }
+      if (!model || !selectedId) return;
+      const k = key.upArrow || input === "[" ? "up" : key.downArrow || input === "]" ? "down" : key.leftArrow ? "left" : key.rightArrow ? "right" : key.tab ? key.shift ? "shiftTab" : "tab" : void 0;
+      if (!k) return;
+      const from = nav && nav.cur === selectedId ? nav : planNavigator.start(model, selectedId);
+      setNav(planNavigator.press(model, from, k));
+    },
+    { isActive: active }
+  );
+  if (!base.ok || !model) {
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: rows, children: [
+      /* @__PURE__ */ jsxs(Text, { children: [
+        "Plan graph unavailable: ",
+        base.ok ? "nothing to draw" : base.message
+      ] }),
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: "q / Esc closes" })
+    ] });
+  }
+  const r = renderPlan(nodes, { maxCols: graphCols, ascii, color, selectedId });
+  if (!r.ok) return /* @__PURE__ */ jsxs(Text, { children: [
+    "Plan graph unavailable: ",
+    r.message
+  ] });
+  const box = r.boxes.find((b) => b.id === selectedId);
+  const vp = box ? followSelection(viewport.current, box, r, { cols: graphCols, rows: graphRows }) : { left: 0, top: 0, width: Math.min(graphCols, r.width), height: Math.min(graphRows, r.height) };
+  viewport.current = vp;
+  const lines = toLines(r.cells, r.styles, [vp.top, vp.top + vp.height], [vp.left, vp.left + vp.width]);
+  const more = scrollIndicators(vp, r);
+  const arrows = `${more.up ? "↑" : " "}${more.down ? "↓" : " "}${more.left ? "←" : " "}${more.right ? "→" : " "}`;
+  const done = nodes.filter((n) => n.status === "done").length;
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", height: rows, children: [
+    /* @__PURE__ */ jsxs(Text, { bold: true, children: [
+      `Plan graph — ${done}/${nodes.length} done `,
+      /* @__PURE__ */ jsx(Text, { dimColor: true, children: arrows })
+    ] }),
+    /* @__PURE__ */ jsxs(Box, { flexDirection: "row", flexGrow: 1, children: [
+      /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: graphCols, children: lines.map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line.length ? line : " " }, i)) }),
+      showDrawer && /* @__PURE__ */ jsx(Box, { flexDirection: "column", width: DRAWER_WIDTH + 1, paddingLeft: 1, borderStyle: "single", borderTop: false, borderBottom: false, borderRight: false, children: detail.slice(drawerOffset, drawerOffset + drawerRows).map((line, i) => /* @__PURE__ */ jsx(Text, { wrap: "truncate", children: line.length ? line : " " }, i)) })
+    ] }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: docked ? "↑↓←→ move · Tab next · j/k PgUp/PgDn scroll details · q close" : "↑↓←→ move · Tab next · Enter details · q close" })
+  ] });
+}
 const HEADER_RE = /^(#{1,6})\s+(.*)$/;
 const CHECKBOX_RE = /^(\s*[-*]\s)\[([ xX])\]\s+(.*)$/;
 const DIFF_LINE_RE = /^(\s*\d+) ([+\- ])(.*)$/;
@@ -323,7 +531,7 @@ const ASSISTANT_INDENT_WIDTH = 2;
 function useStore(store) {
   return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
 }
-const EMPTY_LOG = { lines: [], progressText: "", transientText: "", waitingForOutput: false };
+const EMPTY_LOG = { lines: [], progressText: "", transientText: "", waitingForOutput: false, turnInFlight: false };
 const TOOL_STEP_PREFIXES = [ICONS.toolStep, ICONS.proposalStep, ICONS.deniedStep];
 const ASSISTANT_REPLY_PREFIX = "Aielia>";
 function classifyLineKind(mergedText, streamedReplyWasOpen, stream) {
@@ -345,6 +553,8 @@ class EventLogBridge {
     __publicField(this, "progressText", "");
     __publicField(this, "transientText", "");
     __publicField(this, "waitingForOutput", false);
+    __publicField(this, "turnInFlight", false);
+    __publicField(this, "lastActivityAt");
     __publicField(this, "snapshot", EMPTY_LOG);
     __publicField(this, "listeners", /* @__PURE__ */ new Set());
     __publicField(this, "subscribe", (listener) => {
@@ -356,12 +566,41 @@ class EventLogBridge {
     __publicField(this, "getSnapshot", () => this.snapshot);
   }
   commit() {
-    this.snapshot = { lines: this.lines, progressText: this.progressText, transientText: this.transientText, waitingForOutput: this.waitingForOutput };
+    this.snapshot = {
+      lines: this.lines,
+      progressText: this.progressText,
+      transientText: this.transientText,
+      waitingForOutput: this.waitingForOutput,
+      turnInFlight: this.turnInFlight,
+      lastActivityAt: this.lastActivityAt
+    };
     for (const listener of this.listeners) listener();
   }
   /** Marks the start of a turn's wait for its first output (see `TuiLogState.waitingForOutput`'s doc comment) — called by `TuiApp` right after a chat line or resolved prompt answer is submitted. */
   beginTurn() {
     this.waitingForOutput = true;
+    this.turnInFlight = true;
+    this.lastActivityAt = Date.now();
+    this.commit();
+  }
+  /** A resolved approval/clarification answer: output is expected again, but it says nothing about whether a turn is in flight — `TurnActivityTracker` owns that, so a prompt answer can never leave the indicator stuck on. */
+  expectOutput() {
+    this.waitingForOutput = true;
+    this.commit();
+  }
+  /** Marks a turn in flight (idempotent); the elapsed counter counts from the first call. */
+  markBusy() {
+    if (this.turnInFlight) return;
+    this.turnInFlight = true;
+    this.lastActivityAt = Date.now();
+    this.commit();
+  }
+  /** Marks the turn finished (its `dispatchLine()` settled) — the liveness line stops. Safe to call when no turn is in flight. */
+  endTurn() {
+    if (!this.turnInFlight && !this.waitingForOutput) return;
+    this.turnInFlight = false;
+    this.waitingForOutput = false;
+    this.lastActivityAt = void 0;
     this.commit();
   }
   /**
@@ -387,18 +626,19 @@ class EventLogBridge {
   }
   handleEvent(event) {
     this.waitingForOutput = false;
+    if (this.turnInFlight) this.lastActivityAt = Date.now();
     if (event.type === "progress") {
-      this.progressText = event.text;
+      this.progressText = stripTerminalControls(event.text);
       this.commit();
       return;
     }
     if (event.type === "token") {
-      this.transientText += event.text;
+      this.transientText += stripTerminalControls(event.text);
       this.commit();
       return;
     }
     const streamedReplyWasOpen = this.transientText.length > 0;
-    const merged = this.transientText + event.lines.join("\n");
+    const merged = this.transientText + stripTerminalControls(event.lines.join("\n"));
     const kind = classifyLineKind(merged, streamedReplyWasOpen, event.stream);
     const displayText = kind === "assistant" ? stripAssistantLabel(merged) : kind === "plan" ? stripPlanLabel(merged) : merged;
     this.lines = kind === "plan" ? [...this.lines, { text: displayText, kind }] : (
@@ -413,6 +653,31 @@ class EventLogBridge {
     if (kind === "assistant") this.pushTurnMargin();
   }
 }
+class TurnActivityTracker {
+  constructor(eventLog) {
+    __publicField(this, "dispatches", 0);
+    __publicField(this, "cliBusy", false);
+    this.eventLog = eventLog;
+  }
+  /** Wraps one `dispatchLine()` call. Always settles, whether it resolves or throws. */
+  async track(run) {
+    this.dispatches++;
+    try {
+      return await run();
+    } finally {
+      this.dispatches--;
+      this.settle();
+    }
+  }
+  setCliBusy(busy) {
+    this.cliBusy = busy;
+    if (busy) this.eventLog.markBusy();
+    else this.settle();
+  }
+  settle() {
+    if (this.dispatches === 0 && !this.cliBusy) this.eventLog.endTurn();
+  }
+}
 class PromptBridge {
   constructor() {
     __publicField(this, "pending");
@@ -433,7 +698,10 @@ class PromptBridge {
   }
   ask(question, options) {
     return new Promise((resolve) => {
-      this.pending = { question, options };
+      this.pending = {
+        question: stripTerminalControls(question),
+        options: options == null ? void 0 : options.map((o) => ({ ...o, label: stripTerminalControls(o.label) }))
+      };
       this.resolve = resolve;
       for (const listener of this.listeners) listener();
     });
@@ -463,6 +731,108 @@ class StatusBridge {
     for (const listener of this.listeners) listener();
   }
 }
+const ALT_SCREEN_ON = "\x1B[?1049h";
+const ALT_SCREEN_OFF = "\x1B[?1049l";
+const ALT_SCREEN_SETTLE_MS = 80;
+const SELECT_ARM_DELAY_MS = 400;
+const PLAN_GRAPH_MIN_RENDER_MS = 100;
+class PlanGraphBridge {
+  constructor(writeRaw, settleMs = ALT_SCREEN_SETTLE_MS, minRenderMs = PLAN_GRAPH_MIN_RENDER_MS) {
+    __publicField(this, "view", { mode: "chat", nodes: [] });
+    __publicField(this, "listeners", /* @__PURE__ */ new Set());
+    __publicField(this, "timer");
+    __publicField(this, "pendingNodes");
+    __publicField(this, "transition", Promise.resolve());
+    __publicField(this, "subscribe", (listener) => {
+      this.listeners.add(listener);
+      return () => {
+        this.listeners.delete(listener);
+      };
+    });
+    __publicField(this, "getSnapshot", () => this.view);
+    this.writeRaw = writeRaw;
+    this.settleMs = settleMs;
+    this.minRenderMs = minRenderMs;
+  }
+  isOpen() {
+    return this.view.mode !== "chat";
+  }
+  set(view) {
+    this.view = view;
+    for (const listener of this.listeners) listener();
+  }
+  sleep() {
+    return new Promise((resolve) => setTimeout(resolve, this.settleMs));
+  }
+  open(nodes) {
+    this.transition = this.transition.then(async () => {
+      if (this.view.mode !== "chat") {
+        this.update(nodes);
+        return;
+      }
+      this.set({ mode: "blank", nodes });
+      await this.sleep();
+      this.writeRaw(ALT_SCREEN_ON);
+      this.set({ mode: "pane", nodes: this.pendingNodes ?? nodes });
+      this.pendingNodes = void 0;
+    });
+    return this.transition;
+  }
+  close() {
+    this.transition = this.transition.then(async () => {
+      if (this.view.mode === "chat") return;
+      this.clearTimer();
+      this.set({ mode: "blank", nodes: this.view.nodes });
+      await this.sleep();
+      this.writeRaw(ALT_SCREEN_OFF);
+      this.set({ mode: "chat", nodes: [] });
+    });
+    return this.transition;
+  }
+  /** Synchronous leave for process exit: restores the main screen without waiting. */
+  restore() {
+    this.clearTimer();
+    if (this.view.mode === "pane") this.writeRaw(ALT_SCREEN_OFF);
+    this.view = { mode: "chat", nodes: [] };
+  }
+  /** Throttled node update: the first goes through at once, later ones coalesce to the newest within `minRenderMs`. Identical content is ignored. */
+  update(nodes) {
+    if (this.view.mode === "chat") return;
+    if (this.view.mode === "blank") {
+      this.pendingNodes = nodes;
+      return;
+    }
+    if (this.timer) {
+      this.pendingNodes = nodes;
+      return;
+    }
+    this.apply(nodes);
+    this.timer = setTimeout(() => this.flush(), this.minRenderMs);
+  }
+  apply(nodes) {
+    if (this.view.mode !== "pane" || JSON.stringify(nodes) === JSON.stringify(this.view.nodes)) return;
+    this.set({ mode: "pane", nodes });
+  }
+  flush() {
+    this.timer = void 0;
+    const next = this.pendingNodes;
+    this.pendingNodes = void 0;
+    if (next) {
+      this.apply(next);
+      this.timer = setTimeout(() => this.flush(), this.minRenderMs);
+    }
+  }
+  clearTimer() {
+    if (this.timer) clearTimeout(this.timer);
+    this.timer = void 0;
+    this.pendingNodes = void 0;
+  }
+}
+const NO_PLAN_GRAPH = { subscribe: () => () => {
+}, getSnapshot: /* @__PURE__ */ (() => {
+  const v = { mode: "chat", nodes: [] };
+  return () => v;
+})() };
 function UserMessageBox({ text, width, borderColor = "gray" }) {
   return /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor, flexDirection: "column", paddingX: 1, width, children: text.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { children: line.length > 0 ? line : " " }, i)) });
 }
@@ -491,15 +861,23 @@ function LogLineText({ line, width }) {
 }
 const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 const SPINNER_INTERVAL_MS = 80;
-function Spinner() {
+const LIVENESS_COUNTER_AFTER_S = 3;
+function formatLivenessLabel(elapsedMs, hasProgress) {
+  const seconds = Math.max(0, Math.floor(elapsedMs / 1e3));
+  if (seconds < LIVENESS_COUNTER_AFTER_S) return hasProgress ? "Working…" : "Thinking…";
+  return `Working… ${seconds}s`;
+}
+function Spinner({ since, hasProgress, quietOnly = false }) {
   const [frame, setFrame] = useState(0);
   useEffect(() => {
     const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), SPINNER_INTERVAL_MS);
     return () => clearInterval(id);
   }, []);
+  if (quietOnly && since !== void 0 && Date.now() - since < LIVENESS_COUNTER_AFTER_S * 1e3) return null;
   return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
     SPINNER_FRAMES[frame],
-    " Thinking…"
+    " ",
+    formatLivenessLabel(since === void 0 ? 0 : Date.now() - since, hasProgress)
   ] });
 }
 function StatusLine({ indicators }) {
@@ -509,12 +887,15 @@ function StatusLine({ indicators }) {
   ] }, indicator)) });
 }
 function TuiApp(props) {
-  const { eventLog, prompt, status, onSubmitChat, onExit, columns } = props;
+  const { eventLog, prompt, status, planGraph, onSubmitChat, onExit, columns } = props;
   const log = useStore(eventLog);
   const pending = useStore(prompt);
   const statusIndicators = useStore(status);
   const windowSize = useWindowSize();
   const width = columns ?? windowSize.columns;
+  const graphView = useStore(planGraph ?? NO_PLAN_GRAPH);
+  const frozenLines = useRef(0);
+  if (graphView.mode === "chat") frozenLines.current = log.lines.length;
   useInput((input, key) => {
     if (key.ctrl && input === "c") onExit();
   });
@@ -533,22 +914,36 @@ function TuiApp(props) {
       var _a, _b;
       const displayAnswer = ((_b = (_a = pending == null ? void 0 : pending.options) == null ? void 0 : _a.find((option) => option.key === line)) == null ? void 0 : _b.label) ?? line;
       eventLog.pushEchoLine("> ", (pending == null ? void 0 : pending.question) !== void 0 ? `${pending.question.trimEnd()} → ${displayAnswer}` : line);
-      eventLog.beginTurn();
+      eventLog.expectOutput();
       prompt.submit(line);
     },
     [eventLog, prompt, pending]
   );
+  const closePane = useCallback(() => {
+    void (planGraph == null ? void 0 : planGraph.close());
+  }, [planGraph]);
   const hasTransient = log.progressText.length > 0 || log.transientText.length > 0;
-  const showSpinner = log.waitingForOutput && !hasTransient;
+  const showSpinner = (log.turnInFlight || log.waitingForOutput) && !pending;
+  const staticItems = graphView.mode === "chat" ? log.lines : log.lines.slice(0, frozenLines.current);
+  const paneRows = Math.max(3, (windowSize.rows ?? 24) - 1);
+  if (graphView.mode !== "chat") {
+    const promptRows = pending ? Math.min(10, Math.floor(paneRows / 2)) : 0;
+    return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx(Static, { items: staticItems, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
+      graphView.mode === "pane" && /* @__PURE__ */ jsx(PlanGraphPane, { nodes: graphView.nodes, columns: width, rows: paneRows - promptRows, active: !pending, color: !process.env.NO_COLOR, onClose: closePane }),
+      graphView.mode === "pane" && (pending == null ? void 0 : pending.options) && /* @__PURE__ */ jsx(SelectPrompt, { question: pending.question, options: pending.options, onSubmit: handleSubmitPrompt, armDelayMs: SELECT_ARM_DELAY_MS }),
+      graphView.mode === "pane" && pending && !pending.options && /* @__PURE__ */ jsx(TuiInput, { promptLabel: pending.question, onSubmitChat: handleSubmitChat, onSubmitPrompt: handleSubmitPrompt, columns })
+    ] });
+  }
   return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
-    /* @__PURE__ */ jsx(Static, { items: log.lines, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
-    showSpinner && /* @__PURE__ */ jsx(Spinner, {}),
+    /* @__PURE__ */ jsx(Static, { items: staticItems, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
     hasTransient && /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
       log.progressText.length > 0 && /* @__PURE__ */ jsx(Text, { dimColor: true, children: log.progressText }),
       log.transientText.length > 0 && /* @__PURE__ */ jsx(Text, { children: stripAssistantLabel(log.transientText) })
     ] }),
+    showSpinner && /* @__PURE__ */ jsx(Spinner, { since: log.lastActivityAt, hasProgress: log.progressText.length > 0, quietOnly: log.transientText.length > 0 }),
     /* @__PURE__ */ jsx(Text, { dimColor: true, children: "─".repeat(Math.max(1, width)) }),
-    (pending == null ? void 0 : pending.options) ? /* @__PURE__ */ jsx(SelectPrompt, { question: pending.question, options: pending.options, onSubmit: handleSubmitPrompt }) : /* @__PURE__ */ jsx(
+    (pending == null ? void 0 : pending.options) ? /* @__PURE__ */ jsx(SelectPrompt, { question: pending.question, options: pending.options, onSubmit: handleSubmitPrompt, armDelayMs: SELECT_ARM_DELAY_MS }) : /* @__PURE__ */ jsx(
       TuiInput,
       {
         promptLabel: pending == null ? void 0 : pending.question,
@@ -582,12 +977,20 @@ async function runTuiApp(options = {}) {
   const prompt = new PromptBridge();
   const status = new StatusBridge();
   const originalWrite = process.stdout.write.bind(process.stdout);
+  const activity = new TurnActivityTracker(eventLog);
   const restoreCapture = startCapture((event) => eventLog.handleEvent(event));
+  const planGraph = new PlanGraphBridge((chunk) => void originalWrite(chunk));
+  let instanceRef;
   let instance;
   try {
     const inert = createInertStreams();
     instance = await runCli({
       ...options,
+      onTurnBusyChange: (busy) => activity.setCliBusy(busy),
+      openPlanGraph: (nodes) => void planGraph.open(nodes),
+      onPlanProgress: (tasks) => {
+        if (planGraph.isOpen()) void (instanceRef == null ? void 0 : instanceRef.getPlanGraphNodes(tasks).then((nodes) => nodes && planGraph.update(nodes)));
+      },
       input: options.input ?? inert.input,
       output: options.output ?? inert.output,
       askYesNo: prompt.askYesNo,
@@ -598,23 +1001,32 @@ async function runTuiApp(options = {}) {
     restoreCapture();
     throw err;
   }
+  instanceRef = instance;
   const refreshStatus = async () => {
     status.set(await instance.getStatusIndicators());
+    if (planGraph.isOpen()) {
+      const nodes = await instance.getPlanGraphNodes();
+      if (nodes) planGraph.update(nodes);
+    }
   };
   await refreshStatus();
   const handleSubmitChat = (line) => {
-    void instance.dispatchLine(line).then(refreshStatus);
+    void activity.track(async () => {
+      await instance.dispatchLine(line);
+      await refreshStatus();
+    });
   };
   let exiting = false;
   const exit = () => {
     if (exiting) return;
     exiting = true;
+    planGraph.restore();
     restoreCapture();
     instance.close();
     app.unmount();
     process.exit(0);
   };
-  const app = render(/* @__PURE__ */ jsx(TuiApp, { eventLog, prompt, status, onSubmitChat: handleSubmitChat, onExit: exit }), {
+  const app = render(/* @__PURE__ */ jsx(TuiApp, { eventLog, prompt, status, planGraph, onSubmitChat: handleSubmitChat, onExit: exit }), {
     // Phase 1's startCapture already routes every console.log/process.stdout.write call into
     // eventLog — ink's own patchConsole would double-intercept the same calls with a competing
     // mechanism (writing them above its own Static area independently), not compose with it.
@@ -629,9 +1041,12 @@ async function runTuiApp(options = {}) {
 }
 export {
   EventLogBridge,
+  PlanGraphBridge,
   PromptBridge,
   StatusBridge,
   TuiApp,
+  TurnActivityTracker,
+  formatLivenessLabel,
   runTuiApp
 };
-//# sourceMappingURL=tui-app-DeyZ4Pr9.js.map
+//# sourceMappingURL=tui-app-CJq6YaiP.js.map