reasonix 0.5.24 → 0.7.0

package/dist/index.js

@@ -334,7 +334,7 @@ async function harvest(reasoningContent, client, options = {}, signal) {
   const minLen = options.minReasoningLen ?? 40;
   const trimmed = reasoningContent.trim();
   if (trimmed.length < minLen) return emptyPlanState();
-  const model = options.model ?? "deepseek-chat";
+  const model = options.model ?? "deepseek-v4-flash";
   const maxItems = options.maxItems ?? 5;
   const maxItemLen = options.maxItemLen ?? 80;
   const system = SYSTEM_PROMPT.replace("{maxItems}", String(maxItems)).replace(
@@ -1714,7 +1714,8 @@ var SessionStats = class {
       claudeEquivalentUsd: round(this.totalClaudeEquivalent, 6),
       savingsVsClaudePct: round(this.savingsVsClaude * 100, 2),
       cacheHitRatio: round(this.aggregateCacheHitRatio, 4),
-      lastPromptTokens: last?.usage.promptTokens ?? 0
+      lastPromptTokens: last?.usage.promptTokens ?? 0,
+      lastTurnCostUsd: round(last?.cost ?? 0, 6)
     };
   }
 };
@@ -1725,6 +1726,12 @@ function round(n, digits) {
 
 // src/loop.ts
 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_PREFIX = "<<<NEEDS_PRO";
+var NEEDS_PRO_MARKER_RE = /^<<<NEEDS_PRO(?::\s*([^>]*))?>>>/;
+var NEEDS_PRO_BUFFER_CHARS = 256;
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -1765,11 +1772,44 @@ var CacheFirstLoop = class {
    * `step()` (the prior turn's signal has already fired).
    */
   _turnAbort = new AbortController();
+  /**
+   * "Next turn should run on pro, regardless of this.model." Set by the
+   * `/pro` slash command; consumed at the next turn's start (flipping
+   * `_escalateThisTurn` on and self-clearing) so it's a fire-and-forget
+   * single-turn upgrade. Survives across multiple slash inputs so
+   * typing `/pro` and then hesitating a while before submitting a real
+   * message still applies.
+   */
+  _proArmedForNextTurn = false;
+  /**
+   * Active for the current turn only — true means every model call
+   * this turn uses pro instead of `this.model`. Turned on by EITHER
+   * the pro-armed consumption OR the mid-turn auto-escalation
+   * threshold (see `_turnFailureCount`). Cleared at turn end.
+   */
+  _escalateThisTurn = false;
+  /**
+   * Visible-failure count for the current turn. Incremented by tool
+   * dispatch paths when a result matches a known "flash is struggling"
+   * shape (SEARCH-not-found errors, scavenge / truncation / storm
+   * repair fires). Once it hits {@link FAILURE_ESCALATION_THRESHOLD},
+   * the remainder of the turn's model calls auto-upgrade to pro so
+   * 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;
     this.tools = opts.tools ?? new ToolRegistry();
-    this.model = opts.model ?? "deepseek-v4-pro";
+    this.model = opts.model ?? "deepseek-v4-flash";
     this.reasoningEffort = opts.reasoningEffort ?? "max";
     this.maxToolIters = opts.maxToolIters ?? 64;
     this.hooks = opts.hooks ?? [];
@@ -1792,10 +1832,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) {
@@ -1876,6 +1917,37 @@ var CacheFirstLoop = class {
       }
     }
   }
+  /**
+   * Fired at the END of a turn (just before `done` is yielded). Shrinks
+   * every tool RESULT in the log that exceeds {@link TURN_END_RESULT_CAP_TOKENS}
+   * to a tight cap so the NEXT turn's prompt doesn't re-pay for big
+   * reads or searches done earlier. Unlike the reactive 40/80%
+   * thresholds which react to context pressure, this runs unconditionally
+   * — the win is preventive: each turn's big outputs get trimmed before
+   * they ride into the next prompt. Saves compounding cost on long
+   * sessions.
+   *
+   * Why compact the JUST-finished turn's results too (not just older
+   * turns)? The same-turn iters already consumed the raw content to
+   * make their decisions — the log is only carried forward for future
+   * prompts. And "let me re-read the file" is vastly cheaper than
+   * "carry this 12KB result in every future turn's prompt forever."
+   *
+   * Safe by construction: args-compact for THIS turn already ran
+   * inside `compactToolCallArgsAfterResponse`; this pass is orthogonal.
+   */
+  autoCompactToolResultsOnTurnEnd() {
+    const before = this.log.toMessages();
+    const shrunk = shrinkOversizedToolResultsByTokens(before, TURN_END_RESULT_CAP_TOKENS);
+    if (shrunk.healedCount === 0) return;
+    this.log.compactInPlace(shrunk.messages);
+    if (this.sessionName) {
+      try {
+        rewriteSession(this.sessionName, shrunk.messages);
+      } catch {
+      }
+    }
+  }
   compact(maxTokens = 4e3) {
     const before = this.log.toMessages();
     const resultsPass = shrinkOversizedToolResultsByTokens(before, maxTokens);
@@ -1958,6 +2030,116 @@ var CacheFirstLoop = class {
     }
     this.stream = this.branchEnabled ? false : this._streamPreference;
   }
+  /**
+   * Arm pro for the next turn (consumed at turn start). Called by
+   * `/pro`. Idempotent — repeated calls stay armed, `disarmPro()`
+   * clears. Separate from `/preset max` which persistently switches
+   * this.model; armed state is strictly single-turn.
+   */
+  armProForNextTurn() {
+    this._proArmedForNextTurn = true;
+  }
+  /** Cancel `/pro` arming before the next turn starts. */
+  disarmPro() {
+    this._proArmedForNextTurn = false;
+  }
+  /** UI surface — true while `/pro` is queued but hasn't fired yet. */
+  get proArmed() {
+    return this._proArmedForNextTurn;
+  }
+  /** UI surface — true while the current turn is running on pro (armed or auto-escalated). */
+  get escalatedThisTurn() {
+    return this._escalateThisTurn;
+  }
+  /**
+   * Model the current model call should use. Defaults to `this.model`;
+   * upgrades to {@link ESCALATION_MODEL} when the turn is armed for
+   * pro (via `/pro`) or has hit the failure-escalation threshold.
+   * Same thinking + effort policy applies regardless — pro defaults
+   * to thinking=enabled and effort=max, which the current turn wanted
+   * anyway when flash was struggling.
+   */
+  modelForCurrentCall() {
+    return this._escalateThisTurn ? ESCALATION_MODEL : this.model;
+  }
+  /**
+   * 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 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"
+   * signal and, if so, increment the turn's failure counter. Escalates
+   * the REST of the current turn to pro once the threshold is hit.
+   * Idempotent after escalation — further failures don't re-escalate,
+   * but the turn is already on pro so it doesn't matter.
+   *
+   * Return: `true` when this call tipped the turn into escalation
+   * mode (so the loop can surface a one-time warning to the user).
+   */
+  noteToolFailureSignal(resultJson, repair) {
+    let bumped = false;
+    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) {
+      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;
+      return true;
+    }
+    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];
@@ -2012,8 +2194,24 @@ var CacheFirstLoop = class {
     this._turn++;
     this.scratch.reset();
     this.repair.resetStorm();
+    this._turnFailureCount = 0;
+    this._turnFailureTypes = {};
+    this._escalateThisTurn = false;
+    let armedConsumed = false;
+    if (this._proArmedForNextTurn) {
+      this._escalateThisTurn = true;
+      this._proArmedForNextTurn = false;
+      armedConsumed = true;
+    }
     this._turnAbort = new AbortController();
     const signal = this._turnAbort.signal;
+    if (armedConsumed) {
+      yield {
+        turn: this._turn,
+        role: "warning",
+        content: "\u21E7 /pro armed \u2014 this turn runs on deepseek-v4-pro (one-shot \xB7 disarms after turn)"
+      };
+    }
     let pendingUser = userInput;
     const toolSpecs = this.prefix.tools();
     const warnAt = Math.max(1, Math.floor(this.maxToolIters * 0.7));
@@ -2033,6 +2231,7 @@ var CacheFirstLoop = class {
           content: stoppedMsg,
           forcedSummary: true
         };
+        this.autoCompactToolResultsOnTurnEnd();
         yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
@@ -2109,14 +2308,15 @@ var CacheFirstLoop = class {
               queue.push(sample);
             }
           };
+          const callModel = this.modelForCurrentCall();
           const branchPromise = runBranches(
             this.client,
             {
-              model: this.model,
+              model: callModel,
               messages,
               tools: toolSpecs.length ? toolSpecs : void 0,
               signal,
-              thinking: thinkingModeForModel(this.model),
+              thinking: thinkingModeForModel(callModel),
               reasoningEffort: this.reasoningEffort
             },
             {
@@ -2165,21 +2365,41 @@ var CacheFirstLoop = class {
         } else if (this.stream) {
           const callBuf = /* @__PURE__ */ new Map();
           const readyIndices = /* @__PURE__ */ new Set();
+          const callModel = this.modelForCurrentCall();
+          const bufferForEscalation = callModel !== ESCALATION_MODEL;
+          let escalationBuf = "";
+          let escalationBufFlushed = false;
           for await (const chunk of this.client.stream({
-            model: this.model,
+            model: callModel,
             messages,
             tools: toolSpecs.length ? toolSpecs : void 0,
             signal,
-            thinking: thinkingModeForModel(this.model),
+            thinking: thinkingModeForModel(callModel),
             reasoningEffort: this.reasoningEffort
           })) {
             if (chunk.contentDelta) {
               assistantContent += chunk.contentDelta;
-              yield {
-                turn: this._turn,
-                role: "assistant_delta",
-                content: chunk.contentDelta
-              };
+              if (bufferForEscalation && !escalationBufFlushed) {
+                escalationBuf += chunk.contentDelta;
+                if (this.isEscalationRequest(escalationBuf)) {
+                  break;
+                }
+                if (escalationBuf.length >= NEEDS_PRO_BUFFER_CHARS || !this.looksLikePartialEscalationMarker(escalationBuf)) {
+                  escalationBufFlushed = true;
+                  yield {
+                    turn: this._turn,
+                    role: "assistant_delta",
+                    content: escalationBuf
+                  };
+                  escalationBuf = "";
+                }
+              } else {
+                yield {
+                  turn: this._turn,
+                  role: "assistant_delta",
+                  content: chunk.contentDelta
+                };
+              }
             }
             if (chunk.reasoningDelta) {
               reasoningContent += chunk.reasoningDelta;
@@ -2220,13 +2440,23 @@ var CacheFirstLoop = class {
             if (chunk.usage) usage = chunk.usage;
           }
           toolCalls = [...callBuf.values()];
+          if (bufferForEscalation && !escalationBufFlushed && escalationBuf.length > 0) {
+            if (!this.isEscalationRequest(escalationBuf)) {
+              yield {
+                turn: this._turn,
+                role: "assistant_delta",
+                content: escalationBuf
+              };
+            }
+          }
         } else {
+          const callModel = this.modelForCurrentCall();
           const resp = await this.client.chat({
-            model: this.model,
+            model: callModel,
             messages,
             tools: toolSpecs.length ? toolSpecs : void 0,
             signal,
-            thinking: thinkingModeForModel(this.model),
+            thinking: thinkingModeForModel(callModel),
             reasoningEffort: this.reasoningEffort
           });
           assistantContent = resp.content;
@@ -2236,6 +2466,7 @@ var CacheFirstLoop = class {
         }
       } catch (err) {
         if (signal.aborted) {
+          this.autoCompactToolResultsOnTurnEnd();
           yield { turn: this._turn, role: "done", content: "" };
           return;
         }
@@ -2247,7 +2478,29 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      const turnStats = this.stats.record(this._turn, this.model, usage ?? new Usage());
+      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}${reasonSuffix}`
+        };
+        assistantContent = "";
+        reasoningContent = "";
+        toolCalls = [];
+        usage = null;
+        branchSummary = void 0;
+        preHarvestedPlanState = void 0;
+        iter--;
+        continue;
+      }
+      const turnStats = this.stats.record(
+        this._turn,
+        this.modelForCurrentCall(),
+        usage ?? new Usage()
+      );
       if (pendingUser !== null) {
         this.appendAndPersist({ role: "user", content: pendingUser });
         pendingUser = null;
@@ -2267,7 +2520,12 @@ var CacheFirstLoop = class {
         assistantContent || null
       );
       this.appendAndPersist(
-        this.assistantMessage(assistantContent, repairedCalls, reasoningContent)
+        this.assistantMessage(
+          assistantContent,
+          repairedCalls,
+          this.modelForCurrentCall(),
+          reasoningContent
+        )
       );
       yield {
         turn: this._turn,
@@ -2278,6 +2536,13 @@ var CacheFirstLoop = class {
         repair: report,
         branch: branchSummary
       };
+      if (this.noteToolFailureSignal("", report)) {
+        yield {
+          turn: this._turn,
+          role: "warning",
+          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) {
         const noteTail = report.notes.length ? ` \u2014 ${report.notes[report.notes.length - 1]}` : "";
         const allSuppressed = repairedCalls.length === 0 && toolCalls.length > 0;
@@ -2289,13 +2554,14 @@ var CacheFirstLoop = class {
         };
       }
       if (repairedCalls.length === 0) {
+        this.autoCompactToolResultsOnTurnEnd();
         yield { turn: this._turn, role: "done", content: assistantContent };
         return;
       }
       const ctxMax = DEEPSEEK_CONTEXT_TOKENS[this.model] ?? DEFAULT_CONTEXT_TOKENS;
       if (usage) {
         const ratio = usage.promptTokens / ctxMax;
-        if (ratio > 0.6 && ratio <= 0.8) {
+        if (ratio > 0.4 && ratio <= 0.8) {
           const before = usage.promptTokens;
           const soft = this.compact(4e3);
           if (soft.healedCount > 0) {
@@ -2394,6 +2660,13 @@ ${reason}`;
           content: result
         });
         this.compactToolCallArgsAfterResponse();
+        if (this.noteToolFailureSignal(result)) {
+          yield {
+            turn: this._turn,
+            role: "warning",
+            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 {
           turn: this._turn,
           role: "tool",
@@ -2417,13 +2690,15 @@ ${reason}`;
         role: "user",
         content: "I'm out of tool-call budget for this turn. Summarize in plain prose what you learned from the tool results above. Do NOT emit any tool calls, function-call markup, DSML invocations, or SEARCH/REPLACE edit blocks \u2014 they will be silently discarded. Just plain text."
       });
+      const summaryModel = "deepseek-v4-flash";
+      const summaryEffort = "high";
       const resp = await this.client.chat({
-        model: this.model,
+        model: summaryModel,
         messages,
         // no tools → model is forced to answer in text
         signal: this._turnAbort.signal,
-        thinking: thinkingModeForModel(this.model),
-        reasoningEffort: this.reasoningEffort
+        thinking: thinkingModeForModel(summaryModel),
+        reasoningEffort: summaryEffort
       });
       const rawContent = resp.content?.trim() ?? "";
       const cleaned = stripHallucinatedToolMarkup(rawContent);
@@ -2432,8 +2707,10 @@ ${reason}`;
       const annotated = `${reasonPrefix}
 
 ${summary}`;
-      const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
-      this.appendAndPersist(this.assistantMessage(summary, [], resp.reasoningContent ?? void 0));
+      const summaryStats = this.stats.record(this._turn, summaryModel, resp.usage ?? new Usage());
+      this.appendAndPersist(
+        this.assistantMessage(summary, [], summaryModel, resp.reasoningContent)
+      );
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -2441,6 +2718,7 @@ ${summary}`;
         stats: summaryStats,
         forcedSummary: true
       };
+      this.autoCompactToolResultsOnTurnEnd();
       yield { turn: this._turn, role: "done", content: summary };
     } catch (err) {
       const label = errorLabelFor(opts.reason, this.maxToolIters);
@@ -2450,6 +2728,7 @@ ${summary}`;
         content: "",
         error: `${label} and the fallback summary call failed: ${err.message}. Run /clear and retry with a narrower question, or raise --max-tool-iters.`
       };
+      this.autoCompactToolResultsOnTurnEnd();
       yield { turn: this._turn, role: "done", content: "" };
     }
   }
@@ -2462,28 +2741,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(model) {
@@ -2676,6 +2966,19 @@ function healLoadedMessages(messages, maxChars) {
   const healedCount = shrunk.healedCount + paired.droppedAssistantCalls + paired.droppedStrayTools;
   return { messages: paired.messages, healedCount, healedFrom: shrunk.healedFrom };
 }
+function stampMissingReasoningForThinkingMode(messages, model) {
+  if (!isThinkingModeModel(model)) {
+    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);
@@ -2981,6 +3284,32 @@ import { join as join7, resolve as resolve3 } from "path";
 import { existsSync as existsSync6, readFileSync as readFileSync6, readdirSync as readdirSync3, statSync as statSync3 } from "fs";
 import { homedir as homedir3 } from "os";
 import { join as join6, resolve as resolve2 } from "path";
+
+// src/prompt-fragments.ts
+var TUI_FORMATTING_RULES = `Formatting (rendered in a TUI with a real markdown renderer):
+- Tabular data \u2192 GitHub-Flavored Markdown tables with ASCII pipes (\`| col | col |\` header + \`| --- | --- |\` separator). Never use Unicode box-drawing characters (\u2502 \u2500 \u253C \u250C \u2510 \u2514 \u2518 \u251C \u2524) \u2014 they look intentional but break terminal word-wrap and render as garbled columns at narrow widths.
+- Keep table cells short (one phrase each). If a cell needs a paragraph, use bullets below the table instead.
+- Code, file paths with line ranges, and shell commands \u2192 fenced code blocks (\`\`\`).
+- Do NOT draw decorative frames around content with \`\u250C\u2500\u2500\u2510 \u2502 \u2514\u2500\u2500\u2518\` characters. The renderer adds its own borders; extra ASCII art adds noise and shatters at narrow widths.
+- For flow charts and diagrams: a plain bullet list with \`\u2192\` or \`\u2193\` between steps. Don't try to draw boxes-and-arrows in ASCII; it never survives word-wrap.`;
+var ESCALATION_CONTRACT = `Cost-aware escalation (when you're running on deepseek-v4-flash):
+
+If a task CLEARLY exceeds what flash can do well \u2014 complex cross-file architecture refactors, subtle concurrency / security / correctness invariants you can't resolve with confidence, or a design trade-off you'd be guessing at \u2014 output the marker as the FIRST line of your response (nothing before it, not even whitespace on a separate line). This aborts the current call and retries this turn on deepseek-v4-pro, one shot.
+
+Two accepted forms:
+- \`<<<NEEDS_PRO>>>\` \u2014 bare marker, no rationale.
+- \`<<<NEEDS_PRO: <one-sentence reason>>>>\` \u2014 preferred. The reason text appears in the user-visible warning ("\u21E7 flash requested escalation \u2014 <your reason>"), so they understand WHY a more expensive call is happening. Keep it under ~150 chars, no newlines, no nested \`>\` characters. Examples: \`<<<NEEDS_PRO: cross-file refactor across 6 modules with circular imports>>>\` or \`<<<NEEDS_PRO: subtle session-token race; flash would likely miss the locking invariant>>>\`.
+
+Do NOT emit any other content in the same response when you request escalation. Use this sparingly: normal tasks \u2014 reading files, small edits, clear bug fixes, straightforward feature additions \u2014 stay on flash. Request escalation ONLY when you would otherwise produce a guess or a visibly-mediocre answer. If in doubt, attempt the task on flash first; the system also escalates automatically if you hit 3+ repair / SEARCH-mismatch errors in a single turn (the user sees a typed breakdown).`;
+var NEGATIVE_CLAIM_RULE = `Negative claims ("X is missing", "Y isn't implemented", "there's no Z") are the #1 hallucination shape. They feel safe to write because no citation seems possible \u2014 but that's exactly why you must NOT write them on instinct.
+
+If you have a search tool (\`search_content\`, \`grep\`, web search), call it FIRST before asserting absence:
+- Returns matches \u2192 you were wrong; correct yourself and cite the matches.
+- Returns nothing \u2192 state the absence WITH the search query as evidence: \`No callers of \\\`foo()\\\` found (search_content "foo").\`
+
+If you have no search tool, qualify hard: "I haven't verified \u2014 this is a guess." Never assert absence with fake authority.`;
+
+// src/skills.ts
 var SKILLS_DIRNAME = "skills";
 var SKILL_FILE = "SKILL.md";
 var SKILLS_INDEX_MAX_CHARS = 4e3;
@@ -3123,10 +3452,10 @@ function parseRunAs(raw) {
 }
 function skillIndexLine(s) {
   const safeDesc = s.description.replace(/\n/g, " ").trim();
-  const marker = s.runAs === "subagent" ? "\u{1F9EC} " : "";
-  const max = 130 - s.name.length - marker.length;
+  const tag = s.runAs === "subagent" ? " [\u{1F9EC} subagent]" : "";
+  const max = 130 - s.name.length - tag.length;
   const clipped = safeDesc.length > max ? `${safeDesc.slice(0, Math.max(1, max - 1))}\u2026` : safeDesc;
-  return clipped ? `- ${marker}${s.name} \u2014 ${clipped}` : `- ${marker}${s.name}`;
+  return clipped ? `- ${s.name}${tag} \u2014 ${clipped}` : `- ${s.name}${tag}`;
 }
 function applySkillsIndex(basePrompt, opts = {}) {
   const store = new SkillStore(opts);
@@ -3141,7 +3470,7 @@ function applySkillsIndex(basePrompt, opts = {}) {
     "",
     "# Skills \u2014 playbooks you can invoke",
     "",
-    'One-liner index. Each entry is either a built-in or a user-authored playbook. Call `run_skill({ name: "<skill-name>", arguments: "<task>" })` to invoke one. Skills marked with \u{1F9EC} spawn an **isolated subagent** \u2014 its tool calls and reasoning never enter your context, only its final answer does. Use \u{1F9EC} skills for tasks that would otherwise flood your context (deep exploration, multi-step research, anything where you only need the conclusion). Plain skills are inlined: their body becomes a tool result you read and act on directly. The user can also invoke a skill via `/skill <name>`.',
+    'One-liner index. Each entry is either a built-in or a user-authored playbook. Call `run_skill({ name: "<skill-name>", arguments: "<task>" })` \u2014 the `name` is JUST the skill identifier (e.g. `"explore"`), NOT the `[\u{1F9EC} subagent]` tag that appears after it. Entries tagged `[\u{1F9EC} subagent]` spawn an **isolated subagent** \u2014 its tool calls and reasoning never enter your context, only its final answer does. Use subagent skills for tasks that would otherwise flood your context (deep exploration, multi-step research, anything where you only need the conclusion). Plain skills are inlined: their body becomes a tool result you read and act on directly. The user can also invoke a skill via `/skill <name>`.',
     "",
     "```",
     truncated,
@@ -3163,12 +3492,9 @@ Your final answer:
 - If the question can't be answered from what you found, say so plainly and suggest where to look next.
 - No follow-up offers, no "let me know if you need more." The parent will ask again if they need more.
 
-Formatting (rendered in a TUI):
-- Tabular data \u2192 GitHub-Flavored Markdown tables with ASCII pipes (\`| col | col |\` + \`| --- | --- |\`). Never use Unicode box-drawing characters (\u2502 \u2500 \u253C) \u2014 they break word-wrap.
-- Keep table cells short; if a cell needs a paragraph, use bullets below the table instead.
-- Code, file paths with line ranges, and shell commands \u2192 fenced code blocks (\`\`\`).
-- NEVER draw decorative frames around code or text with \`\u250C\u2500\u2500\u2510 \u2502 \u2514\u2500\u2500\u2518\` box-drawing characters. Use plain code blocks; the renderer adds its own border.
-- For flow charts: use a bullet list with \`\u2192\` or \`\u2193\` between steps, not ASCII boxes-and-arrows.
+${NEGATIVE_CLAIM_RULE}
+
+${TUI_FORMATTING_RULES}
 
 The 'task' the parent gave you is the question you must answer. Treat any other reading of it as scope creep.`;
 var BUILTIN_RESEARCH_BODY = `You are running as a research subagent. Your job is to gather information from code AND the web, synthesize it, and return one focused conclusion.
@@ -3185,12 +3511,9 @@ Your final answer:
 - Distinguish "I verified this in code" from "I read this on a docs page" \u2014 the parent will trust the former more.
 - If the answer is uncertain, say so. Don't invent confidence.
 
-Formatting (rendered in a TUI):
-- Tabular data \u2192 GitHub-Flavored Markdown tables with ASCII pipes (\`| col | col |\` + \`| --- | --- |\`). Never use Unicode box-drawing characters (\u2502 \u2500 \u253C) \u2014 they break word-wrap.
-- Keep table cells short; if a cell needs a paragraph, use bullets below the table instead.
-- Code, file paths with line ranges, and shell commands \u2192 fenced code blocks (\`\`\`).
-- NEVER draw decorative frames around code or text with \`\u250C\u2500\u2500\u2510 \u2502 \u2514\u2500\u2500\u2518\` box-drawing characters. Use plain code blocks; the renderer adds its own border.
-- For flow charts: use a bullet list with \`\u2192\` or \`\u2193\` between steps, not ASCII boxes-and-arrows.
+${NEGATIVE_CLAIM_RULE}
+
+${TUI_FORMATTING_RULES}
 
 The 'task' the parent gave you is the research question. Stay on it.`;
 var BUILTIN_SKILLS = Object.freeze([
@@ -4202,28 +4525,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(plan) {
+  steps;
+  summary;
+  constructor(plan, 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 = plan;
+    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(update) {
+    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 = update.stepId;
+    this.title = update.title;
+    this.result = update.result;
+    this.notes = update.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",
@@ -4231,6 +4759,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"]
@@ -4240,10 +4777,108 @@ function registerPlanTool(registry, opts = {}) {
       if (!plan) {
         throw new Error("submit_plan: empty plan \u2014 write a markdown plan and try again.");
       }
-      opts.onPlanSubmitted?.(plan);
-      throw new PlanProposedError(plan);
+      const steps = sanitizeSteps(args?.steps);
+      const summary = typeof args?.summary === "string" ? args.summary.trim() || void 0 : void 0;
+      opts.onPlanSubmitted?.(plan, steps);
+      throw new PlanProposedError(plan, 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 update = { kind: "step_completed", stepId, result };
+      if (title) update.title = title;
+      if (notes) update.notes = notes;
+      opts.onStepCompleted?.(update);
+      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;
 }
 
@@ -4256,15 +4891,15 @@ Rules:
 - When you're done, your final assistant message is the only thing the parent will see \u2014 make it complete and self-contained. No follow-up offers, no questions, no "let me know if you need more."
 - Prefer one clear, distilled answer over a long log of what you tried.
 
-Formatting rules (the parent renders your reply in a TUI with a real markdown renderer):
-- For tabular data use GitHub-Flavored Markdown tables with ASCII pipes: \`| col | col |\` headers, \`| --- | --- |\` separator. NEVER draw tables with Unicode box-drawing characters (\u2502 \u2500 \u253C \u250C \u2510 \u2514 \u2518 \u251C \u2524). They look intentional but break terminal word-wrap and produce garbled output.
-- Keep table cells short \u2014 one short phrase per cell, not multi-line paragraphs. If a description doesn't fit in ~40 chars, use bullets below the table instead.
-- Use fenced code blocks (\`\`\`) for any code, file paths with line ranges, or shell commands.
-- NEVER draw decorative frames around content with \`\u250C\u2500\u2500\u2510 \u2502 \u2514\u2500\u2500\u2518\` box-drawing characters. The renderer handles code blocks and headings on its own \u2014 extra ASCII art adds noise without value and breaks at narrow terminal widths.
-- For flow charts and diagrams: use a markdown bullet list with \`\u2192\` or \`\u2193\` between steps. Don't try to draw boxes-and-arrows in ASCII; it never survives word-wrap.`;
+${NEGATIVE_CLAIM_RULE}
+
+${ESCALATION_CONTRACT}
+
+${TUI_FORMATTING_RULES}`;
 var DEFAULT_MAX_RESULT_CHARS2 = 8e3;
 var DEFAULT_MAX_ITERS = 16;
-var DEFAULT_SUBAGENT_MODEL = "deepseek-v4-pro";
+var DEFAULT_SUBAGENT_MODEL = "deepseek-v4-flash";
+var DEFAULT_SUBAGENT_EFFORT = "high";
 var SUBAGENT_TOOL_NAME = "spawn_subagent";
 var NEVER_INHERITED_TOOLS = /* @__PURE__ */ new Set([SUBAGENT_TOOL_NAME, "submit_plan"]);
 async function spawnSubagent(opts) {
@@ -4293,6 +4928,10 @@ async function spawnSubagent(opts) {
     prefix: childPrefix,
     tools: childTools,
     model,
+    // Subagents run on a constrained thinking budget by default — the
+    // task is already narrow by construction, and `high` cuts output
+    // tokens substantially vs `max`.
+    reasoningEffort: DEFAULT_SUBAGENT_EFFORT,
     maxToolIters,
     hooks: [],
     stream: false
@@ -4416,8 +5055,8 @@ function registerSubagentTool(parentRegistry, opts) {
         },
         model: {
           type: "string",
-          enum: ["deepseek-v4-flash", "deepseek-v4-pro", "deepseek-chat", "deepseek-reasoner"],
-          description: "Which DeepSeek model the subagent runs on. Default is 'deepseek-v4-pro' \u2014 the strongest model, best for complex subtasks. Override to 'deepseek-v4-flash' (or the legacy 'deepseek-chat' / 'deepseek-reasoner' aliases, which route to flash non-thinking / thinking modes) when the subtask is simple enough that flash's quality suffices \u2014 flash is roughly 12\xD7 cheaper."
+          enum: ["deepseek-v4-flash", "deepseek-v4-pro"],
+          description: "Which DeepSeek model the subagent runs on. Default is 'deepseek-v4-flash' \u2014 cheap and fast, fine for explore/research-style subtasks. Override to 'deepseek-v4-pro' (~12\xD7 more expensive) when the subtask genuinely needs the stronger model: cross-file architecture, subtle bug hunts, anything where flash has empirically underperformed."
         }
       },
       required: ["task"]
@@ -5085,7 +5724,7 @@ function registerShellTools(registry, opts) {
   const allowAll = opts.allowAll ?? false;
   registry.register({
     name: "run_command",
-    description: "Run a shell command in the project root and return its combined stdout+stderr. Common read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
+    description: "Run a shell command in the project root and return its combined stdout+stderr.\n\nConstraints (read these before the first call):\n\u2022 ONE process per call, NO shell expansion. `&&`, `||`, `|`, `;`, `>`, `<`, `2>&1` are all rejected up-front \u2014 split into separate calls and combine results in reasoning. Example: instead of `grep foo *.ts | wc -l`, use `grep -c foo *.ts`; instead of `cd sub && npm test`, use `npm test --prefix sub` (or whatever --cwd flag the binary accepts).\n\u2022 `cd` DOES NOT PERSIST between calls \u2014 each call spawns a fresh process rooted at the project. If a tool needs a subdirectory, pass it via the tool's own flag (`npm --prefix`, `cargo -C`, `git -C`, `pytest tests/\u2026`), NOT via a preceding `cd`.\n\u2022 Avoid commands with unbounded output (`netstat -ano`, `find /`, etc.) \u2014 they waste tokens. Filter at source: `netstat -ano -p TCP`, `find src -name '*.ts'`, `grep -c`, `wc -l`.\n\nCommon read-only inspection and test/lint/typecheck commands run immediately; anything that could mutate state, install dependencies, or touch the network is refused until the user confirms it in the TUI. Prefer this over asking the user to run a command manually \u2014 after edits, run the project's tests to verify.",
     // Plan-mode gate: allow allowlisted commands through (git status,
     // cargo check, ls, grep …) so the model can actually investigate
     // during planning. Anything that would otherwise trigger a
@@ -5128,7 +5767,7 @@ function registerShellTools(registry, opts) {
   });
   registry.register({
     name: "run_background",
-    description: "Spawn a long-running process (dev server, watcher, any command that doesn't naturally exit) and detach. Waits up to `waitSec` seconds for startup (or until the output matches a readiness signal like 'Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. The process keeps running; call `job_output` to tail its logs, `stop_job` to kill it, `list_jobs` to see all running jobs. USE THIS \u2014 not `run_command` \u2014 for: npm/yarn/pnpm run dev, uvicorn / flask run, go run, cargo watch, tsc --watch, webpack serve, anything with 'dev' / 'serve' / 'watch' in the name.",
+    description: "Spawn a long-running process (dev server, watcher, any command that doesn't naturally exit) and detach. Waits up to `waitSec` seconds for startup (or until the output matches a readiness signal like 'Local:', 'listening on', 'compiled successfully'), then returns the job id + startup preview. The process keeps running; call `job_output` to tail its logs, `stop_job` to kill it, `list_jobs` to see all running jobs.\n\nSame shell constraints as run_command: NO `&&` / `||` / `|` / `;` / `>` / `<` / `2>&1`, `cd` doesn't persist. Dev servers that need a subdirectory: use the tool's own --prefix / --cwd flag. For Vite specifically, `--prefix` on npm only tells npm where package.json is; vite's server root still defaults to process cwd, so pass `vite <project-dir>` or configure via `vite.config.ts` root.\n\nUSE THIS \u2014 not `run_command` \u2014 for: npm/yarn/pnpm run dev, uvicorn / flask run, go run, cargo watch, tsc --watch, webpack serve, anything with 'dev' / 'serve' / 'watch' in the name.",
     parameters: {
       type: "object",
       properties: {
@@ -5623,7 +6262,8 @@ function summarizeTurns(turns) {
     claudeEquivalentUsd: round2(totalClaude, 6),
     savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
     cacheHitRatio: round2(cacheHitRatio, 4),
-    lastPromptTokens: lastTurn?.usage.promptTokens ?? 0
+    lastPromptTokens: lastTurn?.usage.promptTokens ?? 0,
+    lastTurnCostUsd: round2(lastTurn?.cost ?? 0, 6)
   };
 }
 function round2(n, digits) {
@@ -6695,7 +7335,7 @@ function sep() {
 // src/code/prompt.ts
 import { existsSync as existsSync10, readFileSync as readFileSync11 } from "fs";
 import { join as join9 } from "path";
-var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, list_directory, search_files, etc.) rooted at the user's working directory.
+var CODE_SYSTEM_PROMPT = `You are Reasonix Code, a coding assistant. You have filesystem tools (read_file, write_file, edit_file, list_directory, directory_tree, search_files, search_content, get_file_info) rooted at the user's working directory, plus run_command / run_background for shell.
 
 # Cite or shut up \u2014 non-negotiable
 
@@ -6728,6 +7368,21 @@ Skip submit_plan for small, obvious changes: one-line typo, clear bug with a cle
 
 Plan body: one-sentence summary, then a file-by-file breakdown of what you'll change and why, and any risks or open questions. If some decisions are genuinely up to the user (naming, tradeoffs, out-of-scope possibilities), list them in an "Open questions" section \u2014 the user sees the plan in a picker and has a text input to answer your questions before approving. Don't pretend certainty you don't have; flagged questions are how the user tells you what they care about. After calling submit_plan, STOP \u2014 don't call any more tools, wait for the user's verdict.
 
+**Do NOT use submit_plan to present A/B/C route menus.** The approve/refine/cancel picker has no branch selector \u2014 a menu plan strands the user. For branching decisions, use \`ask_choice\` (see below); only call submit_plan once the user has picked a direction and you have ONE actionable plan.
+
+# When to ask the user to pick (ask_choice)
+
+You have an \`ask_choice\` tool. **If the user is supposed to pick between alternatives, the tool picks \u2014 you don't enumerate the choices as prose.** Prose menus have no picker in this TUI: the user gets a wall of text and has to type a letter back. The tool fires an arrow-key picker that's strictly better.
+
+Call it when:
+- The user has asked for options / doesn't want a recommendation / wants to decide.
+- You've analyzed multiple approaches and the final call is theirs.
+- It's a preference fork you can't resolve without them (deployment target, team convention, taste).
+
+Skip it when one option is clearly correct (just do it, or submit_plan) or a free-form text answer fits (ask in prose).
+
+Each option: short stable id (A/B/C), one-line title, optional summary. \`allowCustom: true\` when their real answer might not fit. Max 6. A ~1-sentence lead-in before the call is fine ("I see three directions \u2014 letting you pick"); don't repeat the options in it. After the call, STOP.
+
 # Plan mode (/plan)
 
 The user can ALSO enter "plan mode" via /plan, which is a stronger, explicit constraint:
@@ -6736,15 +7391,17 @@ The user can ALSO enter "plan mode" via /plan, which is a stronger, explicit con
 - You MUST call submit_plan before anything will execute. Approve exits plan mode; Refine stays in; Cancel exits without implementing.
 
 
-# Delegating to subagents via Skills (\u{1F9EC})
+# Delegating to subagents via Skills
 
-The pinned Skills index below lists playbooks you can invoke with \`run_skill\`. Skills marked with **\u{1F9EC}** spawn an **isolated subagent** \u2014 a fresh child loop that runs the playbook in its own context and returns only the final answer. The subagent's tool calls and reasoning never enter your context, so \u{1F9EC} skills are how you keep the main session lean.
+The pinned Skills index below lists playbooks you can invoke with \`run_skill\`. Entries tagged \`[\u{1F9EC} subagent]\` spawn an **isolated subagent** \u2014 a fresh child loop that runs the playbook in its own context and returns only the final answer. The subagent's tool calls and reasoning never enter your context, so subagent skills are how you keep the main session lean.
+
+**When you call \`run_skill\`, the \`name\` is ONLY the identifier before the tag** \u2014 e.g. \`run_skill({ name: "explore", arguments: "..." })\`, NOT \`"[\u{1F9EC} subagent] explore"\` and NOT \`"explore [\u{1F9EC} subagent]"\`. The tag is display sugar; the name argument is just the bare identifier.
 
 Two built-ins ship by default:
-- **\u{1F9EC} explore** \u2014 read-only investigation across the codebase. Use when the user says things like "find all places that...", "how does X work across the project", "survey the code for Y". Pass \`arguments\` describing the concrete question.
-- **\u{1F9EC} research** \u2014 combines web search + code reading. Use for "is X supported by lib Y", "what's the canonical way to Z", "compare our impl to the spec".
+- **explore** \`[\u{1F9EC} subagent]\` \u2014 read-only investigation across the codebase. Use when the user says things like "find all places that...", "how does X work across the project", "survey the code for Y". Pass \`arguments\` describing the concrete question.
+- **research** \`[\u{1F9EC} subagent]\` \u2014 combines web search + code reading. Use for "is X supported by lib Y", "what's the canonical way to Z", "compare our impl to the spec".
 
-When to delegate (call \`run_skill\` with a \u{1F9EC} skill):
+When to delegate (call \`run_skill\` with a subagent skill):
 - The task would otherwise need >5 file reads or searches.
 - You only need the conclusion, not the exploration trail.
 - The work is self-contained (you can describe it in one paragraph).
@@ -6855,6 +7512,10 @@ If you notice an obvious issue, MENTION it in one sentence and wait for the user
 - Show edits; don't narrate them in prose. "Here's the fix:" is enough.
 - One short paragraph explaining *why*, then the blocks.
 - If you need to explore first (list / read / search), do it with tool calls before writing any prose \u2014 silence while exploring is fine.
+
+${ESCALATION_CONTRACT}
+
+${TUI_FORMATTING_RULES}
 `;
 function codeSystemPrompt(rootDir) {
   const withMemory = applyMemoryStack(CODE_SYSTEM_PROMPT, rootDir);
@@ -7181,6 +7842,7 @@ export {
   AppendOnlyLog,
   CODE_SYSTEM_PROMPT,
   CacheFirstLoop,
+  ChoiceRequestedError,
   DEFAULT_AT_MENTION_MAX_BYTES,
   DEFAULT_MAX_RESULT_CHARS,
   DEFAULT_MAX_RESULT_TOKENS,
@@ -7200,7 +7862,9 @@ export {
   NeedsConfirmationError,
   PROJECT_MEMORY_FILE,
   PROJECT_MEMORY_MAX_CHARS,
+  PlanCheckpointError,
   PlanProposedError,
+  PlanRevisionProposedError,
   SessionStats,
   SseTransport,
   StdioTransport,
@@ -7290,6 +7954,7 @@ export {
   readUsageLog,
   recordFromLoopEvent,
   redactKey,
+  registerChoiceTool,
   registerFilesystemTools,
   registerMemoryTools,
   registerPlanTool,