@buildaharness/aielia 0.3.1 → 0.3.3

package/dist/review-checker.d.ts

@@ -1,5 +1,15 @@
 import { ILLMClient, TokenUsage } from '@buildaharness/runtime';
 import { BeliefCandidate } from './contradiction-checker.js';
+/**
+ * `AUDIT_SEMANTIC_CHANGE_REVIEW` gate — feature-value audit (Phase C2 of the internal plan).
+ * Default **ON**: the semantic change-reviewer LLM call ships enabled, so an unset / empty / truthy
+ * value keeps today's behaviour. Set to a falsy value (`0` / `false` / `off` / `no` / `disabled`)
+ * to skip the hook entirely, leaving `reviewProposedChange`'s lexical `isNegation` check as the
+ * only conflict check. Read at exactly one call site — `harness-bridge.ts`, where the
+ * `semanticChangeReviewer` host hook is wired. Same shape as `semanticContradictionEnabled()`
+ * (contradiction-checker.ts).
+ */
+export declare function semanticChangeReviewEnabled(env?: Record<string, string | undefined>): boolean;
 /**
  * One LLM call checking a proposed change against everything relevant at once (never one call
  * per belief/prediction) — layered on top of review-proposed-change.ts's lexical `isNegation`

package/dist/scripted-llm-client.d.ts

@@ -2,7 +2,7 @@ import { ILLMClient, LLMStructuredResponse } from '@buildaharness/runtime';
 /**
  * A deterministic, network-free {@link ILLMClient} for tests and demos — the one publicly
  * supported way to drive a real `PersonalAssistant` turn end to end without a proxy, an API key,
- * or a live model. Built for plans/chat_ui_browser_e2e_plan.html phase B1 (the browser-e2e lane
+ * or a live model. Built for the internal plan phase B1 (the browser-e2e lane
  * that unblocks the `ASSISTANT_ONE_LOOP` default-flip), and reusable by chat-ui's `demo-seed.ts`.
  *
  * It mirrors the shape of the internal `ScriptedToolLLMClient` that `assistant.test.ts` has used

package/dist/sea-cache.d.ts

@@ -0,0 +1,9 @@
+/** `~/.buildaharness/personal-assistant/sea-cache/<version>` — same data dir as cli.ts's `defaultDataDir`. */
+export declare function seaCacheDir(version: string, home?: string): string;
+/**
+ * Writes `read()`'s bytes to `<dir>/<fileName>` unless that exact path already exists, and returns
+ * the path. Version-gated by construction: `dir` embeds the CLI version, so a new release never
+ * reuses a stale extraction. Written via a temp file + rename so a crash or a concurrent second
+ * launch can never observe (and then import) a half-written file.
+ */
+export declare function extractAssetOnce(dir: string, fileName: string, read: () => string | ArrayBuffer): string;

package/dist/self-update.d.ts

@@ -0,0 +1,101 @@
+export declare const MANIFEST_URL = "https://myaielia.com/aielia-latest.json";
+export declare const RELEASES_API_URL = "https://api.github.com/repos/3IVIS/buildaharness/releases?per_page=50";
+export declare const RELEASE_TAG_PREFIX = "aielia-v";
+export declare const CHECK_INTERVAL_MS: number;
+export interface ReleaseAsset {
+    url: string;
+    /** From the manifest — the trusted hash (a different origin than the binary's github.com URL). Absent on the GitHub-API fallback. */
+    sha256?: string;
+    size?: number;
+}
+export interface ReleaseInfo {
+    tag: string;
+    version: string;
+    /** Keyed `<process.platform>-<process.arch>`, e.g. `linux-x64`, `darwin-arm64`, `win32-x64`. */
+    assets: Record<string, ReleaseAsset>;
+    source: 'manifest' | 'github';
+}
+export interface UpdateCheckCache {
+    checkedAt: number;
+    latestVersion?: string;
+    latestTag?: string;
+    /** ETag of the GitHub Releases API response, for conditional re-requests. */
+    etag?: string;
+}
+export interface SelfUpdateOptions {
+    fetchFn?: typeof fetch;
+    manifestUrl?: string;
+    releasesApiUrl?: string;
+    /** Test-only: permit http:// manifest/asset URLs (a local mock server). Production never sets this. */
+    allowInsecureHttp?: boolean;
+    now?: () => number;
+    /** Defaults to `~/.buildaharness/personal-assistant`. */
+    dataDir?: string;
+    currentVersion?: string;
+    platform?: NodeJS.Platform;
+    arch?: string;
+    /** Path of the running binary. Defaults to `process.execPath` (which, in a SEA, is the binary itself). */
+    execPath?: string;
+    /** Defaults to whether `node:sea` reports a SEA. */
+    isSea?: boolean;
+    log?: (line: string) => void;
+}
+/** Numeric `major.minor.patch` comparison; a `-prerelease` suffix sorts below the same release. Returns <0, 0, >0. */
+export declare function compareVersions(a: string, b: string): number;
+/** Throws on anything but https:// (unless the test-only override is set) — applied to the manifest URL and every asset URL. */
+export declare function assertHttps(url: string, allowInsecureHttp?: boolean): void;
+/**
+ * Whether the passive check may make its unsolicited outbound request at all. Off for scripted/CI
+ * runs (stdin not a TTY, or `ASSISTANT_NON_INTERACTIVE_APPROVAL` set) and when opted out via
+ * `ASSISTANT_UPDATE_CHECK=disabled` / `/config set updateCheck disabled`.
+ */
+export declare function shouldRunPassiveUpdateCheck(input: {
+    updateCheck: 'enabled' | 'disabled' | undefined;
+    env: NodeJS.ProcessEnv;
+    stdinIsTty: boolean;
+}): boolean;
+/**
+ * Resolves the latest release: the product-scoped manifest first, the GitHub Releases API (filtered
+ * to `aielia-v*` tags, ETag-cached) as fallback. A plain GET each — no query string, no
+ * identifiers, default User-Agent only. Returns `notModified` when the API answered 304 to the
+ * cached ETag; the caller then keeps the cached version.
+ */
+export declare function fetchLatestRelease(options: SelfUpdateOptions, etag?: string): Promise<{
+    release: ReleaseInfo;
+    etag?: string;
+} | {
+    notModified: true;
+}>;
+export interface UpdateCheckResult {
+    latestVersion: string;
+    latestTag?: string;
+    updateAvailable: boolean;
+}
+/**
+ * The passive check: 24h-throttled via `<dataDir>/update-check.json`. Never throws — any failure
+ * (offline, malformed manifest, …) resolves to `null`, since an unsolicited background check must
+ * never disturb a session. Callers are responsible for gating it with `shouldRunPassiveUpdateCheck`
+ * first and for not awaiting it before the prompt renders.
+ */
+export declare function checkForUpdate(options?: SelfUpdateOptions): Promise<UpdateCheckResult | null>;
+/** One-line notice; the instruction branches on how this copy was installed. */
+export declare function updateAvailableNotice(latestVersion: string, currentVersion: string, isSea: boolean): string;
+/** `isSea` the way the rest of the CLI decides it — false under npm/tsx, where nothing can be self-replaced. */
+export declare function isRunningAsSea(): boolean;
+/** Removes leftovers of a previous update (the Windows `.old` rename-aside copy, an interrupted temp download). Never throws. */
+export declare function cleanupStaleUpdateFiles(execPath?: string): void;
+/**
+ * Replaces the binary at `execPath` with the already-verified file at `newFile` (same directory).
+ * Unix: `rename` over the running binary — POSIX lets a still-open inode be replaced. Windows can't
+ * overwrite a running exe, so the current one is renamed aside to `.old` first (cleaned up on the
+ * next launch by `cleanupStaleUpdateFiles`), rolling back if the second rename fails.
+ */
+export declare function replaceBinary(execPath: string, newFile: string, platform?: NodeJS.Platform): void;
+/**
+ * `aielia update [--dry-run]`. Returns the process exit code (0 = up to date / updated / dry-run
+ * reported; 1 = refused or failed) and reports through `options.log`. Always does a fresh check —
+ * never the throttled cache — and works regardless of the `updateCheck` opt-out.
+ */
+export declare function runUpdateCommand(input?: {
+    dryRun?: boolean;
+} & SelfUpdateOptions): Promise<number>;

package/dist/semantic-criterion-coverage.d.ts

@@ -15,6 +15,16 @@ import { Belief } from '@buildaharness/harness';
  * NOT skipped.
  */
 export declare const NON_CHECKABLE_DEFAULT_CRITERION = "Respond helpfully, accurately, and safely to the user request.";
+/**
+ * `AUDIT_SEMANTIC_CRITERION_COVERAGE` gate — feature-value audit (Phase C1 of
+ * the internal plan). Default **ON**: the semantic criterion-coverage LLM call ships enabled, so an
+ * unset / empty / truthy value keeps today's behaviour. Set to a falsy value (`0` / `false` /
+ * `off` / `no` / `disabled`) to skip the hook entirely and leave the reviewer's implementer lens
+ * with its `.includes()` substring check alone. Read at exactly one call site — `harness-bridge.ts`,
+ * where the `semanticCriterionCoverage` host hook is wired. Same shape as
+ * `semanticContradictionEnabled()` (contradiction-checker.ts).
+ */
+export declare function semanticCriterionCoverageEnabled(env?: Record<string, string | undefined>): boolean;
 /**
  * One LLM call per uncovered criterion, checking it against the whole belief set at once — layered
  * on top of reviewerPass's implementerLens (packages/harness/src/nodes/reviewer-pass.ts), which

package/dist/shell-tools.d.ts

@@ -60,7 +60,7 @@ export interface ShellToolsContext extends ShellStagingContext {
      * Hostnames an approved command's HTTP(S)_PROXY traffic may reach (exact match or subdomain) —
      * see network-containment.ts and shell-executor.ts's networkContainmentEnv. Passed through to
      * executeCommand at apply time, same as timeoutMs. Undefined/empty denies all network access,
-     * the safe default (Decision 6, plans/lexical_functions_hardening_plan.html Phase 4).
+     * the safe default (Decision 6, the internal plan Phase 4).
      */
     networkAllowlist?: string[];
     executeCommand: ShellCommandExecutor;

package/dist/spike.js.map

@@ -1 +1 @@
-{"version":3,"file":"spike.js","sources":["../src/tui-spike.tsx"],"sourcesContent":["// Phase 0 feasibility spike for plans/personal_assistant_cli_pinned_input_plan.html.\n// Throwaway — not part of the shipped feature. Delete once Phase 5 confirms Ink\n// works over a real live terminal (raw-mode input + redraw), along with its\n// temporary build entry in vite.config.lib.ts.\nimport React, { useState } from 'react'\nimport { Box, Text, render, useInput } from 'ink'\n\nfunction Spike() {\n  const [lastKey, setLastKey] = useState('(none yet)')\n\n  useInput((input, key) => {\n    if (key.escape || (key.ctrl && input === 'c')) {\n      process.exit(0)\n    }\n    setLastKey(key.return ? '<enter>' : input || JSON.stringify(key))\n  })\n\n  return (\n    <Box borderStyle=\"round\" padding={1}>\n      <Text>Ink spike — hello world. Last key: {lastKey}</Text>\n    </Box>\n  )\n}\n\nrender(<Spike />)\n"],"names":[],"mappings":";;;AAOA,SAAS,QAAQ;AACf,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,YAAY;AAEnD,WAAS,CAAC,OAAO,QAAQ;AACvB,QAAI,IAAI,UAAW,IAAI,QAAQ,UAAU,KAAM;AAC7C,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,eAAW,IAAI,SAAS,YAAY,SAAS,KAAK,UAAU,GAAG,CAAC;AAAA,EAClE,CAAC;AAED,6BACG,KAAA,EAAI,aAAY,SAAQ,SAAS,GAChC,+BAAC,MAAA,EAAK,UAAA;AAAA,IAAA;AAAA,IAAoC;AAAA,EAAA,EAAA,CAAQ,EAAA,CACpD;AAEJ;AAEA,OAAO,oBAAC,SAAM,CAAE;"}
+{"version":3,"file":"spike.js","sources":["../src/tui-spike.tsx"],"sourcesContent":["// Phase 0 feasibility spike for the internal plan.\n// Throwaway — not part of the shipped feature. Delete once Phase 5 confirms Ink\n// works over a real live terminal (raw-mode input + redraw), along with its\n// temporary build entry in vite.config.lib.ts.\nimport React, { useState } from 'react'\nimport { Box, Text, render, useInput } from 'ink'\n\nfunction Spike() {\n  const [lastKey, setLastKey] = useState('(none yet)')\n\n  useInput((input, key) => {\n    if (key.escape || (key.ctrl && input === 'c')) {\n      process.exit(0)\n    }\n    setLastKey(key.return ? '<enter>' : input || JSON.stringify(key))\n  })\n\n  return (\n    <Box borderStyle=\"round\" padding={1}>\n      <Text>Ink spike — hello world. Last key: {lastKey}</Text>\n    </Box>\n  )\n}\n\nrender(<Spike />)\n"],"names":[],"mappings":";;;AAOA,SAAS,QAAQ;AACf,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,YAAY;AAEnD,WAAS,CAAC,OAAO,QAAQ;AACvB,QAAI,IAAI,UAAW,IAAI,QAAQ,UAAU,KAAM;AAC7C,cAAQ,KAAK,CAAC;AAAA,IAChB;AACA,eAAW,IAAI,SAAS,YAAY,SAAS,KAAK,UAAU,GAAG,CAAC;AAAA,EAClE,CAAC;AAED,6BACG,KAAA,EAAI,aAAY,SAAQ,SAAS,GAChC,+BAAC,MAAA,EAAK,UAAA;AAAA,IAAA;AAAA,IAAoC;AAAA,EAAA,EAAA,CAAQ,EAAA,CACpD;AAEJ;AAEA,OAAO,oBAAC,SAAM,CAAE;"}

package/dist/tool-control-plane.d.ts

@@ -1,6 +1,6 @@
 import { WorldModel, EvidenceStore, Diagnostics, FailureDiagnostics, ControlState, ToolAvailability } from '@buildaharness/harness';
 /**
- * Phase 4c of plans/harness_and_assistant_architecture_remediation_plan.html — a live, per-turn
+ * Phase 4c of the internal plan — a live, per-turn
  * harness ControlState, so tool-policy.ts's evaluateToolPolicy() can be given a real
  * controlState instead of the pre-evidence-baseline `undefined` every call site passed before
  * this phase. Deliberately builds on the fallback control-plane design (no packages/harness core

package/dist/tool-policy.d.ts

@@ -1,6 +1,6 @@
 import { RiskLevel } from './turn-intent-classifier.js';
 /**
- * Phase 4 of plans/harness_and_assistant_architecture_remediation_plan.html: the deterministic,
+ * Phase 4 of the internal plan: the deterministic,
  * authoritative decision point for whether a specific tool call may proceed — replacing "advisory
  * LLM classification, checked after the fact" with "deterministic policy informed by real harness
  * state, checked before execution" (the substantive fix both external architecture critiques

package/dist/tool-step.d.ts

@@ -8,6 +8,16 @@ import { ToolStepEvent } from '@buildaharness/runtime';
  */
 export interface AssistantToolStep extends ToolStepEvent {
     summary: string;
+    /**
+     * Set only on a second, follow-up `onToolStep` call fired immediately after `tool-policy.ts`'s
+     * `evaluateToolPolicy()` denies this exact call (see `agent-loop.ts`'s `checkToolPolicy`) — the
+     * first call (this field absent) already reported the proposal itself. Without this, a denied
+     * read-only tool call was invisible to the user: the model saw a "Denied by tool policy: …"
+     * result, but nothing ever told the person watching the transcript that the call didn't happen
+     * (report finding: "no confirmation, no denial message, nothing to distinguish 'the policy
+     * allowed this' from 'there was no policy at all'").
+     */
+    deniedReason?: string;
 }
 /**
  * Strips an MCP-qualified tool name (`mcp__<server>__<tool>`, how Claude Code CLI surfaces

package/dist/trace-events.d.ts

@@ -47,7 +47,7 @@ export type TraceEvent = {
 }
 /**
  * One of the harness's 11 layers did (or explicitly skipped) real work this step —
- * see plans/harness_layer_activation_plan.html Phase 2/3.1. `layer` is a stable slug
+ * see the internal plan Phase 2/3.1. `layer` is a stable slug
  * ('world_model' | 'evidence_reasoning' | 'hypothesis' | 'contradiction' | 'diagnostics' |
  * 'control_state' | 'planning' | 'execution' | 'verification' | 'recovery' | 'reviewer_pass'),
  * not a free-text name, so a "Why?"/`/layers` renderer can key off it directly.
@@ -71,7 +71,7 @@ export type TraceEvent = {
     failedAttempts: number;
 }
 /**
- * Phase 4 of plans/harness_and_assistant_architecture_remediation_plan.html — see
+ * Phase 4 of the internal plan — see
  * execution-mode.ts's own doc comment for each mode's guarantee level.
  */
  | {
@@ -93,14 +93,14 @@ export type TraceEvent = {
  * Which proposer drove this turn — 'posthoc' (flag OFF, or a trivial / no-tool turn),
  * 'flat-oneloop', or 'batch-oneloop' (both flag ON). Emitted once per turn from runTurn, right
  * after `useOneLoop` is resolved. See AssistantTurnResult.proposerKind and
- * plans/chat_ui_browser_e2e_plan.html phase B1 for why this exists.
+ * the internal plan phase B1 for why this exists.
  */
  | {
     kind: 'proposer_selected';
     proposerKind: ProposerKind;
 }
 /**
- * P9 of plans/ask_question_and_plan_mode_plan.html — the lightweight plan-sketch delegate
+ * P9 of the internal plan — the lightweight plan-sketch delegate
  * (PlanSketchService) ran. `requestPreview` is truncated to stay name/status-only per this
  * type's own doc comment, not the full request text. Distinct from `plan_classified`/
  * `plan_updated`, which are about the stateful drafting/approval machinery (PlanDraftingService)
@@ -111,7 +111,7 @@ export type TraceEvent = {
     requestPreview: string;
 }
 /**
- * P10 of plans/ask_question_and_plan_mode_plan.html — a write_file/run_shell_command/send_email
+ * P10 of the internal plan — a write_file/run_shell_command/send_email
  * proposal was auto-applied instead of staged for approval because it was proposed while
  * `taskId` (part of a plan approved with `'approve_trusted'`) was the currently RUNNING task —
  * see PlanRecord.trustApprovedSteps and INV-36. The action itself still went through

package/dist/trust-tagging.d.ts

@@ -15,7 +15,7 @@ export interface InjectionDetection {
 export declare function detectInjectionLikely(text: string): InjectionDetection;
 /**
  * `AUDIT_LLM_INJECTION_DETECT` gate — feature-value audit (Phase A5 of
- * plans/feature_audit_automation_plan.html). Default **ON**: the semantic injection-detection LLM
+ * the internal plan). Default **ON**: the semantic injection-detection LLM
  * call ships enabled, so an unset / empty / truthy value keeps today's behaviour. Set to a falsy
  * value (`0` / `false` / `off` / `no` / `disabled`) to skip the LLM escalation entirely and fall
  * back to the always-on deterministic regex/pattern pass only. Read at exactly one place —

package/dist/{tui-app-DxLPSGh2.js → tui-app-CFfOP2DC.js}

@@ -3,10 +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 } from "react";
+import { useState, useRef, useCallback, useSyncExternalStore, useEffect } from "react";
 import { useWindowSize, usePaste, useInput, Box, Text, render, Static } from "ink";
-import { runCli } from "./cli.js";
+import { r as runCli, P as PLAN_LINE_PREFIX, I as ICONS } from "./bin-Btzhiyzi.js";
 import { format } from "node:util";
+import { h as DIFF_INDENT } from "./cli-session-DnSc6Hhx.js";
 function classify(raw, stream) {
   if (raw.startsWith("\r")) {
     return { type: "progress", text: raw.replace(/\r/g, "").trimEnd() };
@@ -210,18 +211,131 @@ function TuiInput(props) {
     }) })
   ] });
 }
+function SelectPrompt(props) {
+  const { question, options, onSubmit, isActive = true } = props;
+  const [highlighted, setHighlighted] = useState(0);
+  useInput(
+    (input, key) => {
+      if (key.upArrow) {
+        setHighlighted((h) => (h - 1 + options.length) % options.length);
+        return;
+      }
+      if (key.downArrow) {
+        setHighlighted((h) => (h + 1) % options.length);
+        return;
+      }
+      if (key.return) {
+        onSubmit(options[highlighted].key);
+        return;
+      }
+      const matched = options.find((option) => option.key.toLowerCase() === input.toLowerCase());
+      if (matched) onSubmit(matched.key);
+    },
+    { isActive }
+  );
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "yellow", children: question }),
+    /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor: "yellow", flexDirection: "column", paddingX: 1, children: options.map((option, i) => /* @__PURE__ */ jsxs(Text, { inverse: i === highlighted, children: [
+      i === highlighted ? "› " : "  ",
+      "[",
+      option.key,
+      "] ",
+      option.label
+    ] }, option.key)) })
+  ] });
+}
+const HEADER_RE = /^(#{1,6})\s+(.*)$/;
+const CHECKBOX_RE = /^(\s*[-*]\s)\[([ xX])\]\s+(.*)$/;
+const DIFF_LINE_RE = /^(\s*\d+) ([+\- ])(.*)$/;
+const INLINE_TOKEN_RE = /\*\*(.+?)\*\*|`([^`]+)`/g;
+const ASSISTANT_BULLET = "- ";
+function matchDiffLine(text) {
+  if (!text.startsWith(DIFF_INDENT)) return void 0;
+  const rest = text.slice(DIFF_INDENT.length);
+  const match = DIFF_LINE_RE.exec(rest);
+  if (!match) return void 0;
+  const sign = match[2];
+  return { content: rest, color: sign === "+" ? "green" : sign === "-" ? "red" : void 0 };
+}
+function renderDiffLine(text, key) {
+  const diffLine = matchDiffLine(text);
+  if (!diffLine) return void 0;
+  return /* @__PURE__ */ jsxs(Text, { color: diffLine.color, children: [
+    DIFF_INDENT,
+    diffLine.content
+  ] }, key);
+}
+const NEEDS_APPROVAL_RE = /^(\[needs approval[^\]]*\])(.*)$/;
+function renderNeedsApprovalLine(text, key) {
+  const match = NEEDS_APPROVAL_RE.exec(text);
+  if (!match) return void 0;
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    /* @__PURE__ */ jsx(Text, { color: "yellow", children: match[1] }),
+    match[2]
+  ] }, key);
+}
+function renderInlineSegments(text) {
+  const segments = [];
+  let lastIndex = 0;
+  let key = 0;
+  INLINE_TOKEN_RE.lastIndex = 0;
+  let match;
+  while ((match = INLINE_TOKEN_RE.exec(text)) !== null) {
+    if (match.index > lastIndex) segments.push(text.slice(lastIndex, match.index));
+    if (match[1] !== void 0) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { bold: true, children: match[1] }, key++)
+      );
+    } else if (match[2] !== void 0) {
+      segments.push(
+        /* @__PURE__ */ jsx(Text, { color: "cyan", children: match[2] }, key++)
+      );
+    }
+    lastIndex = INLINE_TOKEN_RE.lastIndex;
+  }
+  if (lastIndex < text.length || segments.length === 0) segments.push(text.slice(lastIndex));
+  return segments;
+}
+function renderMarkdownLine(text, key, continuation = false) {
+  const diffElement = renderDiffLine(text, key);
+  if (diffElement) return diffElement;
+  const headerMatch = HEADER_RE.exec(text);
+  if (headerMatch) {
+    return /* @__PURE__ */ jsx(Text, { bold: true, underline: true, children: renderInlineSegments(headerMatch[2]) }, key);
+  }
+  const checkboxMatch = CHECKBOX_RE.exec(text);
+  if (checkboxMatch) {
+    const checked = checkboxMatch[2].toLowerCase() === "x";
+    return /* @__PURE__ */ jsxs(Text, { children: [
+      checkboxMatch[1],
+      checked ? "☑" : "☐",
+      " ",
+      renderInlineSegments(checkboxMatch[3])
+    ] }, key);
+  }
+  if (text.length === 0) return /* @__PURE__ */ jsx(Text, { children: " " }, key);
+  return /* @__PURE__ */ jsxs(Text, { children: [
+    continuation ? "" : ASSISTANT_BULLET,
+    renderInlineSegments(text)
+  ] }, key);
+}
+const ASSISTANT_INDENT_WIDTH = 2;
 function useStore(store) {
   return useSyncExternalStore(store.subscribe, store.getSnapshot, store.getSnapshot);
 }
-const EMPTY_LOG = { lines: [], progressText: "", transientText: "" };
-const TOOL_STEP_PREFIX = "⚙";
+const EMPTY_LOG = { lines: [], progressText: "", transientText: "", waitingForOutput: false };
+const TOOL_STEP_PREFIXES = [ICONS.toolStep, ICONS.proposalStep, ICONS.deniedStep];
 const ASSISTANT_REPLY_PREFIX = "Aielia>";
 function classifyLineKind(mergedText, streamedReplyWasOpen, stream) {
   if (stream === "stderr") return "error";
+  if (mergedText.trimStart().startsWith(PLAN_LINE_PREFIX)) return "plan";
   if (streamedReplyWasOpen || mergedText.trimStart().startsWith(ASSISTANT_REPLY_PREFIX)) return "assistant";
-  if (mergedText.trimStart().startsWith(TOOL_STEP_PREFIX)) return "tool";
+  if (TOOL_STEP_PREFIXES.some((prefix) => mergedText.trimStart().startsWith(prefix))) return "tool";
   return "system";
 }
+function stripPlanLabel(text) {
+  return text.replace(new RegExp(`^\\s*${PLAN_LINE_PREFIX}\\s*`), "");
+}
 function stripAssistantLabel(text) {
   return text.replace(/^\s*Aielia>\s?/, "");
 }
@@ -230,6 +344,7 @@ class EventLogBridge {
     __publicField(this, "lines", []);
     __publicField(this, "progressText", "");
     __publicField(this, "transientText", "");
+    __publicField(this, "waitingForOutput", false);
     __publicField(this, "snapshot", EMPTY_LOG);
     __publicField(this, "listeners", /* @__PURE__ */ new Set());
     __publicField(this, "subscribe", (listener) => {
@@ -241,9 +356,14 @@ class EventLogBridge {
     __publicField(this, "getSnapshot", () => this.snapshot);
   }
   commit() {
-    this.snapshot = { lines: this.lines, progressText: this.progressText, transientText: this.transientText };
+    this.snapshot = { lines: this.lines, progressText: this.progressText, transientText: this.transientText, waitingForOutput: this.waitingForOutput };
     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.commit();
+  }
   /**
    * A blank spacer line ("some margins between different conversations", later extended to "at
    * least one line spacing between the user and system messages") — called from three places in
@@ -260,12 +380,13 @@ class EventLogBridge {
     this.lines = [...this.lines, { text: "", kind: "margin" }];
     this.commit();
   }
-  /** Records a line the user just submitted (chat or a resolved prompt answer) into permanent scrollback — mirrors a real terminal's own line-echo, which the inert (non-TTY) input stream this shell uses never produces on its own. `prefix` is `''` for an ordinary chat line (no "you>" label — see `LogLineText`'s doc comment) and `'> '` for a resolved prompt answer, which keeps its prefix since it's answering a question printed just above it, not identifying whose turn it is. */
+  /** Records a line the user just submitted (chat or a resolved prompt answer) into permanent scrollback — mirrors a real terminal's own line-echo, which the inert (non-TTY) input stream this shell uses never produces on its own. `prefix` is `''` for an ordinary chat line (no "you>" label — see `LogLineText`'s doc comment, kind `'user'`) and `'> '` for a resolved prompt answer (kind `'approval'`, its own box color — see `LogLineText` — distinct from a real chat message even though both are the user's own input), which keeps its prefix since it's answering a question printed just above it, not identifying whose turn it is. */
   pushEchoLine(prefix, text) {
-    this.lines = [...this.lines, { text: `${prefix}${text}`, kind: "user" }];
+    this.lines = [...this.lines, { text: `${prefix}${text}`, kind: prefix === "" ? "user" : "approval" }];
     this.commit();
   }
   handleEvent(event) {
+    this.waitingForOutput = false;
     if (event.type === "progress") {
       this.progressText = event.text;
       this.commit();
@@ -279,8 +400,13 @@ class EventLogBridge {
     const streamedReplyWasOpen = this.transientText.length > 0;
     const merged = this.transientText + event.lines.join("\n");
     const kind = classifyLineKind(merged, streamedReplyWasOpen, event.stream);
-    const displayText = kind === "assistant" ? stripAssistantLabel(merged) : merged;
-    this.lines = [...this.lines, ...displayText.split("\n").map((text) => ({ text, kind }))];
+    const displayText = kind === "assistant" ? stripAssistantLabel(merged) : kind === "plan" ? stripPlanLabel(merged) : merged;
+    this.lines = kind === "plan" ? [...this.lines, { text: displayText, kind }] : (
+      // continuation is only meaningful (and only set) for 'assistant' — every other kind's
+      // LogLine stays a bare { text, kind } so existing exact-shape equality checks elsewhere
+      // (classifyLineKind's own test coverage) don't have to account for an unused field.
+      [...this.lines, ...displayText.split("\n").map((text, i) => kind === "assistant" ? { text, kind, continuation: i > 0 } : { text, kind })]
+    );
     this.transientText = "";
     this.progressText = "";
     this.commit();
@@ -302,10 +428,12 @@ class PromptBridge {
     /** Matches `RunCliOptions.askYesNo`'s exact parsing convention (`answer.trim().toLowerCase().startsWith('y')`) — same fail-closed shape, just answered via the Ink prompt instead of `rl.question`. */
     __publicField(this, "askYesNo", (question) => this.ask(question).then((answer) => answer.trim().toLowerCase().startsWith("y")));
     __publicField(this, "askLine", (question) => this.ask(question));
+    /** Matches `RunCliOptions.askSelect`'s contract exactly — resolves with the chosen `SelectOption.key`, answered via `SelectPrompt` instead of `rl.question`. */
+    __publicField(this, "askSelect", (question, options) => this.ask(question, options));
   }
-  ask(question) {
+  ask(question, options) {
     return new Promise((resolve) => {
-      this.pending = { question };
+      this.pending = { question, options };
       this.resolve = resolve;
       for (const listener of this.listeners) listener();
     });
@@ -335,16 +463,24 @@ class StatusBridge {
     for (const listener of this.listeners) listener();
   }
 }
-function UserMessageBox({ text, width }) {
-  return /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, width, children: text.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { children: line.length > 0 ? line : " " }, i)) });
+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)) });
+}
+function PlanBox({ text, width }) {
+  return /* @__PURE__ */ jsx(Box, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1, width, children: text.split("\n").map((line, i) => /* @__PURE__ */ jsx(Text, { bold: i === 0, children: line.length > 0 ? line : " " }, i)) });
 }
 function LogLineText({ line, width }) {
   switch (line.kind) {
     case "user":
       return /* @__PURE__ */ jsx(UserMessageBox, { text: line.text, width });
+    case "approval":
+      return /* @__PURE__ */ jsx(UserMessageBox, { text: line.text, width, borderColor: "greenBright" });
     case "assistant":
+      return /* @__PURE__ */ jsx(Box, { paddingLeft: ASSISTANT_INDENT_WIDTH, children: renderMarkdownLine(line.text, 0, line.continuation) });
+    case "plan":
+      return /* @__PURE__ */ jsx(PlanBox, { text: line.text, width });
     case "system":
-      return /* @__PURE__ */ jsx(Text, { children: line.text });
+      return renderDiffLine(line.text, 0) ?? renderNeedsApprovalLine(line.text, 0) ?? /* @__PURE__ */ jsx(Text, { children: line.text });
     case "tool":
       return /* @__PURE__ */ jsx(Text, { dimColor: true, children: line.text });
     case "error":
@@ -353,6 +489,19 @@ function LogLineText({ line, width }) {
       return /* @__PURE__ */ jsx(Text, { children: " " });
   }
 }
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const SPINNER_INTERVAL_MS = 80;
+function Spinner() {
+  const [frame, setFrame] = useState(0);
+  useEffect(() => {
+    const id = setInterval(() => setFrame((f) => (f + 1) % SPINNER_FRAMES.length), SPINNER_INTERVAL_MS);
+    return () => clearInterval(id);
+  }, []);
+  return /* @__PURE__ */ jsxs(Text, { dimColor: true, children: [
+    SPINNER_FRAMES[frame],
+    " Thinking…"
+  ] });
+}
 function StatusLine({ indicators }) {
   return /* @__PURE__ */ jsx(Text, { children: indicators.map((indicator, index) => /* @__PURE__ */ jsxs(Text, { children: [
     index > 0 ? "   " : "",
@@ -374,26 +523,32 @@ function TuiApp(props) {
       eventLog.pushTurnMargin();
       eventLog.pushEchoLine("", line);
       eventLog.pushTurnMargin();
+      eventLog.beginTurn();
       onSubmitChat(line);
     },
     [eventLog, onSubmitChat]
   );
   const handleSubmitPrompt = useCallback(
     (line) => {
-      eventLog.pushEchoLine("> ", line);
+      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();
       prompt.submit(line);
     },
-    [eventLog, prompt]
+    [eventLog, prompt, pending]
   );
   const hasTransient = log.progressText.length > 0 || log.transientText.length > 0;
+  const showSpinner = log.waitingForOutput && !hasTransient;
   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, {}),
     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) })
     ] }),
     /* @__PURE__ */ jsx(Text, { dimColor: true, children: "─".repeat(Math.max(1, width)) }),
-    /* @__PURE__ */ jsx(
+    (pending == null ? void 0 : pending.options) ? /* @__PURE__ */ jsx(SelectPrompt, { question: pending.question, options: pending.options, onSubmit: handleSubmitPrompt }) : /* @__PURE__ */ jsx(
       TuiInput,
       {
         promptLabel: pending == null ? void 0 : pending.question,
@@ -436,7 +591,8 @@ async function runTuiApp(options = {}) {
       input: options.input ?? inert.input,
       output: options.output ?? inert.output,
       askYesNo: prompt.askYesNo,
-      askLine: prompt.askLine
+      askLine: prompt.askLine,
+      askSelect: prompt.askSelect
     });
   } catch (err) {
     restoreCapture();
@@ -478,4 +634,4 @@ export {
   TuiApp,
   runTuiApp
 };
-//# sourceMappingURL=tui-app-DxLPSGh2.js.map
+//# sourceMappingURL=tui-app-CFfOP2DC.js.map