kronk-cli 0.1.2 → 0.2.0

package/src/agent.js

@@ -1,9 +1,13 @@
 import { streamChat } from './client.js';
 import { TOOLS, NEEDS_APPROVAL, runTool, describe, preview, mcpNeedsApproval } from './tools.js';
-import { config } from './config.js';
-import { c, fmtUsage, spinner, liveLine } from './ui.js';
+import { config, shouldPreserveThinking } from './config.js';
+import { forRequest } from './reasoning.js';
+import { c, fmtUsage, spinner, liveLine, toolResultLines } from './ui.js';
 import { compact, isOverflow, report } from './compact.js';
 import { maybeDistill } from './distill.js';
+import {
+  carryChecklist, clearPlan, openItems, outstandingLines, planLines, pushNudge,
+} from './plan.js';
 
 export const SYSTEM = `You are kronk-cli, a terse coding assistant running fully offline on the user's machine.
 
@@ -11,35 +15,84 @@ Rules:
 - Inspect before you answer. Use read_file / list_dir / search rather than guessing at code.
 - Prefer one decisive action over narrating options.
 - Keep prose short. Code blocks should be complete and runnable.
-- The working directory is the user's project root. Paths are relative to it.`;
+- The working directory is the user's project root. Paths are relative to it. You are already inside it. Do not \`cd\` above it. If a command reports that this is not a git repository, you have left the project — return to it rather than searching elsewhere.`;
 
 export const SYSTEM_AUTO = `${SYSTEM}
 
 You are running autonomously on a whole task. Finish it before you stop.
+- Before your first edit, call set_plan with one item per acceptance criterion, requirement or checkbox in the request. Copy the wording of the request; do not paraphrase it into something easier.
+- If the request calls a step required, mandatory, or a first step, it is an item, and it is done before the work it gates.
+- Update the plan with set_plan after each item. Record progress with the tool, not in prose.
 - Do not ask the user questions. Make a reasonable choice and proceed.
 - After you write code, RUN it with bash and fix whatever breaks.
 - Never claim something works unless you have executed it and seen the output.
 - Work in small steps: one file or one command per tool call.
-- When the task is genuinely done, reply with a short summary of what you changed.`;
+- Do not reply with a summary while any item is not done. If an item cannot be completed, say in your reply why it was not possible, and only then mark it done — never silently.
+- Before the final reply, re-read the original request and check every item against it.
+- When every item is genuinely done, reply with a short summary of what you changed.`;
 
 /**
- * Run one user turn to completion, looping while the model requests tools.
- * `approve(name, args)` returns a boolean; used for mutating tools.
+ * The reasoning half of an assistant message, or nothing at all.
+ *
+ * A model that emitted no reasoning — `--no-think`, or a non-reasoning model —
+ * must produce exactly the message this agent has always produced, so the key
+ * is absent rather than empty.
  */
-/** Compact in place, preserving the caller's array identity. */
-async function compactInto(messages, model, signal) {
-  const res = await compact(messages, { model, signal });
+const thought = (reasoning) => (reasoning ? { reasoning_content: reasoning } : {});
+
+/**
+ * Compact in place, preserving the caller's array identity.
+ *
+ * `auto` is passed through so the summarizer sees the same reasoning-replay
+ * view as the wire request that just overflowed — see `compact` in
+ * src/compact.js.
+ */
+async function compactInto(messages, model, signal, auto) {
+  const res = await compact(messages, { model, signal, auto });
   if (res.failed || res.skipped) { console.log(report(res)); return false; }
   messages.splice(0, messages.length, ...res.messages);
   console.log(report(res));
   return true;
 }
 
-export async function runTurn({ messages, model, signal, approve, mcp, maxSteps = config.maxSteps }) {
+/** How many times a premature "done" is handed back before the turn ends anyway. */
+const MAX_NUDGES = 2;
+
+/**
+ * Say what was not finished, and hand the transcript back fit to be continued.
+ *
+ * Nothing is taken out of it on the way. A turn always ends on an assistant
+ * message — the reply, or the step-cap note — so a nudge is never left sitting
+ * directly before the next typed prompt.
+ */
+function endTurn(messages) {
+  outstandingLines().forEach((l) => console.log(l));
+  return messages;
+}
+
+/**
+ * Run one user turn to completion, looping while the model requests tools.
+ *
+ * `approve(name, args)` returns a boolean; used for mutating tools. `auto` is
+ * autonomous mode — the system prompt in force, not `--yes` — and decides
+ * both whether a premature "done" is handed back or accepted, and (via
+ * src/reasoning.js) whether the current task's reasoning defaults to being
+ * replayed on the wire.
+ */
+export async function runTurn({
+  messages, model, signal, approve, mcp, auto = false, maxSteps = config.maxSteps,
+}) {
   const tools = mcp ? [...TOOLS, ...mcp.toolDefs()] : TOOLS;
   let totalUsage = null;
   let step = 0;
   let compacted = false;
+  let nudges = 0;
+
+  // A plan belongs to one task, not to a session. Only the store is cleared:
+  // a checklist the previous turn left in the transcript is history, it is
+  // already in the prompt prefix, and rewriting history is what evicts the
+  // prompt cache — see `carryChecklist`.
+  clearPlan();
 
   for (;;) {
     step += 1;
@@ -47,19 +100,33 @@ export async function runTurn({ messages, model, signal, approve, mcp, maxSteps
       console.log(c.yellow(`  ⛔ step cap reached (${maxSteps}). Stopping.`));
       console.log(c.grey('     raise it with --steps N, or /steps N in the REPL'));
       messages.push({ role: 'assistant', content: '(stopped: step cap reached)' });
-      return messages;
+      return endTurn(messages);
     }
     let sp = spinner('thinking');
     let text = '';
+    let reasoning = '';
     let calls = [];
     let wroteAnything = false;
     let inReasoning = false;
 
     try {
       for await (const ev of streamChat({
-        model, messages, tools, signal, maxTokens: config.maxTokens, noThink: config.noThink,
+        model,
+        // The history keeps every step's reasoning; only the current task's
+        // share of it goes on the wire. See src/reasoning.js.
+        messages: forRequest(messages, auto),
+        tools,
+        signal,
+        maxTokens: config.maxTokens,
+        noThink: config.noThink,
+        // Re-read every step: this has to hold for the tool-loop follow-ups too,
+        // and `/think` can flip the answer between one turn and the next.
+        preserveThinking: shouldPreserveThinking(),
       })) {
         if (ev.type === 'reasoning') {
+          // Accumulated before the display check: whether the user watches the
+          // model think has nothing to do with whether the model gets it back.
+          reasoning += ev.value;
           if (!config.showThinking) continue;
           if (sp) { sp.stop(); sp = null; }
           if (!inReasoning) { process.stdout.write(c.grey('\n  ┄ thinking ┄\n  ')); inReasoning = true; }
@@ -88,7 +155,15 @@ export async function runTurn({ messages, model, signal, approve, mcp, maxSteps
       if (isOverflow(e) && !compacted) {
         compacted = true;
         console.log(c.yellow('\n  context full — compacting and retrying'));
-        if (await compactInto(messages, model, signal)) { step -= 1; continue; }
+        // The plan itself is module state, so compaction cannot reach it. The
+        // snapshot it just summarised away is not put back: there is no tool
+        // result left to carry one, and inserting a message here would be the
+        // rewrite `carryChecklist` exists to avoid. The next round's tool
+        // results carry the plan again.
+        if (await compactInto(messages, model, signal, auto)) {
+          step -= 1;
+          continue;
+        }
       }
       throw e;
     } finally {
@@ -106,7 +181,7 @@ export async function runTurn({ messages, model, signal, approve, mcp, maxSteps
       const used = (totalUsage.prompt_tokens ?? 0) + (totalUsage.completion_tokens ?? 0);
       if (used / config.contextWindow >= config.compactAt) {
         console.log(c.yellow(`  context ${Math.round((used / config.contextWindow) * 100)}% full — compacting`));
-        if (!await compactInto(messages, model, signal)) config.autoCompact = false;
+        if (!await compactInto(messages, model, signal, auto)) config.autoCompact = false;
       }
     }
 
@@ -116,16 +191,28 @@ export async function runTurn({ messages, model, signal, approve, mcp, maxSteps
         // Reasoning models sometimes spend the whole budget thinking and emit no
         // answer. Say so rather than returning silence.
         console.log(c.yellow('  (model produced no answer — raise KRONK_MAX_TOKENS or /thinking off)'));
-        messages.push({ role: 'assistant', content: '(no answer produced)' });
+        messages.push({ role: 'assistant', content: '(no answer produced)', ...thought(reasoning) });
       } else {
-        messages.push({ role: 'assistant', content: text });
+        messages.push({ role: 'assistant', content: text, ...thought(reasoning) });
       }
-      return messages;
+
+      // A plan with open items means it stopped early. Hand the list back and
+      // keep going — but only when nobody is watching, and only twice: past
+      // that the model is not going to finish, and looping is worse than
+      // reporting what is left.
+      if (auto && openItems().length && nudges < MAX_NUDGES) {
+        nudges += 1;
+        pushNudge(messages);
+        console.log(c.yellow(`  ⚠ ${openItems().length} checklist items still open — continuing`));
+        continue;
+      }
+      return endTurn(messages);
     }
 
     messages.push({
       role: 'assistant',
       content: text,
+      ...thought(reasoning),
       tool_calls: calls.map((t) => ({
         id: t.id, type: 'function',
         function: { name: t.name, arguments: t.args || '{}' },
@@ -176,15 +263,23 @@ export async function runTurn({ messages, model, signal, approve, mcp, maxSteps
         live.done();
       }
 
-      result = await maybeDistill(result, {
-        model, signal, command: args.cmd ?? describe(call.name, args),
-      });
+      // set_plan hands back a rendering of what the harness just stored; paying a
+      // second model call to paraphrase our own text would be pure waste.
+      if (call.name !== 'set_plan') {
+        result = await maybeDistill(result, {
+          model, signal, command: args.cmd ?? describe(call.name, args),
+        });
+      }
       const failed = result.startsWith('error:');
-      console.log(failed
-        ? c.red(`  ✗ ${result.split('\n')[0]}`)
-        : c.grey(`  ✓ ${result.split('\n').length} lines`));
+      if (failed) toolResultLines(result).forEach((l) => console.log(l));
+      else if (call.name === 'set_plan') planLines().forEach((l) => console.log(l));
+      else console.log(c.grey(`  ✓ ${result.split('\n').length} lines`));
       messages.push({ role: 'tool', tool_call_id: call.id, content: result });
     }
+
+    // On the last tool result rather than in a message of its own, so the
+    // round only ever adds to the prompt. Nothing already sent is touched.
+    carryChecklist(messages);
     // loop: the model now sees the tool output
   }
 }

package/src/argv.js

@@ -0,0 +1,160 @@
+/**
+ * Command-line parsing, kept out of index.js so it can be imported and tested
+ * without running the program.
+ *
+ * One left-to-right pass, each token consumed exactly once. The multi-pass
+ * version this replaces spliced tokens out of argv in source order, so
+ * `--model --no-think x` had already lost `--no-think` by the time the model
+ * option looked at its neighbour and happily took the prompt as a model id.
+ */
+
+/**
+ * The one place that knows how an option is spelled. Both the parser and the
+ * "did you mean" suggestion read from it, so a new option cannot be understood
+ * by one and unknown to the other.
+ *
+ * kind: 'flag' takes nothing, 'value' requires the next token, 'optional' takes
+ * the next token only when it does not look like an option.
+ */
+const SPECS = [
+  { names: ['-h', '--help'], kind: 'flag', key: 'help' },
+  { names: ['-l', '--models', '--list'], kind: 'flag', key: 'models' },
+  { names: ['--mcp-list'], kind: 'flag', key: 'mcpList' },
+  { names: ['--no-context'], kind: 'flag', key: 'noContext' },
+  { names: ['--no-compact'], kind: 'flag', key: 'noCompact' },
+  { names: ['--no-warm'], kind: 'flag', key: 'noWarm' },
+  { names: ['--no-think'], kind: 'flag', key: 'noThink' },
+  { names: ['-a', '--auto'], kind: 'flag', key: 'auto' },
+  { names: ['-y', '--yes'], kind: 'flag', key: 'yes' },
+  { names: ['--dry-run'], kind: 'flag', key: 'dryRun' },
+  { names: ['-m', '--model'], kind: 'value', key: 'model' },
+  { names: ['--steps'], kind: 'value', key: 'steps' },
+  { names: ['--context'], kind: 'value', key: 'context' },
+  { names: ['--mcp'], kind: 'optional', key: 'mcp' },
+];
+
+const BY_NAME = new Map(SPECS.flatMap((s) => s.names.map((n) => [n, s])));
+
+/** Every recognised spelling, sorted so suggestions break ties predictably. */
+export const KNOWN = [...BY_NAME.keys()].sort();
+
+/**
+ * A leading dash with no whitespace after it. The no-whitespace part is what
+ * keeps prose working: `kronk-cli "- fix the dashes bug"` is one argv token and
+ * whoever typed it has no idea an escape hatch exists. A bare `-` is left alone
+ * too — it is the conventional stdin placeholder.
+ */
+const OPTIONISH = /^-\S+$/;
+
+const STEPS_WORDS = /^(0|off|none|inf|unlimited)$/i;
+
+/** Plain Levenshtein distance. Small inputs, no dependency, no cleverness. */
+function distance(a, b) {
+  let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const row = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const sub = prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1);
+      row[j] = Math.min(row[j - 1] + 1, prev[j] + 1, sub);
+    }
+    prev = row;
+  }
+  return prev[b.length];
+}
+
+/**
+ * The flag an unknown token was probably meant to be, or null.
+ *
+ * A wrong suggestion is worse than none, so only two rules apply: one more dash
+ * turns it into a known flag (`-auto` → `--auto`, the whole observed failure
+ * mode), or it is within two edits of a known flag — nearest first, ties broken
+ * alphabetically so the same typo always gets the same answer.
+ */
+export function suggest(token) {
+  if (BY_NAME.has(`-${token}`)) return `-${token}`;
+  let best = null;
+  let bestAt = 3;
+  for (const name of KNOWN) {           // sorted, so the first of a tie wins
+    const d = distance(token, name);
+    if (d < bestAt) { best = name; bestAt = d; }
+  }
+  return best;
+}
+
+const unknown = (token) => {
+  const hint = suggest(token);
+  return [
+    `unknown option: ${token}`,
+    ...(hint ? [`did you mean ${hint}?`] : []),
+    'kronk-cli --help for the full list',
+  ].map((l) => `  ${l}`).join('\n');
+};
+
+/**
+ * Parse argv into a plain result. Never prints, never exits: the caller decides
+ * what a usage error looks like, which is what makes this testable.
+ *
+ * On a usage error `error` is the message to print, and nothing else in the
+ * result should be acted on.
+ */
+export function parseArgv(argv) {
+  const out = {
+    error: null,
+    help: false, models: false, mcpList: false,
+    noContext: false, noCompact: false, noWarm: false, noThink: false,
+    auto: false, yes: false, dryRun: false,
+    model: null,
+    context: null,
+    steps: null,
+    mcp: false, mcpNames: null,
+    words: [],
+  };
+  const fail = (message) => ({ ...out, error: message });
+
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+
+    // Consumed here, before the unknown-option check below can ever see it.
+    if (token === '--') { out.words.push(...argv.slice(i + 1)); break; }
+
+    const spec = BY_NAME.get(token);
+    if (!spec) {
+      if (OPTIONISH.test(token)) return fail(unknown(token));
+      out.words.push(token);            // prose, or a bare word for a subcommand
+      continue;
+    }
+
+    if (spec.kind === 'flag') { out[spec.key] = true; continue; }
+
+    const next = argv[i + 1];
+    if (spec.kind === 'optional') {
+      out.mcp = true;
+      if (next !== undefined && !next.startsWith('-')) {
+        out.mcpNames = next.split(',').map((x) => x.trim()).filter(Boolean);
+        i++;
+      }
+      continue;
+    }
+
+    // 'value': the option must get one. `--steps -1` lands here rather than in
+    // the value check below — one uniform rule, one predictable message.
+    if (next === undefined || OPTIONISH.test(next)) {
+      return fail(`  ${token} needs a value`);
+    }
+    i++;
+
+    if (spec.key === 'steps') {
+      // An unparseable cap used to become NaN, which read as "unlimited" — the
+      // most permissive answer possible, in a tool that runs shell commands.
+      if (STEPS_WORDS.test(next)) out.steps = Infinity;
+      else if (/^\d+$/.test(next)) out.steps = Number(next);
+      else {
+        return fail('  --steps takes a non-negative integer, or one of: 0, off, none, inf, unlimited');
+      }
+      continue;
+    }
+    out[spec.key] = next;
+  }
+
+  return out;
+}

package/src/boot.js

@@ -0,0 +1,59 @@
+import { config, DEFAULT_MODEL } from './config.js';
+import { listLoaded, warm } from './client.js';
+import { c, spinner } from './ui.js';
+
+/** Last resort when neither the flag nor DEFAULT_MODEL is being served. */
+export 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;
+}
+
+/**
+ * Get the chosen model resident before the first prompt.
+ *
+ * A freshly started Kronk serves model *ids* but holds nothing in VRAM — it
+ * admits a model on its first inference request, and there is no endpoint that
+ * does it sooner. Left alone, that 10–25 s cold load lands on the first thing
+ * you type, looking like a hang. Do it here, where a spinner explains the wait
+ * and where a model that will not fit can still fall back to one that will.
+ *
+ * Never fatal: if nothing warms, the original pick stands and the first turn
+ * reports the real error. A warm-up is a convenience, not a gate.
+ *
+ * Returns the id left in `config.model`.
+ */
+export async function ensureLoaded(ids, log = console.error) {
+  const loaded = await listLoaded();
+  const resident = new Set((Array.isArray(loaded) ? loaded : []).map((l) => l.id));
+  if (resident.has(config.model)) return config.model;
+
+  const chosen = config.model;
+  // chosen → configured default → best guess; each distinct id tried once.
+  const chain = [...new Set([
+    chosen,
+    ids.includes(DEFAULT_MODEL) ? DEFAULT_MODEL : null,
+    pickDefault(ids),
+  ])].filter(Boolean);
+
+  for (const id of chain) {
+    if (resident.has(id)) { config.model = id; return id; }
+    const t0 = Date.now();
+    const spin = spinner(`loading ${id.split('/').pop()} — first run takes 10-30s`);
+    try {
+      await warm(id);
+      spin.stop();
+      const how = `${((Date.now() - t0) / 1000).toFixed(1)}s${id === chosen ? '' : ' · fallback'}`;
+      log(c.grey(`  loaded   ${id} · ${how}`));
+      config.model = id;
+      return id;
+    } catch (e) {
+      spin.stop();
+      log(c.yellow(`  ${id} failed to load — ${e.message.split('\n')[0].slice(0, 160)}`));
+    }
+  }
+  // Nothing would load. Keep the original pick and let the first turn say why.
+  config.model = chosen;
+  return chosen;
+}

package/src/client.js

@@ -15,10 +15,81 @@ export async function listModels() {
   return data.map((m) => m.id);
 }
 
+// Which model-metadata key names each sampling parameter, and how the same
+// value is spelled in `model_config['sampling-parameters']` once the profile
+// has been applied.
+const SAMPLING_KEYS = [
+  { meta: 'general.sampling.temp', effective: 'temperature', label: 'temperature' },
+  { meta: 'general.sampling.top_k', effective: 'top_k', label: 'top_k' },
+  { meta: 'general.sampling.top_p', effective: 'top_p', label: 'top_p' },
+];
+
+// Metadata travels GGUF -> YAML -> JSON before it reaches here, and that chain
+// can land a value a few float64 ULPs from where it started — observed on this
+// exact pair: Number('0.95') and 0.9500001 differ by ~1.0e-7. The 1e-9 anchor
+// suggested for this feature is tighter than that observed noise and would
+// misfire on the very case it exists to swallow, so the tolerance here is
+// 1e-6: an order of magnitude above the measured round-trip noise, and still
+// four-plus orders of magnitude below the smallest override a person would
+// plausibly type (e.g. 0.6 vs 1).
+const SAMPLING_TOLERANCE = 1e-6;
+
+// `Number(null)` and `Number('')` are both 0, so coercing first and testing
+// Number.isFinite afterwards reads an absent value as a deliberate zero and
+// warns about a parameter nobody set. Kronk does emit both shapes in
+// `model_config` — `reasoning_effort` and `grammar` come back as empty strings
+// on this server today — so reject them before coercing, not after.
+function num(v) {
+  if (typeof v === 'number') return Number.isFinite(v) ? v : null;
+  if (typeof v !== 'string' || v.trim() === '') return null;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+}
+
+/**
+ * Compare a model's own sampling metadata (GGUF values, always strings) against
+ * the effective sampling-parameters Kronk is actually applying (profile-merged,
+ * always numbers). Pure — no I/O — so this is the whole testable surface for
+ * the startup warning: the boot path just hands it what `/kronk/models/{id}`
+ * already returned.
+ *
+ * A side that is missing, or does not parse to a finite number, is "no
+ * opinion" rather than a difference — a model with no sampling metadata, or a
+ * profile field this build doesn't recognise, must never produce a warning.
+ *
+ * Returns null when there is nothing to report, or the list of parameters
+ * that disagree — each with the model's own value and the effective one —
+ * for the caller to render as a single line.
+ */
+export function samplingOverride(metadata, sampling) {
+  if (!metadata || !sampling) return null;
+  const diffs = [];
+  for (const { meta, effective, label } of SAMPLING_KEYS) {
+    const modelValue = num(metadata[meta]);
+    const effectiveValue = num(sampling[effective]);
+    if (modelValue === null || effectiveValue === null) continue;
+    if (Math.abs(modelValue - effectiveValue) > SAMPLING_TOLERANCE) {
+      diffs.push({ param: label, model: modelValue, effective: effectiveValue });
+    }
+  }
+  return diffs.length ? diffs : null;
+}
+
 /**
- * Effective context window for a model id, plus the model's native maximum.
+ * Effective context window for a model id, the model's native maximum,
+ * whether its chat template understands `preserve_thinking`, and whether the
+ * profile is overriding the model's own sampling values.
  * The id contains slashes, so it must be percent-encoded — Kronk's route takes
  * one path segment and 404s on a raw id.
+ *
+ * The template is the only reliable source for `preserveThinking`: Kronk
+ * reports `model_config["chat-template-kwargs"]` as null even when the
+ * profile sets the flag, so what the server is already doing cannot be read
+ * back. The sampling comparison has no such gap — metadata and the effective
+ * values are both in this same response — so it needs no second request.
+ *
+ * Every failure answers "unknown" / "no warning", which the caller reads as
+ * "say nothing and proceed".
  */
 export async function modelLimits(id) {
   try {
@@ -26,8 +97,17 @@ export async function modelLimits(id) {
     const configured = d.model_config?.['context-window'] ?? null;
     const nativeKey = Object.keys(d.metadata ?? {}).find((k) => k.endsWith('.context_length'));
     const native = nativeKey ? Number(d.metadata[nativeKey]) : null;
-    return { configured, native };
-  } catch { return { configured: null, native: null }; }
+    const template = d.metadata?.['tokenizer.chat_template'];
+    const preserveThinking = typeof template === 'string' && template.includes('preserve_thinking');
+    const samplingDiff = samplingOverride(d.metadata, d.model_config?.['sampling-parameters']);
+    return {
+      configured, native, preserveThinking, samplingDiff,
+    };
+  } catch {
+    return {
+      configured: null, native: null, preserveThinking: false, samplingDiff: null,
+    };
+  }
 }
 
 /** Native Kronk model list: size, projector, validation. */
@@ -64,7 +144,9 @@ export async function tokenize(model, input) {
  *   {type:'usage',     value}
  *   {type:'done',      calls, finish}
  */
-export async function* streamChat({ model, messages, tools, signal, maxTokens, noThink }) {
+export async function* streamChat({
+  model, messages, tools, signal, maxTokens, noThink, preserveThinking,
+}) {
   const res = await req('/chat/completions', {
     method: 'POST',
     signal,
@@ -76,6 +158,7 @@ export async function* streamChat({ model, messages, tools, signal, maxTokens, n
       stream_options: { include_usage: true },
       max_completion_tokens: maxTokens,
       ...(noThink ? { enable_thinking: false } : {}),
+      ...(preserveThinking ? { chat_template_kwargs: { preserve_thinking: true } } : {}),
     }),
   });
 
@@ -113,3 +196,25 @@ export async function* streamChat({ model, messages, tools, signal, maxTokens, n
 
   yield { type: 'done', calls: [...calls.values()], finish };
 }
+
+/**
+ * Load a model into the pool.
+ *
+ * Kronk has no explicit "load" endpoint — admission happens on the first
+ * inference request, so the cheapest possible completion *is* the load
+ * command. A 23 GB MoE takes ~10–25 s off disk. The reply is discarded;
+ * only whether it succeeded matters.
+ */
+export async function warm(id, signal) {
+  const res = await req('/chat/completions', {
+    method: 'POST',
+    signal,
+    body: JSON.stringify({
+      model: id,
+      messages: [{ role: 'user', content: 'hi' }],
+      max_completion_tokens: 1,
+      enable_thinking: false,
+    }),
+  });
+  await res.text();
+}

package/src/compact.js

@@ -1,5 +1,6 @@
 import { streamChat, tokenize } from './client.js';
 import { config } from './config.js';
+import { forRequest } from './reasoning.js';
 import { c } from './ui.js';
 
 const PROMPT = `Summarize the conversation above so it can be continued in a fresh context.
@@ -35,7 +36,15 @@ function fit(text, budgetTokens) {
   };
 }
 
-/** Flatten a message list into something the model can read back. */
+/**
+ * Flatten a message list into something the model can read back.
+ *
+ * Reasoning is flattened alongside content rather than skipped — the summary
+ * is the only thing that survives, so anything left out here is lost for good.
+ * The caller passes the list as it goes on the wire, which means the reasoning
+ * a request had already dropped is not resurrected here just to be baked into
+ * the summary permanently.
+ */
 function transcript(messages) {
   return messages
     .filter((m) => m.role !== 'system')
@@ -44,7 +53,8 @@ function transcript(messages) {
       const calls = m.tool_calls?.length
         ? `\n[called ${m.tool_calls.map((t) => t.function.name).join(', ')}]`
         : '';
-      return `${m.role}: ${m.content ?? ''}${calls}`;
+      const thought = m.reasoning_content ? `[reasoning]\n${m.reasoning_content}\n` : '';
+      return `${m.role}: ${thought}${m.content ?? ''}${calls}`;
     })
     .join('\n\n');
 }
@@ -54,11 +64,18 @@ function transcript(messages) {
  *
  * Tool messages are dropped rather than carried over: they are only valid when
  * paired with the assistant tool_calls that produced them, and a partial carry
- * leaves orphaned tool_call_ids that the API rejects.
+ * leaves orphaned tool_call_ids that the API rejects. Reasoning goes the same
+ * way for the same reason — it belongs to a tool loop that no longer exists
+ * after this — and the replacement below is built literally, so a compacted
+ * history cannot carry a `reasoning_content` from before the summary.
+ *
+ * `auto` is passed straight to `forRequest`: the summarizer must see the same
+ * reasoning-replay view of the current task as the wire request that
+ * triggered it, not a second, independently-computed answer.
  */
-export async function compact(messages, { model, signal } = {}) {
+export async function compact(messages, { model, signal, auto = false } = {}) {
   const system = messages[0];
-  const raw = transcript(messages);
+  const raw = transcript(forRequest(messages, auto));
   if (!raw.trim()) return { messages, before: 0, after: 0 };
 
   const before = await tokenize(model, [system.content, raw].join('\n'));