reasonix 0.5.24 → 0.6.0

package/dist/index.js

@@ -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,11 @@ 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 = "<<<NEEDS_PRO>>>";
+var NEEDS_PRO_BUFFER_CHARS = 80;
 var CacheFirstLoop = class {
   client;
   prefix;
@@ -1765,11 +1771,36 @@ 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;
   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 ?? [];
@@ -1876,6 +1907,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 +2020,78 @@ 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;
+  }
+  /**
+   * 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).
+   */
+  isEscalationRequest(content) {
+    return content.trimStart().startsWith(NEEDS_PRO_MARKER);
+  }
+  /**
+   * 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;
+    if (resultJson.includes('"error"') && resultJson.includes("search text not found")) {
+      this._turnFailureCount += 1;
+      bumped = true;
+    }
+    if (repair) {
+      const repairs = repair.scavenged + repair.truncationsFixed + repair.stormsBroken;
+      if (repairs > 0) {
+        this._turnFailureCount += repairs;
+        bumped = true;
+      }
+    }
+    if (bumped && !this._escalateThisTurn && this._turnFailureCount >= FAILURE_ESCALATION_THRESHOLD) {
+      this._escalateThisTurn = true;
+      return true;
+    }
+    return false;
+  }
   buildMessages(pendingUser) {
     const healed = healLoadedMessages(this.log.toMessages(), DEFAULT_MAX_RESULT_CHARS);
     const msgs = [...this.prefix.toMessages(), ...healed.messages];
@@ -2012,8 +2146,23 @@ var CacheFirstLoop = class {
     this._turn++;
     this.scratch.reset();
     this.repair.resetStorm();
+    this._turnFailureCount = 0;
+    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 +2182,7 @@ var CacheFirstLoop = class {
           content: stoppedMsg,
           forcedSummary: true
         };
+        this.autoCompactToolResultsOnTurnEnd();
         yield { turn: this._turn, role: "done", content: stoppedMsg };
         return;
       }
@@ -2109,14 +2259,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 +2316,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 || escalationBuf.includes("\n")) {
+                  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 +2391,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 +2417,7 @@ var CacheFirstLoop = class {
         }
       } catch (err) {
         if (signal.aborted) {
+          this.autoCompactToolResultsOnTurnEnd();
           yield { turn: this._turn, role: "done", content: "" };
           return;
         }
@@ -2247,7 +2429,27 @@ var CacheFirstLoop = class {
         };
         return;
       }
-      const turnStats = this.stats.record(this._turn, this.model, usage ?? new Usage());
+      if (this.modelForCurrentCall() !== ESCALATION_MODEL && this.isEscalationRequest(assistantContent)) {
+        this._escalateThisTurn = true;
+        yield {
+          turn: this._turn,
+          role: "warning",
+          content: `\u21E7 flash requested escalation \u2014 retrying this turn on ${ESCALATION_MODEL}`
+        };
+        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;
@@ -2278,6 +2480,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._turnFailureCount} repair/error signals. 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 +2498,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 +2604,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._turnFailureCount} edit failure(s). Next turn falls back to ${this.model} unless /pro is armed.`
+          };
+        }
         yield {
           turn: this._turn,
           role: "tool",
@@ -2417,13 +2634,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,7 +2651,7 @@ ${reason}`;
       const annotated = `${reasonPrefix}
 
 ${summary}`;
-      const summaryStats = this.stats.record(this._turn, this.model, resp.usage ?? new Usage());
+      const summaryStats = this.stats.record(this._turn, summaryModel, resp.usage ?? new Usage());
       this.appendAndPersist(this.assistantMessage(summary, [], resp.reasoningContent ?? void 0));
       yield {
         turn: this._turn,
@@ -2441,6 +2660,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 +2670,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: "" };
     }
   }
@@ -2981,6 +3202,28 @@ 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 exact string \`<<<NEEDS_PRO>>>\` 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. 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.`;
+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 +3366,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 +3384,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 +3406,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 +3425,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([
@@ -4256,15 +4493,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 +4530,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
@@ -5085,7 +5326,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 +5369,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 +5864,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 +6937,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
 
@@ -6736,15 +6978,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\`. 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.
 
-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.
+**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 +7099,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);