@buildaharness/aielia 0.3.5 → 0.3.7

package/dist/reply-audit.d.ts

@@ -0,0 +1,67 @@
+import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
+/**
+ * A reply can say things the turn did not do (benchmark scenarios 13, 15 and 10): "Done, I added the type hints"
+ * with no write behind it, "let me fix all of it" followed by nothing, or facts about a changelog the assistant
+ * never read because the network was unavailable. The reply is already on screen when this runs (it is streamed),
+ * so the result is a separate notice, like `reviewNotice`.
+ */
+export interface ReplyAuditInput {
+    userMessage: string;
+    reply: string;
+    /** What the system recorded as carried out this turn (write/shell/email), see describeAppliedAction. */
+    actions: string[];
+    /** Parallel to `actions`: for a write, what it changed (a short diff), so a reply's account of the file can be checked against it. */
+    actionDetails?: string[];
+    /** What it recorded in earlier turns of this session (most recent last), so restating old results is not mistaken for new work. */
+    earlierActions?: string[];
+    /** Recent shell commands with the start and end of their output (most recent last). */
+    recentCommandOutputs?: {
+        command: string;
+        output: string;
+    }[];
+    /** Files and pages the turn read (tool and target). */
+    sourcesRead: string[];
+    /** Files, directories and pages read in EARLIER turns of this session (most recent last): an answer about them is not an outside fact, and a statement about which tools were used must be checked against them too. */
+    earlierSourcesRead?: string[];
+    /** A command this session already got the network-containment refusal for. */
+    lookupUnavailable: boolean;
+}
+export interface ReplyAudit {
+    claimsUnrecordedWork: boolean;
+    promisesWorkNotDone: boolean;
+    unverifiedOutsideFacts: boolean;
+    contradictsCommandOutput: boolean;
+    /** The reply denies or contradicts what the system recorded: says it did not touch, run or use something that a recorded write, command or read shows it did (benchmark scenarios 12 and 08). */
+    contradictsRecordedWork: boolean;
+    /** The reply thinks aloud: it starts a statement, then corrects or retracts it inside the answer, instead of one clean answer (benchmark scenarios 08 and 14). */
+    leaksSelfCorrection: boolean;
+    /** The reply does not respond to the user's message at all: placeholder text, a stray JSON object, an unrelated topic (benchmark scenario 13 turn 3: the whole reply was `{"favorite_marble":"... the response ..."}`). */
+    nonAnswer: boolean;
+}
+export declare const CLEAN_AUDIT: Readonly<ReplyAudit>;
+/** Replies longer than this are never checked for being a non-answer: junk such as a stray JSON object or placeholder text is short, and the extra calls are not worth making for a long reply. */
+export declare const NON_ANSWER_CHECK_MAX_CHARS = 300;
+/**
+ * Two audit calls at once, and a third only when they disagree about a category: a category stands when at least two of the calls
+ * raise it. One sample of a classifier is noisy both ways: a false flag costs the user a pointless correction turn, a miss lets an
+ * invented claim stand (benchmark scenario 10 turn 2: the same reply was flagged by 6 of 8 production audits and passed by the
+ * rest). Asking the second call only after a flag made a miss on the first call final; asking both together also takes less time
+ * when the endpoint is slow. Fewer than two usable answers (an error or unparseable reply) returns a clean audit: a failed check
+ * must never flag a reply.
+ */
+export declare function auditReply(input: ReplyAuditInput, llmClient: ILLMClient, model?: string, onUsage?: (usage: TokenUsage) => void, options?: {
+    checkNonAnswer?: boolean;
+}): Promise<ReplyAudit>;
+/** The user-facing lines for what the audit found; undefined when it found nothing. */
+export declare function replyAuditNotice(audit: ReplyAudit, actions: string[]): string | undefined;
+/**
+ * `AIELIA_REPLY_AUDIT` gate. Default ON outside vitest (one extra bounded LLM call per successful turn); `0`/`false`/`off`/`no`/`disabled`
+ * turns it off. Same shape as `semanticGroundingEnabled()`.
+ */
+export declare function replyAuditEnabled(env?: Record<string, string | undefined>): boolean;
+/**
+ * The message for the one automatic retry, or undefined when the reply needs none. A claim or promise of work the system
+ * did not record asks for the work to be done now or the claim withdrawn; details that disagree with the command output
+ * or outside facts stated as verified ask for a corrected answer.
+ */
+export declare function auditRetryNudge(audit: ReplyAudit, recorded: string[], userMessage?: string): string | undefined;

package/dist/side-call-policy.d.ts

@@ -0,0 +1,30 @@
+import { ILLMClient } from '@buildaharness/runtime';
+/**
+ * The small structured JSON calls a turn makes around its reply (risk classification, scope and goal-thread matching, the reply
+ * audit and its extra samples, next steps) are quick on a healthy endpoint, but a few simply never answer, and a turn waits on all of
+ * them: in the benchmark a finished-looking reply stayed busy for minutes and a queued message started late (scenarios 05, 06, 09, 10,
+ * 13, 15). Measured on the benchmark's model through OpenRouter with the real risk-classifier prompt (16 calls, 4 at a time): median
+ * 12 s, 75th percentile 27 s, 90th percentile 59 s, and one call that had not answered after 300 s. So a legitimate answer can take
+ * about a minute, and a fixed short bound kills those (a 45 s bound did: two turns of benchmark scenario 03 ended as "risk
+ * classification failed" and were never answered), while a long bound makes every hang cost minutes.
+ *
+ * So the call is hedged instead of cut off: when the first attempt has not answered after HEDGE_AFTER_MS a second identical attempt
+ * starts beside it, and whichever answers first is used. A slow answer is never discarded, a hung call costs about the hedge delay
+ * plus a normal response, and each attempt keeps its own hard bound. A failure waits for the other attempt if one is running; after that a
+ * transient one (a timeout, 408, 429, 5xx: benchmark scenarios 02, 08 and 10 each ended a classification on "The LLM proxy returned an error")
+ * gets one more attempt, while a refusal or a malformed answer would come back the same and is returned at once.
+ */
+export declare const SIDE_CALL_HEDGE_AFTER_MS = 25000;
+export declare const SIDE_CALL_TIMEOUT_MS = 120000;
+/** A failure worth one more attempt: a request that timed out, or an endpoint status that comes and goes (408, 429, any 5xx). A 4xx refusal or a bad answer is final. */
+export declare function isTransientFailure(err: unknown): boolean;
+export interface SideCallPolicyOptions {
+    /** Called once when a second attempt is started because the first has not answered yet. */
+    onHedge?: (info: {
+        afterMs: number;
+    }) => void;
+    /** Test hook: how long the first attempt gets before the second starts. */
+    hedgeAfterMs?: number;
+}
+/** Wraps a client so every structuredOutput call (never a main chat or tool-loop call) is hedged as described above. */
+export declare function withSideCallPolicy(client: ILLMClient, policy?: SideCallPolicyOptions): ILLMClient;

package/dist/tool-step.d.ts

@@ -31,3 +31,9 @@ export declare function stripMcpToolPrefix(name: string): string;
  * parsing) so "what step is this" reads identically no matter where it's rendered.
  */
 export declare function summarizeToolStep(tool: string, input: Record<string, unknown>): string;
+/**
+ * The same step once its turn has finished: a write or command that was only "proposed" while the model was working is
+ * reported as done ("Wrote …", "Ran: …"), so the transcript never says "Proposing" about something that already happened.
+ * Only call this for a step of a completed turn that was not denied (`deniedReason` unset); every other tool reads the same.
+ */
+export declare function summarizeSettledToolStep(tool: string, input: Record<string, unknown>): string;

package/dist/trace-events.d.ts

@@ -14,7 +14,7 @@ export type TraceEvent = {
 } | {
     kind: 'turn_end';
     sessionId: string;
-    status: 'ok' | 'needs_approval' | 'escalated' | 'needs_clarification' | 'needs_plan_approval';
+    status: 'ok' | 'needs_approval' | 'escalated' | 'needs_clarification' | 'needs_plan_approval' | 'cancelled';
 } | {
     kind: 'risk_classified';
     riskLevel: RiskLevel;

package/dist/trust-tagging.d.ts

@@ -7,6 +7,8 @@ import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
  * instruction that content in this tag is data, never instructions.
  */
 export declare function wrapUntrusted(text: string): string;
+/** A literal delimiter tag inside text is neutralised (`<`) so the text cannot close or re-open the untrusted boundary. String scan, not a regex: a structural delimiter check, not a natural-language gate. */
+export declare function defangUntrustedTags(text: string): string;
 export interface InjectionDetection {
     flagged: boolean;
     reason?: string;

package/dist/{tui-app-BLR-PRFp.js → tui-app-C0J6HRzv.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, useMemo, 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 renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-CjKpxDxl.js";
+import { s as sanitizeLabel, r as renderPlan, t as toLines, a as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-C_hgDdSf.js";
 import { format } from "node:util";
-import { n as DIFF_INDENT } from "./provider-setup-LFsaTkpf.js";
+import { o as DIFF_INDENT, bM as stripTerminalControls } from "./provider-setup-wX2IBw2X.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;
@@ -272,11 +291,17 @@ const planNavigator = {
       return { cur: m.taskOrder[(i2 + (key === "tab" ? 1 : -1) + n) % n], k: 0 };
     }
     if (key === "up" || key === "down") {
-      const origin = st.lastKey === key && st.lastFrom !== void 0 ? st.lastFrom : st.cur;
-      const cands = byX(m, (key === "up" ? m.deps[origin] : m.dependents[origin]) ?? []);
+      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 = st.lastKey === key ? (st.k + 1) % cands.length : 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]));
@@ -338,17 +363,17 @@ function planDetailLines(nodes, id, width) {
   const w = Math.max(10, width);
   const name = (i) => {
     var _a;
-    return ((_a = nodes.find((n) => n.id === i)) == null ? void 0 : _a.id) ?? i;
+    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(node.id, w),
+    ...wrap(sanitizeLabel(node.id), w),
     "",
-    ...wrap(node.label, 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.join(", ") : "nothing"}`, w)
+    ...wrap(`Needed by: ${dependents.length ? dependents.map(sanitizeLabel).join(", ") : "nothing"}`, w)
   ];
 }
 const DRAWER_DOCK_COLUMNS = 120;
@@ -506,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) {
@@ -528,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) => {
@@ -539,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();
   }
   /**
@@ -570,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 }] : (
@@ -596,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");
@@ -616,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();
     });
@@ -649,6 +734,7 @@ class StatusBridge {
 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) {
@@ -775,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 }) {
@@ -820,7 +914,7 @@ 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]
@@ -829,7 +923,7 @@ function TuiApp(props) {
     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") {
@@ -837,19 +931,19 @@ function TuiApp(props) {
     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 }),
+      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: staticItems, children: (line, index) => /* @__PURE__ */ jsx(LogLineText, { line, width }, index) }),
-    showSpinner && /* @__PURE__ */ jsx(Spinner, {}),
     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,
@@ -883,6 +977,7 @@ 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;
@@ -891,6 +986,7 @@ async function runTuiApp(options = {}) {
     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)));
@@ -915,7 +1011,10 @@ async function runTuiApp(options = {}) {
   };
   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 = () => {
@@ -946,6 +1045,8 @@ export {
   PromptBridge,
   StatusBridge,
   TuiApp,
+  TurnActivityTracker,
+  formatLivenessLabel,
   runTuiApp
 };
-//# sourceMappingURL=tui-app-BLR-PRFp.js.map
+//# sourceMappingURL=tui-app-C0J6HRzv.js.map