kronk-cli 0.1.2 → 0.2.0

package/src/config.js

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import { readFileSync } from 'node:fs';
 
 const RC = join(homedir(), '.kronk-cli.json');
+const MODEL_CONFIG = join(homedir(), '.kronk', 'models', 'model_config.yaml');
 
 function fileConfig() {
   try { return JSON.parse(readFileSync(RC, 'utf8')); } catch { return {}; }
@@ -13,6 +14,13 @@ const file = fileConfig();
 /** Used when nothing is passed on the command line or in the environment. */
 export const DEFAULT_MODEL = 'unsloth/Qwen3.6-35B-A3B-UD-Q4_K_M/AGENT';
 
+// Three states, not a boolean: unset means "no opinion, let src/reasoning.js
+// pick the autonomous-only default"; set means "override it, in either
+// direction". Collapsing unset into `true` or `false` here would make that
+// distinction impossible to recover downstream.
+const fileReplayReasoning = file.replayReasoning === undefined ? undefined : String(file.replayReasoning);
+const replayReasoningRaw = process.env.KRONK_REPLAY_REASONING ?? fileReplayReasoning;
+
 export const config = {
   baseUrl: process.env.KRONK_URL   ?? file.baseUrl ?? 'http://localhost:11435/v1',
   token:   process.env.KRONK_TOKEN ?? file.token   ?? 'kronk',
@@ -23,18 +31,48 @@ export const config = {
   maxSteps: Number(process.env.KRONK_MAX_STEPS ?? file.maxSteps ?? Infinity),
   showThinking: (process.env.KRONK_THINKING ?? String(file.showThinking ?? 'true')) !== 'false',
   noThink: (process.env.KRONK_NO_THINK ?? String(file.noThink ?? '')) === '1',
+  // The chat template drops earlier <think> blocks once a newer user message
+  // arrives, which rewrites the prefix and throws the whole session cache away.
+  // Pinning them costs the tokens the blocks occupy and saves the re-prefill.
+  preserveThinking:
+    (process.env.KRONK_PRESERVE_THINKING ?? String(file.preserveThinking ?? 'true')) !== 'false',
+  // Send the current task's own reasoning back with each tool-loop step, so
+  // the model does not re-derive its plan from tool output alone every time.
+  // Earlier turns are dropped at the boundary the template already uses —
+  // src/reasoning.js has the full argument, including why the *default* for
+  // this is computed there from `auto`, not here as a plain boolean.
+  // `undefined` here means "no override": src/reasoning.js decides. `true`
+  // or `false` here forces the answer regardless of autonomous vs. REPL.
+  replayReasoning: replayReasoningRaw === undefined ? undefined : replayReasoningRaw !== 'false',
+  // Kronk admits a model on its first inference request, not at server start.
+  // Pay that cold load at boot rather than on the first typed prompt.
+  warm: (process.env.KRONK_WARM ?? String(file.warm ?? 'true')) !== 'false',
   autoCompact: (process.env.KRONK_AUTO_COMPACT ?? String(file.autoCompact ?? 'true')) !== 'false',
   compactAt: Number(process.env.KRONK_COMPACT_AT ?? file.compactAt ?? 0.85),
   // Large tool output is summarized in a throwaway context so the raw text
   // never enters the conversation. Set KRONK_DISTILL=false to keep it whole.
   distill: (process.env.KRONK_DISTILL ?? String(file.distill ?? 'true')) !== 'false',
   distillAt: Number(process.env.KRONK_DISTILL_AT ?? file.distillAt ?? 8000),
+  // Kronk's per-model runtime settings. `setup` is the only thing that writes
+  // it; the override exists so tests never go near the real one.
+  modelConfigPath: process.env.KRONK_MODEL_CONFIG ?? file.modelConfigPath ?? MODEL_CONFIG,
   lastUsed: 0,
   contextWindow: null,   // filled in at boot from Kronk
   nativeContext: null,
+  templatePreservesThinking: false,   // filled in at boot from the model's template
+  samplingOverride: null,   // filled in at boot: params where the profile overrides the model's own
   rcPath: RC,
 };
 
+/**
+ * Whether this request should pin the earlier think blocks: the user wants it,
+ * the model's template declares the parameter, and reasoning is on at all —
+ * with `--no-think` there is nothing to preserve. Read per request, because
+ * `/think` flips `noThink` in the middle of a session.
+ */
+export const shouldPreserveThinking = () =>
+  config.preserveThinking && config.templatePreservesThinking && !config.noThink;
+
 /**
  * File contents and command output leave this process in request bodies, which
  * is the whole job. Over loopback that is fine. Pointed at a remote host over

package/src/index.js

@@ -4,33 +4,26 @@ import { stdin, stdout } from 'node:process';
 import { readFile } from 'node:fs/promises';
 import { config, DEFAULT_MODEL, warnIfInsecure } from './config.js';
 import { listModels, listModelDetails, listLoaded, modelLimits, tokenize } from './client.js';
+import { pickDefault, ensureLoaded } from './boot.js';
 import { runTurn, SYSTEM, SYSTEM_AUTO } from './agent.js';
 import { c, banner, fmtContext, statusLine } from './ui.js';
 import { projectContext } from './context.js';
+import { forRequest } from './reasoning.js';
 import { compact, report } from './compact.js';
 import { loadServers, McpHub, reportFailures } from './mcp.js';
 import { resolveSandbox, sandbox } from './tools.js';
+import { parseArgv } from './argv.js';
+import { runSetup } from './setup.js';
 
 // ---- argv -------------------------------------------------------------
-const argv = process.argv.slice(2);
-const flag = (...names) => {
-  const i = argv.findIndex((a) => names.includes(a));
-  if (i === -1) return false;
-  argv.splice(i, 1);
-  return true;
-};
-let AUTO_YES = flag('-y', '--yes');
-if (flag('--no-think')) config.noThink = true;
-// --auto: run the whole task unattended (implies --yes)
-const AUTO = flag('-a', '--auto');
-if (AUTO) AUTO_YES = true;
-
-const SHOW_MODELS = flag('--models', '-l', '--list');
-const SHOW_MCP = flag('--mcp-list');
-const NO_CONTEXT = flag('--no-context');
-if (flag('--no-compact')) config.autoCompact = false;
+const args = parseArgv(process.argv.slice(2));
+if (args.error) {
+  // A usage error is not a conversation: stderr, exit 2, nothing sent anywhere.
+  console.error(`\n${args.error}\n`);
+  process.exit(2);
+}
 
-if (flag('-h', '--help')) {
+if (args.help) {
   console.log(`
   kronk-cli — a terminal agent for local models served by Kronk
 
@@ -39,10 +32,16 @@ if (flag('-h', '--help')) {
     kronk-cli "<prompt>"            run one prompt and exit
     <cmd> | kronk-cli "<prompt>"    pipe stdin in as extra context
 
+  SUBCOMMANDS
+    kronk-cli setup [--model <id>] [--context <n>] [-y] [--dry-run]
+                                    pull the model, write its /AGENT profile to
+                                    ~/.kronk/models/model_config.yaml, restart Kronk
+
   OPTIONS
     -l, --models        list the models Kronk is serving, then exit
         --no-context    skip the startup scan of the working directory
         --no-compact    never auto-compact; fail instead when the window fills
+        --no-warm       don't preload the model; let the first prompt trigger it
         --mcp [names]   attach MCP servers; bare for all, or a comma list
         --mcp-list      show configured MCP servers and their tools, then exit
     -m, --model <id>    model to use; substring is enough, /AGENT profiles win
@@ -52,14 +51,20 @@ if (flag('-h', '--help')) {
         --no-think      disable the model's reasoning pass (faster)
         --steps <n>     cap tool calls per task (default: unlimited)
     -h, --help          this message
+        --              end option parsing; everything after is the prompt
 
   ENVIRONMENT
     KRONK_URL           default http://localhost:11435/v1
     KRONK_TOKEN         any non-empty value when Kronk runs open
     KRONK_MODEL         overrides the default model
+    KRONK_MODEL_CONFIG  path to Kronk's model_config.yaml, used by setup
     KRONK_MAX_TOKENS    output cap per response (default 8192)
     KRONK_MAX_STEPS     cap on tool calls per task (default unlimited)
     KRONK_NO_THINK      set to 1 to disable reasoning
+    KRONK_PRESERVE_THINKING
+                        false to stop pinning earlier think blocks in the
+                        prompt (smaller prompts, cache lost on every turn)
+    KRONK_WARM          false to skip the boot-time model preload
     KRONK_AUTO_COMPACT  false to disable automatic compaction
     KRONK_COMPACT_AT    fraction of the window that triggers it (default 0.85)
 
@@ -67,42 +72,22 @@ if (flag('-h', '--help')) {
 `);
   process.exit(0);
 }
-const opt = (name) => {
-  const i = argv.findIndex((a) => a === name);
-  if (i === -1) return null;
-  const v = argv[i + 1];
-  argv.splice(i, 2);
-  return v;
-};
-const modelArg = opt('--model') ?? opt('-m');
-if (modelArg) config.model = modelArg;
-// `--mcp` alone attaches everything configured; `--mcp nx,kronk` narrows it.
-let MCP_ON = false;
-let MCP_WANTED = null;
-{
-  const i = argv.findIndex((a) => a === '--mcp');
-  if (i !== -1) {
-    MCP_ON = true;
-    const next = argv[i + 1];
-    if (next && !next.startsWith('-')) {
-      MCP_WANTED = next.split(',').map((x) => x.trim()).filter(Boolean);
-      argv.splice(i, 2);
-    } else {
-      argv.splice(i, 1);
-    }
-  }
-}
 
-const stepsArg = opt('--steps');
-if (stepsArg) config.maxSteps = /^(0|off|none|inf|unlimited)$/i.test(stepsArg) ? Infinity : Number(stepsArg);
+// --auto: run the whole task unattended (implies --yes)
+const AUTO = args.auto;
+const AUTO_YES = args.yes || AUTO;
+const SHOW_MODELS = args.models;
+const SHOW_MCP = args.mcpList;
+const NO_CONTEXT = args.noContext;
+// `--mcp` alone attaches everything configured; `--mcp nx,kronk` narrows it.
+const MCP_ON = args.mcp;
+const MCP_WANTED = args.mcpNames;
 
-/** Last resort when neither the flag nor DEFAULT_MODEL is being served. */
-function pickDefault(ids) {
-  const chat = ids.filter((id) => !/embedding|rerank/i.test(id));
-  const agent = chat.filter((id) => id.endsWith('/AGENT'));
-  const pool = agent.length ? agent : chat;
-  return pool.sort((a, b) => b.length - a.length)[0] ?? null;
-}
+if (args.noThink) config.noThink = true;
+if (args.noCompact) config.autoCompact = false;
+if (args.noWarm) config.warm = false;
+if (args.model) config.model = args.model;
+if (args.steps !== null) config.maxSteps = args.steps;
 
 async function boot() {
   let ids;
@@ -139,9 +124,15 @@ async function boot() {
   }
   if (!config.model) config.model = pickDefault(ids);
 
-  const { configured, native } = await modelLimits(config.model);
+  if (config.warm) await ensureLoaded(ids);
+
+  const {
+    configured, native, preserveThinking, samplingDiff,
+  } = await modelLimits(config.model);
   config.contextWindow = configured;
   config.nativeContext = native;
+  config.templatePreservesThinking = preserveThinking;
+  config.samplingOverride = samplingDiff;
   return ids;
 }
 
@@ -322,7 +313,7 @@ async function oneShot(prompt) {
     return false;
   };
   try {
-    await runTurn({ messages, model: config.model, signal: ac.signal, approve, mcp });
+    await runTurn({ messages, model: config.model, signal: ac.signal, approve, mcp, auto: AUTO });
   } catch (e) {
     if (e.name !== 'AbortError') { console.error(c.red(`  ${e.message}`)); process.exitCode = 1; }
   } finally {
@@ -334,21 +325,58 @@ async function main() {
   // Before anything reaches the network, on every path through the program.
   warnIfInsecure();
 
+  // Subcommands are dispatched before the one-shot path below, so `setup` is
+  // never mistaken for a one-word prompt and sent to the model.
+  if (args.words[0] === 'setup') {
+    if (args.words.length > 1) {
+      console.error(`\n  setup takes no arguments — got: ${args.words.slice(1).join(' ')}\n`);
+      process.exitCode = 2;
+      return;
+    }
+    process.exitCode = await runSetup({
+      model: args.model,
+      context: args.context,
+      yes: args.yes,
+      dryRun: args.dryRun,
+    });
+    return;
+  }
+
   if (SHOW_MODELS) { await showModels(); return; }
   if (SHOW_MCP) { await showMcp(); process.exit(0); }
 
   // non-interactive: `kronk-cli "prompt"` or `echo prompt | kronk-cli`
-  const inline = argv.join(' ').trim();
+  const inline = args.words.join(' ').trim();
   // With an inline prompt, stdin is optional extra context — don't block on it.
   // Without one, stdin IS the prompt, so wait longer before giving up.
   const piped = await readStdin(inline ? 200 : 10_000);
   const oneShotPrompt = inline && piped ? `${inline}\n\n${piped}` : (inline || piped);
-  if (oneShotPrompt) { await oneShot(oneShotPrompt); return; }
+  if (oneShotPrompt) {
+    // stdin has given us everything it is going to. When it is a pipe the
+    // caller never closes — a script, an editor task, a CI step — the read
+    // above stays pending and its handle would keep the process alive long
+    // after the answer was printed. Let go of it before answering.
+    stdin.pause();
+    stdin.unref?.();
+    await oneShot(oneShotPrompt);
+    return;
+  }
 
   const rl = readline.createInterface({ input: stdin, output: stdout, historySize: 500 });
   await boot();
   const { content, ctx } = await systemMessage(AUTO);
   console.log(banner(config.model, config.baseUrl));
+
+  // Information, not a failure: the profile is doing exactly what it was
+  // told to, it's just not what the model's own GGUF recommends. One-shot
+  // mode never reaches this line because it never prints the banner either.
+  if (config.samplingOverride) {
+    const named = config.samplingOverride
+      .map((d) => `${d.param} ${d.effective} (model recommends ${d.model})`)
+      .join(', ');
+    console.log(c.grey(`  note     profile overrides the model's own sampling: ${named}`));
+  }
+
   const mcp = await startMcp();
 
   if (ctx) {
@@ -368,6 +396,9 @@ async function main() {
     : c.grey(`paths + ${backend}`)}\n`);
 
   const messages = [{ role: 'system', content }];
+  // The system prompt is the one record of which mode we are in — /auto rewrites
+  // it — so both the status line and the turn read the answer from there.
+  const isAuto = () => messages[0].content.startsWith(SYSTEM_AUTO);
 
   // Ctrl-C aborts the in-flight request instead of killing the process.
   let ac = null;
@@ -386,9 +417,11 @@ async function main() {
   for (;;) {
     const status = statusLine({
       model: config.model,
-      auto: autoApprove && messages[0].content.startsWith(SYSTEM_AUTO),
+      auto: autoApprove && isAuto(),
       yes: autoApprove,
       noThink: config.noThink,
+      // Only news when the model could have had it and the user said no.
+      noPreserve: config.templatePreservesThinking && !config.noThink && !config.preserveThinking,
       mcp: mcp?.routes.size ? [...mcp.servers.keys()].join(',') : null,
       steps: config.maxSteps,
       used: config.lastUsed,
@@ -418,9 +451,8 @@ async function main() {
       continue;
     }
     if (input === '/auto') {
-      const now = !messages[0].content.startsWith(SYSTEM_AUTO);
-      const primer = messages[0].content.slice(
-        (messages[0].content.startsWith(SYSTEM_AUTO) ? SYSTEM_AUTO : SYSTEM).length);
+      const now = !isAuto();
+      const primer = messages[0].content.slice((isAuto() ? SYSTEM_AUTO : SYSTEM).length);
       messages[0] = { role: 'system', content: (now ? SYSTEM_AUTO : SYSTEM) + primer };
       autoApprove = now;
       console.log(c.grey(`  autonomous mode ${now ? 'on — tools auto-approved, runs to completion' : 'off'}`));
@@ -448,14 +480,18 @@ async function main() {
     if (input === '/compact') {
       if (messages.length < 2) { console.log(c.grey('  nothing to compact')); continue; }
       const sp = new AbortController();
-      const res = await compact(messages, { model: config.model, signal: sp.signal });
+      const res = await compact(messages, { model: config.model, signal: sp.signal, auto: isAuto() });
       if (res.failed) { console.log(c.red('  compaction produced nothing — conversation unchanged')); continue; }
       if (!res.skipped) messages.splice(0, messages.length, ...res.messages);
       console.log(report(res));
       continue;
     }
     if (input === '/context') {
-      const used = await tokenize(config.model, messages.map((m) => m.content ?? '').join('\n'));
+      // Count what the next request would actually carry, replayed reasoning
+      // included — the history holds reasoning that is never sent, and a meter
+      // that charged for it would read high for the whole session.
+      const used = await tokenize(config.model, forRequest(messages, isAuto())
+        .map((m) => `${m.reasoning_content ?? ''}${m.content ?? ''}`).join('\n'));
       console.log(`  ${fmtContext(used, config.contextWindow) || c.grey('unknown')}`);
       console.log(c.grey(`  window: ${config.contextWindow?.toLocaleString() ?? '?'} tokens`
         + (config.nativeContext ? ` · model supports up to ${config.nativeContext.toLocaleString()}` : '')));
@@ -488,7 +524,7 @@ async function main() {
     messages.push({ role: 'user', content: input });
     ac = new AbortController();
     try {
-      await runTurn({ messages, model: config.model, signal: ac.signal, approve, mcp });
+      await runTurn({ messages, model: config.model, signal: ac.signal, approve, mcp, auto: isAuto() });
     } catch (e) {
       if (e.name === 'AbortError') messages.push({ role: 'assistant', content: '(interrupted)' });
       else console.error(c.red(`\n  ${e.message}`));

package/src/plan.js

@@ -0,0 +1,167 @@
+import { c } from './ui.js';
+
+/**
+ * The checklist for the task currently being run.
+ *
+ * Module state rather than a message, because `compactInto` splices the whole
+ * transcript when the window fills — a plan that lived only in `messages`
+ * would be summarised away on exactly the long runs that need it. What the
+ * model sees each round is a snapshot of this store, appended to the tool
+ * result that round produced; see `carryChecklist` for why it is appended and
+ * never moved.
+ */
+
+/** Long enough for any real ticket; short enough that a runaway list is caught. */
+export const MAX_ITEMS = 40;
+
+const STATUSES = ['todo', 'doing', 'done'];
+
+/** Every checklist snapshot and every nudge opens with this, so both are greppable. */
+export const REMINDER_TAG = 'CHECKLIST —';
+
+let items = [];
+
+export const plan = () => items;
+export const openItems = () => items.filter((i) => i.status !== 'done');
+
+/** Called at the start of every turn: a plan belongs to one task, not to a session. */
+export function clearPlan() { items = []; }
+
+/** The stored plan as text — what `set_plan` hands back, so the model sees what it committed to. */
+export function render() {
+  if (!items.length) return 'plan: (empty)';
+  const done = items.length - openItems().length;
+  const rows = items.map((i, n) => `${n + 1}. [${i.status}] ${i.text}`);
+  return [`plan — ${done}/${items.length} done`, ...rows].join('\n');
+}
+
+/**
+ * Replace the checklist wholesale.
+ *
+ * Full replacement, never a patch: partial-update semantics are where a small
+ * model quietly drops half its list. Overlong lists are cut rather than
+ * refused, and the loss is reported back in the result so it is not silent.
+ */
+export function setPlan(raw) {
+  if (!Array.isArray(raw)) throw new Error('set_plan needs an "items" array of {text, status}');
+
+  const kept = raw.slice(0, MAX_ITEMS).map((item, n) => {
+    const text = String(item?.text ?? '').trim();
+    if (!text) throw new Error(`set_plan: item ${n + 1} has no text`);
+    const status = item.status ?? 'todo';
+    if (!STATUSES.includes(status)) {
+      throw new Error(`set_plan: item ${n + 1} has status "${status}" — use todo, doing or done`);
+    }
+    return { text, status };
+  });
+
+  items = kept;
+  const dropped = raw.length - kept.length;
+  if (!dropped) return render();
+  return `${render()}\n\nnote: ${raw.length} items were sent and the list is capped at ${MAX_ITEMS}`
+    + `, so the last ${dropped} were dropped. Send a shorter plan if they matter.`;
+}
+
+const MARK = { todo: '·', doing: '▸', done: '✓' };
+
+/** The plan on screen: one line each, greyed except whatever is being worked on. */
+export function planLines() {
+  return items.map((i) => {
+    const line = `    ${MARK[i.status]} ${i.text}`;
+    return i.status === 'doing' ? line : c.grey(line);
+  });
+}
+
+/** What was left unfinished, in yellow, when the turn ends anyway. */
+export function outstandingLines() {
+  const open = openItems();
+  if (!open.length) return [];
+  return [
+    c.yellow(`  ⚠ ${open.length} of ${items.length} checklist items were not finished:`),
+    ...open.map((i) => c.yellow(`    ${MARK[i.status]} ${i.text}`)),
+  ];
+}
+
+const tally = () => `${items.length - openItems().length}/${items.length} items done`;
+const openLines = () => openItems().map((i) => `- [${i.status}] ${i.text}`);
+
+/**
+ * The snapshot appended to a round's last tool result.
+ *
+ * Phrased as a point in time on purpose: earlier rounds keep the snapshot they
+ * were given, so several sit in the history at once and only the last one is
+ * current. Saying so is what stops a stale one being read as the truth.
+ */
+function snapshotText() {
+  return [
+    `${REMINDER_TAG} where the plan stands at this step. ${tally()}. Still open:`,
+    ...openLines(),
+    'An earlier snapshot above is out of date — this is the current one.',
+    'Keep working through the open items, and record each one with set_plan as it is finished.',
+  ].join('\n');
+}
+
+function nudgeText() {
+  return [
+    `${REMINDER_TAG} you stopped with work outstanding. ${tally()}. Still open:`,
+    ...openLines(),
+    'Do not summarise yet. Carry on with the next open item. If one genuinely cannot be'
+    + ' done, say in your reply why not, and only then mark it done with set_plan.',
+  ].join('\n');
+}
+
+/** A nudge is the only checklist text that is a message of its own. */
+export const isNudge = (m) =>
+  m?.role === 'user' && typeof m.content === 'string' && m.content.startsWith(REMINDER_TAG);
+
+/** Tool results already carrying a snapshot, held by identity. */
+const carried = new WeakSet();
+
+/**
+ * Append the checklist to the last tool result of the round that just ran.
+ *
+ * Append-only, and that is the entire point. This used to be a `user` message
+ * of its own, spliced out of the middle of `messages` and re-pushed at the end
+ * every round. Removing a message changes the rendered prompt from that point
+ * on, and Kronk's incremental prompt cache cannot recover past the change: it
+ * keeps the longest common prefix and re-prefills the rest. Measured over four
+ * rounds against Kronk 1.31.9 with preserve_thinking on, moving the message
+ * gave cached 0 / 607 / 607 / 607 with re-prefill 724 / 193 / 269 / 345 —
+ * pinned at the first reminder and growing without bound — where appending
+ * gives cached 607 / 715 / 814 / 913 with re-prefill 113 / 104 / 104 / 104.
+ * In the field that was a median 14.3s to first token against 0.5s.
+ *
+ * So: never remove or move anything already in `messages`. Only append. A tool
+ * result created this round has not been sent yet, so growing it extends the
+ * prefix instead of rewriting it, and it is still the last thing the model
+ * reads. Older rounds keep their own snapshot; going back to strip them is the
+ * very edit that costs the cache.
+ */
+export function carryChecklist(messages) {
+  if (!openItems().length) return;
+
+  // The tail only. A `role: 'tool'` message further back belongs to a round
+  // that has already gone out, and editing that is the eviction described
+  // above. A round that produced no tool result has nowhere to put this.
+  const last = messages.at(-1);
+  if (last?.role !== 'tool') return;
+
+  // Identity, not a search for the tag in the text: a tool result can hold the
+  // tag legitimately — a grep of this file does — and appending twice to one
+  // message is a bug, not a second snapshot.
+  if (carried.has(last)) return;
+  carried.add(last);
+  last.content = `${last.content}\n\n${snapshotText()}`;
+}
+
+/**
+ * Hand the open items back as a `user` message when the model stops early.
+ *
+ * This one stays a message, because a new message on the end is exactly what
+ * the cache tolerates: everything before it is untouched. It is pushed and
+ * never removed again.
+ */
+export function pushNudge(messages) {
+  if (!openItems().length) return;
+  messages.push({ role: 'user', content: nudgeText() });
+}

package/src/reasoning.js

@@ -0,0 +1,118 @@
+import { config } from './config.js';
+
+/**
+ * Index of the last *real* user message, or -1 when there is none.
+ *
+ * Tool results are `role: 'tool'`, so they do not move it: one user prompt and
+ * the whole tool loop it kicked off share a single boundary. That is the same
+ * boundary the Qwen3.6 template computes as `ns.last_query_index`, on purpose —
+ * see `forRequest` below.
+ */
+export function lastUserIndex(messages) {
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    if (messages[i].role === 'user') return i;
+  }
+  return -1;
+}
+
+/**
+ * Whether this request should carry the current task's reasoning back.
+ *
+ * `auto` is autonomous mode, the same flag `runTurn` already threads through
+ * for the task-plan nudge — not a second source of truth for "am I
+ * autonomous". The default this resolves to is autonomous-only: with no
+ * override, `config.replayReasoning` is `undefined` and `auto` alone decides.
+ * `config.replayReasoning` set to `true` or `false` overrides that default in
+ * either direction — replay on in the REPL, or off in `--auto` — which is why
+ * it is read as three states in src/config.js rather than coerced to a
+ * boolean. See that default's rationale on `forRequest` below.
+ *
+ * Read per request, because `/think` flips `noThink` mid-session.
+ *
+ * Gated on `templatePreservesThinking` — the same startup detection the
+ * `preserve_thinking` request field already uses — because a template that
+ * does not declare the parameter is also not one that reads
+ * `message.reasoning_content`: it drops the blocks on the floor and the replay
+ * is pure prompt overhead for nothing.
+ *
+ * Deliberately *not* gated on `config.preserveThinking`. That flag only pins
+ * the blocks at or before the boundary; everything after it renders under the
+ * template's own `loop.index0 > ns.last_query_index` arm regardless. On the
+ * fixture measured under `forRequest`, `preserve_thinking: false` still costs
+ * the same +107 tokens for the current tool loop, and costs nothing at all for
+ * the history the template throws away. The pin and the replay answer
+ * different questions; turning one off must not silently turn the other off.
+ */
+export const shouldReplayReasoning = (auto = false) =>
+  (config.replayReasoning ?? auto) && config.templatePreservesThinking && !config.noThink;
+
+/**
+ * The message list as it goes on the wire: reasoning is kept for the assistant
+ * messages that belong to the current tool loop and stripped from every one at
+ * or before the last real user message.
+ *
+ * ---- why this boundary and not another ----
+ *
+ * Within one task the model reasons about tool result N before it chooses tool
+ * N+1. Dropping that, which is what this agent did before, makes it re-derive
+ * its plan from the tool output alone at every step; that is the loss that
+ * actually degrades agentic behaviour.
+ *
+ * Current-turn reasoning is append-only. Those tokens are new on every step
+ * anyway, so they were never part of the cached prefix and replaying them
+ * costs nothing in cache terms.
+ *
+ * Historical reasoning is prefix-resident. It inflates the cached prefix
+ * permanently and eats window. This agent compacts at 85% of the window, every
+ * compaction invalidates the cached prefix and forces a full prefill, so
+ * replaying all of history would partly undo the prefix stability that sending
+ * `preserve_thinking` bought.
+ *
+ * It also matches how the Messages API treats thinking alongside tool use:
+ * thinking is passed back with the tool result inside the turn, while earlier
+ * turns' blocks are stripped.
+ *
+ * Measured against Kronk 1.31.9 on the /AGENT profile, on a fixture of two
+ * user turns and a two-call tool loop, `preserve_thinking: true`: dropping all
+ * reasoning 207 prompt tokens, this policy 314 (+107), replaying all of
+ * history 368 (+161). The +54 that separates the last two is the part that
+ * would sit in the prefix for the rest of the session and grow with it.
+ *
+ * ---- why autonomous-only, not on everywhere ----
+ *
+ * The cost above lands at the *next* prompt, not this one: stripping the
+ * previous task's blocks at the boundary rewrites the prefix a newer user
+ * message sits after, which throws away the cached prefix and forces a full
+ * re-prefill. Measured on a live server, first turn after a second prompt,
+ * prompt tokens cached vs. re-prefilled:
+ *
+ *     never replay        cached 906, re-prefill  60
+ *     replay current task cached 757, re-prefill 516   <- cache reset to the system prompt
+ *     replay everything   cached 1827, re-prefill 367
+ *
+ * `--auto` runs exactly one user prompt through the whole tool loop, so that
+ * boundary is never crossed in a run: this policy's within-task benefit is
+ * free there, and the reset above never happens. The REPL is a user typing
+ * repeatedly, so every prompt after the first pays it — measured 4.4-7.4 s to
+ * first token against 0.7-1.2 s once cached. Hence the default: on for
+ * `--auto`, off for the REPL. `config.replayReasoning` overrides it either way
+ * — see `shouldReplayReasoning` above.
+ *
+ * The array is rebuilt but the untouched messages are shared, not copied: the
+ * caller's history keeps its reasoning for the steps that come next.
+ */
+export function forRequest(messages, auto = false) {
+  const boundary = lastUserIndex(messages);
+  const replay = shouldReplayReasoning(auto);
+  return messages.map((m, i) => {
+    if (m.reasoning_content === undefined) return m;
+    // An empty string is stripped as well as dropped history: the template
+    // renders an empty <think> block for a message that carries no reasoning
+    // either way, so sending the key buys nothing and only invites a server
+    // that validates it more strictly than this one to reject the request.
+    if (replay && i > boundary && m.reasoning_content) return m;
+    const stripped = { ...m };
+    delete stripped.reasoning_content;
+    return stripped;
+  });
+}