reasonix 0.6.0 → 0.7.0

package/dist/cli/index.js

@@ -10,7 +10,7 @@ import {
   memoryEnabled,
   readProjectMemory,
   sanitizeMemoryName
-} from "./chunk-NXYPGKA3.js";
+} from "./chunk-5DZMZCCW.js";
 
 // src/cli/index.ts
 import { Command } from "commander";
@@ -443,7 +443,7 @@ async function harvest(reasoningContent, client, options = {}, signal) {
   const minLen = options.minReasoningLen ?? 40;
   const trimmed = reasoningContent.trim();
   if (trimmed.length < minLen) return emptyPlanState();
-  const model2 = options.model ?? "deepseek-chat";
+  const model2 = options.model ?? "deepseek-v4-flash";
   const maxItems = options.maxItems ?? 5;
   const maxItemLen = options.maxItemLen ?? 80;
   const system = SYSTEM_PROMPT.replace("{maxItems}", String(maxItems)).replace(
@@ -1838,8 +1838,9 @@ var ARGS_COMPACT_THRESHOLD_TOKENS = 800;
 var TURN_END_RESULT_CAP_TOKENS = 3e3;
 var FAILURE_ESCALATION_THRESHOLD = 3;
 var ESCALATION_MODEL = "deepseek-v4-pro";
-var NEEDS_PRO_MARKER = "<<<NEEDS_PRO>>>";
-var NEEDS_PRO_BUFFER_CHARS = 80;
+var NEEDS_PRO_MARKER_PREFIX = "<<<NEEDS_PRO";
+var NEEDS_PRO_MARKER_RE = /^<<<NEEDS_PRO(?::\s*([^>]*))?>>>/;
+var NEEDS_PRO_BUFFER_CHARS = 256;
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -1905,6 +1906,14 @@ var CacheFirstLoop = class {
    * the user doesn't watch flash retry the same edit 5 times.
    */
   _turnFailureCount = 0;
+  /**
+   * Per-type breakdown of failure signals counted toward the turn's
+   * auto-escalation threshold. Surfaced in the warning when the
+   * threshold trips so the user sees what kind of trouble flash
+   * actually hit ("3× search-mismatch, 2× truncated") rather than
+   * just a bare count. Reset alongside _turnFailureCount.
+   */
+  _turnFailureTypes = {};
   constructor(opts) {
     this.client = opts.client;
     this.prefix = opts.prefix;
@@ -1932,10 +1941,11 @@ var CacheFirstLoop = class {
     this.sessionName = opts.session ?? null;
     if (this.sessionName) {
       const prior = loadSessionMessages(this.sessionName);
-      const { messages, healedCount, tokensSaved } = healLoadedMessagesByTokens(
-        prior,
-        DEFAULT_MAX_RESULT_TOKENS
-      );
+      const shrunk = healLoadedMessagesByTokens(prior, DEFAULT_MAX_RESULT_TOKENS);
+      const stamped = stampMissingReasoningForThinkingMode(shrunk.messages, this.model);
+      const messages = stamped.messages;
+      const healedCount = shrunk.healedCount + stamped.stampedCount;
+      const tokensSaved = shrunk.tokensSaved;
       for (const msg of messages) this.log.append(msg);
       this.resumedMessageCount = messages.length;
       if (healedCount > 0) {
@@ -2162,15 +2172,41 @@ var CacheFirstLoop = class {
     return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
   }
   /**
-   * True when the assistant's content is a self-reported escalation
-   * request. Only the FIRST line matters — the model is instructed
-   * to emit the marker as the first output token if at all. Matching
-   * anywhere else in the text is a normal content reference (e.g.
-   * the user asked about the marker itself, or prose that happens
-   * to contain angle-brackets).
+   * Parse the escalation marker out of the model's leading content.
+   * Returns `{ matched: true, reason? }` for both bare and reason-
+   * carrying forms. Only the FIRST line matters — the model is
+   * instructed to emit the marker as the first output token if at
+   * all. Matches anywhere else in the text are normal content
+   * references (e.g. the user asked about the marker itself).
    */
+  parseEscalationMarker(content) {
+    const m = NEEDS_PRO_MARKER_RE.exec(content.trimStart());
+    if (!m) return { matched: false };
+    const reason = m[1]?.trim();
+    return { matched: true, reason: reason || void 0 };
+  }
+  /** Convenience boolean — same gate the streaming path used to call. */
   isEscalationRequest(content) {
-    return content.trimStart().startsWith(NEEDS_PRO_MARKER);
+    return this.parseEscalationMarker(content).matched;
+  }
+  /**
+   * Could `buf` STILL plausibly become the full marker as more chunks
+   * arrive? Drives the streaming buffer's flush decision: while this
+   * is true we keep accumulating; once it's false (or the buffer
+   * exceeds the byte limit) we flush so the user isn't staring at a
+   * delayed display for arbitrary content that just happens to start
+   * with `<`.
+   */
+  looksLikePartialEscalationMarker(buf) {
+    const t = buf.trimStart();
+    if (t.length === 0) return true;
+    if (t.length <= NEEDS_PRO_MARKER_PREFIX.length) {
+      return NEEDS_PRO_MARKER_PREFIX.startsWith(t);
+    }
+    if (!t.startsWith(NEEDS_PRO_MARKER_PREFIX)) return false;
+    const rest = t.slice(NEEDS_PRO_MARKER_PREFIX.length);
+    if (rest[0] !== ">" && rest[0] !== ":") return false;
+    return true;
   }
   /**
    * Check whether a tool result string looks like a "flash struggled"
@@ -2184,16 +2220,18 @@ var CacheFirstLoop = class {
    */
   noteToolFailureSignal(resultJson, repair) {
     let bumped = false;
-    if (resultJson.includes('"error"') && resultJson.includes("search text not found")) {
-      this._turnFailureCount += 1;
+    const bump = (kind, by = 1) => {
+      this._turnFailureCount += by;
+      this._turnFailureTypes[kind] = (this._turnFailureTypes[kind] ?? 0) + by;
       bumped = true;
+    };
+    if (resultJson.includes('"error"') && resultJson.includes("search text not found")) {
+      bump("search-mismatch");
     }
     if (repair) {
-      const repairs = repair.scavenged + repair.truncationsFixed + repair.stormsBroken;
-      if (repairs > 0) {
-        this._turnFailureCount += repairs;
-        bumped = true;
-      }
+      if (repair.scavenged > 0) bump("scavenged", repair.scavenged);
+      if (repair.truncationsFixed > 0) bump("truncated", repair.truncationsFixed);
+      if (repair.stormsBroken > 0) bump("storm-broken", repair.stormsBroken);
     }
     if (bumped && !this._escalateThisTurn && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
       this._escalateThisTurn = true;
@@ -2201,6 +2239,16 @@ var CacheFirstLoop = class {
     }
     return false;
   }
+  /**
+   * Render `_turnFailureTypes` as a comma-separated breakdown like
+   * "2× search-mismatch, 1× truncated" for the auto-escalation
+   * warning. Empty if no types have been recorded yet (defensive —
+   * the warning sites only call this after a bump).
+   */
+  formatFailureBreakdown() {
+    const parts = Object.entries(this._turnFailureTypes).filter(([, n]) => n > 0).map(([kind, n]) => `${n}\xD7 ${kind}`);
+    return parts.length > 0 ? parts.join(", ") : `${this._turnFailureCount} repair/error signal(s)`;
+  }
   buildMessages(pendingUser) {
     const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
     const msgs = [...this.prefix.toMessages(), ...healed.messages];
@@ -2256,6 +2304,7 @@ var CacheFirstLoop = class {
     this.scratch.reset();
     this.repair.resetStorm();
     this._turnFailureCount = 0;
+    this._turnFailureTypes = {};
     this._escalateThisTurn = false;
     let armedConsumed = false;
     if (this._proArmedForNextTurn) {
@@ -2444,7 +2493,7 @@ var CacheFirstLoop = class {
                 if (this.isEscalationRequest(escalationBuf)) {
                   break;
                 }
-                if (escalationBuf.length >= NEEDS_PRO_BUFFER_CHARS || escalationBuf.includes("\n")) {
+                if (escalationBuf.length >= NEEDS_PRO_BUFFER_CHARS || !this.looksLikePartialEscalationMarker(escalationBuf)) {
                   escalationBufFlushed = true;
                   yield {
                     turn: this._turn,
@@ -2539,11 +2588,13 @@ var CacheFirstLoop = class {
         return;
       }
       if (this.modelForCurrentCall() !== ESCALATION_MODEL && this.isEscalationRequest(assistantContent)) {
+        const { reason } = this.parseEscalationMarker(assistantContent);
         this._escalateThisTurn = true;
+        const reasonSuffix = reason ? ` \u2014 ${reason}` : "";
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u21E7 flash requested escalation \u2014 retrying this turn on ${ESCALATION_MODEL}`
+          content: `\u21E7 flash requested escalation \u2014 retrying this turn on ${ESCALATION_MODEL}${reasonSuffix}`
         };
         assistantContent = "";
         reasoningContent = "";
@@ -2578,7 +2629,12 @@ var CacheFirstLoop = class {
         assistantContent || null
       );
       this.appendAndPersist(
-        this.assistantMessage(assistantContent, repairedCalls, reasoningContent)
+        this.assistantMessage(
+          assistantContent,
+          repairedCalls,
+          this.modelForCurrentCall(),
+          reasoningContent
+        )
       );
       yield {
         turn: this._turn,
@@ -2593,7 +2649,7 @@ var CacheFirstLoop = class {
         yield {
           turn: this._turn,
           role: "warning",
-          content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailureCount} repair/error signals. Next turn falls back to ${this.model} unless /pro is armed.`
+          content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
         };
       }
       if (report.stormsBroken > 0) {
@@ -2717,7 +2773,7 @@ ${reason}`;
           yield {
             turn: this._turn,
             role: "warning",
-            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this._turnFailureCount} edit failure(s). Next turn falls back to ${this.model} unless /pro is armed.`
+            content: `\u21E7 auto-escalating to ${ESCALATION_MODEL} for the rest of this turn \u2014 flash hit ${this.formatFailureBreakdown()}. Next turn falls back to ${this.model} unless /pro is armed.`
           };
         }
         yield {
@@ -2761,7 +2817,9 @@ ${reason}`;
 
 ${summary}`;
       const summaryStats = this.stats.record(this._turn, summaryModel, resp.usage ?? new Usage());
-      this.appendAndPersist(this.assistantMessage(summary, [], resp.reasoningContent ?? void 0));
+      this.appendAndPersist(
+        this.assistantMessage(summary, [], summaryModel, resp.reasoningContent)
+      );
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2792,28 +2850,39 @@ ${summary}`;
     }
     return final;
   }
-  assistantMessage(content, toolCalls, reasoningContent) {
+  /**
+   * Build an assistant message for the log. The `producingModel` arg is
+   * the model that actually generated this turn (flash, pro, the
+   * forced-summary flash call, `this.model` for synthetics, etc.) —
+   * NOT `this.model`, because escalation + forced-summary can both
+   * route a single turn to a different model.
+   *
+   * The single invariant this encodes: if the producing model is
+   * thinking-mode, `reasoning_content` MUST be present on the
+   * persisted message — even as an empty string. DeepSeek's validator
+   * 400s the NEXT request if any historical thinking-mode assistant
+   * turn is missing it. We used to gate on `reasoning.length > 0`,
+   * which silently dropped the field whenever the stream emitted zero
+   * reasoning deltas or the API returned `reasoning_content: null` —
+   * both legitimate edge cases the 0.5.15/0.5.18 fixes missed.
+   */
+  assistantMessage(content, toolCalls, producingModel, reasoningContent) {
     const msg = { role: "assistant", content };
     if (toolCalls.length > 0) msg.tool_calls = toolCalls;
-    if (reasoningContent && reasoningContent.length > 0) {
-      msg.reasoning_content = reasoningContent;
+    if (isThinkingModeModel(producingModel)) {
+      msg.reasoning_content = reasoningContent ?? "";
     }
     return msg;
   }
   /**
-   * Build a synthetic assistant message we insert into the log without
-   * a real API round trip (abort notices, future system injections).
-   * Reasoner models reject follow-up requests whose assistant history
-   * is missing `reasoning_content`, so we stamp an empty-string
-   * placeholder on reasoner sessions to satisfy the validator. V3
-   * doesn't care — field stays absent there.
+   * Synthetic assistant message (abort notices, future system injections)
+   * — no real API round trip. Delegates to {@link assistantMessage} with
+   * `this.model` as the stand-in producer, so the same thinking-mode
+   * invariant applies: reasoner sessions get an empty-string
+   * `reasoning_content`; V3 sessions get nothing.
    */
   syntheticAssistantMessage(content) {
-    const msg = { role: "assistant", content };
-    if (isThinkingModeModel(this.model)) {
-      msg.reasoning_content = "";
-    }
-    return msg;
+    return this.assistantMessage(content, [], this.model, "");
   }
 };
 function isThinkingModeModel(model2) {
@@ -3006,6 +3075,19 @@ function healLoadedMessages(messages, maxChars) {
   const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
   return { messages: paired.messages, healedCount, healedFrom: shrunk.healedFrom };
 }
+function stampMissingReasoningForThinkingMode(messages, model2) {
+  if (!isThinkingModeModel(model2)) {
+    return { messages, stampedCount: 0 };
+  }
+  let stampedCount = 0;
+  const out = messages.map((msg) => {
+    if (msg.role !== "assistant") return msg;
+    if (Object.hasOwn(msg, "reasoning_content")) return msg;
+    stampedCount += 1;
+    return { ...msg, reasoning_content: "" };
+  });
+  return { messages: out, stampedCount };
+}
 function healLoadedMessagesByTokens(messages, maxTokens) {
   const shrunk = shrinkOversizedToolResultsByTokens(messages, maxTokens);
   const paired = fixToolCallPairing(shrunk.messages);
@@ -3963,28 +4045,233 @@ function registerMemoryTools(registry, opts = {}) {
   return registry;
 }
 
-// src/tools/plan.ts
+// src/tools/choice.ts
+var ChoiceRequestedError = class extends Error {
+  question;
+  options;
+  allowCustom;
+  constructor(question, options, allowCustom) {
+    super(
+      "ChoiceRequestedError: choice submitted. STOP calling tools now \u2014 the TUI has shown the options to the user. Wait for their next message; it will either be 'user picked <id>' (carry on with that branch), 'user answered: <text>' (custom free-form reply; read and proceed), or 'user cancelled the choice' (drop the question and ask what they want instead). Don't call any tools in the meantime."
+    );
+    this.name = "ChoiceRequestedError";
+    this.question = question;
+    this.options = options;
+    this.allowCustom = allowCustom;
+  }
+  toToolResult() {
+    return {
+      error: `${this.name}: ${this.message}`,
+      question: this.question,
+      options: this.options,
+      allowCustom: this.allowCustom
+    };
+  }
+};
+function sanitizeOptions(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry;
+    const id = typeof e.id === "string" ? e.id.trim() : "";
+    const title = typeof e.title === "string" ? e.title.trim() : "";
+    if (!id || !title) continue;
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const summary = typeof e.summary === "string" ? e.summary.trim() || void 0 : void 0;
+    const opt = { id, title };
+    if (summary) opt.summary = summary;
+    out.push(opt);
+  }
+  return out;
+}
+function registerChoiceTool(registry, opts = {}) {
+  registry.register({
+    name: "ask_choice",
+    description: "Present 2\u20136 alternatives to the user. The principle: if the user is supposed to pick, the tool picks \u2014 you don't enumerate the choices as prose. Prose menus have no picker in this TUI, so the user gets a wall of text to scroll through and a letter to type, strictly worse than the magenta picker this tool renders. Call it whenever (a) the user has asked for options, (b) you've analyzed multiple approaches and the final call is theirs, or (c) it's a preference fork you can't resolve without them. Skip it when one option is clearly best (just do it, or submit_plan) or a free-form text answer fits (ask in prose). Keep option ids short and stable (A/B/C). Each option: title + optional summary. allowCustom=true when their real answer might not fit. Max 6 options \u2014 narrow first if more. A one-sentence lead-in before the call is fine; don't repeat the options in it.",
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        question: {
+          type: "string",
+          description: "The question to put in front of the user. One sentence. Don't repeat the options in the question text \u2014 the picker renders them separately."
+        },
+        options: {
+          type: "array",
+          description: "2\u20134 alternatives. Each needs a stable id and a short title; summary is optional.",
+          items: {
+            type: "object",
+            properties: {
+              id: { type: "string", description: "Short stable id (A, B, C, or option-1)." },
+              title: { type: "string", description: "One-line title shown as the option label." },
+              summary: {
+                type: "string",
+                description: "Optional. A second dimmed line with more detail. Keep under ~80 chars."
+              }
+            },
+            required: ["id", "title"]
+          }
+        },
+        allowCustom: {
+          type: "boolean",
+          description: "If true, the picker shows a 'Let me type my own answer' escape hatch. Default false. Turn on when the user's real answer might not fit any of your pre-defined options."
+        }
+      },
+      required: ["question", "options"]
+    },
+    fn: async (args) => {
+      const question = (args?.question ?? "").trim();
+      if (!question) {
+        throw new Error(
+          "ask_choice: question is required \u2014 write one sentence explaining the decision."
+        );
+      }
+      const options = sanitizeOptions(args?.options);
+      if (options.length < 2) {
+        throw new Error(
+          "ask_choice: need at least 2 well-formed options (each with a non-empty id and title). If you just need a text answer, ask the user in plain assistant text instead."
+        );
+      }
+      if (options.length > 6) {
+        throw new Error(
+          "ask_choice: too many options (max 6). If you really have this many branches, split into two sequential ask_choice calls or narrow down first."
+        );
+      }
+      const allowCustom = args?.allowCustom === true;
+      opts.onChoiceRequested?.(question, options);
+      throw new ChoiceRequestedError(question, options, allowCustom);
+    }
+  });
+  return registry;
+}
+
+// src/tools/plan-errors.ts
 var PlanProposedError = class extends Error {
   plan;
-  constructor(plan2) {
+  steps;
+  summary;
+  constructor(plan2, steps, summary) {
     super(
       "PlanProposedError: plan submitted. STOP calling tools now \u2014 the TUI has shown the plan to the user. Wait for their next message; it will either approve (you'll then implement the plan), request a refinement (you should explore more and submit an updated plan), or cancel (drop the plan and ask what they want instead). Don't call any tools in the meantime."
     );
     this.name = "PlanProposedError";
     this.plan = plan2;
+    this.steps = steps;
+    this.summary = summary;
   }
   /**
    * Structured tool-result shape. Consumed by the TUI to extract the
-   * plan without regex-scraping the error message.
+   * plan without regex-scraping the error message. Optional fields
+   * are omitted from the payload when absent so consumers don't see
+   * `undefined` keys in the JSON.
    */
   toToolResult() {
-    return { error: `${this.name}: ${this.message}`, plan: this.plan };
+    const payload = {
+      error: `${this.name}: ${this.message}`,
+      plan: this.plan
+    };
+    if (this.steps && this.steps.length > 0) payload.steps = this.steps;
+    if (this.summary) payload.summary = this.summary;
+    return payload;
   }
 };
-function registerPlanTool(registry, opts = {}) {
+var PlanCheckpointError = class extends Error {
+  stepId;
+  title;
+  result;
+  notes;
+  constructor(update2) {
+    super(
+      "PlanCheckpointError: step complete \u2014 STOP calling tools. The TUI has paused the plan for user review. Wait for the next user message; it will either say continue (proceed to the next step), request a revision (adjust the remaining plan), or stop (summarize and end)."
+    );
+    this.name = "PlanCheckpointError";
+    this.stepId = update2.stepId;
+    this.title = update2.title;
+    this.result = update2.result;
+    this.notes = update2.notes;
+  }
+  toToolResult() {
+    const payload = {
+      error: `${this.name}: ${this.message}`,
+      kind: "step_completed",
+      stepId: this.stepId,
+      result: this.result
+    };
+    if (this.title) payload.title = this.title;
+    if (this.notes) payload.notes = this.notes;
+    return payload;
+  }
+};
+var PlanRevisionProposedError = class extends Error {
+  reason;
+  remainingSteps;
+  summary;
+  constructor(reason, remainingSteps, summary) {
+    super(
+      "PlanRevisionProposedError: revision submitted. STOP calling tools now \u2014 the TUI has paused for the user to review your proposed change. Wait for their next message; it will say 'revision accepted' (proceed with the new step list), 'revision rejected' (keep the original plan and continue), or 'revision cancelled' (drop the proposal entirely). Don't call any tools in the meantime."
+    );
+    this.name = "PlanRevisionProposedError";
+    this.reason = reason;
+    this.remainingSteps = remainingSteps;
+    this.summary = summary;
+  }
+  toToolResult() {
+    const payload = {
+      error: `${this.name}: ${this.message}`,
+      reason: this.reason,
+      remainingSteps: this.remainingSteps
+    };
+    if (this.summary) payload.summary = this.summary;
+    return payload;
+  }
+};
+
+// src/tools/plan-core.ts
+var SUBMIT_PLAN_DESCRIPTION = "Submit ONE concrete plan you've already decided on. Use this for tasks that warrant a review gate \u2014 multi-file refactors, architecture changes, anything that would be expensive or confusing to undo. Skip it for small fixes (one-line typo, obvious bug with a clear fix) \u2014 just make the change. The user will either approve (you then implement it), ask for refinement, or cancel. If the user has already enabled /plan mode, writes are blocked at dispatch and you MUST use this. CRITICAL: do NOT use submit_plan to present alternative routes (A/B/C, option 1/2/3) for the user to pick from \u2014 the picker only exposes approve/refine/cancel, so a menu plan strands the user with no way to choose. For branching decisions, call `ask_choice` instead; only call submit_plan once the user has picked a direction and you have a single actionable plan. Write the plan as markdown with a one-line summary, a bulleted list of files to touch and what will change, and any risks or open questions. STRONGLY PREFERRED: pass `steps` \u2014 an array of {id, title, action, risk?} \u2014 so the UI renders a structured step list above the approval picker and tracks per-step progress. Use risk='high' for steps that touch prod data / break public APIs / are hard to undo; 'med' for non-trivial but reversible (multi-file edits, schema tweaks); 'low' for safe local work. After each step, call `mark_step_complete` so the user sees progress ticks.";
+var MARK_STEP_COMPLETE_DESCRIPTION = "Mark one step of the approved plan as done AND pause for the user to review. Call this after finishing each step. The TUI shows a \u2713 progress row and mounts a Continue / Revise / Stop picker \u2014 you MUST stop calling tools after this fires and wait for the next user message. Pass the `stepId` from the plan's steps array, a short `result` (what you did), and optional `notes` for anything surprising (errors, scope changes, follow-ups). This tool doesn't change any files. Don't call it if the plan didn't include structured steps, and don't invent ids that weren't in the original plan.";
+var REVISE_PLAN_DESCRIPTION = "Surgically replace the REMAINING steps of an in-flight plan. Call this when the user has given feedback at a checkpoint that warrants a structured plan change \u2014 skip a step, swap two steps, add a new step, change risk, etc. Pass: `reason` (one sentence why), `remainingSteps` (the new tail of the plan, replacing whatever steps haven't been done yet), and optional `summary` (updated one-line plan summary). Done steps are NEVER touched \u2014 keep them out of `remainingSteps`. The TUI shows a diff (removed in red, kept in gray, added in green) and the user accepts or rejects. Don't call this for trivial mid-step adjustments \u2014 just keep executing. Don't call submit_plan for revisions either \u2014 that resets the whole plan including completed steps. Use submit_plan only when the entire approach has changed; use revise_plan when the tail needs editing.";
+var STEP_ITEM_SCHEMA = {
+  type: "object",
+  properties: {
+    id: { type: "string", description: "Stable id, e.g. step-1." },
+    title: { type: "string", description: "Short imperative title." },
+    action: { type: "string", description: "One-sentence description of the concrete action." },
+    risk: {
+      type: "string",
+      enum: ["low", "med", "high"],
+      description: "Self-assessed risk. 'high' = hard-to-undo / touches prod / breaks API; 'med' = non-trivial but reversible; 'low' = safe local work. The UI shows a colored dot per step so the user knows where to focus review. Omit if you're unsure."
+    }
+  },
+  required: ["id", "title", "action"]
+};
+function sanitizeRisk(raw) {
+  if (raw === "low" || raw === "med" || raw === "high") return raw;
+  return void 0;
+}
+function sanitizeSteps(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const steps = [];
+  for (const entry of raw) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry;
+    const id = typeof e.id === "string" ? e.id.trim() : "";
+    const title = typeof e.title === "string" ? e.title.trim() : "";
+    const action = typeof e.action === "string" ? e.action.trim() : "";
+    if (!id || !title || !action) continue;
+    const step = { id, title, action };
+    const risk = sanitizeRisk(e.risk);
+    if (risk) step.risk = risk;
+    steps.push(step);
+  }
+  return steps.length > 0 ? steps : void 0;
+}
+function registerSubmitPlan(registry, opts) {
   registry.register({
     name: "submit_plan",
-    description: "Submit a concrete plan to the user for review before executing. Use this for tasks that warrant a review gate \u2014 multi-file refactors, architecture changes, anything that would be expensive or confusing to undo. Skip it for small fixes (one-line typo, obvious bug with a clear fix) \u2014 just make the change. The user will either approve (you then implement it), ask for refinement, or cancel. If the user has already enabled /plan mode, writes are blocked at dispatch and you MUST use this. Write the plan as markdown with a one-line summary, a bulleted list of files to touch and what will change, and any risks or open questions.",
+    description: SUBMIT_PLAN_DESCRIPTION,
     readOnly: true,
     parameters: {
       type: "object",
@@ -3992,6 +4279,15 @@ function registerPlanTool(registry, opts = {}) {
         plan: {
           type: "string",
           description: "Markdown-formatted plan. Lead with a one-sentence summary. Then a file-by-file breakdown of what you'll change and why. Flag any risks or open questions at the end so the user can weigh in before you start."
+        },
+        steps: {
+          type: "array",
+          description: "Structured step list (strongly recommended). When provided, the UI renders a compact step list above the approval picker AND tracks per-step progress via `mark_step_complete`. Use stable ids (step-1, step-2, ...). Skip only for tiny one-step plans where the markdown body is enough.",
+          items: STEP_ITEM_SCHEMA
+        },
+        summary: {
+          type: "string",
+          description: "Optional. One-sentence human-friendly title for the plan, ~80 chars max. Surfaces in the PlanConfirm picker header and in /plans listings ('\u25B8 refactor auth into signed tokens \xB7 2/5 done'). Skip for trivial plans where the first line of the markdown body is already short and clear."
         }
       },
       required: ["plan"]
@@ -4001,10 +4297,108 @@ function registerPlanTool(registry, opts = {}) {
       if (!plan2) {
         throw new Error("submit_plan: empty plan \u2014 write a markdown plan and try again.");
       }
-      opts.onPlanSubmitted?.(plan2);
-      throw new PlanProposedError(plan2);
+      const steps = sanitizeSteps(args?.steps);
+      const summary = typeof args?.summary === "string" ? args.summary.trim() || void 0 : void 0;
+      opts.onPlanSubmitted?.(plan2, steps);
+      throw new PlanProposedError(plan2, steps, summary);
+    }
+  });
+}
+function registerMarkStepComplete(registry, opts) {
+  registry.register({
+    name: "mark_step_complete",
+    description: MARK_STEP_COMPLETE_DESCRIPTION,
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        stepId: {
+          type: "string",
+          description: "The id of the step being marked complete. Must match one from submit_plan's steps array."
+        },
+        title: {
+          type: "string",
+          description: "Optional. The step's title, echoed back for the UI. If omitted, the UI falls back to the id."
+        },
+        result: {
+          type: "string",
+          description: "One-sentence summary of what was done for this step."
+        },
+        notes: {
+          type: "string",
+          description: "Optional. Anything surprising \u2014 blockers hit, assumptions revised, follow-ups for later steps."
+        }
+      },
+      required: ["stepId", "result"]
+    },
+    fn: async (args) => {
+      const stepId = (args?.stepId ?? "").trim();
+      const result = (args?.result ?? "").trim();
+      if (!stepId) {
+        throw new Error("mark_step_complete: stepId is required.");
+      }
+      if (!result) {
+        throw new Error(
+          "mark_step_complete: result is required \u2014 say in one sentence what you did."
+        );
+      }
+      const title = typeof args?.title === "string" ? args.title.trim() || void 0 : void 0;
+      const notes = typeof args?.notes === "string" ? args.notes.trim() || void 0 : void 0;
+      const update2 = { kind: "step_completed", stepId, result };
+      if (title) update2.title = title;
+      if (notes) update2.notes = notes;
+      opts.onStepCompleted?.(update2);
+      throw new PlanCheckpointError({ stepId, title, result, notes });
+    }
+  });
+}
+function registerRevisePlan(registry, opts) {
+  registry.register({
+    name: "revise_plan",
+    description: REVISE_PLAN_DESCRIPTION,
+    readOnly: true,
+    parameters: {
+      type: "object",
+      properties: {
+        reason: {
+          type: "string",
+          description: "One sentence explaining why you're revising \u2014 what the user asked for, what changed your assessment."
+        },
+        remainingSteps: {
+          type: "array",
+          description: "The new tail of the plan \u2014 what should run from here on. Each entry: {id, title, action, risk?}. Use stable ids; reuse old ids when a step is just being adjusted, generate new ones for genuinely new steps.",
+          items: STEP_ITEM_SCHEMA
+        },
+        summary: {
+          type: "string",
+          description: "Optional. Updated one-line plan summary if the overall framing has shifted."
+        }
+      },
+      required: ["reason", "remainingSteps"]
+    },
+    fn: async (args) => {
+      const reason = (args?.reason ?? "").trim();
+      if (!reason) {
+        throw new Error(
+          "revise_plan: reason is required \u2014 write one sentence explaining the change."
+        );
+      }
+      const remainingSteps = sanitizeSteps(args?.remainingSteps);
+      if (!remainingSteps || remainingSteps.length === 0) {
+        throw new Error(
+          "revise_plan: remainingSteps must be a non-empty array of well-formed steps. If the user wants to STOP rather than continue, don't revise \u2014 the picker has its own Stop option."
+        );
+      }
+      const summary = typeof args?.summary === "string" ? args.summary.trim() || void 0 : void 0;
+      opts.onPlanRevisionProposed?.(reason, remainingSteps, summary);
+      throw new PlanRevisionProposedError(reason, remainingSteps, summary);
     }
   });
+}
+function registerPlanTool(registry, opts = {}) {
+  registerSubmitPlan(registry, opts);
+  registerMarkStepComplete(registry, opts);
+  registerRevisePlan(registry, opts);
   return registry;
 }
 
@@ -6700,13 +7094,13 @@ function formatLogSize(path = defaultUsageLogPath()) {
 }
 
 // src/cli/commands/chat.tsx
-import { existsSync as existsSync11, statSync as statSync6 } from "fs";
+import { existsSync as existsSync12, statSync as statSync7 } from "fs";
 import { render } from "ink";
-import React19, { useState as useState12 } from "react";
+import React23, { useState as useState12 } from "react";
 
 // src/cli/ui/App.tsx
-import { Box as Box15, Static, useApp, useInput as useInput5 } from "ink";
-import React16, { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo3, useRef as useRef5, useState as useState10 } from "react";
+import { Box as Box19, Static, useApp, useInput as useInput5 } from "ink";
+import React20, { useCallback as useCallback4, useEffect as useEffect5, useMemo as useMemo3, useRef as useRef5, useState as useState10 } from "react";
 
 // src/code/pending-edits.ts
 import { existsSync as existsSync9, mkdirSync as mkdirSync6, readFileSync as readFileSync11, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "fs";
@@ -6760,6 +7154,166 @@ function clearPendingEdits(sessionName) {
   }
 }
 
+// src/code/plan-store.ts
+import {
+  existsSync as existsSync10,
+  mkdirSync as mkdirSync7,
+  readFileSync as readFileSync12,
+  readdirSync as readdirSync3,
+  renameSync,
+  statSync as statSync5,
+  unlinkSync as unlinkSync4,
+  writeFileSync as writeFileSync6
+} from "fs";
+import { dirname as dirname9, join as join10 } from "path";
+function planStatePath(sessionName) {
+  return join10(sessionsDir(), `${sanitizeName(sessionName)}.plan.json`);
+}
+function loadPlanState(sessionName) {
+  const path = planStatePath(sessionName);
+  if (!existsSync10(path)) return null;
+  try {
+    const raw = readFileSync12(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    if (parsed.version !== 1) return null;
+    if (!Array.isArray(parsed.steps)) return null;
+    if (!Array.isArray(parsed.completedStepIds)) return null;
+    if (typeof parsed.updatedAt !== "string") return null;
+    const steps = [];
+    for (const s of parsed.steps) {
+      if (!s || typeof s !== "object") continue;
+      const e = s;
+      if (typeof e.id !== "string" || !e.id) continue;
+      if (typeof e.title !== "string" || !e.title) continue;
+      if (typeof e.action !== "string" || !e.action) continue;
+      const step = { id: e.id, title: e.title, action: e.action };
+      if (e.risk === "low" || e.risk === "med" || e.risk === "high") step.risk = e.risk;
+      steps.push(step);
+    }
+    if (steps.length === 0) return null;
+    const completedStepIds = parsed.completedStepIds.filter(
+      (id) => typeof id === "string" && id.length > 0
+    );
+    const out = {
+      version: 1,
+      steps,
+      completedStepIds,
+      updatedAt: parsed.updatedAt
+    };
+    if (typeof parsed.body === "string" && parsed.body) out.body = parsed.body;
+    if (typeof parsed.summary === "string" && parsed.summary) out.summary = parsed.summary;
+    return out;
+  } catch {
+    return null;
+  }
+}
+function savePlanState(sessionName, steps, completedStepIds, extras) {
+  const path = planStatePath(sessionName);
+  try {
+    mkdirSync7(dirname9(path), { recursive: true });
+    const state = {
+      version: 1,
+      steps,
+      completedStepIds: [...completedStepIds],
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (extras?.body) state.body = extras.body;
+    if (extras?.summary) state.summary = extras.summary;
+    writeFileSync6(path, `${JSON.stringify(state, null, 2)}
+`, "utf8");
+  } catch (err) {
+    process.stderr.write(
+      `\u25B8 plan-store: failed to save plan for "${sessionName}": ${err.message}
+`
+    );
+  }
+}
+function clearPlanState(sessionName) {
+  const path = planStatePath(sessionName);
+  try {
+    if (existsSync10(path)) unlinkSync4(path);
+  } catch {
+  }
+}
+function archivePlanState(sessionName) {
+  const active = planStatePath(sessionName);
+  if (!existsSync10(active)) return null;
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const suffix = Math.random().toString(36).slice(2, 6);
+  const archive = join10(
+    sessionsDir(),
+    `${sanitizeName(sessionName)}.plan.${stamp}-${suffix}.done.json`
+  );
+  try {
+    renameSync(active, archive);
+    return archive;
+  } catch (err) {
+    process.stderr.write(
+      `\u25B8 plan-store: failed to archive plan for "${sessionName}": ${err.message}
+`
+    );
+    return null;
+  }
+}
+function listPlanArchives(sessionName) {
+  const dir = sessionsDir();
+  if (!existsSync10(dir)) return [];
+  const prefix = `${sanitizeName(sessionName)}.plan.`;
+  const suffix = ".done.json";
+  let entries;
+  try {
+    entries = readdirSync3(dir);
+  } catch {
+    return [];
+  }
+  const summaries = [];
+  for (const name of entries) {
+    if (!name.startsWith(prefix) || !name.endsWith(suffix)) continue;
+    const full = join10(dir, name);
+    try {
+      const raw = readFileSync12(full, "utf8");
+      const parsed = JSON.parse(raw);
+      if (parsed.version !== 1) continue;
+      if (!Array.isArray(parsed.steps) || parsed.steps.length === 0) continue;
+      const steps = parsed.steps.filter(
+        (s) => !!s && typeof s === "object" && typeof s.id === "string" && typeof s.title === "string" && typeof s.action === "string"
+      );
+      if (steps.length === 0) continue;
+      const completedStepIds = Array.isArray(parsed.completedStepIds) ? parsed.completedStepIds.filter((id) => typeof id === "string" && !!id) : [];
+      let completedAt = typeof parsed.updatedAt === "string" ? parsed.updatedAt : "";
+      if (!completedAt || Number.isNaN(Date.parse(completedAt))) {
+        try {
+          completedAt = statSync5(full).mtime.toISOString();
+        } catch {
+          completedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+        }
+      }
+      const entry = { path: full, completedAt, steps, completedStepIds };
+      if (typeof parsed.body === "string" && parsed.body) entry.body = parsed.body;
+      if (typeof parsed.summary === "string" && parsed.summary) entry.summary = parsed.summary;
+      summaries.push(entry);
+    } catch {
+    }
+  }
+  summaries.sort((a, b) => b.completedAt.localeCompare(a.completedAt));
+  return summaries;
+}
+function relativeTime(updatedAt, now = Date.now()) {
+  const t = Date.parse(updatedAt);
+  if (Number.isNaN(t)) return updatedAt;
+  const diffMs = Math.max(0, now - t);
+  const sec = Math.floor(diffMs / 1e3);
+  if (sec < 60) return `${sec}s ago`;
+  const min = Math.floor(sec / 60);
+  if (min < 60) return `${min}m ago`;
+  const hr = Math.floor(min / 60);
+  if (hr < 24) return `${hr}h ago`;
+  const day = Math.floor(hr / 24);
+  if (day < 7) return `${day}d ago`;
+  return updatedAt.slice(0, 10);
+}
+
 // src/tools/skills.ts
 function registerSkillTools(registry, opts = {}) {
   const store = new SkillStore({
@@ -6869,51 +7423,195 @@ function FileRow({ path, isSelected }) {
   return /* @__PURE__ */ React.createElement(Box, null, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, marker, " ", base, dir ? `  ${dir}` : ""));
 }
 
-// src/cli/ui/EditConfirm.tsx
-import { Box as Box2, Text as Text2, useInput, useStdout } from "ink";
-import React2, { useMemo, useState } from "react";
+// src/cli/ui/ChoiceConfirm.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import React3 from "react";
 
-// src/code/diff-preview.ts
-function formatEditBlockDiff(block, opts = {}) {
-  const contextLines = Math.max(0, opts.contextLines ?? 2);
-  const maxLines = Math.max(4, opts.maxLines ?? 20);
-  const indent = opts.indent ?? "        ";
-  const search = block.search === "" ? [] : block.search.split("\n");
-  const replace = block.replace.split("\n");
-  if (search.length === 0) {
-    return renderAllPlus(replace, indent, maxLines);
-  }
-  let leading = 0;
-  while (leading < search.length && leading < replace.length && search[leading] === replace[leading]) {
-    leading++;
-  }
-  let trailing = 0;
-  while (trailing < search.length - leading && trailing < replace.length - leading && search[search.length - 1 - trailing] === replace[replace.length - 1 - trailing]) {
-    trailing++;
-  }
-  const searchMiddle = search.slice(leading, search.length - trailing);
-  const replaceMiddle = replace.slice(leading, replace.length - trailing);
-  const leadShown = search.slice(Math.max(0, leading - contextLines), leading);
-  const leadHidden = leading - leadShown.length;
-  const trailShown = search.slice(
-    search.length - trailing,
-    search.length - trailing + contextLines
+// src/cli/ui/Select.tsx
+import { Box as Box2, Text as Text2, useInput } from "ink";
+import React2, { useState } from "react";
+function SingleSelect({
+  items,
+  initialValue,
+  onSubmit,
+  onCancel,
+  footer
+}) {
+  const initialIndex = Math.max(
+    0,
+    items.findIndex((i) => i.value === initialValue && !i.disabled)
   );
-  const trailHidden = trailing - trailShown.length;
-  const out = [];
-  if (leadHidden > 0) {
-    out.push(`${indent}  \u2026 ${leadHidden} unchanged line${leadHidden === 1 ? "" : "s"} above`);
-  }
-  for (const l of leadShown) out.push(`${indent}  ${l}`);
-  for (const l of searchMiddle) out.push(`${indent}- ${l}`);
-  for (const l of replaceMiddle) out.push(`${indent}+ ${l}`);
-  for (const l of trailShown) out.push(`${indent}  ${l}`);
-  if (trailHidden > 0) {
-    out.push(`${indent}  \u2026 ${trailHidden} unchanged line${trailHidden === 1 ? "" : "s"} below`);
-  }
-  return capLines(out, maxLines, indent);
-}
-function formatAllBlockDiffs(blocks, opts = {}) {
+  const [index, setIndex] = useState(initialIndex === -1 ? 0 : initialIndex);
+  useInput((_input, key) => {
+    if (key.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (key.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, 1));
+    } else if (key.return) {
+      const chosen = items[index];
+      if (chosen && !chosen.disabled) onSubmit(chosen.value);
+    } else if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, items.map((item, i) => /* @__PURE__ */ React2.createElement(
+    SelectRow,
+    {
+      key: item.value,
+      item,
+      active: i === index,
+      marker: i === index ? "\u25B8" : " "
+    }
+  )), footer ? /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, footer)) : null);
+}
+function MultiSelect({
+  items,
+  initialSelected = [],
+  onSubmit,
+  onCancel,
+  footer
+}) {
+  const [index, setIndex] = useState(() => {
+    const first = items.findIndex((i) => !i.disabled);
+    return first === -1 ? 0 : first;
+  });
+  const [selected, setSelected] = useState(new Set(initialSelected));
+  useInput((input, key) => {
+    if (key.upArrow) {
+      setIndex((i) => findNextEnabled(items, i, -1));
+    } else if (key.downArrow) {
+      setIndex((i) => findNextEnabled(items, i, 1));
+    } else if (input === " ") {
+      const item = items[index];
+      if (!item || item.disabled) return;
+      setSelected((prev) => {
+        const next = new Set(prev);
+        if (next.has(item.value)) next.delete(item.value);
+        else next.add(item.value);
+        return next;
+      });
+    } else if (key.return) {
+      const ordered = items.filter((i) => selected.has(i.value)).map((i) => i.value);
+      onSubmit(ordered);
+    } else if (key.escape && onCancel) {
+      onCancel();
+    }
+  });
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, items.map((item, i) => {
+    const checked = selected.has(item.value);
+    const marker = checked ? "[x]" : "[ ]";
+    return /* @__PURE__ */ React2.createElement(
+      SelectRow,
+      {
+        key: item.value,
+        item,
+        active: i === index,
+        marker: `${i === index ? "\u25B8" : " "} ${marker}`
+      }
+    );
+  }), footer ? /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, footer)) : null);
+}
+function SelectRow({
+  item,
+  active,
+  marker
+}) {
+  const color = item.disabled ? "gray" : active ? "cyan" : void 0;
+  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column" }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color }, marker, " ", item.label)), item.hint ? /* @__PURE__ */ React2.createElement(Box2, { paddingLeft: marker.length + 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, item.hint)) : null);
+}
+function findNextEnabled(items, from, step) {
+  if (items.length === 0) return 0;
+  let i = from;
+  for (let tries = 0; tries < items.length; tries++) {
+    i = (i + step + items.length) % items.length;
+    if (!items[i]?.disabled) return i;
+  }
+  return from;
+}
+
+// src/cli/ui/ChoiceConfirm.tsx
+var CUSTOM_VALUE = "__custom__";
+var CANCEL_VALUE = "__cancel__";
+function ChoiceConfirmInner({ question, options, allowCustom, onChoose }) {
+  const items = options.map((opt) => ({
+    value: opt.id,
+    label: `${opt.id} \xB7 ${opt.title}`,
+    hint: opt.summary
+  }));
+  if (allowCustom) {
+    items.push({
+      value: CUSTOM_VALUE,
+      label: "Let me type my own answer",
+      hint: "None of the above fits \u2014 type a free-form reply. The model reads it verbatim."
+    });
+  }
+  items.push({
+    value: CANCEL_VALUE,
+    label: "Cancel \u2014 drop the question",
+    hint: "Model stops and asks what you want instead."
+  });
+  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React3.createElement(Box3, null, /* @__PURE__ */ React3.createElement(Text3, { bold: true, color: "magenta" }, "\u{1F500} the model is asking you to pick")), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(Text3, null, question)), /* @__PURE__ */ React3.createElement(Box3, { marginTop: 1 }, /* @__PURE__ */ React3.createElement(
+    SingleSelect,
+    {
+      initialValue: options[0]?.id,
+      items,
+      onSubmit: (v) => {
+        if (v === CUSTOM_VALUE) onChoose({ kind: "custom" });
+        else if (v === CANCEL_VALUE) onChoose({ kind: "cancel" });
+        else onChoose({ kind: "pick", optionId: v });
+      },
+      onCancel: () => onChoose({ kind: "cancel" }),
+      footer: "[\u2191\u2193] navigate  \xB7  [Enter] select  \xB7  [Esc] cancel"
+    }
+  )));
+}
+var ChoiceConfirm = React3.memo(ChoiceConfirmInner);
+
+// src/cli/ui/EditConfirm.tsx
+import { Box as Box4, Text as Text4, useInput as useInput2, useStdout } from "ink";
+import React4, { useMemo, useState as useState2 } from "react";
+
+// src/code/diff-preview.ts
+function formatEditBlockDiff(block, opts = {}) {
+  const contextLines = Math.max(0, opts.contextLines ?? 2);
+  const maxLines = Math.max(4, opts.maxLines ?? 20);
+  const indent = opts.indent ?? "        ";
+  const search = block.search === "" ? [] : block.search.split("\n");
+  const replace = block.replace.split("\n");
+  if (search.length === 0) {
+    return renderAllPlus(replace, indent, maxLines);
+  }
+  let leading = 0;
+  while (leading < search.length && leading < replace.length && search[leading] === replace[leading]) {
+    leading++;
+  }
+  let trailing = 0;
+  while (trailing < search.length - leading && trailing < replace.length - leading && search[search.length - 1 - trailing] === replace[replace.length - 1 - trailing]) {
+    trailing++;
+  }
+  const searchMiddle = search.slice(leading, search.length - trailing);
+  const replaceMiddle = replace.slice(leading, replace.length - trailing);
+  const leadShown = search.slice(Math.max(0, leading - contextLines), leading);
+  const leadHidden = leading - leadShown.length;
+  const trailShown = search.slice(
+    search.length - trailing,
+    search.length - trailing + contextLines
+  );
+  const trailHidden = trailing - trailShown.length;
+  const out = [];
+  if (leadHidden > 0) {
+    out.push(`${indent}  \u2026 ${leadHidden} unchanged line${leadHidden === 1 ? "" : "s"} above`);
+  }
+  for (const l of leadShown) out.push(`${indent}  ${l}`);
+  for (const l of searchMiddle) out.push(`${indent}- ${l}`);
+  for (const l of replaceMiddle) out.push(`${indent}+ ${l}`);
+  for (const l of trailShown) out.push(`${indent}  ${l}`);
+  if (trailHidden > 0) {
+    out.push(`${indent}  \u2026 ${trailHidden} unchanged line${trailHidden === 1 ? "" : "s"} below`);
+  }
+  return capLines(out, maxLines, indent);
+}
+function formatAllBlockDiffs(blocks, opts = {}) {
   const out = [];
   for (let i = 0; i < blocks.length; i++) {
     const b = blocks[i];
@@ -6953,10 +7651,10 @@ function EditConfirm({ block, onChoose }) {
     () => formatEditBlockDiff(block, { contextLines: 2, maxLines: 1e5, indent: "  " }),
     [block]
   );
-  const [scroll, setScroll] = useState(0);
+  const [scroll, setScroll] = useState2(0);
   const maxScroll = Math.max(0, allLines.length - budget);
   const effectiveScroll = Math.min(scroll, maxScroll);
-  useInput((input, key) => {
+  useInput2((input, key) => {
     if (key.return || input === "y") {
       onChoose("apply");
       return;
@@ -7007,18 +7705,18 @@ function EditConfirm({ block, onChoose }) {
   const hiddenBelow = Math.max(0, allLines.length - effectiveScroll - budget);
   const totalLines = allLines.length;
   const showScrollHud = hiddenAbove + hiddenBelow > 0;
-  return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "cyan" }, "\u25B8 model wants to edit a file")), /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, null, /* @__PURE__ */ React2.createElement(Text2, { color: isNew ? "green" : "yellow", bold: true }, `[${tag}] `), /* @__PURE__ */ React2.createElement(Text2, { color: "cyan" }, block.path), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, `  (-${removed} +${added} lines)`), showScrollHud ? /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, `  \xB7  viewing ${effectiveScroll + 1}-${effectiveScroll + visibleLines.length}/${totalLines}`) : null)), hiddenAbove > 0 ? /* @__PURE__ */ React2.createElement(
-    Text2,
+  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, "\u25B8 model wants to edit a file")), /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, null, /* @__PURE__ */ React4.createElement(Text4, { color: isNew ? "green" : "yellow", bold: true }, `[${tag}] `), /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, block.path), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, `  (-${removed} +${added} lines)`), showScrollHud ? /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, `  \xB7  viewing ${effectiveScroll + 1}-${effectiveScroll + visibleLines.length}/${totalLines}`) : null)), hiddenAbove > 0 ? /* @__PURE__ */ React4.createElement(
+    Text4,
     {
       dimColor: true
     },
     `  \u2191 ${hiddenAbove} line${hiddenAbove === 1 ? "" : "s"} above  (\u2191/k or PgUp)`
-  ) : null, /* @__PURE__ */ React2.createElement(Box2, { marginTop: hiddenAbove > 0 ? 0 : 1, flexDirection: "column" }, visibleLines.map((line, i) => {
+  ) : null, /* @__PURE__ */ React4.createElement(Box4, { marginTop: hiddenAbove > 0 ? 0 : 1, flexDirection: "column" }, visibleLines.map((line, i) => {
     const trimmed = line.trimStart();
     const color = trimmed.startsWith("+") ? "green" : trimmed.startsWith("-") ? "red" : void 0;
     const dim = !color;
-    return /* @__PURE__ */ React2.createElement(
-      Text2,
+    return /* @__PURE__ */ React4.createElement(
+      Text4,
       {
         key: `diff-${effectiveScroll}-${i}`,
         color,
@@ -7026,22 +7724,22 @@ function EditConfirm({ block, onChoose }) {
       },
       line
     );
-  })), hiddenBelow > 0 ? /* @__PURE__ */ React2.createElement(
-    Text2,
+  })), hiddenBelow > 0 ? /* @__PURE__ */ React4.createElement(
+    Text4,
     {
       dimColor: true
     },
     `  \u2193 ${hiddenBelow} line${hiddenBelow === 1 ? "" : "s"} below  (\u2193/j or Space/PgDn)`
-  ) : null, /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "[", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "y"), "/Enter] apply  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "n"), "] reject  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "a"), "] apply rest  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "A"), "] flip AUTO  \xB7  [", /* @__PURE__ */ React2.createElement(Text2, { color: "cyan", bold: true }, "\u2191\u2193/Space"), "] scroll  \xB7  [Esc] abort")));
+  ) : null, /* @__PURE__ */ React4.createElement(Box4, { marginTop: 1 }, /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "[", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "y"), "/Enter] apply  \xB7  [", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "n"), "] reject  \xB7  [", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "a"), "] apply rest  \xB7  [", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "A"), "] flip AUTO  \xB7  [", /* @__PURE__ */ React4.createElement(Text4, { color: "cyan", bold: true }, "\u2191\u2193/Space"), "] scroll  \xB7  [Esc] abort")));
 }
 
 // src/cli/ui/EventLog.tsx
-import { Box as Box5, Text as Text5, useStdout as useStdout2 } from "ink";
-import React6 from "react";
+import { Box as Box8, Text as Text8, useStdout as useStdout2 } from "ink";
+import React9 from "react";
 
 // src/cli/ui/PlanStateBlock.tsx
-import { Box as Box3, Text as Text3 } from "ink";
-import React3 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import React5 from "react";
 function PlanStateBlock({ planState }) {
   const fields = [];
   if (planState.subgoals.length) fields.push(["subgoals", planState.subgoals, "cyan", false]);
@@ -7052,14 +7750,69 @@ function PlanStateBlock({ planState }) {
   if (planState.rejectedPaths.length)
     fields.push(["rejected", planState.rejectedPaths, "red", true]);
   if (fields.length === 0) return null;
-  return /* @__PURE__ */ React3.createElement(Box3, { flexDirection: "column", marginBottom: 1 }, fields.map(([label, items, color, dim]) => /* @__PURE__ */ React3.createElement(Text3, { key: label }, /* @__PURE__ */ React3.createElement(Text3, { color, bold: true, dimColor: dim }, "\u2039 ", label), /* @__PURE__ */ React3.createElement(Text3, { dimColor: true }, ` (${items.length})`), /* @__PURE__ */ React3.createElement(Text3, null, `: ${items.join(" \xB7 ")}`))));
+  return /* @__PURE__ */ React5.createElement(Box5, { flexDirection: "column", marginBottom: 1 }, fields.map(([label, items, color, dim]) => /* @__PURE__ */ React5.createElement(Text5, { key: label }, /* @__PURE__ */ React5.createElement(Text5, { color, bold: true, dimColor: dim }, "\u2039 ", label), /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, ` (${items.length})`), /* @__PURE__ */ React5.createElement(Text5, null, `: ${items.join(" \xB7 ")}`))));
 }
 
+// src/cli/ui/PlanStepList.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import React6 from "react";
+function riskDots(risk) {
+  switch (risk) {
+    case "high":
+      return { dots: "\u25CF\u25CF\u25CF", color: "red" };
+    case "med":
+      return { dots: "\u25CF\u25CF ", color: "yellow" };
+    case "low":
+      return { dots: "\u25CF  ", color: "green" };
+    default:
+      return { dots: "   ", color: "gray" };
+  }
+}
+function statusGlyph(status2) {
+  switch (status2) {
+    case "done":
+      return { glyph: "\u2713", color: "green" };
+    case "running":
+      return { glyph: "\u25B6", color: "cyan" };
+    case "skipped":
+      return { glyph: "\u2014", color: "gray" };
+    default:
+      return { glyph: " ", color: "yellow" };
+  }
+}
+function getStatus(stepId, statuses) {
+  if (!statuses) return "pending";
+  if (statuses instanceof Map) {
+    return statuses.get(stepId) ?? "pending";
+  }
+  return statuses[stepId] ?? "pending";
+}
+function PlanStepListInner({ steps, statuses, focusStepId }) {
+  if (steps.length === 0) return null;
+  const hasAnyRisk = steps.some((s) => s.risk !== void 0);
+  const doneCount = Array.from(
+    { length: steps.length },
+    (_, i) => getStatus(steps[i].id, statuses)
+  ).filter((s) => s === "done").length;
+  return /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, `${steps.length} step${steps.length === 1 ? "" : "s"}`, doneCount > 0 ? ` \xB7 ${doneCount} done` : "", hasAnyRisk ? " \xB7 risk: " : ""), hasAnyRisk ? /* @__PURE__ */ React6.createElement(RiskLegend, null) : null), /* @__PURE__ */ React6.createElement(Box6, { flexDirection: "column", marginTop: 1 }, steps.map((step) => {
+    const status2 = getStatus(step.id, statuses);
+    const focus = focusStepId === step.id;
+    const risk = riskDots(step.risk);
+    const glyph = statusGlyph(status2);
+    const titleDim = status2 === "done" || status2 === "skipped";
+    return /* @__PURE__ */ React6.createElement(Box6, { key: step.id }, /* @__PURE__ */ React6.createElement(Text6, { color: focus ? "cyan" : "gray", bold: focus }, focus ? "\u203A " : "  "), /* @__PURE__ */ React6.createElement(Text6, { color: risk.color, bold: true }, risk.dots), /* @__PURE__ */ React6.createElement(Text6, { color: glyph.color, bold: true }, ` ${glyph.glyph} `), /* @__PURE__ */ React6.createElement(Text6, { dimColor: titleDim }, `${step.id} \xB7 ${step.title}`));
+  })));
+}
+function RiskLegend() {
+  return /* @__PURE__ */ React6.createElement(Box6, null, /* @__PURE__ */ React6.createElement(Text6, { color: "green" }, "\u25CF"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " low "), /* @__PURE__ */ React6.createElement(Text6, { color: "yellow" }, "\u25CF\u25CF"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " med "), /* @__PURE__ */ React6.createElement(Text6, { color: "red" }, "\u25CF\u25CF\u25CF"), /* @__PURE__ */ React6.createElement(Text6, { dimColor: true }, " high"));
+}
+var PlanStepList = React6.memo(PlanStepListInner);
+
 // src/cli/ui/markdown.tsx
-import { readFileSync as readFileSync12, statSync as statSync5 } from "fs";
-import { isAbsolute as isAbsolute4, join as join10 } from "path";
-import { Box as Box4, Text as Text4 } from "ink";
-import React4 from "react";
+import { readFileSync as readFileSync13, statSync as statSync6 } from "fs";
+import { isAbsolute as isAbsolute4, join as join11 } from "path";
+import { Box as Box7, Text as Text7 } from "ink";
+import React7 from "react";
 var SUPERSCRIPT = {
   "0": "\u2070",
   "1": "\xB9",
@@ -7136,10 +7889,10 @@ function validateCitation(url, projectRoot) {
   const parts = parseCitationUrl(url);
   if (!parts || !parts.path) return { ok: false, reason: "empty path" };
   const normalized = parts.path.replace(/^[/\\]+/, "");
-  const fullPath = isAbsolute4(normalized) ? normalized : join10(projectRoot, normalized);
+  const fullPath = isAbsolute4(normalized) ? normalized : join11(projectRoot, normalized);
   let stat;
   try {
-    stat = statSync5(fullPath);
+    stat = statSync6(fullPath);
   } catch {
     return { ok: false, reason: "file not found" };
   }
@@ -7147,7 +7900,7 @@ function validateCitation(url, projectRoot) {
   if (parts.startLine === void 0) return { ok: true };
   let lineCount;
   try {
-    lineCount = readFileSync12(fullPath, "utf8").split("\n").length;
+    lineCount = readFileSync13(fullPath, "utf8").split("\n").length;
   } catch {
     return { ok: false, reason: "unreadable" };
   }
@@ -7184,57 +7937,57 @@ function InlineMd({
   for (const m of text.matchAll(INLINE_RE)) {
     const start = m.index ?? 0;
     if (start > last) {
-      parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `t${idx++}` }, text.slice(last, start)));
+      parts.push(/* @__PURE__ */ React7.createElement(Text7, { key: `t${idx++}` }, text.slice(last, start)));
     }
     if (m[2] !== void 0 && m[3] !== void 0) {
       const linkText = m[2];
       const url = m[3];
       if (isExternalUrl(url)) {
         parts.push(
-          /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "blue", underline: true }, linkText)
+          /* @__PURE__ */ React7.createElement(Text7, { key: `l${idx++}`, color: "blue", underline: true }, linkText)
         );
       } else {
         const status2 = citations?.get(url);
         if (status2 && !status2.ok) {
           parts.push(
-            /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "red", strikethrough: true }, `${linkText} \u2717`)
+            /* @__PURE__ */ React7.createElement(Text7, { key: `l${idx++}`, color: "red", strikethrough: true }, `${linkText} \u2717`)
           );
         } else {
           parts.push(
-            /* @__PURE__ */ React4.createElement(Text4, { key: `l${idx++}`, color: "cyan", underline: true }, linkText)
+            /* @__PURE__ */ React7.createElement(Text7, { key: `l${idx++}`, color: "cyan", underline: true }, linkText)
           );
         }
       }
     } else if (m[4] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React4.createElement(Text4, { key: `b${idx++}`, bold: true }, m[4])
+        /* @__PURE__ */ React7.createElement(Text7, { key: `b${idx++}`, bold: true }, m[4])
       );
     } else if (m[5] !== void 0) {
       const stripped = m[5].replace(/^(\w+)\s+/, "");
       parts.push(
-        /* @__PURE__ */ React4.createElement(Text4, { key: `c${idx++}`, color: "yellow" }, stripped)
+        /* @__PURE__ */ React7.createElement(Text7, { key: `c${idx++}`, color: "yellow" }, stripped)
       );
     } else if (m[6] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React4.createElement(Text4, { key: `c${idx++}`, color: "yellow" }, m[6])
+        /* @__PURE__ */ React7.createElement(Text7, { key: `c${idx++}`, color: "yellow" }, m[6])
       );
     } else if (m[7] !== void 0) {
       parts.push(
-        /* @__PURE__ */ React4.createElement(Text4, { key: `i${idx++}`, italic: true }, m[7])
+        /* @__PURE__ */ React7.createElement(Text7, { key: `i${idx++}`, italic: true }, m[7])
       );
     }
     last = start + m[0].length;
   }
   if (last < text.length) {
-    parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `t${idx++}` }, text.slice(last)));
+    parts.push(/* @__PURE__ */ React7.createElement(Text7, { key: `t${idx++}` }, text.slice(last)));
   }
   if (padTo !== void 0) {
     const seen = visibleWidth(text);
     if (seen < padTo) {
-      parts.push(/* @__PURE__ */ React4.createElement(Text4, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
+      parts.push(/* @__PURE__ */ React7.createElement(Text7, { key: `pad${idx++}` }, " ".repeat(padTo - seen)));
     }
   }
-  return /* @__PURE__ */ React4.createElement(Text4, null, parts);
+  return /* @__PURE__ */ React7.createElement(Text7, null, parts);
 }
 function stripInlineMarkup(s) {
   return s.replace(/\[([^\]\n]+)\]\(([^)\n]+)\)/g, "$1").replace(/\*\*([^*\n]+?)\*\*/g, "$1").replace(/```([^\n]+?)```/g, (_m, c) => c.replace(/^(\w+)\s+/, "")).replace(/`([^`\n]+?)`/g, "$1").replace(/(?<![*\w])\*([^*\n]+?)\*(?!\w)/g, "$1");
@@ -7430,19 +8183,19 @@ function parseBlocks(raw) {
 function BlockView({ block, citations }) {
   switch (block.kind) {
     case "heading":
-      return /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, /* @__PURE__ */ React4.createElement(InlineMd, { text: block.text, citations }));
+      return /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "cyan" }, /* @__PURE__ */ React7.createElement(InlineMd, { text: block.text, citations }));
     case "paragraph":
-      return /* @__PURE__ */ React4.createElement(InlineMd, { text: block.text, citations });
+      return /* @__PURE__ */ React7.createElement(InlineMd, { text: block.text, citations });
     case "bullet":
-      return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React4.createElement(Box4, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React4.createElement(Text4, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React4.createElement(InlineMd, { text: item, citations }))));
+      return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, block.items.map((item, i) => /* @__PURE__ */ React7.createElement(Box7, { key: `${i}-${item.slice(0, 24)}` }, /* @__PURE__ */ React7.createElement(Text7, { color: "cyan" }, block.ordered ? ` ${block.start + i}. ` : "  \u2022 "), /* @__PURE__ */ React7.createElement(InlineMd, { text: item, citations }))));
     case "code":
-      return /* @__PURE__ */ React4.createElement(Box4, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "yellow" }, block.text));
+      return /* @__PURE__ */ React7.createElement(Box7, { borderStyle: "single", borderColor: "gray", paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "yellow" }, block.text));
     case "edit-block":
-      return /* @__PURE__ */ React4.createElement(EditBlockRow, { block });
+      return /* @__PURE__ */ React7.createElement(EditBlockRow, { block });
     case "table":
-      return /* @__PURE__ */ React4.createElement(TableBlockRow, { block, citations });
+      return /* @__PURE__ */ React7.createElement(TableBlockRow, { block, citations });
     case "hr":
-      return /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      return /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
   }
 }
 function splitTableRow(line) {
@@ -7460,14 +8213,14 @@ function TableBlockRow({ block, citations }) {
     widths.push(Math.min(40, Math.max(3, ...cellLengths)));
   }
   const separator = widths.map((w) => "\u2500".repeat(w)).join("\u2500\u253C\u2500");
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column" }, /* @__PURE__ */ React4.createElement(Box4, null, block.header.map((cell, ci) => (
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box7, null, block.header.map((cell, ci) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table columns never reorder — derived from a static header array
-    /* @__PURE__ */ React4.createElement(Text4, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React4.createElement(InlineMd, { text: cell, padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
-  ))), /* @__PURE__ */ React4.createElement(Text4, { dimColor: true }, separator), block.rows.map((row2, ri) => (
+    /* @__PURE__ */ React7.createElement(Text7, { key: `h-${ci}`, bold: true, color: "cyan" }, /* @__PURE__ */ React7.createElement(InlineMd, { text: cell, padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
+  ))), /* @__PURE__ */ React7.createElement(Text7, { dimColor: true }, separator), block.rows.map((row2, ri) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: table rows render in source order and don't reorder
-    /* @__PURE__ */ React4.createElement(Box4, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
+    /* @__PURE__ */ React7.createElement(Box7, { key: `r-${ri}` }, Array.from({ length: colCount }).map((_, ci) => (
       // biome-ignore lint/suspicious/noArrayIndexKey: same — column axis is fixed by the table shape
-      /* @__PURE__ */ React4.createElement(Text4, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React4.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
+      /* @__PURE__ */ React7.createElement(Text7, { key: `c-${ri}-${ci}` }, /* @__PURE__ */ React7.createElement(InlineMd, { text: row2[ci] ?? "", padTo: widths[ci] ?? 3, citations }), ci < colCount - 1 ? " \u2502 " : "")
     )))
   )));
 }
@@ -7487,48 +8240,169 @@ function EditBlockRow({ block }) {
   const isNewFile = block.search.length === 0;
   const searchLines = block.search.split("\n");
   const replaceLines = block.replace.split("\n");
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Box4, null, /* @__PURE__ */ React4.createElement(Text4, { bold: true, color: "cyan" }, block.filename), isNewFile ? /* @__PURE__ */ React4.createElement(Text4, { color: "green", bold: true }, " (new file)") : null), isNewFile ? null : /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: 1 }, searchLines.map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: `s-${i}-${line.length}`, color: "red" }, `- ${line}`))), /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", marginTop: isNewFile ? 1 : 0 }, replaceLines.map((line, i) => /* @__PURE__ */ React4.createElement(Text4, { key: `r-${i}-${line.length}`, color: "green" }, `+ ${line}`))));
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React7.createElement(Box7, null, /* @__PURE__ */ React7.createElement(Text7, { bold: true, color: "cyan" }, block.filename), isNewFile ? /* @__PURE__ */ React7.createElement(Text7, { color: "green", bold: true }, " (new file)") : null), isNewFile ? null : /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginTop: 1 }, searchLines.map((line, i) => /* @__PURE__ */ React7.createElement(Text7, { key: `s-${i}-${line.length}`, color: "red" }, `- ${line}`))), /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", marginTop: isNewFile ? 1 : 0 }, replaceLines.map((line, i) => /* @__PURE__ */ React7.createElement(Text7, { key: `r-${i}-${line.length}`, color: "green" }, `+ ${line}`))));
 }
 function Markdown({ text, projectRoot }) {
   const cleaned = stripMath(text);
   const root = projectRoot ?? process.cwd();
-  const citations = React4.useMemo(() => collectCitations(cleaned, root), [cleaned, root]);
-  const blocks = React4.useMemo(() => parseBlocks(cleaned), [cleaned]);
+  const citations = React7.useMemo(() => collectCitations(cleaned, root), [cleaned, root]);
+  const blocks = React7.useMemo(() => parseBlocks(cleaned), [cleaned]);
   const broken = [];
   for (const [url, status2] of citations) {
     if (!status2.ok) broken.push({ url, reason: status2.reason });
   }
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", gap: 1 }, blocks.map((b, i) => /* @__PURE__ */ React4.createElement(BlockView, { key: `${i}-${b.kind}`, block: b, citations })), broken.length > 0 ? /* @__PURE__ */ React4.createElement(BrokenCitationsBlock, { items: broken }) : null);
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", gap: 1 }, blocks.map((b, i) => /* @__PURE__ */ React7.createElement(BlockView, { key: `${i}-${b.kind}`, block: b, citations })), broken.length > 0 ? /* @__PURE__ */ React7.createElement(BrokenCitationsBlock, { items: broken }) : null);
 }
 function BrokenCitationsBlock({ items }) {
-  return /* @__PURE__ */ React4.createElement(Box4, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1 }, /* @__PURE__ */ React4.createElement(Text4, { color: "red", bold: true }, `\u26A0 ${items.length} broken citation${items.length > 1 ? "s" : ""} \u2014 the model referenced paths or lines that don't exist`), items.map((b, i) => (
+  return /* @__PURE__ */ React7.createElement(Box7, { flexDirection: "column", borderStyle: "round", borderColor: "red", paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text7, { color: "red", bold: true }, `\u26A0 ${items.length} broken citation${items.length > 1 ? "s" : ""} \u2014 the model referenced paths or lines that don't exist`), items.map((b, i) => (
     // biome-ignore lint/suspicious/noArrayIndexKey: list is derived from a Map iteration order, stable per render
-    /* @__PURE__ */ React4.createElement(Text4, { key: `bc-${i}`, color: "red" }, `  \u2717 ${b.url} \u2192 ${b.reason}`)
+    /* @__PURE__ */ React7.createElement(Text7, { key: `bc-${i}`, color: "red" }, `  \u2717 ${b.url} \u2192 ${b.reason}`)
   )));
 }
 
 // src/cli/ui/ticker.tsx
-import React5, { createContext, useContext, useEffect, useState as useState2 } from "react";
+import React8, { createContext, useContext, useEffect, useState as useState3 } from "react";
 var TICK_MS = 120;
 var TickContext = createContext(0);
 function TickerProvider({ children, disabled }) {
-  const [tick, setTick] = useState2(0);
+  const [tick, setTick] = useState3(0);
   useEffect(() => {
     if (disabled) return;
     const id = setInterval(() => setTick((t) => t + 1), TICK_MS);
     return () => clearInterval(id);
   }, [disabled]);
-  return /* @__PURE__ */ React5.createElement(TickContext.Provider, { value: tick }, children);
+  return /* @__PURE__ */ React8.createElement(TickContext.Provider, { value: tick }, children);
 }
 function useTick() {
   return useContext(TickContext);
 }
 function useElapsedSeconds() {
-  const [start] = useState2(() => Date.now());
+  const [start] = useState3(() => Date.now());
   useTick();
   return Math.floor((Date.now() - start) / 1e3);
 }
 
+// src/cli/ui/tool-summary.ts
+var MAX_SUMMARY_CHARS = 80;
+var TRAILING_ELLIPSIS = "\u2026";
+function clip(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, Math.max(1, max - TRAILING_ELLIPSIS.length)) + TRAILING_ELLIPSIS;
+}
+function firstNonEmptyLine(text) {
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return "";
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) return "";
+  if (ms < 100) return `${Math.round(ms)}ms`;
+  if (ms < 1e3) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 1e4) return `${(ms / 1e3).toFixed(1)}s`;
+  if (ms < 6e4) return `${Math.round(ms / 1e3)}s`;
+  const totalSec = Math.round(ms / 1e3);
+  const m = Math.floor(totalSec / 60);
+  const s = totalSec % 60;
+  return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+function formatBytes(n) {
+  if (n < 1e3) return `${n}B`;
+  if (n < 1e6) return `${(n / 1e3).toFixed(1)}KB`;
+  return `${(n / 1e6).toFixed(1)}MB`;
+}
+function formatLineCount(text) {
+  const lines = text.split(/\r?\n/).length;
+  return `${lines} line${lines === 1 ? "" : "s"}`;
+}
+function summarizeStructured(content) {
+  const trimmed = content.trim();
+  if (!trimmed.startsWith("{")) return null;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (!parsed || typeof parsed !== "object") return null;
+    const obj = parsed;
+    if (typeof obj.error === "string") {
+      const tag = obj.error.split(":", 1)[0]?.trim() ?? "error";
+      const detail = obj.error.slice(tag.length + 1).trim();
+      const summary = detail ? `${tag} \u2014 ${detail}` : tag;
+      const isControlSignal = tag === "PlanProposedError" || tag === "PlanCheckpointError" || tag === "PlanRevisionProposedError" || tag === "ChoiceRequestedError" || tag === "NeedsConfirmationError";
+      return { summary: clip(summary, MAX_SUMMARY_CHARS), isError: !isControlSignal };
+    }
+    if (obj.kind === "step_completed" && typeof obj.stepId === "string") {
+      const result = typeof obj.result === "string" ? obj.result : "";
+      return {
+        summary: clip(`\u2713 ${obj.stepId}: ${result}`, MAX_SUMMARY_CHARS),
+        isError: false
+      };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function summarizeKnownTool(toolName, content) {
+  if (toolName === "read_file") {
+    const lines = formatLineCount(content);
+    const bytes = formatBytes(content.length);
+    const head = clip(
+      firstNonEmptyLine(content),
+      MAX_SUMMARY_CHARS - lines.length - bytes.length - 8
+    );
+    return {
+      summary: head ? `${head} \xB7 ${lines} \xB7 ${bytes}` : `${lines} \xB7 ${bytes}`,
+      isError: false
+    };
+  }
+  if (toolName === "list_directory" || toolName === "directory_tree") {
+    const entries = content.split(/\r?\n/).filter((l) => l.trim()).length;
+    return { summary: `${entries} entr${entries === 1 ? "y" : "ies"}`, isError: false };
+  }
+  if (toolName === "search_files" || toolName === "search_content") {
+    const matches = content.split(/\r?\n/).filter((l) => l.trim()).length;
+    if (matches === 0) return { summary: "no matches", isError: false };
+    const first = firstNonEmptyLine(content);
+    return {
+      summary: clip(`${matches} match${matches === 1 ? "" : "es"} \xB7 ${first}`, MAX_SUMMARY_CHARS),
+      isError: false
+    };
+  }
+  if (toolName === "run_command" || toolName === "run_background") {
+    const exitMatch = content.match(/exit (?:code )?(-?\d+)/i);
+    const first = firstNonEmptyLine(content);
+    if (exitMatch) {
+      const code = exitMatch[1];
+      const isError = code !== "0";
+      return {
+        summary: clip(`exit ${code} \xB7 ${first}`, MAX_SUMMARY_CHARS),
+        isError
+      };
+    }
+    return { summary: clip(first || "(no output)", MAX_SUMMARY_CHARS), isError: false };
+  }
+  return null;
+}
+function summarizeToolResult(toolName, content) {
+  const isExplicitError = content.startsWith("ERROR:");
+  if (isExplicitError) {
+    const stripped = content.slice("ERROR:".length).trim();
+    return { summary: clip(stripped || "(unknown error)", MAX_SUMMARY_CHARS), isError: true };
+  }
+  const structured = summarizeStructured(content);
+  if (structured) return structured;
+  const known = summarizeKnownTool(toolName, content);
+  if (known) return known;
+  const first = firstNonEmptyLine(content);
+  if (!content.trim()) return { summary: "(empty)", isError: false };
+  if (content.length <= MAX_SUMMARY_CHARS) {
+    return { summary: clip(first, MAX_SUMMARY_CHARS), isError: false };
+  }
+  const sizeHint = formatBytes(content.length);
+  const head = clip(first, MAX_SUMMARY_CHARS - sizeHint.length - 3);
+  return { summary: `${head} \xB7 ${sizeHint}`, isError: false };
+}
+
 // src/cli/ui/EventLog.tsx
 var ROLE_GLYPH = {
   user: "\u25C7",
@@ -7544,53 +8418,98 @@ function RoleGlyph({
   glyph,
   color
 }) {
-  return /* @__PURE__ */ React6.createElement(Text5, { color, bold: true }, glyph);
+  return /* @__PURE__ */ React9.createElement(Text8, { color, bold: true }, glyph);
 }
-var EventRow = React6.memo(function EventRow2({
+var EventRow = React9.memo(function EventRow2({
   event,
   projectRoot
 }) {
   if (event.role === "user") {
-    return /* @__PURE__ */ React6.createElement(Box5, { marginTop: event.leadSeparator ? 1 : 0 }, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.user, color: "cyan" }), /* @__PURE__ */ React6.createElement(Text5, null, "  ", event.text));
+    return /* @__PURE__ */ React9.createElement(Box8, { marginTop: event.leadSeparator ? 1 : 0 }, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph: ROLE_GLYPH.user, color: "cyan" }), /* @__PURE__ */ React9.createElement(Text8, null, "  ", event.text));
   }
   if (event.role === "assistant") {
-    if (event.streaming) return /* @__PURE__ */ React6.createElement(StreamingAssistant, { event });
-    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.assistant, color: "green" }), event.stats ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, `  ${event.stats.model}`) : null), /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, event.branch ? /* @__PURE__ */ React6.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React6.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React6.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React6.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React6.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React6.createElement(Text5, { color: "magenta" }, event.repair) : null));
+    if (event.streaming) return /* @__PURE__ */ React9.createElement(StreamingAssistant, { event });
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph: ROLE_GLYPH.assistant, color: "green" }), event.stats ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `  ${event.stats.model}`) : null), /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, event.branch ? /* @__PURE__ */ React9.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React9.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React9.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React9.createElement(Markdown, { text: event.text, projectRoot }) : /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React9.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React9.createElement(Text8, { color: "magenta" }, event.repair) : null));
   }
   if (event.role === "tool") {
-    const isError = event.text.startsWith("ERROR:");
-    const color = isError ? "red" : "yellow";
-    const glyph = isError ? ROLE_GLYPH.toolErr : ROLE_GLYPH.toolOk;
-    const marker = isError ? "\u2717" : "\u2192";
-    const isEditFile = (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) && !isError;
-    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph, color }), /* @__PURE__ */ React6.createElement(Text5, { color, bold: true }, `  ${event.toolName ?? "?"}`), /* @__PURE__ */ React6.createElement(Text5, { color, dimColor: true }, `  ${marker}`)), /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, isEditFile ? /* @__PURE__ */ React6.createElement(EditFileDiff, { text: event.text }) : /* @__PURE__ */ React6.createElement(Text5, { color: isError ? "red" : void 0, dimColor: !isError }, truncate2(event.text, 400))));
+    const isExplicitError = event.text.startsWith("ERROR:");
+    const isEditFile = (event.toolName === "edit_file" || event.toolName?.endsWith("_edit_file")) && !isExplicitError;
+    if (isEditFile) {
+      return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph: ROLE_GLYPH.toolOk, color: "yellow" }), /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", bold: true }, `  ${event.toolName ?? "?"}`), /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", dimColor: true }, "  \u2192")), /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", paddingLeft: 2, marginTop: 1 }, /* @__PURE__ */ React9.createElement(EditFileDiff, { text: event.text })));
+    }
+    const summary = summarizeToolResult(event.toolName ?? "?", event.text);
+    const color = summary.isError ? "red" : "yellow";
+    const glyph = summary.isError ? ROLE_GLYPH.toolErr : ROLE_GLYPH.toolOk;
+    const marker = summary.isError ? "\u2717" : "\u2192";
+    const durationLabel = event.durationMs !== void 0 && event.durationMs >= 100 ? ` (${formatDuration(event.durationMs)})` : "";
+    const indexHint = event.toolIndex !== void 0 ? `  /tool ${event.toolIndex}` : "";
+    return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph, color }), /* @__PURE__ */ React9.createElement(Text8, { color, bold: true }, `  ${event.toolName ?? "?"}`), durationLabel ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, durationLabel) : null, /* @__PURE__ */ React9.createElement(Text8, { color, dimColor: true }, `  ${marker}  `), /* @__PURE__ */ React9.createElement(Text8, { color: summary.isError ? "red" : void 0, dimColor: !summary.isError }, summary.summary), indexHint ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, indexHint) : null);
   }
   if (event.role === "error") {
-    return /* @__PURE__ */ React6.createElement(Box5, { marginTop: 1 }, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.error, color: "red" }), /* @__PURE__ */ React6.createElement(Text5, { color: "red" }, "  ", event.text));
+    return /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph: ROLE_GLYPH.error, color: "red" }), /* @__PURE__ */ React9.createElement(Text8, { color: "red" }, "  ", event.text));
   }
   if (event.role === "info") {
-    return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, event.text));
+    return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, event.text));
   }
   if (event.role === "plan") {
-    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { bold: true, color: "cyan" }, "\u{1F4CB} plan proposed \u2014 pick a choice below")), /* @__PURE__ */ React6.createElement(Box5, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Markdown, { text: event.text, projectRoot })));
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "cyan" }, "\u{1F4CB} plan proposed \u2014 pick a choice below")), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Markdown, { text: event.text, projectRoot })));
+  }
+  if (event.role === "step-progress") {
+    const sp = event.stepProgress;
+    const counter = sp && sp.total > 0 ? `  (${sp.completed}/${sp.total})` : "";
+    const label = sp?.title ? `${sp.stepId} \xB7 ${sp.title}` : sp?.stepId ?? "";
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, "\u2713"), /* @__PURE__ */ React9.createElement(Text8, { color: "green" }, `  ${label}`), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, counter)), event.text ? /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, event.text)) : null, sp?.notes ? /* @__PURE__ */ React9.createElement(Box8, { paddingLeft: 2 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", dimColor: true }, `note: ${sp.notes}`)) : null);
+  }
+  if (event.role === "plan-resumed") {
+    const rp = event.resumedPlan;
+    if (!rp || rp.steps.length === 0) return null;
+    const total = rp.steps.length;
+    const done = rp.completedStepIds.length;
+    const completedSet = new Set(rp.completedStepIds);
+    const statuses = new Map(
+      rp.steps.map((s) => [
+        s.id,
+        completedSet.has(s.id) ? "done" : "pending"
+      ])
+    );
+    const nextStep = rp.steps.find((s) => !completedSet.has(s.id));
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "cyan" }, "\u25B8 resumed plan"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `  ${done}/${total} done \xB7 last touched ${rp.relativeTime}`)), rp.summary ? /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, `  ${rp.summary}`)) : null), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(PlanStepList, { steps: rp.steps, statuses, focusStepId: nextStep?.id })));
+  }
+  if (event.role === "plan-replay") {
+    const r = event.replayPlan;
+    if (!r || r.steps.length === 0) return null;
+    const total = r.steps.length;
+    const completedSet = new Set(r.completedStepIds);
+    const done = completedSet.size;
+    const statuses = new Map(
+      r.steps.map((s) => [s.id, completedSet.has(s.id) ? "done" : "pending"])
+    );
+    const navHint = r.total > 1 ? ` \xB7 ${r.index}/${r.total}` : "";
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "gray", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, dimColor: true }, "\u23EA replay"), /* @__PURE__ */ React9.createElement(
+      Text8,
+      {
+        dimColor: true
+      },
+      `  completed ${r.relativeTime} \xB7 ${done}/${total} done${navHint}`
+    )), r.summary ? /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `  ${r.summary}`)) : null, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `  ${r.archiveBasename}`))), r.body ? /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Markdown, { text: r.body, projectRoot })) : null, /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React9.createElement(PlanStepList, { steps: r.steps, statuses })), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, r.total > 1 ? `(read-only \xB7 /replay ${r.index === 1 ? 2 : 1} for the ${r.index === 1 ? "next" : "newest"} archive)` : "(read-only \xB7 this is an archived plan)")));
   }
   if (event.role === "warning") {
-    return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(RoleGlyph, { glyph: ROLE_GLYPH.warning, color: "yellow" }), /* @__PURE__ */ React6.createElement(Text5, { color: "yellow" }, "  ", event.text));
+    return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(RoleGlyph, { glyph: ROLE_GLYPH.warning, color: "yellow" }), /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "  ", event.text));
   }
-  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, null, event.text));
+  return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, null, event.text));
 });
 function EditFileDiff({ text }) {
   const lines = text.split(/\r?\n/);
   const [statusHeader, hunkHeader, ...body] = lines;
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column" }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, ` ${statusHeader ?? ""}`), hunkHeader !== void 0 ? /* @__PURE__ */ React6.createElement(Text5, { color: "cyan", bold: true }, hunkHeader) : null, body.map((line, i) => {
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, ` ${statusHeader ?? ""}`), hunkHeader !== void 0 ? /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, hunkHeader) : null, body.map((line, i) => {
     const key = `${i}-${line.slice(0, 32)}`;
     if (line.startsWith("- ")) {
-      return /* @__PURE__ */ React6.createElement(Text5, { key, color: "red" }, line);
+      return /* @__PURE__ */ React9.createElement(Text8, { key, color: "red" }, line);
     }
     if (line.startsWith("+ ")) {
-      return /* @__PURE__ */ React6.createElement(Text5, { key, color: "green" }, line);
+      return /* @__PURE__ */ React9.createElement(Text8, { key, color: "green" }, line);
     }
-    return /* @__PURE__ */ React6.createElement(Text5, { key, dimColor: true }, line);
+    return /* @__PURE__ */ React9.createElement(Text8, { key, dimColor: true }, line);
   }));
 }
 function BranchBlock({ branch: branch2 }) {
@@ -7599,33 +8518,33 @@ function BranchBlock({ branch: branch2 }) {
     const t = (branch2.temperatures[i] ?? 0).toFixed(1);
     return `${marker} #${i} T=${t} u=${u}`;
   }).join("  ");
-  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "\u2387 branched ", /* @__PURE__ */ React6.createElement(Text5, { bold: true }, branch2.budget), ` samples \u2192 picked #${branch2.chosenIndex}   `, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, per)));
+  return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "\u2387 branched ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, branch2.budget), ` samples \u2192 picked #${branch2.chosenIndex}   `, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, per)));
 }
 function ReasoningBlock({ reasoning }) {
   const max = 260;
   const flat = reasoning.replace(/\s+/g, " ").trim();
   const preview = flat.length <= max ? flat : `\u2026 (+${flat.length - max} earlier chars) ${flat.slice(-max)}`;
-  return /* @__PURE__ */ React6.createElement(Box5, { marginBottom: 1 }, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u258F "), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true, italic: true }, "thinking ", preview));
+  return /* @__PURE__ */ React9.createElement(Box8, { marginBottom: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u258F "), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, italic: true }, "thinking ", preview));
 }
 function Elapsed() {
   const s = useElapsedSeconds();
   const mm = String(Math.floor(s / 60)).padStart(2, "0");
   const ss = String(s % 60).padStart(2, "0");
-  return /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, `${mm}:${ss}`);
+  return /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, `${mm}:${ss}`);
 }
 function PulsingAssistantGlyph() {
   const tick = useTick();
   const on = Math.floor(tick / 4) % 2 === 0;
-  return /* @__PURE__ */ React6.createElement(Text5, { color: "green", bold: true }, on ? ROLE_GLYPH.assistant : ROLE_GLYPH.assistantPulse);
+  return /* @__PURE__ */ React9.createElement(Text8, { color: "green", bold: true }, on ? ROLE_GLYPH.assistant : ROLE_GLYPH.assistantPulse);
 }
 function StreamingAssistant({ event }) {
   if (event.branchProgress) {
     const p = event.branchProgress;
     if (p.completed === 0) {
-      return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "  \u2387 launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026  "), /* @__PURE__ */ React6.createElement(Elapsed, null)), /* @__PURE__ */ React6.createElement(Text5, { color: "yellow" }, "  ", "spread across T=0.0/0.5/1.0 \xB7 reasoner typically takes 30-90s \u2014 this is normal"));
+      return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "  \u2387 launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026  "), /* @__PURE__ */ React9.createElement(Elapsed, null)), /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "  ", "spread across T=0.0/0.5/1.0 \xB7 reasoner typically takes 30-90s \u2014 this is normal"));
     }
     const pct2 = Math.round(p.completed / p.total * 100);
-    return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, { color: "blue" }, "  \u2387 branching ", p.completed, "/", p.total, " (", pct2, "%)  "), /* @__PURE__ */ React6.createElement(Elapsed, null)), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
+    return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "  \u2387 branching ", p.completed, "/", p.total, " (", pct2, "%)  "), /* @__PURE__ */ React9.createElement(Elapsed, null)), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
   }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
@@ -7655,16 +8574,16 @@ function StreamingAssistant({ event }) {
     label = parts.join(" \xB7 ");
     labelColor = "green";
   }
-  return /* @__PURE__ */ React6.createElement(Box5, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React6.createElement(Text5, null, "  "), /* @__PURE__ */ React6.createElement(Pulse, null), /* @__PURE__ */ React6.createElement(Text5, { color: labelColor }, ` ${label} `), /* @__PURE__ */ React6.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u25B8 ", tail) : preFirstByte ? (
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(PulsingAssistantGlyph, null), /* @__PURE__ */ React9.createElement(Text8, null, "  "), /* @__PURE__ */ React9.createElement(Pulse, null), /* @__PURE__ */ React9.createElement(Text8, { color: labelColor }, ` ${label} `), /* @__PURE__ */ React9.createElement(Elapsed, null)), reasoningTail ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, italic: true }, "\u21B3 thinking: ", reasoningTail) : null, tail ? /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u25B8 ", tail) : preFirstByte ? (
     // Non-dim yellow: first-time users misread the dim version as
     // "app frozen". The reassurance has to be VISIBLE to do its job.
-    /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  waiting for first byte \u2014 this is normal, typically 5-60s depending on model + load")
-  ) : reasoningOnly ? /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  R1 is thinking before it speaks \u2014 body text arrives when reasoning finishes (typically 20-90s, this is normal)") : toolCallOnly ? /* @__PURE__ */ React6.createElement(Text5, { color: "magenta", italic: true }, "  tool-call arguments streaming \u2014 the model is about to dispatch a tool") : event.reasoning ? /* @__PURE__ */ React6.createElement(Text5, { color: "yellow", italic: true }, "  R1 still reasoning \u2014 body text or tool call arrives when thinking finishes") : null);
+    /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", italic: true }, "  waiting for first byte \u2014 this is normal, typically 5-60s depending on model + load")
+  ) : reasoningOnly ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", italic: true }, "  R1 is thinking before it speaks \u2014 body text arrives when reasoning finishes (typically 20-90s, this is normal)") : toolCallOnly ? /* @__PURE__ */ React9.createElement(Text8, { color: "magenta", italic: true }, "  tool-call arguments streaming \u2014 the model is about to dispatch a tool") : event.reasoning ? /* @__PURE__ */ React9.createElement(Text8, { color: "yellow", italic: true }, "  R1 still reasoning \u2014 body text or tool call arrives when thinking finishes") : null);
 }
 function Pulse() {
   const tick = useTick();
   const frames = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
-  return /* @__PURE__ */ React6.createElement(Text5, { color: "cyan" }, frames[Math.floor(tick / 4) % frames.length]);
+  return /* @__PURE__ */ React9.createElement(Text8, { color: "cyan" }, frames[Math.floor(tick / 4) % frames.length]);
 }
 function formatToolCallIndex(tb) {
   if (!tb || tb.index === void 0) return "";
@@ -7683,36 +8602,17 @@ function lastLine(s, maxChars) {
 }
 function StatsLine({ stats: stats2 }) {
   const hit = (stats2.cacheHitRatio * 100).toFixed(1);
-  return /* @__PURE__ */ React6.createElement(Box5, null, /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "\u258F "), /* @__PURE__ */ React6.createElement(Text5, { dimColor: true }, "cache ", hit, "% \xB7 tokens ", stats2.usage.promptTokens, " \u2192 ", stats2.usage.completionTokens, " \xB7 $", stats2.cost.toFixed(6)));
-}
-function truncate2(s, max) {
-  if (s.length <= max) return s;
-  if (s.startsWith("ERROR:")) {
-    const firstNl = s.indexOf("\n");
-    const firstLine = firstNl === -1 ? s : s.slice(0, firstNl);
-    if (firstLine.length >= max) {
-      return `${firstLine.slice(0, max)}\u2026 (+${s.length - max} chars \u2014 /tool N for full)`;
-    }
-    const budget = max - firstLine.length - 10;
-    const tail = s.slice(-budget);
-    const skipped2 = s.length - firstLine.length - tail.length;
-    return `${firstLine}
-\u2026 (+${skipped2} chars) \u2026
-${tail}`;
-  }
-  const skipped = s.length - max;
-  return `\u2026 (+${skipped} earlier chars \u2014 /tool N for full) \u2026
-${s.slice(-max)}`;
+  return /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "\u258F "), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "cache ", hit, "% \xB7 tokens ", stats2.usage.promptTokens, " \u2192 ", stats2.usage.completionTokens, " \xB7 $", stats2.cost.toFixed(6)));
 }
 
 // src/cli/ui/LiveRows.tsx
-import { Box as Box6, Text as Text6 } from "ink";
-import React7 from "react";
+import { Box as Box9, Text as Text9 } from "ink";
+import React10 from "react";
 var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 function StatusRow({ text }) {
   const tick = useTick();
   const elapsed = useElapsedSeconds();
-  return /* @__PURE__ */ React7.createElement(Box6, { marginY: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React7.createElement(Text6, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, ` ${elapsed}s`));
+  return /* @__PURE__ */ React10.createElement(Box9, { marginY: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React10.createElement(Text9, { color: "magenta" }, ` ${text}`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, ` ${elapsed}s`));
 }
 function ModeStatusBar({
   editMode,
@@ -7724,15 +8624,15 @@ function ModeStatusBar({
 }) {
   useTick();
   const running = jobs2?.runningCount() ?? 0;
-  const jobsTag = running > 0 ? /* @__PURE__ */ React7.createElement(Text6, { color: "yellow", bold: true }, `  \xB7  \u23F5 ${running} job${running === 1 ? "" : "s"}`) : null;
+  const jobsTag = running > 0 ? /* @__PURE__ */ React10.createElement(Text9, { color: "yellow", bold: true }, `  \xB7  \u23F5 ${running} job${running === 1 ? "" : "s"}`) : null;
   if (planMode) {
-    return /* @__PURE__ */ React7.createElement(Box6, { paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "red", bold: true, inverse: flash }, "\u25B8 PLAN"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, "  writes gated \u2014 submit_plan + approval required  \xB7  /plan off to leave"), jobsTag);
+    return /* @__PURE__ */ React10.createElement(Box9, { paddingX: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "red", bold: true, inverse: flash }, "\u25B8 PLAN"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, "  writes gated \u2014 submit_plan + approval required  \xB7  /plan off to leave"), jobsTag);
   }
   const label = editMode === "auto" ? "AUTO" : "review";
   const color = editMode === "auto" ? "magenta" : "cyan";
   const mid = editMode === "auto" ? undoArmed ? "edits apply immediately  \xB7  u = undo last batch" : "edits apply immediately  \xB7  5s undo window after each batch" : pendingCount > 0 ? `${pendingCount} queued  \xB7  y = /apply  \xB7  n = /discard` : "edits queue for review  \xB7  y = /apply  \xB7  n = /discard";
   const flip = editMode === "auto" ? "Shift+Tab \u2192 review" : "Shift+Tab \u2192 AUTO";
-  return /* @__PURE__ */ React7.createElement(Box6, { paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color, bold: true, inverse: flash }, `\u25B8 ${label}`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, `  ${mid}  \xB7  ${flip}`), jobsTag);
+  return /* @__PURE__ */ React10.createElement(Box9, { paddingX: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color, bold: true, inverse: flash }, `\u25B8 ${label}`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, `  ${mid}  \xB7  ${flip}`), jobsTag);
 }
 function UndoBanner({
   banner
@@ -7742,14 +8642,14 @@ function UndoBanner({
   const remainingSec = Math.ceil(remainingMs / 1e3);
   const ok = banner.results.filter((r) => r.status === "applied" || r.status === "created").length;
   const total = banner.results.length;
-  return /* @__PURE__ */ React7.createElement(Box6, { marginY: 1, borderStyle: "round", borderColor: "magenta", paddingX: 1 }, /* @__PURE__ */ React7.createElement(Text6, { color: "magenta", bold: true }, "\u2713 auto-applied "), /* @__PURE__ */ React7.createElement(Text6, { color: "magenta" }, `${ok}/${total} edit${total === 1 ? "" : "s"}`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, " \xB7 press "), /* @__PURE__ */ React7.createElement(Text6, { color: "magenta", bold: true }, "u"), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, " to undo  ("), /* @__PURE__ */ React7.createElement(Text6, { color: remainingSec <= 1 ? "red" : "magenta" }, `${remainingSec}s`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, ")"));
+  return /* @__PURE__ */ React10.createElement(Box9, { marginY: 1, borderStyle: "round", borderColor: "magenta", paddingX: 1 }, /* @__PURE__ */ React10.createElement(Text9, { color: "magenta", bold: true }, "\u2713 auto-applied "), /* @__PURE__ */ React10.createElement(Text9, { color: "magenta" }, `${ok}/${total} edit${total === 1 ? "" : "s"}`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " \xB7 press "), /* @__PURE__ */ React10.createElement(Text9, { color: "magenta", bold: true }, "u"), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, " to undo  ("), /* @__PURE__ */ React10.createElement(Text9, { color: remainingSec <= 1 ? "red" : "magenta" }, `${remainingSec}s`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, ")"));
 }
 function SubagentRow({
   activity
 }) {
   const tick = useTick();
   const seconds = (activity.elapsedMs / 1e3).toFixed(1);
-  return /* @__PURE__ */ React7.createElement(Box6, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text6, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React7.createElement(Text6, { color: "magenta" }, ` \u232C subagent: ${activity.task}`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
+  return /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { color: "magenta" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React10.createElement(Text9, { color: "magenta" }, ` \u232C subagent: ${activity.task}`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, ` \xB7 iter ${activity.iter} \xB7 ${seconds}s`));
 }
 function OngoingToolRow({
   tool: tool2,
@@ -7758,7 +8658,7 @@ function OngoingToolRow({
   const tick = useTick();
   const elapsed = useElapsedSeconds();
   const summary = summarizeToolArgs(tool2.name, tool2.args);
-  return /* @__PURE__ */ React7.createElement(Box6, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React7.createElement(Box6, null, /* @__PURE__ */ React7.createElement(Text6, { color: "cyan" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React7.createElement(Text6, { color: "yellow" }, ` tool<${tool2.name}> running\u2026`), /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, ` ${elapsed}s`)), progress ? /* @__PURE__ */ React7.createElement(Box6, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text6, { color: "cyan" }, renderProgressLine(progress))) : null, summary ? /* @__PURE__ */ React7.createElement(Box6, { paddingLeft: 2 }, /* @__PURE__ */ React7.createElement(Text6, { dimColor: true }, summary)) : null);
+  return /* @__PURE__ */ React10.createElement(Box9, { marginY: 1, flexDirection: "column" }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { color: "cyan" }, SPINNER_FRAMES[tick % SPINNER_FRAMES.length]), /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, ` tool<${tool2.name}> running\u2026`), /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, ` ${elapsed}s`)), progress ? /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { color: "cyan" }, renderProgressLine(progress))) : null, summary ? /* @__PURE__ */ React10.createElement(Box9, { paddingLeft: 2 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, summary)) : null);
 }
 function renderProgressLine(p) {
   const msg = p.message ? `  ${p.message}` : "";
@@ -7813,116 +8713,71 @@ function summarizeToolArgs(name, args) {
   return args.length > 80 ? `${args.slice(0, 80)}\u2026` : args;
 }
 
-// src/cli/ui/PlanConfirm.tsx
-import { Box as Box8, Text as Text8 } from "ink";
-import React9 from "react";
-
-// src/cli/ui/Select.tsx
-import { Box as Box7, Text as Text7, useInput as useInput2 } from "ink";
-import React8, { useState as useState3 } from "react";
-function SingleSelect({
-  items,
-  initialValue,
-  onSubmit,
-  onCancel,
-  footer
+// src/cli/ui/PlanCheckpointConfirm.tsx
+import { Box as Box10, Text as Text10 } from "ink";
+import React11 from "react";
+function PlanCheckpointConfirmInner({
+  stepId,
+  title,
+  completed,
+  total,
+  steps,
+  completedStepIds,
+  onChoose
 }) {
-  const initialIndex = Math.max(
-    0,
-    items.findIndex((i) => i.value === initialValue && !i.disabled)
-  );
-  const [index, setIndex] = useState3(initialIndex === -1 ? 0 : initialIndex);
-  useInput2((_input, key) => {
-    if (key.upArrow) {
-      setIndex((i) => findNextEnabled(items, i, -1));
-    } else if (key.downArrow) {
-      setIndex((i) => findNextEnabled(items, i, 1));
-    } else if (key.return) {
-      const chosen = items[index];
-      if (chosen && !chosen.disabled) onSubmit(chosen.value);
-    } else if (key.escape && onCancel) {
-      onCancel();
-    }
-  });
-  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column" }, items.map((item, i) => /* @__PURE__ */ React8.createElement(
-    SelectRow,
+  const label = title ? `${stepId} \xB7 ${title}` : stepId;
+  const counter = total > 0 ? ` (${completed}/${total})` : "";
+  const isLast = total > 0 && completed >= total;
+  const statuses = buildStatusMap(steps, completedStepIds, stepId, isLast);
+  return /* @__PURE__ */ React11.createElement(Box10, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React11.createElement(Box10, null, /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: "green" }, "\u25B8 checkpoint \u2014 step done"), /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, `  ${label}${counter}`)), steps && steps.length > 0 ? /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React11.createElement(PlanStepList, { steps, statuses, focusStepId: stepId })) : null, /* @__PURE__ */ React11.createElement(Box10, { marginTop: 1 }, /* @__PURE__ */ React11.createElement(
+    SingleSelect,
     {
-      key: item.value,
-      item,
-      active: i === index,
-      marker: i === index ? "\u25B8" : " "
+      initialValue: isLast ? "stop" : "continue",
+      items: [
+        {
+          value: "continue",
+          label: "Continue \u2014 run the next step",
+          hint: "Model resumes with the next step. Use this when the result looks right and you don't need to tweak the remaining plan."
+        },
+        {
+          value: "revise",
+          label: "Revise \u2014 give feedback before the next step",
+          hint: "Stay paused, type guidance (scope changes, skip steps, alternative approach). The model adjusts the remaining plan based on your message."
+        },
+        {
+          value: "stop",
+          label: "Stop \u2014 end the plan here",
+          hint: "Model summarizes what was done and ends. Remaining steps are skipped."
+        }
+      ],
+      onSubmit: (v) => onChoose(v),
+      onCancel: () => onChoose("stop"),
+      footer: "[\u2191\u2193] navigate  \xB7  [Enter] select  \xB7  [Esc] stop"
     }
-  )), footer ? /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, footer)) : null);
+  )));
 }
-function MultiSelect({
-  items,
-  initialSelected = [],
-  onSubmit,
-  onCancel,
-  footer
-}) {
-  const [index, setIndex] = useState3(() => {
-    const first = items.findIndex((i) => !i.disabled);
-    return first === -1 ? 0 : first;
-  });
-  const [selected, setSelected] = useState3(new Set(initialSelected));
-  useInput2((input, key) => {
-    if (key.upArrow) {
-      setIndex((i) => findNextEnabled(items, i, -1));
-    } else if (key.downArrow) {
-      setIndex((i) => findNextEnabled(items, i, 1));
-    } else if (input === " ") {
-      const item = items[index];
-      if (!item || item.disabled) return;
-      setSelected((prev) => {
-        const next = new Set(prev);
-        if (next.has(item.value)) next.delete(item.value);
-        else next.add(item.value);
-        return next;
-      });
-    } else if (key.return) {
-      const ordered = items.filter((i) => selected.has(i.value)).map((i) => i.value);
-      onSubmit(ordered);
-    } else if (key.escape && onCancel) {
-      onCancel();
+var PlanCheckpointConfirm = React11.memo(PlanCheckpointConfirmInner);
+function buildStatusMap(steps, completedStepIds, currentStepId, isLast) {
+  const map = /* @__PURE__ */ new Map();
+  if (!steps) return map;
+  for (const step of steps) {
+    if (completedStepIds?.has(step.id) || step.id === currentStepId) {
+      map.set(step.id, "done");
+    } else {
+      map.set(step.id, "pending");
     }
-  });
-  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column" }, items.map((item, i) => {
-    const checked = selected.has(item.value);
-    const marker = checked ? "[x]" : "[ ]";
-    return /* @__PURE__ */ React8.createElement(
-      SelectRow,
-      {
-        key: item.value,
-        item,
-        active: i === index,
-        marker: `${i === index ? "\u25B8" : " "} ${marker}`
-      }
-    );
-  }), footer ? /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, footer)) : null);
-}
-function SelectRow({
-  item,
-  active,
-  marker
-}) {
-  const color = item.disabled ? "gray" : active ? "cyan" : void 0;
-  return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column" }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { color }, marker, " ", item.label)), item.hint ? /* @__PURE__ */ React8.createElement(Box7, { paddingLeft: marker.length + 1 }, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, item.hint)) : null);
-}
-function findNextEnabled(items, from, step) {
-  if (items.length === 0) return 0;
-  let i = from;
-  for (let tries = 0; tries < items.length; tries++) {
-    i = (i + step + items.length) % items.length;
-    if (!items[i]?.disabled) return i;
   }
-  return from;
+  if (isLast) {
+  }
+  return map;
 }
 
 // src/cli/ui/PlanConfirm.tsx
-function PlanConfirmInner({ plan: plan2, onChoose }) {
+import { Box as Box11, Text as Text11 } from "ink";
+import React12 from "react";
+function PlanConfirmInner({ plan: plan2, steps, summary, onChoose }) {
   const hasOpenQuestions = /^#{1,6}\s*(open[-\s]?questions?|risks?|unknowns?|assumptions?|unclear)/im.test(plan2) || /^#{1,6}\s*(待确认|开放问题|风险|未知|假设|不确定)/im.test(plan2);
-  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React9.createElement(Box8, null, /* @__PURE__ */ React9.createElement(Text8, { bold: true, color: "cyan" }, "\u25B8 plan proposed (full text above) \u2014 approve / refine / cancel")), hasOpenQuestions ? /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u25B2 the plan flags open questions or risks \u2014 pick", " ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "Refine / answer questions"), " to write concrete answers before the model moves on.")) : null, /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(
+  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column" }, /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "cyan" }, "\u25B8 plan proposed (full text above) \u2014 approve / refine / cancel")), summary ? /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, `  ${summary}`)) : null), hasOpenQuestions ? /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow" }, "\u25B2 the plan flags open questions or risks \u2014 pick", " ", /* @__PURE__ */ React12.createElement(Text11, { bold: true }, "Refine / answer questions"), " to write concrete answers before the model moves on.")) : null, steps && steps.length > 0 ? /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React12.createElement(PlanStepList, { steps })) : null, /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(
     SingleSelect,
     {
       initialValue: hasOpenQuestions ? "refine" : "approve",
@@ -7949,11 +8804,11 @@ function PlanConfirmInner({ plan: plan2, onChoose }) {
     }
   )));
 }
-var PlanConfirm = React9.memo(PlanConfirmInner);
+var PlanConfirm = React12.memo(PlanConfirmInner);
 
 // src/cli/ui/PlanRefineInput.tsx
-import { Box as Box9, Text as Text9, useInput as useInput3 } from "ink";
-import React10, { useState as useState4 } from "react";
+import { Box as Box12, Text as Text12, useInput as useInput3 } from "ink";
+import React13, { useState as useState4 } from "react";
 function PlanRefineInput({ mode: mode2, onSubmit, onCancel }) {
   const [value, setValue] = useState4("");
   useInput3((input, key) => {
@@ -7973,15 +8828,84 @@ function PlanRefineInput({ mode: mode2, onSubmit, onCancel }) {
       setValue((v) => v + input);
     }
   });
-  const title = mode2 === "approve" ? "\u25B8 approving \u2014 any last instructions or answers to open questions?" : "\u25B8 refining \u2014 what should the model change?";
-  const hint = mode2 === "approve" ? "Answer questions the plan raised, add constraints, or just press Enter to approve as-is." : "Describe what's wrong or missing, or answer questions the plan raised.";
-  const blankHint = mode2 === "approve" ? " (Enter with blank = approve without extra instructions.)" : " (Enter with blank = ask the model to list concrete questions.)";
-  return /* @__PURE__ */ React10.createElement(Box9, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React10.createElement(Box9, null, /* @__PURE__ */ React10.createElement(Text9, { bold: true, color: "yellow" }, title)), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, { dimColor: true }, hint, " Enter to send \xB7 Esc to return to the picker.", value === "" ? blankHint : "")), /* @__PURE__ */ React10.createElement(Box9, { marginTop: 1 }, /* @__PURE__ */ React10.createElement(Text9, null, /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u203A "), /* @__PURE__ */ React10.createElement(Text9, null, value || " "), /* @__PURE__ */ React10.createElement(Text9, { color: "yellow" }, "\u258D"))));
+  const title = mode2 === "approve" ? "\u25B8 approving \u2014 any last instructions or answers to open questions?" : mode2 === "checkpoint-revise" ? "\u25B8 revising \u2014 what should change before the next step?" : mode2 === "choice-custom" ? "\u25B8 custom answer \u2014 type whatever fits" : "\u25B8 refining \u2014 what should the model change?";
+  const hint = mode2 === "approve" ? "Answer questions the plan raised, add constraints, or just press Enter to approve as-is." : mode2 === "checkpoint-revise" ? "Scope change, skip steps, alternative approach \u2014 the model will adjust the remaining plan based on this." : mode2 === "choice-custom" ? "Free-form reply. The model reads it verbatim and proceeds \u2014 no need to match the listed options." : "Describe what's wrong or missing, or answer questions the plan raised.";
+  const blankHint = mode2 === "approve" ? " (Enter with blank = approve without extra instructions.)" : mode2 === "checkpoint-revise" ? " (Enter with blank = continue with the current plan.)" : mode2 === "choice-custom" ? " (Enter with blank = ask the model what you actually want.)" : " (Enter with blank = ask the model to list concrete questions.)";
+  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { bold: true, color: "yellow" }, title)), /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, hint, " Enter to send \xB7 Esc to return to the picker.", value === "" ? blankHint : "")), /* @__PURE__ */ React13.createElement(Box12, { marginTop: 1 }, /* @__PURE__ */ React13.createElement(Text12, null, /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, "\u203A "), /* @__PURE__ */ React13.createElement(Text12, null, value || " "), /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, "\u258D"))));
 }
 
+// src/cli/ui/PlanReviseConfirm.tsx
+import { Box as Box13, Text as Text13 } from "ink";
+import React14 from "react";
+function computeDiff(oldSteps, newSteps) {
+  const oldIds = new Set(oldSteps.map((s) => s.id));
+  const newIds = new Set(newSteps.map((s) => s.id));
+  const rows = [];
+  for (const s of oldSteps) {
+    if (!newIds.has(s.id)) rows.push({ kind: "removed", step: s });
+  }
+  for (const s of newSteps) {
+    rows.push({ kind: oldIds.has(s.id) ? "kept" : "added", step: s });
+  }
+  return rows;
+}
+function riskDots2(risk) {
+  switch (risk) {
+    case "high":
+      return { dots: "\u25CF\u25CF\u25CF", color: "red" };
+    case "med":
+      return { dots: "\u25CF\u25CF ", color: "yellow" };
+    case "low":
+      return { dots: "\u25CF  ", color: "green" };
+    default:
+      return { dots: "   ", color: "gray" };
+  }
+}
+function PlanReviseConfirmInner({
+  reason,
+  oldRemaining,
+  newRemaining,
+  summary,
+  onChoose
+}) {
+  const rows = computeDiff(oldRemaining, newRemaining);
+  const removedCount = rows.filter((r) => r.kind === "removed").length;
+  const addedCount = rows.filter((r) => r.kind === "added").length;
+  const keptCount = rows.filter((r) => r.kind === "kept").length;
+  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { bold: true, color: "yellow" }, "\u270F plan revision proposed"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `  \u2212${removedCount} +${addedCount} (${keptCount} kept)`)), /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(Text13, null, reason)), summary ? /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, `updated summary: ${summary}`)) : null, /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1, flexDirection: "column" }, rows.map((row2) => {
+    const risk = riskDots2(row2.step.risk);
+    const prefix = row2.kind === "removed" ? "\u2212" : row2.kind === "added" ? "+" : " ";
+    const prefixColor = row2.kind === "removed" ? "red" : row2.kind === "added" ? "green" : "gray";
+    const dim = row2.kind === "kept";
+    const strike = row2.kind === "removed";
+    return /* @__PURE__ */ React14.createElement(Box13, { key: `${row2.kind}-${row2.step.id}` }, /* @__PURE__ */ React14.createElement(Text13, { color: prefixColor, bold: true }, `${prefix} `), /* @__PURE__ */ React14.createElement(Text13, { color: risk.color, bold: true, dimColor: dim }, risk.dots), /* @__PURE__ */ React14.createElement(Text13, { dimColor: dim, strikethrough: strike }, ` ${row2.step.id} \xB7 ${row2.step.title}`));
+  })), /* @__PURE__ */ React14.createElement(Box13, { marginTop: 1 }, /* @__PURE__ */ React14.createElement(
+    SingleSelect,
+    {
+      initialValue: "accept",
+      items: [
+        {
+          value: "accept",
+          label: "Accept revision \u2014 apply the new step list",
+          hint: "Replaces the remaining plan with the proposed steps. Done steps are untouched."
+        },
+        {
+          value: "reject",
+          label: "Reject \u2014 keep the original plan",
+          hint: "Drops the proposal. Model continues with the original remaining steps."
+        }
+      ],
+      onSubmit: (v) => onChoose(v),
+      onCancel: () => onChoose("reject"),
+      footer: "[\u2191\u2193] navigate  \xB7  [Enter] select  \xB7  [Esc] reject"
+    }
+  )));
+}
+var PlanReviseConfirm = React14.memo(PlanReviseConfirmInner);
+
 // src/cli/ui/PromptInput.tsx
-import { Box as Box10, Text as Text10, useInput as useInput4 } from "ink";
-import React11, { useRef, useState as useState5 } from "react";
+import { Box as Box14, Text as Text14, useInput as useInput4 } from "ink";
+import React15, { useRef, useState as useState5 } from "react";
 
 // src/cli/ui/multiline-keys.ts
 var BACKSLASH_SUFFIX = /\\$/;
@@ -8141,13 +9065,13 @@ function PromptInput({
   const lines = value.length > 0 ? value.split("\n") : [""];
   const borderColor = disabled ? "gray" : "cyan";
   const { line: cursorLine, col: cursorCol } = lineAndColumn(value, cursor);
-  return /* @__PURE__ */ React11.createElement(Box10, { borderStyle: "round", borderColor, paddingX: 1, flexDirection: "column" }, lines.map((line, i) => {
+  return /* @__PURE__ */ React15.createElement(Box14, { borderStyle: "round", borderColor, paddingX: 1, flexDirection: "column" }, lines.map((line, i) => {
     const isFirst = i === 0;
     const showPlaceholder = isFirst && value.length === 0;
     const isCursorLine = i === cursorLine;
     return (
       // biome-ignore lint/suspicious/noArrayIndexKey: stable by construction — lines are derived from `value.split("\n")` and never reordered
-      /* @__PURE__ */ React11.createElement(Box10, { key: i }, isFirst ? /* @__PURE__ */ React11.createElement(Text10, { bold: true, color: borderColor }, "you \u203A", " ") : /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, "     "), showPlaceholder ? /* @__PURE__ */ React11.createElement(React11.Fragment, null, isCursorLine && !disabled ? /* @__PURE__ */ React11.createElement(Text10, { color: borderColor }, showCursor ? "\u258C" : " ") : null, /* @__PURE__ */ React11.createElement(Text10, { dimColor: true }, effectivePlaceholder)) : isCursorLine && !disabled ? /* @__PURE__ */ React11.createElement(
+      /* @__PURE__ */ React15.createElement(Box14, { key: i }, isFirst ? /* @__PURE__ */ React15.createElement(Text14, { bold: true, color: borderColor }, "you \u203A", " ") : /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "     "), showPlaceholder ? /* @__PURE__ */ React15.createElement(React15.Fragment, null, isCursorLine && !disabled ? /* @__PURE__ */ React15.createElement(Text14, { color: borderColor }, showCursor ? "\u258C" : " ") : null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, effectivePlaceholder)) : isCursorLine && !disabled ? /* @__PURE__ */ React15.createElement(
         LineWithCursor,
         {
           line,
@@ -8155,7 +9079,7 @@ function PromptInput({
           showCursor,
           borderColor
         }
-      ) : /* @__PURE__ */ React11.createElement(Text10, null, line))
+      ) : /* @__PURE__ */ React15.createElement(Text14, null, line))
     );
   }));
 }
@@ -8169,17 +9093,17 @@ function LineWithCursor({
   const atCursor = line.slice(col, col + 1);
   const after = line.slice(col + 1);
   if (atCursor.length === 0) {
-    return /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Text10, null, before), /* @__PURE__ */ React11.createElement(Text10, { color: borderColor }, showCursor ? "\u258C" : " "));
+    return /* @__PURE__ */ React15.createElement(React15.Fragment, null, /* @__PURE__ */ React15.createElement(Text14, null, before), /* @__PURE__ */ React15.createElement(Text14, { color: borderColor }, showCursor ? "\u258C" : " "));
   }
-  return /* @__PURE__ */ React11.createElement(React11.Fragment, null, /* @__PURE__ */ React11.createElement(Text10, null, before), /* @__PURE__ */ React11.createElement(Text10, { inverse: showCursor }, atCursor), /* @__PURE__ */ React11.createElement(Text10, null, after));
+  return /* @__PURE__ */ React15.createElement(React15.Fragment, null, /* @__PURE__ */ React15.createElement(Text14, null, before), /* @__PURE__ */ React15.createElement(Text14, { inverse: showCursor }, atCursor), /* @__PURE__ */ React15.createElement(Text14, null, after));
 }
 
 // src/cli/ui/ShellConfirm.tsx
-import { Box as Box11, Text as Text11 } from "ink";
-import React12 from "react";
+import { Box as Box15, Text as Text15 } from "ink";
+import React16 from "react";
 function ShellConfirm({ command, allowPrefix, kind, onChoose }) {
   const isBackground = kind === "run_background";
-  return /* @__PURE__ */ React12.createElement(Box11, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { bold: true, color: "yellow" }, isBackground ? "\u25B8 model wants to start a BACKGROUND process" : "\u25B8 model wants to run a shell command")), isBackground ? /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "  (long-running: dev server / watcher; keeps running after approval, /kill to stop)")) : null, /* @__PURE__ */ React12.createElement(Box11, null, /* @__PURE__ */ React12.createElement(Text11, { color: "yellow", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(Text11, null, /* @__PURE__ */ React12.createElement(Text11, { dimColor: true }, "$ "), /* @__PURE__ */ React12.createElement(Text11, { color: "cyan" }, command))), /* @__PURE__ */ React12.createElement(Box11, { marginTop: 1 }, /* @__PURE__ */ React12.createElement(
+  return /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, marginY: 1 }, /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { bold: true, color: "yellow" }, isBackground ? "\u25B8 model wants to start a BACKGROUND process" : "\u25B8 model wants to run a shell command")), isBackground ? /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "  (long-running: dev server / watcher; keeps running after approval, /kill to stop)")) : null, /* @__PURE__ */ React16.createElement(Box15, null, /* @__PURE__ */ React16.createElement(Text15, { color: "yellow", dimColor: true }, "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500")), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(Text15, null, /* @__PURE__ */ React16.createElement(Text15, { dimColor: true }, "$ "), /* @__PURE__ */ React16.createElement(Text15, { color: "cyan" }, command))), /* @__PURE__ */ React16.createElement(Box15, { marginTop: 1 }, /* @__PURE__ */ React16.createElement(
     SingleSelect,
     {
       initialValue: "run_once",
@@ -8236,8 +9160,8 @@ function derivePrefix(command) {
 }
 
 // src/cli/ui/SlashArgPicker.tsx
-import { Box as Box12, Text as Text12 } from "ink";
-import React13 from "react";
+import { Box as Box16, Text as Text16 } from "ink";
+import React17 from "react";
 function SlashArgPicker({
   matches,
   selectedIndex,
@@ -8246,11 +9170,11 @@ function SlashArgPicker({
   partial
 }) {
   if (kind === "hint") {
-    return /* @__PURE__ */ React13.createElement(Box12, { paddingX: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "  ", /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary));
+    return /* @__PURE__ */ React17.createElement(Box16, { paddingX: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "  ", /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary));
   }
   if (matches === null) return null;
   if (matches.length === 0) {
-    return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "  ", /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), /* @__PURE__ */ React13.createElement(Text12, { color: "yellow" }, ' no match for "', partial, '" \u2014 keep typing, or Backspace to edit'));
+    return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "  ", /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), /* @__PURE__ */ React17.createElement(Text16, { color: "yellow" }, ' no match for "', partial, '" \u2014 keep typing, or Backspace to edit'));
   }
   const MAX = 8;
   const total = matches.length;
@@ -8258,26 +9182,26 @@ function SlashArgPicker({
   const shown = matches.slice(windowStart, windowStart + MAX);
   const hiddenAbove = windowStart;
   const hiddenBelow = total - windowStart - shown.length;
-  return /* @__PURE__ */ React13.createElement(Box12, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, "  ", /* @__PURE__ */ React13.createElement(Text12, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), hiddenAbove > 0 ? /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((value, i) => /* @__PURE__ */ React13.createElement(ArgRow, { key: value, value, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
+  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, "  ", /* @__PURE__ */ React17.createElement(Text16, { bold: true }, "/", spec.cmd), spec.argsHint ? ` ${spec.argsHint}` : "", " \u2014 ", spec.summary), hiddenAbove > 0 ? /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((value, i) => /* @__PURE__ */ React17.createElement(ArgRow, { key: value, value, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
 }
 function ArgRow({ value, isSelected }) {
   const marker = isSelected ? "\u25B8" : " ";
   if (isSelected) {
-    return /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { bold: true, color: "cyan" }, marker, " ", value));
+    return /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { bold: true, color: "cyan" }, marker, " ", value));
   }
-  return /* @__PURE__ */ React13.createElement(Box12, null, /* @__PURE__ */ React13.createElement(Text12, { dimColor: true }, marker, " ", value));
+  return /* @__PURE__ */ React17.createElement(Box16, null, /* @__PURE__ */ React17.createElement(Text16, { dimColor: true }, marker, " ", value));
 }
 
 // src/cli/ui/SlashSuggestions.tsx
-import { Box as Box13, Text as Text13 } from "ink";
-import React14 from "react";
+import { Box as Box17, Text as Text17 } from "ink";
+import React18 from "react";
 function SlashSuggestions({
   matches,
   selectedIndex
 }) {
   if (matches === null) return null;
   if (matches.length === 0) {
-    return /* @__PURE__ */ React14.createElement(Box13, { paddingX: 1 }, /* @__PURE__ */ React14.createElement(Text13, { color: "yellow" }, "no slash command matches that prefix"), /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2014 Backspace to edit, or /help for the full list"));
+    return /* @__PURE__ */ React18.createElement(Box17, { paddingX: 1 }, /* @__PURE__ */ React18.createElement(Text17, { color: "yellow" }, "no slash command matches that prefix"), /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, " \u2014 Backspace to edit, or /help for the full list"));
   }
   const MAX = 8;
   const total = matches.length;
@@ -8285,21 +9209,21 @@ function SlashSuggestions({
   const shown = matches.slice(windowStart, windowStart + MAX);
   const hiddenAbove = windowStart;
   const hiddenBelow = total - windowStart - shown.length;
-  return /* @__PURE__ */ React14.createElement(Box13, { flexDirection: "column", paddingX: 1 }, hiddenAbove > 0 ? /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((spec, i) => /* @__PURE__ */ React14.createElement(SuggestionRow, { key: spec.cmd, spec, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
+  return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", paddingX: 1 }, hiddenAbove > 0 ? /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, " \u2191 ", hiddenAbove, " more above") : null, shown.map((spec, i) => /* @__PURE__ */ React18.createElement(SuggestionRow, { key: spec.cmd, spec, isSelected: windowStart + i === selectedIndex })), hiddenBelow > 0 ? /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, " \u2193 ", hiddenBelow, " more below") : null, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, " [\u2191\u2193] navigate \xB7 [Tab]/[Enter] pick"));
 }
 function SuggestionRow({ spec, isSelected }) {
   const marker = isSelected ? "\u25B8" : " ";
   const name = `/${spec.cmd}`;
   const argsSuffix = spec.argsHint ? ` ${spec.argsHint}` : "";
   if (isSelected) {
-    return /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { bold: true, color: "cyan" }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16)), /* @__PURE__ */ React14.createElement(Text13, { color: "cyan" }, " ", spec.summary));
+    return /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { bold: true, color: "cyan" }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16)), /* @__PURE__ */ React18.createElement(Text17, { color: "cyan" }, " ", spec.summary));
   }
-  return /* @__PURE__ */ React14.createElement(Box13, null, /* @__PURE__ */ React14.createElement(Text13, { dimColor: true }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16), " ", spec.summary));
+  return /* @__PURE__ */ React18.createElement(Box17, null, /* @__PURE__ */ React18.createElement(Text17, { dimColor: true }, marker, " ", name.padEnd(12), argsSuffix.padEnd(16), " ", spec.summary));
 }
 
 // src/cli/ui/StatsPanel.tsx
-import { Box as Box14, Text as Text14, useStdout as useStdout3 } from "ink";
-import React15 from "react";
+import { Box as Box18, Text as Text18, useStdout as useStdout3 } from "ink";
+import React19 from "react";
 var WORDMARK_STYLES = [
   { ch: "\u25C8", color: "#5eead4", isLogo: true },
   // teal — brand mark
@@ -8325,7 +9249,7 @@ function Wordmark({ busy }) {
   const tick = useTick();
   const period = busy ? 5 : 12;
   const bright = Math.floor(tick / period) % 2 === 0;
-  return /* @__PURE__ */ React15.createElement(Text14, null, WORDMARK_STYLES.map((c) => /* @__PURE__ */ React15.createElement(Text14, { key: `${c.ch}-${c.color}`, color: c.color, bold: c.isLogo ? bright : true }, c.ch)));
+  return /* @__PURE__ */ React19.createElement(Text18, null, WORDMARK_STYLES.map((c) => /* @__PURE__ */ React19.createElement(Text18, { key: `${c.ch}-${c.color}`, color: c.color, bold: c.isLogo ? bright : true }, c.ch)));
 }
 var NARROW_BREAKPOINT = 120;
 var COLD_START_TURNS = 3;
@@ -8351,7 +9275,7 @@ function StatsPanel({
   const columns = stdout2?.columns ?? 80;
   const narrow = columns < NARROW_BREAKPOINT;
   const coldStart = summary.turns <= COLD_START_TURNS;
-  return /* @__PURE__ */ React15.createElement(Box14, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React15.createElement(
+  return /* @__PURE__ */ React19.createElement(Box18, { borderStyle: "round", borderColor: "cyan", flexDirection: "column", paddingX: 1 }, /* @__PURE__ */ React19.createElement(
     Header,
     {
       model: model2,
@@ -8369,7 +9293,7 @@ function StatsPanel({
       proArmed: proArmed ?? false,
       escalated: escalated ?? false
     }
-  ), narrow ? /* @__PURE__ */ React15.createElement(
+  ), narrow ? /* @__PURE__ */ React19.createElement(
     StackedMetrics,
     {
       summary,
@@ -8378,7 +9302,7 @@ function StatsPanel({
       balance,
       coldStart
     }
-  ) : /* @__PURE__ */ React15.createElement(
+  ) : /* @__PURE__ */ React19.createElement(
     InlineMetrics,
     {
       summary,
@@ -8405,7 +9329,7 @@ function Header({
   proArmed,
   escalated
 }) {
-  return /* @__PURE__ */ React15.createElement(Box14, { justifyContent: "space-between" }, /* @__PURE__ */ React15.createElement(Box14, null, /* @__PURE__ */ React15.createElement(Wordmark, { busy }), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, ` v${VERSION}`), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React15.createElement(Text14, { color: "yellow" }, model2), narrow ? null : /* @__PURE__ */ React15.createElement(React15.Fragment, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, prefixHash)), harvestOn ? /* @__PURE__ */ React15.createElement(Text14, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React15.createElement(Text14, { color: "blue" }, " \xB7 branch", branchBudget) : null, reasoningEffort === "max" ? /* @__PURE__ */ React15.createElement(Text14, { color: "green" }, " \xB7 max") : null, reasoningEffort === "high" ? /* @__PURE__ */ React15.createElement(Text14, { color: "yellow" }, " \xB7 high") : null, planMode ? /* @__PURE__ */ React15.createElement(Text14, { color: "red", bold: true }, " \xB7 PLAN") : null, editMode ? /* @__PURE__ */ React15.createElement(Text14, { color: editMode === "auto" ? "magenta" : "cyan", bold: true }, editMode === "auto" ? " \xB7 AUTO" : " \xB7 review") : null, escalated ? /* @__PURE__ */ React15.createElement(Text14, { color: "red", bold: true }, " \xB7 \u21E7 pro escalated") : proArmed ? /* @__PURE__ */ React15.createElement(Text14, { color: "yellow", bold: true }, " \xB7 \u21E7 pro armed") : null), /* @__PURE__ */ React15.createElement(Text14, null, updateAvailable ? /* @__PURE__ */ React15.createElement(Text14, { color: "yellow", bold: true }, `update: ${updateAvailable} \xB7 `) : null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, narrow ? `turn ${turns}` : `turn ${turns} \xB7 /help`)));
+  return /* @__PURE__ */ React19.createElement(Box18, { justifyContent: "space-between" }, /* @__PURE__ */ React19.createElement(Box18, null, /* @__PURE__ */ React19.createElement(Wordmark, { busy }), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, ` v${VERSION}`), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React19.createElement(Text18, { color: "yellow" }, model2), narrow ? null : /* @__PURE__ */ React19.createElement(React19.Fragment, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, " \xB7 "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, prefixHash)), harvestOn ? /* @__PURE__ */ React19.createElement(Text18, { color: "magenta" }, " \xB7 harvest") : null, branchOn ? /* @__PURE__ */ React19.createElement(Text18, { color: "blue" }, " \xB7 branch", branchBudget) : null, reasoningEffort === "max" ? /* @__PURE__ */ React19.createElement(Text18, { color: "green" }, " \xB7 max") : null, reasoningEffort === "high" ? /* @__PURE__ */ React19.createElement(Text18, { color: "yellow" }, " \xB7 high") : null, planMode ? /* @__PURE__ */ React19.createElement(Text18, { color: "red", bold: true }, " \xB7 PLAN") : null, editMode ? /* @__PURE__ */ React19.createElement(Text18, { color: editMode === "auto" ? "magenta" : "cyan", bold: true }, editMode === "auto" ? " \xB7 AUTO" : " \xB7 review") : null, escalated ? /* @__PURE__ */ React19.createElement(Text18, { color: "red", bold: true }, " \xB7 \u21E7 pro escalated") : proArmed ? /* @__PURE__ */ React19.createElement(Text18, { color: "yellow", bold: true }, " \xB7 \u21E7 pro armed") : null), /* @__PURE__ */ React19.createElement(Text18, null, updateAvailable ? /* @__PURE__ */ React19.createElement(Text18, { color: "yellow", bold: true }, `update: ${updateAvailable} \xB7 `) : null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, narrow ? `turn ${turns}` : `turn ${turns} \xB7 /help`)));
 }
 function InlineMetrics({
   summary,
@@ -8414,7 +9338,7 @@ function InlineMetrics({
   balance,
   coldStart
 }) {
-  return /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React15.createElement(ContextCell, { ratio: ctxRatio, promptTokens: summary.lastPromptTokens, ctxMax }), /* @__PURE__ */ React15.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React15.createElement(CostCell, { summary, coldStart }), balance ? /* @__PURE__ */ React15.createElement(BalanceCell, { balance }) : null);
+  return /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React19.createElement(ContextCell, { ratio: ctxRatio, promptTokens: summary.lastPromptTokens, ctxMax }), /* @__PURE__ */ React19.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React19.createElement(CostCell, { summary, coldStart }), balance ? /* @__PURE__ */ React19.createElement(BalanceCell, { balance }) : null);
 }
 function StackedMetrics({
   summary,
@@ -8423,7 +9347,7 @@ function StackedMetrics({
   balance,
   coldStart
 }) {
-  return /* @__PURE__ */ React15.createElement(Box14, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React15.createElement(
+  return /* @__PURE__ */ React19.createElement(Box18, { marginTop: 1, flexDirection: "column" }, /* @__PURE__ */ React19.createElement(
     ContextCell,
     {
       ratio: ctxRatio,
@@ -8431,7 +9355,7 @@ function StackedMetrics({
       ctxMax,
       showBar: true
     }
-  ), balance ? /* @__PURE__ */ React15.createElement(BalanceCell, { balance }) : null, /* @__PURE__ */ React15.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React15.createElement(CostCell, { summary, coldStart }));
+  ), balance ? /* @__PURE__ */ React19.createElement(BalanceCell, { balance }) : null, /* @__PURE__ */ React19.createElement(CacheCell, { hitRatio: summary.cacheHitRatio, coldStart, turns: summary.turns }), /* @__PURE__ */ React19.createElement(CostCell, { summary, coldStart }));
 }
 function ContextCell({
   ratio,
@@ -8440,11 +9364,11 @@ function ContextCell({
   showBar
 }) {
   if (promptTokens === 0) {
-    return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "ctx "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "\u2014 (no turns yet)"));
+    return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "ctx "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "\u2014 (no turns yet)"));
   }
   const color = ratio >= 0.8 ? "red" : ratio >= 0.6 ? "yellow" : "green";
   const pct2 = Math.round(ratio * 100);
-  return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "ctx "), showBar ? /* @__PURE__ */ React15.createElement(Bar, { ratio, color }) : null, showBar ? /* @__PURE__ */ React15.createElement(Text14, null, " ") : null, /* @__PURE__ */ React15.createElement(Text14, { color, bold: true }, formatTokens(promptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " (", pct2, "%)"), ratio >= 0.8 ? /* @__PURE__ */ React15.createElement(Text14, { color: "red", bold: true }, "  \xB7  /compact") : null);
+  return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "ctx "), showBar ? /* @__PURE__ */ React19.createElement(Bar, { ratio, color }) : null, showBar ? /* @__PURE__ */ React19.createElement(Text18, null, " ") : null, /* @__PURE__ */ React19.createElement(Text18, { color, bold: true }, formatTokens(promptTokens), "/", formatTokens(ctxMax)), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, " (", pct2, "%)"), ratio >= 0.8 ? /* @__PURE__ */ React19.createElement(Text18, { color: "red", bold: true }, "  \xB7  /compact") : null);
 }
 function CacheCell({
   hitRatio,
@@ -8453,13 +9377,13 @@ function CacheCell({
 }) {
   const pct2 = (hitRatio * 100).toFixed(1);
   if (turns === 0) {
-    return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "cache "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "\u2014"));
+    return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "cache "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "\u2014"));
   }
   if (coldStart) {
-    return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "cache "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, pct2, "% "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true, italic: true }, "(cold start)"));
+    return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "cache "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, pct2, "% "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true, italic: true }, "(cold start)"));
   }
   const color = hitRatio >= 0.7 ? "green" : hitRatio >= 0.4 ? "yellow" : "red";
-  return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "cache "), /* @__PURE__ */ React15.createElement(Text14, { color, bold: true }, pct2, "%"));
+  return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "cache "), /* @__PURE__ */ React19.createElement(Text18, { color, bold: true }, pct2, "%"));
 }
 function turnCostColor(cost) {
   if (cost <= 0) return void 0;
@@ -8478,21 +9402,21 @@ function CostCell({
   coldStart
 }) {
   if (summary.turns === 0) {
-    return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "cost "), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "\u2014"));
+    return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "cost "), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "\u2014"));
   }
   const turnColor = coldStart ? void 0 : turnCostColor(summary.lastTurnCostUsd);
   const sessionColor = coldStart ? void 0 : sessionCostColor(summary.totalCostUsd);
-  return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "turn "), /* @__PURE__ */ React15.createElement(Text14, { color: turnColor, bold: !coldStart, dimColor: coldStart }, "$", summary.lastTurnCostUsd.toFixed(4)), /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, " \xB7 session "), /* @__PURE__ */ React15.createElement(Text14, { color: sessionColor, bold: !coldStart, dimColor: coldStart }, "$", summary.totalCostUsd.toFixed(4)));
+  return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "turn "), /* @__PURE__ */ React19.createElement(Text18, { color: turnColor, bold: !coldStart, dimColor: coldStart }, "$", summary.lastTurnCostUsd.toFixed(4)), /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, " \xB7 session "), /* @__PURE__ */ React19.createElement(Text18, { color: sessionColor, bold: !coldStart, dimColor: coldStart }, "$", summary.totalCostUsd.toFixed(4)));
 }
 function BalanceCell({ balance }) {
   const color = balance.total < 1 ? "red" : balance.total < 5 ? "yellow" : "green";
-  return /* @__PURE__ */ React15.createElement(Text14, null, /* @__PURE__ */ React15.createElement(Text14, { dimColor: true }, "balance "), /* @__PURE__ */ React15.createElement(Text14, { color, bold: true }, balance.currency === "USD" ? "$" : "", balance.total.toFixed(2), balance.currency !== "USD" ? ` ${balance.currency}` : ""));
+  return /* @__PURE__ */ React19.createElement(Text18, null, /* @__PURE__ */ React19.createElement(Text18, { dimColor: true }, "balance "), /* @__PURE__ */ React19.createElement(Text18, { color, bold: true }, balance.currency === "USD" ? "$" : "", balance.total.toFixed(2), balance.currency !== "USD" ? ` ${balance.currency}` : ""));
 }
 function Bar({ ratio, color }) {
   const cells = 10;
   const filled = Math.max(0, Math.min(cells, Math.round(ratio * cells)));
   const bar = "\u2588".repeat(filled) + "\u2591".repeat(cells - filled);
-  return /* @__PURE__ */ React15.createElement(Text14, { color }, bar);
+  return /* @__PURE__ */ React19.createElement(Text18, { color }, bar);
 }
 function formatTokens(n) {
   if (n < 1024) return String(n);
@@ -8738,7 +9662,7 @@ function formatLongPaste(input, opts = {}) {
   if (originalChars <= charCap && originalLines <= lineCap) {
     return { displayText: input, collapsed: false, originalChars, originalLines };
   }
-  const header2 = `\u25B8 pasted ${formatBytes(originalChars)} (${originalLines} lines) \u2014 first ${Math.min(headN, originalLines)} shown, full text sent to model`;
+  const header2 = `\u25B8 pasted ${formatBytes2(originalChars)} (${originalLines} lines) \u2014 first ${Math.min(headN, originalLines)} shown, full text sent to model`;
   const head = lines.slice(0, headN).join("\n");
   const remaining = originalLines - headN;
   const footer = remaining > 0 ? `\u2026 (${remaining} more line${remaining === 1 ? "" : "s"})` : "";
@@ -8748,7 +9672,7 @@ ${footer}` : `${header2}
 ${head}`;
   return { displayText, collapsed: true, originalChars, originalLines };
 }
-function formatBytes(n) {
+function formatBytes2(n) {
   if (n < 1024) return `${n} B`;
   const kb = n / 1024;
   if (kb < 1024) return `${kb.toFixed(kb >= 10 ? 0 : 1)} KB`;
@@ -8846,6 +9770,12 @@ var SLASH_COMMANDS = [
     summary: "shrink oversized tool results AND tool-call args (edit_file search/replace) in the log; cap in tokens, default 4000"
   },
   { cmd: "keys", summary: "show all keyboard shortcuts and prompt prefixes" },
+  { cmd: "plans", summary: "list this session's active + archived plans, newest first" },
+  {
+    cmd: "replay",
+    summary: "load an archived plan as a read-only Time Travel snapshot (default: newest)",
+    argsHint: "[N]"
+  },
   { cmd: "sessions", summary: "list saved sessions (current marked with \u25B8)" },
   { cmd: "forget", summary: "delete the current session from disk" },
   { cmd: "setup", summary: "reminds you to exit and run `reasonix setup`" },
@@ -8943,7 +9873,7 @@ function parseSlash(text) {
 }
 
 // src/cli/commands/stats.ts
-import { existsSync as existsSync10, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync14 } from "fs";
 function statsCommand(opts) {
   if (opts.transcript) {
     transcriptSummary(opts.transcript);
@@ -8952,11 +9882,11 @@ function statsCommand(opts) {
   dashboard(opts);
 }
 function transcriptSummary(path) {
-  if (!existsSync10(path)) {
+  if (!existsSync11(path)) {
     console.error(`no such transcript: ${path}`);
     process.exit(1);
   }
-  const lines = readFileSync13(path, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = readFileSync14(path, "utf8").split(/\r?\n/).filter(Boolean);
   let assistantTurns = 0;
   let toolCalls = 0;
   let lastTurn = 0;
@@ -9800,7 +10730,7 @@ var model = (args, loop, ctx) => {
   const id = args[0];
   const known = ctx.models ?? null;
   if (!id) {
-    const hint = known && known.length > 0 ? known.join(" | ") : "try deepseek-chat or deepseek-reasoner \u2014 run /models to fetch the live list";
+    const hint = known && known.length > 0 ? known.join(" | ") : "try deepseek-v4-flash or deepseek-v4-pro \u2014 run /models to fetch the live list";
     return { info: `usage: /model <id>   (${hint})` };
   }
   loop.configure({ model: id });
@@ -9961,7 +10891,7 @@ var think = (_args, loop) => {
   const raw = loop.scratch.reasoning;
   if (!raw || !raw.trim()) {
     return {
-      info: "no reasoning cached. `/think` shows the full R1 thought for the most recent turn \u2014 only `deepseek-reasoner` produces it, and only once the turn completes."
+      info: "no reasoning cached. `/think` shows the full thinking-mode thought for the most recent turn \u2014 only thinking-mode models (deepseek-v4-flash / -v4-pro / -reasoner) produce it, and only once the turn completes."
     };
   }
   return { info: `\u21B3 full thinking (${raw.length} chars):
@@ -10108,6 +11038,90 @@ var handlers8 = {
   compact
 };
 
+// src/cli/ui/slash/handlers/plans.ts
+import { basename } from "path";
+var plans = (_args, loop) => {
+  const sessionName = loop.sessionName;
+  if (!sessionName) {
+    return {
+      info: "no session attached \u2014 `/plans` is per-session. Run `reasonix code` in a project to get a session."
+    };
+  }
+  const lines = [];
+  const active = loadPlanState(sessionName);
+  if (active && active.steps.length > 0) {
+    const total = active.steps.length;
+    const done = active.completedStepIds.length;
+    const when = relativeTime(active.updatedAt);
+    const label = active.summary ? `: ${active.summary}` : "";
+    lines.push(
+      `\u25B8 active plan${label} \u2014 ${done}/${total} step${total === 1 ? "" : "s"} done \xB7 last touched ${when}`
+    );
+  } else {
+    lines.push("\u25B8 active plan: (none)");
+  }
+  const archives = listPlanArchives(sessionName);
+  if (archives.length === 0) {
+    lines.push("");
+    lines.push(
+      "no archived plans yet for this session \u2014 they auto-archive when every step is done"
+    );
+    return { info: lines.join("\n") };
+  }
+  lines.push("");
+  lines.push(`Archived (${archives.length}):`);
+  for (const a of archives) {
+    const when = relativeTime(a.completedAt);
+    const total = a.steps.length;
+    const done = a.completedStepIds.length;
+    const completion = done >= total ? "complete" : `${done}/${total}`;
+    const label = a.summary ?? a.path.split(/[\\/]/).pop() ?? a.path;
+    lines.push(
+      `  \u2713 ${when.padEnd(10)}  ${total} step${total === 1 ? "" : "s"} \xB7 ${completion}  ${label}`
+    );
+  }
+  return { info: lines.join("\n") };
+};
+var replay = (args, loop) => {
+  const sessionName = loop.sessionName;
+  if (!sessionName) {
+    return {
+      info: "no session attached \u2014 `/replay` is per-session. Run `reasonix code` in a project to get a session."
+    };
+  }
+  const archives = listPlanArchives(sessionName);
+  if (archives.length === 0) {
+    return {
+      info: "no archived plans yet for this session \u2014 `/replay` lights up once a plan completes (auto-archives when every step is done)."
+    };
+  }
+  const arg = args[0]?.trim() ?? "";
+  const index = arg ? Number.parseInt(arg, 10) : 1;
+  if (!Number.isFinite(index) || index < 1 || index > archives.length) {
+    return {
+      info: `invalid index \u2014 \`/replay\` takes 1..${archives.length} (newest = 1). Use \`/plans\` to see the list.`
+    };
+  }
+  const a = archives[index - 1];
+  return {
+    replayPlan: {
+      summary: a.summary,
+      body: a.body,
+      steps: a.steps,
+      completedStepIds: a.completedStepIds,
+      completedAt: a.completedAt,
+      relativeTime: relativeTime(a.completedAt),
+      archiveBasename: basename(a.path),
+      index,
+      total: archives.length
+    }
+  };
+};
+var handlers9 = {
+  plans,
+  replay
+};
+
 // src/cli/ui/slash/handlers/sessions.ts
 var sessions = (_args, loop) => {
   const items = listSessions();
@@ -10139,7 +11153,7 @@ var forget = (_args, loop) => {
     info: ok ? `\u25B8 deleted session "${name}" \u2014 current screen still shows the conversation, but next launch starts fresh` : `could not delete session "${name}" (already gone?)`
   };
 };
-var handlers9 = {
+var handlers10 = {
   sessions,
   forget
 };
@@ -10215,7 +11229,7 @@ ${found.body}${argsLine}`;
     resubmit: payload
   };
 };
-var handlers10 = {
+var handlers11 = {
   skill,
   skills: skill
 };
@@ -10231,7 +11245,8 @@ var HANDLERS = {
   ...handlers7,
   ...handlers8,
   ...handlers9,
-  ...handlers10
+  ...handlers10,
+  ...handlers11
 };
 function handleSlash(cmd, args, loop, ctx = {}) {
   const h = HANDLERS[cmd];
@@ -10788,6 +11803,11 @@ function App({
   const [pendingShell, setPendingShell] = useState10(null);
   const [pendingPlan, setPendingPlan] = useState10(null);
   const [stagedInput, setStagedInput] = useState10(null);
+  const [pendingCheckpoint, setPendingCheckpoint] = useState10(null);
+  const [stagedCheckpointRevise, setStagedCheckpointRevise] = useState10(null);
+  const [pendingRevision, setPendingRevision] = useState10(null);
+  const [pendingChoice, setPendingChoice] = useState10(null);
+  const [stagedChoiceCustom, setStagedChoiceCustom] = useState10(null);
   const [planMode, setPlanMode] = useState10(false);
   const [proArmed, setProArmed] = useState10(false);
   const [turnOnPro, setTurnOnPro] = useState10(false);
@@ -10796,6 +11816,23 @@ function App({
   const historyCursor = useRef5(-1);
   const assistantIterCounter = useRef5(0);
   const toolHistoryRef = useRef5([]);
+  const planStepsRef = useRef5(null);
+  const completedStepIdsRef = useRef5(/* @__PURE__ */ new Set());
+  const planBodyRef = useRef5(null);
+  const planSummaryRef = useRef5(null);
+  const toolStartedAtRef = useRef5(null);
+  const persistPlanState = useCallback4(() => {
+    if (!session) return;
+    const steps = planStepsRef.current;
+    if (!steps || steps.length === 0) {
+      clearPlanState(session);
+      return;
+    }
+    const extras = {};
+    if (planBodyRef.current) extras.body = planBodyRef.current;
+    if (planSummaryRef.current) extras.summary = planSummaryRef.current;
+    savePlanState(session, steps, completedStepIdsRef.current, extras);
+  }, [session]);
   const [summary, setSummary] = useState10({
     turns: 0,
     totalCostUsd: 0,
@@ -10958,6 +11995,30 @@ function App({
         ]);
       }
     }
+    if (session) {
+      const restoredPlan = loadPlanState(session);
+      if (restoredPlan && restoredPlan.steps.length > 0) {
+        planStepsRef.current = restoredPlan.steps;
+        completedStepIdsRef.current = new Set(restoredPlan.completedStepIds);
+        planBodyRef.current = restoredPlan.body ?? null;
+        planSummaryRef.current = restoredPlan.summary ?? null;
+        const when = relativeTime(restoredPlan.updatedAt);
+        setHistorical((prev) => [
+          ...prev,
+          {
+            id: `sys-plan-${Date.now()}`,
+            role: "plan-resumed",
+            text: "",
+            resumedPlan: {
+              steps: restoredPlan.steps,
+              completedStepIds: restoredPlan.completedStepIds,
+              relativeTime: when,
+              summary: restoredPlan.summary
+            }
+          }
+        ]);
+      }
+    }
     if (codeMode && !editModeHintShown()) {
       setHistorical((prev) => [
         ...prev,
@@ -10983,7 +12044,7 @@ function App({
       loop.abort();
       return;
     }
-    if (codeMode && key.shift && key.tab && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview) {
+    if (codeMode && key.shift && key.tab && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && !pendingChoice && !stagedChoiceCustom && !pendingRevision) {
       setEditMode((m) => {
         const next = m === "auto" ? "review" : "auto";
         setHistorical((prev) => [
@@ -10998,7 +12059,7 @@ function App({
       });
       return;
     }
-    if (codeMode && input.length === 0 && (chKey === "u" || chKey === "U") && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && // Fire when EITHER the banner is up OR there's any non-undone
+    if (codeMode && input.length === 0 && (chKey === "u" || chKey === "U") && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && !pendingChoice && !stagedChoiceCustom && !pendingRevision && // Fire when EITHER the banner is up OR there's any non-undone
     // history entry — the keybind is useful long after the 5-second
     // banner expires, which users rightly want.
     (undoBanner || hasUndoable())) {
@@ -11364,6 +12425,27 @@ function App({
             }
           ]);
         }
+        if (result.replayPlan) {
+          const rp = result.replayPlan;
+          setHistorical((prev) => [
+            ...prev,
+            {
+              id: `replay-${Date.now()}-${Math.random()}`,
+              role: "plan-replay",
+              text: "",
+              replayPlan: {
+                summary: rp.summary,
+                body: rp.body,
+                steps: rp.steps,
+                completedStepIds: rp.completedStepIds,
+                relativeTime: rp.relativeTime,
+                archiveBasename: rp.archiveBasename,
+                index: rp.index,
+                total: rp.total
+              }
+            }
+          ]);
+        }
         if (result.resubmit) {
           text = result.resubmit;
         } else {
@@ -11570,6 +12652,7 @@ function App({
           } else if (ev.role === "tool_start") {
             setOngoingTool({ name: ev.toolName ?? "?", args: ev.toolArgs });
             setToolProgress(null);
+            toolStartedAtRef.current = Date.now();
             if (codeMode && ev.toolArgs) {
               try {
                 const parsed = JSON.parse(ev.toolArgs);
@@ -11587,19 +12670,28 @@ function App({
             flush();
             setOngoingTool(null);
             setToolProgress(null);
-            toolHistoryRef.current.push({
-              toolName: ev.toolName ?? "?",
-              text: ev.content
-            });
-            setHistorical((prev) => [
-              ...prev,
-              {
-                id: `t-${Date.now()}-${Math.random()}`,
-                role: "tool",
-                text: ev.content,
-                toolName: ev.toolName
-              }
-            ]);
+            const isStepProgressTool = ev.toolName === "mark_step_complete";
+            const startedAt = toolStartedAtRef.current;
+            const durationMs = startedAt !== null ? Date.now() - startedAt : void 0;
+            toolStartedAtRef.current = null;
+            if (!isStepProgressTool) {
+              toolHistoryRef.current.push({
+                toolName: ev.toolName ?? "?",
+                text: ev.content
+              });
+              const toolIndex = toolHistoryRef.current.length;
+              setHistorical((prev) => [
+                ...prev,
+                {
+                  id: `t-${Date.now()}-${Math.random()}`,
+                  role: "tool",
+                  text: ev.content,
+                  toolName: ev.toolName,
+                  toolIndex,
+                  durationMs
+                }
+              ]);
+            }
             if (codeMode && (ev.toolName === "run_command" || ev.toolName === "run_background") && ev.content.includes('"NeedsConfirmationError:') && ev.toolArgs) {
               try {
                 const parsed = JSON.parse(ev.toolArgs);
@@ -11618,6 +12710,12 @@ function App({
                 if (typeof parsed.plan === "string" && parsed.plan.trim()) {
                   const planText = parsed.plan.trim();
                   setPendingPlan(planText);
+                  const steps = Array.isArray(parsed.steps) ? parsed.steps : null;
+                  planStepsRef.current = steps;
+                  completedStepIdsRef.current = /* @__PURE__ */ new Set();
+                  planBodyRef.current = planText;
+                  planSummaryRef.current = typeof parsed.summary === "string" && parsed.summary.trim() ? parsed.summary.trim() : null;
+                  persistPlanState();
                   setHistorical((prev) => [
                     ...prev,
                     {
@@ -11630,6 +12728,85 @@ function App({
               } catch {
               }
             }
+            if (ev.toolName === "revise_plan" && ev.content.includes('"PlanRevisionProposedError:')) {
+              try {
+                const parsed = JSON.parse(ev.content);
+                const reason = typeof parsed.reason === "string" ? parsed.reason.trim() : "";
+                const remainingSteps = Array.isArray(parsed.remainingSteps) ? parsed.remainingSteps.filter(
+                  (s) => s && typeof s.id === "string" && s.id.trim() && typeof s.title === "string" && s.title.trim() && typeof s.action === "string" && s.action.trim()
+                ) : [];
+                if (reason && remainingSteps.length > 0) {
+                  const summary2 = typeof parsed.summary === "string" ? parsed.summary.trim() || void 0 : void 0;
+                  setPendingRevision({ reason, remainingSteps, summary: summary2 });
+                }
+              } catch {
+              }
+            }
+            if (ev.toolName === "ask_choice" && ev.content.includes('"ChoiceRequestedError:')) {
+              try {
+                const parsed = JSON.parse(ev.content);
+                const question = typeof parsed.question === "string" ? parsed.question.trim() : "";
+                const options = Array.isArray(parsed.options) ? parsed.options.filter(
+                  (o) => o && typeof o.id === "string" && o.id.trim() && typeof o.title === "string" && o.title.trim()
+                ) : [];
+                if (question && options.length >= 2) {
+                  setPendingChoice({
+                    question,
+                    options,
+                    allowCustom: parsed.allowCustom === true
+                  });
+                }
+              } catch {
+              }
+            }
+            if (ev.toolName === "mark_step_complete") {
+              try {
+                const parsed = JSON.parse(ev.content);
+                const stepId = parsed.stepId;
+                if (parsed.kind === "step_completed" && typeof stepId === "string") {
+                  completedStepIdsRef.current.add(stepId);
+                  persistPlanState();
+                  const total = planStepsRef.current?.length ?? 0;
+                  const completed = completedStepIdsRef.current.size;
+                  const stepFromPlan = planStepsRef.current?.find((s) => s.id === stepId);
+                  const title = parsed.title ?? stepFromPlan?.title;
+                  const result = typeof parsed.result === "string" ? parsed.result : "";
+                  const notes = parsed.notes;
+                  setHistorical((prev) => [
+                    ...prev,
+                    {
+                      id: `step-${stepId}-${Date.now()}-${Math.random()}`,
+                      role: "step-progress",
+                      text: result,
+                      stepProgress: {
+                        stepId,
+                        title,
+                        completed,
+                        total,
+                        notes
+                      }
+                    }
+                  ]);
+                  if (session && total > 0 && completed >= total) {
+                    const archive = archivePlanState(session);
+                    if (archive) {
+                      setHistorical((prev) => [
+                        ...prev,
+                        {
+                          id: `plan-archived-${Date.now()}`,
+                          role: "info",
+                          text: `\u25B8 plan complete \u2014 all ${total} step${total === 1 ? "" : "s"} done \xB7 archived`
+                        }
+                      ]);
+                    }
+                  }
+                  if (typeof parsed.error === "string" && parsed.error.startsWith("PlanCheckpointError:")) {
+                    setPendingCheckpoint({ stepId, title, completed, total });
+                  }
+                }
+              } catch {
+              }
+            }
           } else if (ev.role === "error") {
             setHistorical((prev) => [
               ...prev,
@@ -11717,7 +12894,8 @@ function App({
       refreshBalance,
       refreshLatestVersion,
       refreshModels,
-      proArmed
+      proArmed,
+      persistPlanState
     ]
   );
   const handleShellConfirm = useCallback4(
@@ -11840,6 +13018,11 @@ ${body}`;
         return;
       }
       setPendingPlan(null);
+      planStepsRef.current = null;
+      completedStepIdsRef.current = /* @__PURE__ */ new Set();
+      planBodyRef.current = null;
+      planSummaryRef.current = null;
+      persistPlanState();
       togglePlanMode(false);
       const marker = "\u25B8 plan cancelled";
       const synthetic = "The plan was cancelled. Drop it entirely. Ask me what I actually want before proposing another plan or making any changes.";
@@ -11854,7 +13037,7 @@ ${body}`;
         await handleSubmit(synthetic);
       }
     },
-    [pendingPlan, togglePlanMode, busy, loop, handleSubmit]
+    [pendingPlan, togglePlanMode, busy, loop, handleSubmit, persistPlanState]
   );
   const handlePlanConfirmRef = useRef5(handlePlanConfirm);
   useEffect5(() => {
@@ -11917,104 +13100,364 @@ Stay in plan mode \u2014 address the feedback (explore more if needed), then sub
     if (stagedInput?.plan) setPendingPlan(stagedInput.plan);
     setStagedInput(null);
   }, [stagedInput]);
-  return /* @__PURE__ */ React16.createElement(TickerProvider, { disabled: PLAIN_UI || !!pendingPlan || !!pendingShell || !!pendingEditReview }, /* @__PURE__ */ React16.createElement(Box15, { flexDirection: "column" }, /* @__PURE__ */ React16.createElement(
-    StatsPanel,
-    {
-      summary,
-      model: loop.model,
-      prefixHash,
-      harvestOn: loop.harvestEnabled,
-      branchBudget: loop.branchOptions.budget,
-      reasoningEffort: loop.reasoningEffort,
-      planMode,
-      editMode: codeMode ? editMode : void 0,
-      balance,
-      busy,
-      updateAvailable,
-      proArmed,
-      escalated: turnOnPro
-    }
-  ), /* @__PURE__ */ React16.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React16.createElement(EventRow, { key: item.id, event: item, projectRoot: hookCwd })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && streaming ? /* @__PURE__ */ React16.createElement(Box15, { marginY: 1 }, /* @__PURE__ */ React16.createElement(EventRow, { event: streaming, projectRoot: hookCwd })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && ongoingTool ? /* @__PURE__ */ React16.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && subagentActivity ? /* @__PURE__ */ React16.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !ongoingTool && statusLine ? /* @__PURE__ */ React16.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && undoBanner && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview ? /* @__PURE__ */ React16.createElement(UndoBanner, { banner: undoBanner }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React16.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React16.createElement(
-    PlanRefineInput,
-    {
-      mode: stagedInput.mode,
-      onSubmit: handleStagedInputSubmit,
-      onCancel: handleStagedInputCancel
-    }
-  ) : pendingPlan ? /* @__PURE__ */ React16.createElement(
-    PlanConfirm,
-    {
-      plan: pendingPlan,
-      onChoose: stableHandlePlanConfirm,
-      projectRoot: hookCwd
-    }
-  ) : pendingShell ? /* @__PURE__ */ React16.createElement(
-    ShellConfirm,
-    {
-      command: pendingShell.command,
-      allowPrefix: derivePrefix(pendingShell.command),
-      kind: pendingShell.kind,
-      onChoose: handleShellConfirm
-    }
-  ) : pendingEditReview ? /* @__PURE__ */ React16.createElement(
-    EditConfirm,
-    {
-      block: pendingEditReview,
-      onChoose: (choice) => {
-        const resolve8 = editReviewResolveRef.current;
-        if (resolve8) {
-          editReviewResolveRef.current = null;
-          resolve8(choice);
+  const handleCheckpointConfirm = useCallback4(
+    async (choice) => {
+      const snap = pendingCheckpoint;
+      if (!snap) return;
+      setPendingCheckpoint(null);
+      if (choice === "revise") {
+        setStagedCheckpointRevise(snap);
+        return;
+      }
+      const label = snap.title ? `${snap.stepId} \xB7 ${snap.title}` : snap.stepId;
+      const counter = snap.total > 0 ? ` (${snap.completed}/${snap.total})` : "";
+      const { marker, synthetic } = choice === "continue" ? {
+        marker: `\u25B8 continuing after ${label}${counter}`,
+        synthetic: `Step ${label} is complete. Proceed with the next step of the approved plan. If no steps remain, summarize the whole run.`
+      } : {
+        marker: `\u25B8 plan stopped at ${label}${counter}`,
+        synthetic: `The user stopped the plan after step ${label}. Do not run any more steps and do not call any tools. Write a short summary of what was completed across all finished steps and what's left unfinished.`
+      };
+      setHistorical((prev) => [
+        ...prev,
+        { id: `cp-${choice}-${Date.now()}`, role: "info", text: marker }
+      ]);
+      if (busy) {
+        loop.abort();
+        setQueuedSubmit(synthetic);
+      } else {
+        await handleSubmit(synthetic);
+      }
+    },
+    [pendingCheckpoint, busy, loop, handleSubmit]
+  );
+  const handleCheckpointConfirmRef = useRef5(handleCheckpointConfirm);
+  useEffect5(() => {
+    handleCheckpointConfirmRef.current = handleCheckpointConfirm;
+  }, [handleCheckpointConfirm]);
+  const stableHandleCheckpointConfirm = useCallback4(
+    async (choice) => handleCheckpointConfirmRef.current(choice),
+    []
+  );
+  const handleCheckpointReviseSubmit = useCallback4(
+    async (feedback) => {
+      const snap = stagedCheckpointRevise;
+      setStagedCheckpointRevise(null);
+      if (!snap) return;
+      const label = snap.title ? `${snap.stepId} \xB7 ${snap.title}` : snap.stepId;
+      const trimmed = feedback.trim();
+      const synthetic = trimmed ? `Step ${label} is complete. Before running the next step, adjust based on this user feedback:
+
+${trimmed}
+
+If the feedback only tweaks how you execute (extra constraints, style preferences), continue with the updated guidance. If it changes which steps run (skip a step, swap two steps, add a new step), call \`revise_plan\` with the updated remainingSteps \u2014 that pops a diff picker the user can accept or reject. Only call submit_plan again if the entire approach has fundamentally changed.` : `Step ${label} is complete. Continue with the current plan.`;
+      const marker = trimmed ? `\u25B8 revising after ${label} \u2014 ${trimmed.length > 50 ? `${trimmed.slice(0, 50)}\u2026` : trimmed}` : `\u25B8 continuing after ${label}`;
+      setHistorical((prev) => [
+        ...prev,
+        { id: `cp-revise-${Date.now()}`, role: "info", text: marker }
+      ]);
+      if (busy) {
+        loop.abort();
+        setQueuedSubmit(synthetic);
+      } else {
+        await handleSubmit(synthetic);
+      }
+    },
+    [stagedCheckpointRevise, busy, loop, handleSubmit]
+  );
+  const handleCheckpointReviseCancel = useCallback4(() => {
+    const snap = stagedCheckpointRevise;
+    setStagedCheckpointRevise(null);
+    if (snap) setPendingCheckpoint(snap);
+  }, [stagedCheckpointRevise]);
+  const handleChoiceConfirm = useCallback4(
+    async (choice) => {
+      const snap = pendingChoice;
+      if (!snap) return;
+      setPendingChoice(null);
+      if (choice.kind === "custom") {
+        setStagedChoiceCustom(snap);
+        return;
+      }
+      if (choice.kind === "cancel") {
+        const synthetic2 = "The user cancelled the choice. Don't act on any of the options you presented. Ask what they actually want before doing anything else.";
+        setHistorical((prev) => [
+          ...prev,
+          { id: `choice-cancel-${Date.now()}`, role: "info", text: "\u25B8 choice cancelled" }
+        ]);
+        if (busy) {
+          loop.abort();
+          setQueuedSubmit(synthetic2);
+        } else {
+          await handleSubmit(synthetic2);
         }
+        return;
       }
-    }
-  ) : /* @__PURE__ */ React16.createElement(React16.Fragment, null, codeMode ? /* @__PURE__ */ React16.createElement(
-    ModeStatusBar,
-    {
-      editMode,
-      pendingCount,
-      flash: modeFlash,
-      planMode,
-      undoArmed: !!undoBanner || hasUndoable(),
-      jobs: codeMode.jobs
-    }
-  ) : null, /* @__PURE__ */ React16.createElement(
-    PromptInput,
-    {
-      value: input,
-      onChange: setInput,
-      onSubmit: handleSubmit,
-      disabled: busy
-    }
-  ), /* @__PURE__ */ React16.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }), /* @__PURE__ */ React16.createElement(
-    AtMentionSuggestions,
-    {
-      matches: atMatches,
-      selectedIndex: atSelected,
-      query: atPicker?.query ?? ""
-    }
-  ), slashArgContext ? /* @__PURE__ */ React16.createElement(
-    SlashArgPicker,
+      const picked = snap.options.find((o) => o.id === choice.optionId);
+      const label = picked ? `${picked.id} \xB7 ${picked.title}` : choice.optionId;
+      const synthetic = `The user picked option ${choice.optionId}${picked ? ` ("${picked.title}")` : ""}. Proceed with that branch. Do not re-ask the same question.`;
+      setHistorical((prev) => [
+        ...prev,
+        { id: `choice-pick-${Date.now()}`, role: "info", text: `\u25B8 chose ${label}` }
+      ]);
+      if (busy) {
+        loop.abort();
+        setQueuedSubmit(synthetic);
+      } else {
+        await handleSubmit(synthetic);
+      }
+    },
+    [pendingChoice, busy, loop, handleSubmit]
+  );
+  const handleChoiceConfirmRef = useRef5(handleChoiceConfirm);
+  useEffect5(() => {
+    handleChoiceConfirmRef.current = handleChoiceConfirm;
+  }, [handleChoiceConfirm]);
+  const stableHandleChoiceConfirm = useCallback4(
+    async (choice) => handleChoiceConfirmRef.current(choice),
+    []
+  );
+  const handleChoiceCustomSubmit = useCallback4(
+    async (answer) => {
+      setStagedChoiceCustom(null);
+      const trimmed = answer.trim();
+      const synthetic = trimmed ? `The user answered with a custom reply (none of the pre-defined options fit):
+
+${trimmed}
+
+Read it carefully and proceed \u2014 don't snap back to the options you listed unless the user's reply clearly maps to one.` : "The user pressed Enter without typing anything. Ask what they actually want.";
+      const marker = trimmed ? `\u25B8 custom answer \u2014 ${trimmed.length > 50 ? `${trimmed.slice(0, 50)}\u2026` : trimmed}` : "\u25B8 custom answer \u2014 (blank)";
+      setHistorical((prev) => [
+        ...prev,
+        { id: `choice-custom-${Date.now()}`, role: "info", text: marker }
+      ]);
+      if (busy) {
+        loop.abort();
+        setQueuedSubmit(synthetic);
+      } else {
+        await handleSubmit(synthetic);
+      }
+    },
+    [busy, loop, handleSubmit]
+  );
+  const handleChoiceCustomCancel = useCallback4(() => {
+    const snap = stagedChoiceCustom;
+    setStagedChoiceCustom(null);
+    if (snap) setPendingChoice(snap);
+  }, [stagedChoiceCustom]);
+  const handleReviseConfirm = useCallback4(
+    async (choice) => {
+      const snap = pendingRevision;
+      if (!snap) return;
+      setPendingRevision(null);
+      if (choice === "reject") {
+        const synthetic2 = "The user rejected the proposed plan revision. Don't apply it. Continue executing the original plan from the next pending step. If you genuinely cannot proceed without the change, stop and explain in plain text why.";
+        setHistorical((prev) => [
+          ...prev,
+          { id: `revise-reject-${Date.now()}`, role: "info", text: "\u25B8 revision rejected" }
+        ]);
+        if (busy) {
+          loop.abort();
+          setQueuedSubmit(synthetic2);
+        } else {
+          await handleSubmit(synthetic2);
+        }
+        return;
+      }
+      const completed = completedStepIdsRef.current;
+      const oldSteps = planStepsRef.current ?? [];
+      const donePrefix = oldSteps.filter((s) => completed.has(s.id));
+      const merged = [...donePrefix];
+      for (const s of snap.remainingSteps) {
+        if (completed.has(s.id)) continue;
+        merged.push(s);
+      }
+      planStepsRef.current = merged;
+      persistPlanState();
+      const removedCount = oldSteps.filter(
+        (s) => !completed.has(s.id) && !snap.remainingSteps.some((n) => n.id === s.id)
+      ).length;
+      const addedCount = snap.remainingSteps.filter(
+        (s) => !oldSteps.some((o) => o.id === s.id)
+      ).length;
+      const marker = `\u25B8 revision accepted \u2014 \u2212${removedCount} +${addedCount}: ${snap.reason}`;
+      setHistorical((prev) => [
+        ...prev,
+        { id: `revise-accept-${Date.now()}`, role: "info", text: marker }
+      ]);
+      const synthetic = `Revision accepted. The remaining plan is now:
+${snap.remainingSteps.map((s, i) => `  ${i + 1}. ${s.id} \xB7 ${s.title} \u2014 ${s.action}`).join(
+        "\n"
+      )}
+
+Continue executing from the next pending step. Call mark_step_complete after each one as before.`;
+      if (busy) {
+        loop.abort();
+        setQueuedSubmit(synthetic);
+      } else {
+        await handleSubmit(synthetic);
+      }
+    },
+    [pendingRevision, busy, loop, handleSubmit, persistPlanState]
+  );
+  const handleReviseConfirmRef = useRef5(handleReviseConfirm);
+  useEffect5(() => {
+    handleReviseConfirmRef.current = handleReviseConfirm;
+  }, [handleReviseConfirm]);
+  const stableHandleReviseConfirm = useCallback4(
+    async (choice) => handleReviseConfirmRef.current(choice),
+    []
+  );
+  return /* @__PURE__ */ React20.createElement(
+    TickerProvider,
     {
-      matches: slashArgMatches,
-      selectedIndex: slashArgSelected,
-      spec: slashArgContext.spec,
-      kind: slashArgContext.kind,
-      partial: slashArgContext.partial
-    }
-  ) : null)));
+      disabled: PLAIN_UI || !!pendingPlan || !!pendingShell || !!pendingEditReview || !!pendingCheckpoint || !!stagedCheckpointRevise || !!pendingChoice || !!stagedChoiceCustom || !!pendingRevision
+    },
+    /* @__PURE__ */ React20.createElement(Box19, { flexDirection: "column" }, /* @__PURE__ */ React20.createElement(
+      StatsPanel,
+      {
+        summary,
+        model: loop.model,
+        prefixHash,
+        harvestOn: loop.harvestEnabled,
+        branchBudget: loop.branchOptions.budget,
+        reasoningEffort: loop.reasoningEffort,
+        planMode,
+        editMode: codeMode ? editMode : void 0,
+        balance,
+        busy,
+        updateAvailable,
+        proArmed,
+        escalated: turnOnPro
+      }
+    ), /* @__PURE__ */ React20.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React20.createElement(EventRow, { key: item.id, event: item, projectRoot: hookCwd })), !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && streaming ? /* @__PURE__ */ React20.createElement(Box19, { marginY: 1 }, /* @__PURE__ */ React20.createElement(EventRow, { event: streaming, projectRoot: hookCwd })) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && ongoingTool ? /* @__PURE__ */ React20.createElement(OngoingToolRow, { tool: ongoingTool, progress: toolProgress }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && subagentActivity ? /* @__PURE__ */ React20.createElement(SubagentRow, { activity: subagentActivity }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && !ongoingTool && statusLine ? /* @__PURE__ */ React20.createElement(StatusRow, { text: statusLine }) : null, !PLAIN_UI && undoBanner && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && !pendingChoice && !stagedChoiceCustom && !pendingRevision ? /* @__PURE__ */ React20.createElement(UndoBanner, { banner: undoBanner }) : null, !PLAIN_UI && !pendingShell && !pendingPlan && !stagedInput && !pendingEditReview && !pendingCheckpoint && !stagedCheckpointRevise && busy && !streaming && !ongoingTool && !statusLine ? /* @__PURE__ */ React20.createElement(StatusRow, { text: "processing\u2026" }) : null, stagedInput ? /* @__PURE__ */ React20.createElement(
+      PlanRefineInput,
+      {
+        mode: stagedInput.mode,
+        onSubmit: handleStagedInputSubmit,
+        onCancel: handleStagedInputCancel
+      }
+    ) : stagedCheckpointRevise ? /* @__PURE__ */ React20.createElement(
+      PlanRefineInput,
+      {
+        mode: "checkpoint-revise",
+        onSubmit: handleCheckpointReviseSubmit,
+        onCancel: handleCheckpointReviseCancel
+      }
+    ) : stagedChoiceCustom ? /* @__PURE__ */ React20.createElement(
+      PlanRefineInput,
+      {
+        mode: "choice-custom",
+        onSubmit: handleChoiceCustomSubmit,
+        onCancel: handleChoiceCustomCancel
+      }
+    ) : pendingChoice ? /* @__PURE__ */ React20.createElement(
+      ChoiceConfirm,
+      {
+        question: pendingChoice.question,
+        options: pendingChoice.options,
+        allowCustom: pendingChoice.allowCustom,
+        onChoose: stableHandleChoiceConfirm
+      }
+    ) : pendingRevision ? /* @__PURE__ */ React20.createElement(
+      PlanReviseConfirm,
+      {
+        reason: pendingRevision.reason,
+        oldRemaining: (planStepsRef.current ?? []).filter(
+          (s) => !completedStepIdsRef.current.has(s.id)
+        ),
+        newRemaining: pendingRevision.remainingSteps,
+        summary: pendingRevision.summary,
+        onChoose: stableHandleReviseConfirm
+      }
+    ) : pendingCheckpoint ? /* @__PURE__ */ React20.createElement(
+      PlanCheckpointConfirm,
+      {
+        stepId: pendingCheckpoint.stepId,
+        title: pendingCheckpoint.title,
+        completed: pendingCheckpoint.completed,
+        total: pendingCheckpoint.total,
+        steps: planStepsRef.current ?? void 0,
+        completedStepIds: completedStepIdsRef.current,
+        onChoose: stableHandleCheckpointConfirm
+      }
+    ) : pendingPlan ? /* @__PURE__ */ React20.createElement(
+      PlanConfirm,
+      {
+        plan: pendingPlan,
+        steps: planStepsRef.current ?? void 0,
+        summary: planSummaryRef.current ?? void 0,
+        onChoose: stableHandlePlanConfirm,
+        projectRoot: hookCwd
+      }
+    ) : pendingShell ? /* @__PURE__ */ React20.createElement(
+      ShellConfirm,
+      {
+        command: pendingShell.command,
+        allowPrefix: derivePrefix(pendingShell.command),
+        kind: pendingShell.kind,
+        onChoose: handleShellConfirm
+      }
+    ) : pendingEditReview ? /* @__PURE__ */ React20.createElement(
+      EditConfirm,
+      {
+        block: pendingEditReview,
+        onChoose: (choice) => {
+          const resolve8 = editReviewResolveRef.current;
+          if (resolve8) {
+            editReviewResolveRef.current = null;
+            resolve8(choice);
+          }
+        }
+      }
+    ) : /* @__PURE__ */ React20.createElement(React20.Fragment, null, codeMode ? /* @__PURE__ */ React20.createElement(
+      ModeStatusBar,
+      {
+        editMode,
+        pendingCount,
+        flash: modeFlash,
+        planMode,
+        undoArmed: !!undoBanner || hasUndoable(),
+        jobs: codeMode.jobs
+      }
+    ) : null, /* @__PURE__ */ React20.createElement(
+      PromptInput,
+      {
+        value: input,
+        onChange: setInput,
+        onSubmit: handleSubmit,
+        disabled: busy
+      }
+    ), /* @__PURE__ */ React20.createElement(SlashSuggestions, { matches: slashMatches, selectedIndex: slashSelected }), /* @__PURE__ */ React20.createElement(
+      AtMentionSuggestions,
+      {
+        matches: atMatches,
+        selectedIndex: atSelected,
+        query: atPicker?.query ?? ""
+      }
+    ), slashArgContext ? /* @__PURE__ */ React20.createElement(
+      SlashArgPicker,
+      {
+        matches: slashArgMatches,
+        selectedIndex: slashArgSelected,
+        spec: slashArgContext.spec,
+        kind: slashArgContext.kind,
+        partial: slashArgContext.partial
+      }
+    ) : null))
+  );
 }
 
 // src/cli/ui/SessionPicker.tsx
-import { Box as Box16, Text as Text15 } from "ink";
-import React17 from "react";
+import { Box as Box20, Text as Text19 } from "ink";
+import React21 from "react";
 function SessionPicker({
   sessionName,
   messageCount,
   lastActive,
   onChoose
 }) {
-  return /* @__PURE__ */ React17.createElement(Box16, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React17.createElement(Box16, { marginBottom: 1 }, /* @__PURE__ */ React17.createElement(Text15, { bold: true, color: "cyan" }, `Session "${sessionName}" has ${messageCount} prior message${messageCount === 1 ? "" : "s"}`), /* @__PURE__ */ React17.createElement(Text15, { dimColor: true }, ` \xB7 last active ${relativeTime(lastActive)}`)), /* @__PURE__ */ React17.createElement(
+  return /* @__PURE__ */ React21.createElement(Box20, { flexDirection: "column", marginY: 1 }, /* @__PURE__ */ React21.createElement(Box20, { marginBottom: 1 }, /* @__PURE__ */ React21.createElement(Text19, { bold: true, color: "cyan" }, `Session "${sessionName}" has ${messageCount} prior message${messageCount === 1 ? "" : "s"}`), /* @__PURE__ */ React21.createElement(Text19, { dimColor: true }, ` \xB7 last active ${relativeTime2(lastActive)}`)), /* @__PURE__ */ React21.createElement(
     SingleSelect,
     {
       initialValue: "new",
@@ -12037,9 +13480,9 @@ function SessionPicker({
       ],
       onSubmit: (v) => onChoose(v)
     }
-  ), /* @__PURE__ */ React17.createElement(Box16, { marginTop: 1 }, /* @__PURE__ */ React17.createElement(Text15, { dimColor: true }, "\u2191\u2193 to move \xB7 Enter to pick")));
+  ), /* @__PURE__ */ React21.createElement(Box20, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text19, { dimColor: true }, "\u2191\u2193 to move \xB7 Enter to pick")));
 }
-function relativeTime(date) {
+function relativeTime2(date) {
   const ms = Date.now() - date.getTime();
   const mins = Math.floor(ms / 6e4);
   if (mins < 1) return "just now";
@@ -12053,9 +13496,9 @@ function relativeTime(date) {
 }
 
 // src/cli/ui/Setup.tsx
-import { Box as Box17, Text as Text16, useApp as useApp2 } from "ink";
+import { Box as Box21, Text as Text20, useApp as useApp2 } from "ink";
 import TextInput from "ink-text-input";
-import React18, { useState as useState11 } from "react";
+import React22, { useState as useState11 } from "react";
 function Setup({ onReady }) {
   const [value, setValue] = useState11("");
   const [error, setError] = useState11(null);
@@ -12079,7 +13522,7 @@ function Setup({ onReady }) {
     }
     onReady(trimmed);
   };
-  return /* @__PURE__ */ React18.createElement(Box17, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React18.createElement(Text16, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React18.createElement(
+  return /* @__PURE__ */ React22.createElement(Box21, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React22.createElement(Text20, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React22.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text20, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React22.createElement(Text20, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React22.createElement(Text20, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React22.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text20, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React22.createElement(
     TextInput,
     {
       value,
@@ -12088,7 +13531,7 @@ function Setup({ onReady }) {
       mask: "\u2022",
       placeholder: "sk-..."
     }
-  )), error ? /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { color: "red" }, error)) : value ? /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React18.createElement(Box17, { marginTop: 1 }, /* @__PURE__ */ React18.createElement(Text16, { dimColor: true }, "(Type /exit to abort.)")));
+  )), error ? /* @__PURE__ */ React22.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text20, { color: "red" }, error)) : value ? /* @__PURE__ */ React22.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text20, { dimColor: true }, "preview: ", redactKey(value))) : null, /* @__PURE__ */ React22.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React22.createElement(Text20, { dimColor: true }, "(Type /exit to abort.)")));
 }
 
 // src/cli/commands/chat.tsx
@@ -12104,7 +13547,7 @@ function Root({
   const [key, setKey] = useState12(initialKey);
   const [pending, setPending] = useState12(sessionPreview);
   if (!key) {
-    return /* @__PURE__ */ React19.createElement(
+    return /* @__PURE__ */ React23.createElement(
       Setup,
       {
         onReady: (k) => {
@@ -12116,7 +13559,7 @@ function Root({
   }
   process.env.DEEPSEEK_API_KEY = key;
   if (pending && appProps.session) {
-    return /* @__PURE__ */ React19.createElement(
+    return /* @__PURE__ */ React23.createElement(
       SessionPicker,
       {
         sessionName: appProps.session,
@@ -12131,7 +13574,7 @@ function Root({
       }
     );
   }
-  return /* @__PURE__ */ React19.createElement(
+  return /* @__PURE__ */ React23.createElement(
     App,
     {
       model: appProps.model,
@@ -12222,20 +13665,21 @@ async function chatCommand(opts) {
   if (!opts.seedTools) {
     if (!tools) tools = new ToolRegistry();
     registerMemoryTools(tools, {});
+    registerChoiceTool(tools);
   }
   let sessionPreview;
   if (opts.session && !opts.forceResume && !opts.forceNew) {
     const prior = loadSessionMessages(opts.session);
     if (prior.length > 0) {
       const p = sessionPath(opts.session);
-      const mtime = existsSync11(p) ? statSync6(p).mtime : /* @__PURE__ */ new Date();
+      const mtime = existsSync12(p) ? statSync7(p).mtime : /* @__PURE__ */ new Date();
       sessionPreview = { messageCount: prior.length, lastActive: mtime };
     }
   } else if (opts.session && opts.forceNew) {
     rewriteSession(opts.session, []);
   }
   const { waitUntilExit } = render(
-    /* @__PURE__ */ React19.createElement(
+    /* @__PURE__ */ React23.createElement(
       Root,
       {
         initialKey,
@@ -12259,11 +13703,11 @@ async function chatCommand(opts) {
 }
 
 // src/cli/commands/code.tsx
-import { basename, resolve as resolve7 } from "path";
+import { basename as basename2, resolve as resolve7 } from "path";
 async function codeCommand(opts = {}) {
-  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-KX6A4DVX.js");
+  const { codeSystemPrompt: codeSystemPrompt2 } = await import("./prompt-2OABSPAW.js");
   const rootDir = resolve7(opts.dir ?? process.cwd());
-  const session = opts.noSession ? void 0 : `code-${sanitizeName(basename(rootDir))}`;
+  const session = opts.noSession ? void 0 : `code-${sanitizeName(basename2(rootDir))}`;
   const tools = new ToolRegistry();
   registerFilesystemTools(tools, { rootDir });
   const jobs2 = new JobRegistry();
@@ -12278,6 +13722,7 @@ async function codeCommand(opts = {}) {
     jobs: jobs2
   });
   registerPlanTool(tools);
+  registerChoiceTool(tools);
   registerMemoryTools(tools, { projectRoot: rootDir });
   process.stderr.write(
     `\u25B8 reasonix code: rooted at ${rootDir}, session "${session ?? "(ephemeral)"}" \xB7 ${tools.size} native tool(s)
@@ -12303,37 +13748,37 @@ async function codeCommand(opts = {}) {
 }
 
 // src/cli/commands/diff.ts
-import { writeFileSync as writeFileSync6 } from "fs";
-import { basename as basename2 } from "path";
+import { writeFileSync as writeFileSync7 } from "fs";
+import { basename as basename3 } from "path";
 import { render as render2 } from "ink";
-import React22 from "react";
+import React26 from "react";
 
 // src/cli/ui/DiffApp.tsx
-import { Box as Box19, Static as Static2, Text as Text18, useApp as useApp3, useInput as useInput6 } from "ink";
-import React21, { useState as useState13 } from "react";
+import { Box as Box23, Static as Static2, Text as Text22, useApp as useApp3, useInput as useInput6 } from "ink";
+import React25, { useState as useState13 } from "react";
 
 // src/cli/ui/RecordView.tsx
-import { Box as Box18, Text as Text17 } from "ink";
-import React20 from "react";
+import { Box as Box22, Text as Text21 } from "ink";
+import React24 from "react";
 function RecordView({ rec, compact: compact2 = false }) {
   const toolArgsMax = compact2 ? 120 : 200;
   const toolContentMax = compact2 ? 200 : 400;
   if (rec.role === "user") {
-    return /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text17, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React20.createElement(Text17, null, rec.content));
+    return /* @__PURE__ */ React24.createElement(Box22, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text21, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React24.createElement(Text21, null, rec.content));
   }
   if (rec.role === "assistant_final") {
-    return /* @__PURE__ */ React20.createElement(Box18, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React20.createElement(Box18, null, /* @__PURE__ */ React20.createElement(Text17, { bold: true, color: "green" }, "assistant"), rec.cost !== void 0 ? /* @__PURE__ */ React20.createElement(Text17, { dimColor: true }, "  $", rec.cost.toFixed(6)) : null, rec.usage ? /* @__PURE__ */ React20.createElement(CacheBadge, { usage: rec.usage }) : null), rec.planState ? /* @__PURE__ */ React20.createElement(PlanStateBlock, { planState: rec.planState }) : null, rec.content ? /* @__PURE__ */ React20.createElement(Text17, null, rec.content) : /* @__PURE__ */ React20.createElement(Text17, { dimColor: true, italic: true }, "(tool-call response only)"));
+    return /* @__PURE__ */ React24.createElement(Box22, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React24.createElement(Box22, null, /* @__PURE__ */ React24.createElement(Text21, { bold: true, color: "green" }, "assistant"), rec.cost !== void 0 ? /* @__PURE__ */ React24.createElement(Text21, { dimColor: true }, "  $", rec.cost.toFixed(6)) : null, rec.usage ? /* @__PURE__ */ React24.createElement(CacheBadge, { usage: rec.usage }) : null), rec.planState ? /* @__PURE__ */ React24.createElement(PlanStateBlock, { planState: rec.planState }) : null, rec.content ? /* @__PURE__ */ React24.createElement(Text21, null, rec.content) : /* @__PURE__ */ React24.createElement(Text21, { dimColor: true, italic: true }, "(tool-call response only)"));
   }
   if (rec.role === "tool") {
-    return /* @__PURE__ */ React20.createElement(Box18, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text17, { color: "yellow" }, "tool<", rec.tool ?? "?", ">"), rec.args ? /* @__PURE__ */ React20.createElement(Text17, { dimColor: true }, "  args: ", truncate3(rec.args, toolArgsMax)) : null, /* @__PURE__ */ React20.createElement(Text17, { dimColor: true }, "  \u2192 ", truncate3(rec.content, toolContentMax)));
+    return /* @__PURE__ */ React24.createElement(Box22, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text21, { color: "yellow" }, "tool<", rec.tool ?? "?", ">"), rec.args ? /* @__PURE__ */ React24.createElement(Text21, { dimColor: true }, "  args: ", truncate2(rec.args, toolArgsMax)) : null, /* @__PURE__ */ React24.createElement(Text21, { dimColor: true }, "  \u2192 ", truncate2(rec.content, toolContentMax)));
   }
   if (rec.role === "error") {
-    return /* @__PURE__ */ React20.createElement(Box18, { marginTop: 1 }, /* @__PURE__ */ React20.createElement(Text17, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React20.createElement(Text17, { color: "red" }, rec.error ?? rec.content));
+    return /* @__PURE__ */ React24.createElement(Box22, { marginTop: 1 }, /* @__PURE__ */ React24.createElement(Text21, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React24.createElement(Text21, { color: "red" }, rec.error ?? rec.content));
   }
   if (rec.role === "done" || rec.role === "assistant_delta") {
     return null;
   }
-  return /* @__PURE__ */ React20.createElement(Box18, null, /* @__PURE__ */ React20.createElement(Text17, { dimColor: true }, "[", rec.role, "] ", rec.content));
+  return /* @__PURE__ */ React24.createElement(Box22, null, /* @__PURE__ */ React24.createElement(Text21, { dimColor: true }, "[", rec.role, "] ", rec.content));
 }
 function CacheBadge({ usage }) {
   const hit = usage.prompt_cache_hit_tokens ?? 0;
@@ -12342,9 +13787,9 @@ function CacheBadge({ usage }) {
   if (total === 0) return null;
   const pct2 = hit / total * 100;
   const color = pct2 >= 70 ? "green" : pct2 >= 40 ? "yellow" : "red";
-  return /* @__PURE__ */ React20.createElement(Text17, null, /* @__PURE__ */ React20.createElement(Text17, { dimColor: true }, "  \xB7 cache "), /* @__PURE__ */ React20.createElement(Text17, { color }, pct2.toFixed(1), "%"));
+  return /* @__PURE__ */ React24.createElement(Text21, null, /* @__PURE__ */ React24.createElement(Text21, { dimColor: true }, "  \xB7 cache "), /* @__PURE__ */ React24.createElement(Text21, { color }, pct2.toFixed(1), "%"));
 }
-function truncate3(s, max) {
+function truncate2(s, max) {
   return s.length <= max ? s : `${s.slice(0, max)}\u2026 (+${s.length - max} chars)`;
 }
 
@@ -12376,7 +13821,7 @@ function DiffApp({ report }) {
     }
   });
   const pair = report.pairs[idx];
-  return /* @__PURE__ */ React21.createElement(Box19, { flexDirection: "column" }, /* @__PURE__ */ React21.createElement(DiffHeader, { report }), /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1, paddingX: 1, justifyContent: "space-between" }, /* @__PURE__ */ React21.createElement(Text18, { color: "cyan", bold: true }, "turn ", pair?.turn ?? "?", " (", idx + 1, " / ", report.pairs.length, ")"), /* @__PURE__ */ React21.createElement(Text18, null, pair ? /* @__PURE__ */ React21.createElement(KindBadge, { kind: pair.kind }) : null)), /* @__PURE__ */ React21.createElement(Box19, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React21.createElement(Pane, { label: report.a.label, headerColor: "blue", records: paneRecords(pair, "a") }), /* @__PURE__ */ React21.createElement(Pane, { label: report.b.label, headerColor: "magenta", records: paneRecords(pair, "b") })), pair?.divergenceNote ? /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React21.createElement(Text18, { color: "yellow" }, "\u2605 "), /* @__PURE__ */ React21.createElement(Text18, null, pair.divergenceNote)) : null, /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "j"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "\u2193"), " next \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "k"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "\u2191"), " ", "prev \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "n"), " next-diverge \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "N"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "p"), " ", "prev-diverge \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "g"), "/", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "G"), " first/last \xB7 ", /* @__PURE__ */ React21.createElement(Text18, { bold: true }, "q"), " ", "quit")));
+  return /* @__PURE__ */ React25.createElement(Box23, { flexDirection: "column" }, /* @__PURE__ */ React25.createElement(DiffHeader, { report }), /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1, paddingX: 1, justifyContent: "space-between" }, /* @__PURE__ */ React25.createElement(Text22, { color: "cyan", bold: true }, "turn ", pair?.turn ?? "?", " (", idx + 1, " / ", report.pairs.length, ")"), /* @__PURE__ */ React25.createElement(Text22, null, pair ? /* @__PURE__ */ React25.createElement(KindBadge, { kind: pair.kind }) : null)), /* @__PURE__ */ React25.createElement(Box23, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React25.createElement(Pane, { label: report.a.label, headerColor: "blue", records: paneRecords(pair, "a") }), /* @__PURE__ */ React25.createElement(Pane, { label: report.b.label, headerColor: "magenta", records: paneRecords(pair, "b") })), pair?.divergenceNote ? /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React25.createElement(Text22, { color: "yellow" }, "\u2605 "), /* @__PURE__ */ React25.createElement(Text22, null, pair.divergenceNote)) : null, /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "j"), "/", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "\u2193"), " next \xB7 ", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "k"), "/", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "\u2191"), " ", "prev \xB7 ", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "n"), " next-diverge \xB7 ", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "N"), "/", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "p"), " ", "prev-diverge \xB7 ", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "g"), "/", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "G"), " first/last \xB7 ", /* @__PURE__ */ React25.createElement(Text22, { bold: true }, "q"), " ", "quit")));
 }
 function DiffHeader({ report }) {
   const a = report.a;
@@ -12394,15 +13839,15 @@ function DiffHeader({ report }) {
   } else if (a.stats.prefixHashes[0] && a.stats.prefixHashes[0] === b.stats.prefixHashes[0]) {
     prefixLine = `shared prefix hash ${a.stats.prefixHashes[0].slice(0, 12)}\u2026 \u2014 cache delta attributable to log stability, not prompt change.`;
   }
-  return /* @__PURE__ */ React21.createElement(Box19, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React21.createElement(Box19, { justifyContent: "space-between" }, /* @__PURE__ */ React21.createElement(Text18, null, /* @__PURE__ */ React21.createElement(Text18, { color: "cyan", bold: true }, "reasonix diff"), /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, " \xB7 A="), /* @__PURE__ */ React21.createElement(Text18, { color: "blue" }, a.label), /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, " vs B="), /* @__PURE__ */ React21.createElement(Text18, { color: "magenta" }, b.label)), /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, report.pairs.length, " turns aligned")), /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React21.createElement(Text18, null, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, "cache "), /* @__PURE__ */ React21.createElement(Text18, null, (a.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React21.createElement(Text18, null, (b.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React21.createElement(Text18, { color: cacheDelta >= 0 ? "green" : "red", bold: true }, "  ", cacheDelta >= 0 ? "+" : "", (cacheDelta * 100).toFixed(1), "pp")), /* @__PURE__ */ React21.createElement(Text18, null, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, "cost "), /* @__PURE__ */ React21.createElement(Text18, null, "$", a.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React21.createElement(Text18, null, "$", b.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React21.createElement(Text18, { color: costDelta2 <= 0 ? "green" : "red", bold: true }, "  ", costDelta2 >= 0 ? "+" : "", costDelta2.toFixed(1), "%")), /* @__PURE__ */ React21.createElement(Text18, null, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true }, "model calls "), /* @__PURE__ */ React21.createElement(Text18, null, a.stats.turns, " \u2192 ", b.stats.turns))), prefixLine ? /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true, italic: true }, prefixLine)) : null);
+  return /* @__PURE__ */ React25.createElement(Box23, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React25.createElement(Box23, { justifyContent: "space-between" }, /* @__PURE__ */ React25.createElement(Text22, null, /* @__PURE__ */ React25.createElement(Text22, { color: "cyan", bold: true }, "reasonix diff"), /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, " \xB7 A="), /* @__PURE__ */ React25.createElement(Text22, { color: "blue" }, a.label), /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, " vs B="), /* @__PURE__ */ React25.createElement(Text22, { color: "magenta" }, b.label)), /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, report.pairs.length, " turns aligned")), /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React25.createElement(Text22, null, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, "cache "), /* @__PURE__ */ React25.createElement(Text22, null, (a.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React25.createElement(Text22, null, (b.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React25.createElement(Text22, { color: cacheDelta >= 0 ? "green" : "red", bold: true }, "  ", cacheDelta >= 0 ? "+" : "", (cacheDelta * 100).toFixed(1), "pp")), /* @__PURE__ */ React25.createElement(Text22, null, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, "cost "), /* @__PURE__ */ React25.createElement(Text22, null, "$", a.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React25.createElement(Text22, null, "$", b.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React25.createElement(Text22, { color: costDelta2 <= 0 ? "green" : "red", bold: true }, "  ", costDelta2 >= 0 ? "+" : "", costDelta2.toFixed(1), "%")), /* @__PURE__ */ React25.createElement(Text22, null, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true }, "model calls "), /* @__PURE__ */ React25.createElement(Text22, null, a.stats.turns, " \u2192 ", b.stats.turns))), prefixLine ? /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true, italic: true }, prefixLine)) : null);
 }
 function Pane({
   label,
   headerColor,
   records
 }) {
-  return /* @__PURE__ */ React21.createElement(
-    Box19,
+  return /* @__PURE__ */ React25.createElement(
+    Box23,
     {
       flexDirection: "column",
       flexGrow: 1,
@@ -12410,21 +13855,21 @@ function Pane({
       borderStyle: "single",
       borderColor: headerColor
     },
-    /* @__PURE__ */ React21.createElement(Text18, { color: headerColor, bold: true }, label),
-    records.length === 0 ? /* @__PURE__ */ React21.createElement(Box19, { marginTop: 1 }, /* @__PURE__ */ React21.createElement(Text18, { dimColor: true, italic: true }, "(no records on this side for this turn)")) : /* @__PURE__ */ React21.createElement(Static2, { items: records.map((rec, i) => ({ key: `${label}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React21.createElement(RecordView, { key, rec, compact: true }))
+    /* @__PURE__ */ React25.createElement(Text22, { color: headerColor, bold: true }, label),
+    records.length === 0 ? /* @__PURE__ */ React25.createElement(Box23, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text22, { dimColor: true, italic: true }, "(no records on this side for this turn)")) : /* @__PURE__ */ React25.createElement(Static2, { items: records.map((rec, i) => ({ key: `${label}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React25.createElement(RecordView, { key, rec, compact: true }))
   );
 }
 function KindBadge({ kind }) {
   if (kind === "match") {
-    return /* @__PURE__ */ React21.createElement(Text18, { color: "green" }, "\u2713 match");
+    return /* @__PURE__ */ React25.createElement(Text22, { color: "green" }, "\u2713 match");
   }
   if (kind === "diverge") {
-    return /* @__PURE__ */ React21.createElement(Text18, { color: "yellow" }, "\u2605 diverge");
+    return /* @__PURE__ */ React25.createElement(Text22, { color: "yellow" }, "\u2605 diverge");
   }
   if (kind === "only_in_a") {
-    return /* @__PURE__ */ React21.createElement(Text18, { color: "blue" }, "\u2190 only in A");
+    return /* @__PURE__ */ React25.createElement(Text22, { color: "blue" }, "\u2190 only in A");
   }
-  return /* @__PURE__ */ React21.createElement(Text18, { color: "magenta" }, "\u2192 only in B");
+  return /* @__PURE__ */ React25.createElement(Text22, { color: "magenta" }, "\u2192 only in B");
 }
 function paneRecords(pair, side) {
   if (!pair) return [];
@@ -12440,8 +13885,8 @@ async function diffCommand(opts) {
   const aParsed = readTranscript(opts.a);
   const bParsed = readTranscript(opts.b);
   const report = diffTranscripts(
-    { label: opts.labelA ?? basename2(opts.a), parsed: aParsed },
-    { label: opts.labelB ?? basename2(opts.b), parsed: bParsed }
+    { label: opts.labelA ?? basename3(opts.a), parsed: aParsed },
+    { label: opts.labelB ?? basename3(opts.b), parsed: bParsed }
   );
   const wantMarkdown = !!opts.mdPath;
   const wantPrint = opts.print || !process.stdout.isTTY;
@@ -12449,13 +13894,13 @@ async function diffCommand(opts) {
   if (wantMarkdown) {
     console.log(renderSummaryTable(report));
     const md = renderMarkdown(report);
-    writeFileSync6(opts.mdPath, md, "utf8");
+    writeFileSync7(opts.mdPath, md, "utf8");
     console.log(`
 markdown report written to ${opts.mdPath}`);
     return;
   }
   if (wantTui) {
-    const { waitUntilExit } = render2(React22.createElement(DiffApp, { report }), {
+    const { waitUntilExit } = render2(React26.createElement(DiffApp, { report }), {
       exitOnCtrlC: true,
       patchConsole: false
     });
@@ -12596,11 +14041,11 @@ function pad2(s, width) {
 
 // src/cli/commands/replay.ts
 import { render as render3 } from "ink";
-import React24 from "react";
+import React28 from "react";
 
 // src/cli/ui/ReplayApp.tsx
-import { Box as Box20, Static as Static3, Text as Text19, useApp as useApp4, useInput as useInput7 } from "ink";
-import React23, { useMemo as useMemo4, useState as useState14 } from "react";
+import { Box as Box24, Static as Static3, Text as Text23, useApp as useApp4, useInput as useInput7 } from "ink";
+import React27, { useMemo as useMemo4, useState as useState14 } from "react";
 function ReplayApp({ meta, pages }) {
   const { exit: exit2 } = useApp4();
   const maxIdx = Math.max(0, pages.length - 1);
@@ -12640,14 +14085,14 @@ function ReplayApp({ meta, pages }) {
   const prefixHash = cumStats.prefixHashes.length === 1 ? cumStats.prefixHashes[0].slice(0, 16) : cumStats.prefixHashes.length === 0 ? "(untracked)" : `(churned \xD7${cumStats.prefixHashes.length})`;
   const currentPage = pages[idx];
   const progressLabel = pages.length === 0 ? "empty transcript" : `turn ${idx + 1} / ${pages.length}`;
-  return /* @__PURE__ */ React23.createElement(Box20, { flexDirection: "column" }, /* @__PURE__ */ React23.createElement(
+  return /* @__PURE__ */ React27.createElement(Box24, { flexDirection: "column" }, /* @__PURE__ */ React27.createElement(
     StatsPanel,
     {
       summary,
       model: cumStats.models[0] ?? meta?.model ?? "?",
       prefixHash
     }
-  ), /* @__PURE__ */ React23.createElement(Box20, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React23.createElement(Box20, { justifyContent: "space-between" }, /* @__PURE__ */ React23.createElement(Text19, { color: "cyan", bold: true }, progressLabel), meta ? /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, meta.source, meta.task ? ` \xB7 ${meta.task}` : "", meta.mode ? ` \xB7 ${meta.mode}` : "") : null), currentPage ? /* @__PURE__ */ React23.createElement(Static3, { items: currentPage.records.map((rec, i) => ({ key: `${idx}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React23.createElement(RecordView, { key, rec })) : /* @__PURE__ */ React23.createElement(Text19, { dimColor: true, italic: true }, "no records")), /* @__PURE__ */ React23.createElement(Box20, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React23.createElement(Text19, { dimColor: true }, /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "j"), "/", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "\u2193"), "/", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "space"), " next \xB7 ", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "k"), "/", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "\u2191"), " prev \xB7 ", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "g"), " first \xB7 ", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "G"), " last \xB7", " ", /* @__PURE__ */ React23.createElement(Text19, { bold: true }, "q"), " quit")));
+  ), /* @__PURE__ */ React27.createElement(Box24, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React27.createElement(Box24, { justifyContent: "space-between" }, /* @__PURE__ */ React27.createElement(Text23, { color: "cyan", bold: true }, progressLabel), meta ? /* @__PURE__ */ React27.createElement(Text23, { dimColor: true }, meta.source, meta.task ? ` \xB7 ${meta.task}` : "", meta.mode ? ` \xB7 ${meta.mode}` : "") : null), currentPage ? /* @__PURE__ */ React27.createElement(Static3, { items: currentPage.records.map((rec, i) => ({ key: `${idx}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React27.createElement(RecordView, { key, rec })) : /* @__PURE__ */ React27.createElement(Text23, { dimColor: true, italic: true }, "no records")), /* @__PURE__ */ React27.createElement(Box24, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React27.createElement(Text23, { dimColor: true }, /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "j"), "/", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "\u2193"), "/", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "space"), " next \xB7 ", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "k"), "/", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "\u2191"), " prev \xB7 ", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "g"), " first \xB7 ", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "G"), " last \xB7", " ", /* @__PURE__ */ React27.createElement(Text23, { bold: true }, "q"), " quit")));
 }
 
 // src/cli/commands/replay.ts
@@ -12659,7 +14104,7 @@ async function replayCommand(opts) {
   }
   const { parsed } = replayFromFile(opts.path);
   const pages = groupRecordsByTurn(parsed.records);
-  const { waitUntilExit } = render3(React24.createElement(ReplayApp, { meta: parsed.meta, pages }), {
+  const { waitUntilExit } = render3(React28.createElement(ReplayApp, { meta: parsed.meta, pages }), {
     exitOnCtrlC: true,
     patchConsole: false
   });
@@ -12944,32 +14389,32 @@ function renderMessage(msg, turnIdx, verbose) {
     if (verbose && msg.tool_calls?.length) {
       for (const tc of msg.tool_calls) {
         console.log(
-          `         \u2192 call ${tc.function?.name} ${truncate4(tc.function?.arguments ?? "", 80)}`
+          `         \u2192 call ${tc.function?.name} ${truncate3(tc.function?.arguments ?? "", 80)}`
         );
       }
     }
   } else if (msg.role === "tool") {
-    console.log(`${turn} TOOL ${msg.name ?? "?"}: ${truncate4(flat, 160)}`);
+    console.log(`${turn} TOOL ${msg.name ?? "?"}: ${truncate3(flat, 160)}`);
   } else if (msg.role === "system") {
-    if (verbose) console.log(`${turn} SYSTEM: ${truncate4(flat, 160)}`);
+    if (verbose) console.log(`${turn} SYSTEM: ${truncate3(flat, 160)}`);
   }
 }
 function oneLine3(s, max = 200) {
   const collapsed = s.replace(/\s+/g, " ").trim();
   return collapsed.length > max ? `${collapsed.slice(0, max)}\u2026` : collapsed;
 }
-function truncate4(s, max) {
+function truncate3(s, max) {
   return s.length <= max ? s : `${s.slice(0, max)}\u2026`;
 }
 
 // src/cli/commands/setup.tsx
 import { render as render4 } from "ink";
-import React26 from "react";
+import React30 from "react";
 
 // src/cli/ui/Wizard.tsx
-import { Box as Box21, Text as Text20, useApp as useApp5, useInput as useInput8 } from "ink";
+import { Box as Box25, Text as Text24, useApp as useApp5, useInput as useInput8 } from "ink";
 import TextInput2 from "ink-text-input";
-import React25, { useState as useState15 } from "react";
+import React29, { useState as useState15 } from "react";
 
 // src/cli/ui/presets.ts
 var PRESETS = {
@@ -13017,7 +14462,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     if (key.escape && step !== "saved" && onCancel) onCancel();
   });
   if (step === "apiKey") {
-    return /* @__PURE__ */ React25.createElement(
+    return /* @__PURE__ */ React29.createElement(
       ApiKeyStep,
       {
         onSubmit: (key) => {
@@ -13031,7 +14476,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     );
   }
   if (step === "preset") {
-    return /* @__PURE__ */ React25.createElement(StepFrame, { title: "Pick a preset", step: 1, total: 3 }, /* @__PURE__ */ React25.createElement(
+    return /* @__PURE__ */ React29.createElement(StepFrame, { title: "Pick a preset", step: 1, total: 3 }, /* @__PURE__ */ React29.createElement(
       SingleSelect,
       {
         items: presetItems(),
@@ -13041,10 +14486,10 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
           setStep("mcp");
         }
       }
-    ), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "\u2191/\u2193 move \xB7 enter confirm \xB7 esc cancel")));
+    ), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "\u2191/\u2193 move \xB7 enter confirm \xB7 esc cancel")));
   }
   if (step === "mcp") {
-    return /* @__PURE__ */ React25.createElement(StepFrame, { title: "Which MCP servers should Reasonix wire up for you?", step: 2, total: 3 }, /* @__PURE__ */ React25.createElement(
+    return /* @__PURE__ */ React29.createElement(StepFrame, { title: "Which MCP servers should Reasonix wire up for you?", step: 2, total: 3 }, /* @__PURE__ */ React29.createElement(
       MultiSelect,
       {
         items: mcpItems(),
@@ -13069,7 +14514,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
     }
     const currentName = pending[0];
     const entry = CATALOG_BY_NAME.get(currentName);
-    return /* @__PURE__ */ React25.createElement(
+    return /* @__PURE__ */ React29.createElement(
       McpArgsStep,
       {
         entry,
@@ -13087,7 +14532,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
   }
   if (step === "review") {
     const specs = data.selectedCatalog.map((name) => buildSpec(name, data.catalogArgs));
-    return /* @__PURE__ */ React25.createElement(StepFrame, { title: "Ready to save", step: 3, total: 3 }, /* @__PURE__ */ React25.createElement(Box21, { flexDirection: "column" }, /* @__PURE__ */ React25.createElement(SummaryLine, { label: "API key", value: redactKey(data.apiKey) }), /* @__PURE__ */ React25.createElement(SummaryLine, { label: "Preset", value: data.preset }), /* @__PURE__ */ React25.createElement(
+    return /* @__PURE__ */ React29.createElement(StepFrame, { title: "Ready to save", step: 3, total: 3 }, /* @__PURE__ */ React29.createElement(Box25, { flexDirection: "column" }, /* @__PURE__ */ React29.createElement(SummaryLine, { label: "API key", value: redactKey(data.apiKey) }), /* @__PURE__ */ React29.createElement(SummaryLine, { label: "Preset", value: data.preset }), /* @__PURE__ */ React29.createElement(
       SummaryLine,
       {
         label: "MCP",
@@ -13095,8 +14540,8 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
       }
     ), specs.map((spec, i) => (
       // biome-ignore lint/suspicious/noArrayIndexKey: review-only render, order fixed
-      /* @__PURE__ */ React25.createElement(Box21, { key: i, paddingLeft: 14 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "\xB7 ", spec))
-    )), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, null, "Saves to ", defaultConfigPath())), error ? /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { color: "red" }, error)) : null, /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "enter save \xB7 esc cancel"))), /* @__PURE__ */ React25.createElement(
+      /* @__PURE__ */ React29.createElement(Box25, { key: i, paddingLeft: 14 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "\xB7 ", spec))
+    )), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, null, "Saves to ", defaultConfigPath())), error ? /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: "red" }, error)) : null, /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "enter save \xB7 esc cancel"))), /* @__PURE__ */ React29.createElement(
       ReviewConfirm,
       {
         onConfirm: () => {
@@ -13122,7 +14567,7 @@ function Wizard({ onComplete, onCancel, existingApiKey, initial }) {
       }
     ));
   }
-  return /* @__PURE__ */ React25.createElement(Box21, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1 }, /* @__PURE__ */ React25.createElement(Text20, { bold: true, color: "green" }, "\u25B8 Saved."), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, null, "Run `reasonix` any time to start chatting \u2014 your settings are remembered.")), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "Press enter to exit.")), /* @__PURE__ */ React25.createElement(ExitOnEnter, { onExit: exit2 }));
+  return /* @__PURE__ */ React29.createElement(Box25, { flexDirection: "column", borderStyle: "round", borderColor: "green", paddingX: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "green" }, "\u25B8 Saved."), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, null, "Run `reasonix` any time to start chatting \u2014 your settings are remembered.")), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "Press enter to exit.")), /* @__PURE__ */ React29.createElement(ExitOnEnter, { onExit: exit2 }));
 }
 function ApiKeyStep({
   onSubmit,
@@ -13130,7 +14575,7 @@ function ApiKeyStep({
   onError
 }) {
   const [value, setValue] = useState15("");
-  return /* @__PURE__ */ React25.createElement(Box21, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React25.createElement(Text20, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React25.createElement(
+  return /* @__PURE__ */ React29.createElement(Box25, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, "Welcome to Reasonix."), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, null, "Paste your DeepSeek API key to get started.")), /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "Get one (free credit on signup): https://platform.deepseek.com/api_keys"), /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "Saved locally to ", defaultConfigPath()), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, "key \u203A "), /* @__PURE__ */ React29.createElement(
     TextInput2,
     {
       value,
@@ -13147,7 +14592,7 @@ function ApiKeyStep({
       mask: "\u2022",
       placeholder: "sk-..."
     }
-  )), error ? /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { color: "red" }, error)) : value ? /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "preview: ", redactKey(value))) : null);
+  )), error ? /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: "red" }, error)) : value ? /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "preview: ", redactKey(value))) : null);
 }
 function McpArgsStep({
   entry,
@@ -13156,7 +14601,7 @@ function McpArgsStep({
   onError
 }) {
   const [value, setValue] = useState15("");
-  return /* @__PURE__ */ React25.createElement(StepFrame, { title: `Configure ${entry.name}`, step: 2, total: 3 }, /* @__PURE__ */ React25.createElement(Box21, { flexDirection: "column" }, /* @__PURE__ */ React25.createElement(Text20, null, entry.summary), entry.note ? /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, entry.note)) : null, /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, null, "Required parameter: "), /* @__PURE__ */ React25.createElement(Text20, { bold: true }, entry.userArgs)), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { bold: true, color: "cyan" }, entry.userArgs, " \u203A "), /* @__PURE__ */ React25.createElement(
+  return /* @__PURE__ */ React29.createElement(StepFrame, { title: `Configure ${entry.name}`, step: 2, total: 3 }, /* @__PURE__ */ React29.createElement(Box25, { flexDirection: "column" }, /* @__PURE__ */ React29.createElement(Text24, null, entry.summary), entry.note ? /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, entry.note)) : null, /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, null, "Required parameter: "), /* @__PURE__ */ React29.createElement(Text24, { bold: true }, entry.userArgs)), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, entry.userArgs, " \u203A "), /* @__PURE__ */ React29.createElement(
     TextInput2,
     {
       value,
@@ -13172,7 +14617,7 @@ function McpArgsStep({
       },
       placeholder: placeholderFor(entry)
     }
-  )), error ? /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1 }, /* @__PURE__ */ React25.createElement(Text20, { color: "red" }, error)) : null));
+  )), error ? /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1 }, /* @__PURE__ */ React29.createElement(Text24, { color: "red" }, error)) : null));
 }
 function ReviewConfirm({ onConfirm }) {
   useInput8((_i, key) => {
@@ -13192,10 +14637,10 @@ function StepFrame({
   total,
   children
 }) {
-  return /* @__PURE__ */ React25.createElement(Box21, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React25.createElement(Box21, null, /* @__PURE__ */ React25.createElement(Text20, { dimColor: true }, "Step ", step, "/", total, " \xB7", " "), /* @__PURE__ */ React25.createElement(Text20, { bold: true, color: "cyan" }, title)), /* @__PURE__ */ React25.createElement(Box21, { marginTop: 1, flexDirection: "column" }, children));
+  return /* @__PURE__ */ React29.createElement(Box25, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React29.createElement(Box25, null, /* @__PURE__ */ React29.createElement(Text24, { dimColor: true }, "Step ", step, "/", total, " \xB7", " "), /* @__PURE__ */ React29.createElement(Text24, { bold: true, color: "cyan" }, title)), /* @__PURE__ */ React29.createElement(Box25, { marginTop: 1, flexDirection: "column" }, children));
 }
 function SummaryLine({ label, value }) {
-  return /* @__PURE__ */ React25.createElement(Box21, null, /* @__PURE__ */ React25.createElement(Text20, null, label.padEnd(12)), /* @__PURE__ */ React25.createElement(Text20, { bold: true }, value));
+  return /* @__PURE__ */ React29.createElement(Box25, null, /* @__PURE__ */ React29.createElement(Text24, null, label.padEnd(12)), /* @__PURE__ */ React29.createElement(Text24, { bold: true }, value));
 }
 function presetItems() {
   return ["fast", "smart", "max"].map((name) => ({
@@ -13251,7 +14696,7 @@ async function setupCommand(_opts = {}) {
   const existingKey = loadApiKey();
   const existing = readConfig();
   const { waitUntilExit, unmount } = render4(
-    /* @__PURE__ */ React26.createElement(
+    /* @__PURE__ */ React30.createElement(
       Wizard,
       {
         existingApiKey: existingKey,