kronk-cli 0.3.1 → 0.5.0

package/src/client.js

@@ -75,10 +75,41 @@ export function samplingOverride(metadata, sampling) {
   return diffs.length ? diffs : null;
 }
 
+export const NO_LIMITS = {
+  configured: null, native: null, preserveThinking: false, samplingDiff: null, maxTokens: null,
+};
+
+/**
+ * Everything about one model that the rest of the program is allowed to
+ * assume, read out of that model's own profile — pure, so the whole surface
+ * is testable without a server.
+ *
+ * `maxTokens` is the profile's own output cap. Kronk reports 0 for a model
+ * whose profile does not set one, which is "no opinion" and not a limit of
+ * zero, so it comes back null and the caller keeps its default. Anything else
+ * is what the person who wrote the profile decided this model may generate,
+ * and it is not ours to halve.
+ */
+export function parseLimits(d) {
+  if (!d) return NO_LIMITS;
+  const sampling = d.model_config?.['sampling-parameters'];
+  const profileMax = num(sampling?.max_tokens);
+  const nativeKey = Object.keys(d.metadata ?? {}).find((k) => k.endsWith('.context_length'));
+  const template = d.metadata?.['tokenizer.chat_template'];
+  return {
+    configured: d.model_config?.['context-window'] ?? null,
+    native: nativeKey ? Number(d.metadata[nativeKey]) : null,
+    preserveThinking: typeof template === 'string' && template.includes('preserve_thinking'),
+    samplingDiff: samplingOverride(d.metadata, sampling),
+    maxTokens: profileMax && profileMax > 0 ? profileMax : null,
+  };
+}
+
 /**
- * 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.
+ * Effective context window for a model id, the model's native maximum, the
+ * output cap its profile sets, 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.
  *
@@ -93,20 +124,9 @@ export function samplingOverride(metadata, sampling) {
  */
 export async function modelLimits(id) {
   try {
-    const d = await (await req(`/kronk/models/${encodeURIComponent(id)}`)).json();
-    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;
-    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,
-    };
+    return parseLimits(await (await req(`/kronk/models/${encodeURIComponent(id)}`)).json());
   } catch {
-    return {
-      configured: null, native: null, preserveThinking: false, samplingDiff: null,
-    };
+    return NO_LIMITS;
   }
 }
 

package/src/compact.js

@@ -73,16 +73,19 @@ function transcript(messages) {
  * 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, auto = false } = {}) {
+export async function compact(messages, {
+  model, signal, auto = false, window = config.contextWindow, maxTokens = config.maxTokens,
+} = {}) {
   const system = messages[0];
   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'));
 
-  // Leave room for the instruction and the summary itself.
-  const window = config.contextWindow ?? 32768;
-  const { text: body, elided } = fit(raw, Math.floor(window * 0.6));
+  // Leave room for the instruction and the summary itself. The window belongs
+  // to the model this compaction runs on, which is not always the one the
+  // session started with — see applyLimits in src/config.js.
+  const { text: body, elided } = fit(raw, Math.floor((window ?? 32768) * 0.6));
   if (elided) console.log(c.grey(`  transcript too large for one pass — elided ${elided.toLocaleString()} chars from the middle`));
 
   let summary = '';
@@ -92,7 +95,7 @@ export async function compact(messages, { model, signal, auto = false } = {}) {
       { role: 'user', content: `${body}\n\n---\n\n${PROMPT}` },
     ],
     signal,
-    maxTokens: Math.min(4096, config.maxTokens),
+    maxTokens: Math.min(4096, maxTokens),
     noThink: true,
   })) {
     if (ev.type === 'text') summary += ev.value;

package/src/config.js

@@ -14,6 +14,11 @@ function fileConfig() {
 
 const file = fileConfig();
 
+/** Only ever used when neither the user nor the model's profile has a number. */
+export const DEFAULT_MAX_TOKENS = 8192;
+
+const maxTokensRaw = process.env.KRONK_MAX_TOKENS ?? file.maxTokens;
+
 /** 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';
 
@@ -28,7 +33,13 @@ export const config = {
   baseUrl: process.env.KRONK_URL   ?? file.baseUrl ?? 'http://localhost:11435/v1',
   token:   process.env.KRONK_TOKEN ?? file.token   ?? 'kronk',
   model:   process.env.KRONK_MODEL ?? file.model   ?? null,   // null → DEFAULT_MODEL, then auto-pick
-  maxTokens: Number(process.env.KRONK_MAX_TOKENS ?? file.maxTokens ?? 8192),
+  maxTokens: Number(maxTokensRaw ?? DEFAULT_MAX_TOKENS),
+  // Whether the number above is the user's answer or ours. When it is ours,
+  // boot replaces it with whatever the chosen model's own /AGENT profile
+  // allows — see applyLimits. Without this flag there is no way to tell a
+  // deliberate 8192 from the default one, and the profile would silently
+  // overrule a number the user typed.
+  maxTokensExplicit: maxTokensRaw !== undefined,
   // Unlimited by default — a run stops when the model is done or you press Ctrl-C.
   // Set --steps / KRONK_MAX_STEPS to opt into a cap.
   maxSteps: Number(process.env.KRONK_MAX_STEPS ?? file.maxSteps ?? Infinity),
@@ -50,12 +61,24 @@ export const config = {
   // 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',
+  // 'auto' asks the terminal what colour its background is; 'dark' or 'light'
+  // pins the palette when it answers wrong or cannot answer at all. See
+  // src/theme.js — the value is only ever read there.
+  theme: process.env.KRONK_THEME ?? file.theme ?? 'auto',
   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),
+  // Delegation. A sub-agent runs one task in a context of its own and hands
+  // back only its report, so what it read never enters this conversation —
+  // src/subagent.js has the argument. The step cap is finite where the main
+  // one is not: nobody is watching a sub-agent, and its report is worth less
+  // than the window it would spend earning it.
+  subagents: (process.env.KRONK_SUBAGENTS ?? String(file.subagents ?? 'true')) !== 'false',
+  subagentModel: process.env.KRONK_SUBAGENT_MODEL ?? file.subagentModel ?? null,
+  subagentSteps: Number(process.env.KRONK_SUBAGENT_STEPS ?? file.subagentSteps ?? 40),
   // 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,
@@ -66,13 +89,39 @@ export const config = {
     .filter((p) => typeof p === 'string' && p.trim())
     .map((p) => (p.startsWith('~/') ? join(homedir(), p.slice(2)) : p)),
   lastUsed: 0,
-  contextWindow: null,   // filled in at boot from Kronk
+  // The startup scan of the working directory, kept so a sub-agent starts
+  // knowing what the project is instead of spending its first two steps on it.
+  projectPrimer: null,
+  contextWindow: null,   // filled in at boot from the chosen model's profile
   nativeContext: null,
+  // The sub-agent model's own limits, when one is configured. A sub-agent on
+  // a 32k model must not compact against the main model's 131k window.
+  subagentLimits: 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,
 };
 
+/**
+ * Point the session's limits at one model's profile.
+ *
+ * Every one of these was resolved once at boot and then treated as a property
+ * of the program rather than of the model, so `/model` could move the session
+ * to a 32k model while compaction still aimed at 131k and `preserve_thinking`
+ * was still sent to a template that does not declare it. They are properties
+ * of whichever model is selected now.
+ */
+export function applyLimits({
+  configured, native, preserveThinking, samplingDiff, maxTokens,
+} = {}) {
+  config.contextWindow = configured ?? null;
+  config.nativeContext = native ?? null;
+  config.templatePreservesThinking = Boolean(preserveThinking);
+  config.samplingOverride = samplingDiff ?? null;
+  if (!config.maxTokensExplicit) config.maxTokens = maxTokens ?? DEFAULT_MAX_TOKENS;
+  return config;
+}
+
 /**
  * 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 —

package/src/distill.js

@@ -103,10 +103,13 @@ export function shouldDistill(result) {
 
 export async function maybeDistill(result, opts) {
   if (!shouldDistill(result)) return result;
+  // `out` so a sub-agent's distillation prints inside its own indented block
+  // rather than at the caller's margin. See runTask in src/subagent.js.
+  const out = opts.out ?? console.log;
   const before = await tokenize(opts.model, result);
   const digest = await distill(result, opts);
   if (!digest || digest.length >= result.length) return result;
   const after = await tokenize(opts.model, digest);
-  console.log(c.grey(`    distilled ${before.toLocaleString()} → ${after.toLocaleString()} tokens (separate context)`));
+  out(c.grey(`    distilled ${before.toLocaleString()} → ${after.toLocaleString()} tokens (separate context)`));
   return digest;
 }

package/src/index.js

@@ -1,19 +1,21 @@
 #!/usr/bin/env node
-import readline from 'node:readline/promises';
 import { stdin, stdout } from 'node:process';
 import { homedir } from 'node:os';
 import { readFile } from 'node:fs/promises';
-import { config, DEFAULT_MODEL, warnIfInsecure } from './config.js';
+import { config, DEFAULT_MODEL, applyLimits, 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 { resolveTheme, theme, useTheme } from './theme.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 { deferredPrompt } from './prompt.js';
+import { AGENTS } from './subagent.js';
 import { runSetup } from './setup.js';
 
 // ---- argv -------------------------------------------------------------
@@ -50,6 +52,7 @@ if (args.help) {
     -a, --auto          autonomous: approve tools automatically, finish the task
     -y, --yes           approve tools automatically (no autonomous prompt)
         --no-think      disable the model's reasoning pass (faster)
+        --no-subagents  remove the task tool; no delegation
         --steps <n>     cap tool calls per task (default: unlimited)
     -h, --help          this message
         --              end option parsing; everything after is the prompt
@@ -59,15 +62,23 @@ if (args.help) {
     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_TOKENS    output cap per response; overrides the cap the
+                        chosen model's own profile sets (8192 if it sets none)
     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_THEME         dark or light to pin the palette; default auto, which
+                        asks the terminal for its background colour
     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)
+    KRONK_SUBAGENTS     false to remove the task tool
+    KRONK_SUBAGENT_MODEL
+                        model sub-agents run on (default: the main model)
+    KRONK_SUBAGENT_STEPS
+                        tool-call cap for one delegated task (default 40)
 
   Config file: ~/.kronk-cli.json
 `);
@@ -88,6 +99,7 @@ const MCP_ON = args.mcp;
 const MCP_WANTED = args.mcpNames;
 
 if (args.noThink) config.noThink = true;
+if (args.noSubagents) config.subagents = false;
 if (args.noCompact) config.autoCompact = false;
 if (args.noWarm) config.warm = false;
 if (args.model) config.model = args.model;
@@ -128,18 +140,51 @@ async function boot() {
   }
   if (!config.model) config.model = pickDefault(ids);
 
+  // Resolved against what Kronk is actually serving, exactly like the main
+  // model: a substring in the config file that matches nothing would otherwise
+  // only surface as a 404 in the middle of somebody's first delegated task.
+  if (config.subagentModel) {
+    const subs = ids.filter((id) => id.includes(config.subagentModel));
+    const hit = ids.find((id) => id === config.subagentModel)
+             ?? subs.find((id) => id.endsWith('/AGENT'))
+             ?? subs[0];
+    if (hit) config.subagentModel = hit;
+    else {
+      console.error(c.yellow(`  no model matching "${config.subagentModel}" for sub-agents`
+        + ' — they will use the main model'));
+      config.subagentModel = null;
+    }
+  }
+
   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;
+  // After `ensureLoaded`, which may have fallen back to a different model
+  // than the one asked for. Reading the profile before that point would
+  // describe a model this session is not using.
+  applyLimits(await modelLimits(config.model));
+
+  // The sub-agent model's profile is its own. Resolved once here rather than
+  // on the first delegation, where the wait would land mid-task.
+  config.subagentLimits = config.subagentModel
+    ? await modelLimits(config.subagentModel)
+    : null;
   return ids;
 }
 
+/**
+ * Move the session onto another model, limits and all.
+ *
+ * `/model` used to assign `config.model` and stop there, so a switch to a 32k
+ * model kept compacting against the previous model's 131k window and kept
+ * sending `preserve_thinking` to a template that never declared it. Every
+ * limit is a property of the selected model, so every limit is re-read here.
+ */
+async function switchModel(id) {
+  config.model = id;
+  applyLimits(await modelLimits(id));
+  return id;
+}
+
 const gb = (n) => `${(n / 1e9).toFixed(1)} GB`;
 
 /** Connect the MCP servers the user asked for. Never fatal. */
@@ -244,8 +289,10 @@ const HELP = `
   ${c.bold('/think')}           turn reasoning off entirely (much faster)
   ${c.bold('/auto')}            autonomous mode: auto-approve tools, run to completion
   ${c.bold('/steps [n|off]')}   cap tool calls per task (default: unlimited)
+  ${c.bold('/agents')}          sub-agents you can delegate to with the task tool
   ${c.bold('/mcp')}             list attached MCP servers and their tools
   ${c.bold('/context')}         how much of the context window is used
+  ${c.bold('/theme [d|l]')}     dark or light palette, for when the terminal guessed wrong
   ${c.bold('/compact')}         replace the conversation with a summary of itself
   ${c.bold('/clear')}           reset the conversation
   ${c.bold('/exit')}            quit
@@ -260,6 +307,9 @@ async function systemMessage(auto) {
   const base = auto ? SYSTEM_AUTO : SYSTEM;
   if (NO_CONTEXT) return { content: base, ctx: null };
   const ctx = await projectContext(process.cwd());
+  // Kept for the sub-agents, which get the same primer without paying for the
+  // scan again — see systemFor in src/subagent.js.
+  config.projectPrimer = ctx.text;
   const budget = config.contextWindow
     ? `\n\nYour context window is ${config.contextWindow.toLocaleString()} tokens, shared by `
       + `everything in this conversation: these instructions, file contents you read, command `
@@ -379,7 +429,26 @@ async function main() {
     return;
   }
 
-  const rl = readline.createInterface({ input: stdin, output: stdout, historySize: 500 });
+  // Before readline takes stdin, because settling the palette may mean asking
+  // the terminal for its background colour and reading the reply in raw mode.
+  await resolveTheme({ prefer: config.theme, input: stdin, output: stdout });
+
+  // Not created yet: the interface is opened by the first question, below.
+  // Everything between here and there — the model load, the project scan, the
+  // MCP connections — is time somebody may spend typing, and readline emits
+  // lines whether or not anything is listening. See src/prompt.js.
+  let ac = null;
+  const rl = deferredPrompt({
+    input: stdin,
+    output: stdout,
+    historySize: 500,
+    // Ctrl-C aborts the in-flight request instead of killing the process.
+    onSigint: () => {
+      if (ac) { ac.abort(); ac = null; console.log(c.yellow('\n  interrupted')); }
+      else { console.log(); rl.close(); }
+    },
+  });
+
   await boot();
   const { content, ctx } = await systemMessage(AUTO);
   console.log(banner(config.model, config.baseUrl));
@@ -417,13 +486,6 @@ async function main() {
   // 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;
-  rl.on('SIGINT', () => {
-    if (ac) { ac.abort(); ac = null; console.log(c.yellow('\n  interrupted')); }
-    else { console.log(); rl.close(); }
-  });
-
   let autoApprove = AUTO_YES;
   const approve = async (name) => {
     if (autoApprove) return true;
@@ -500,6 +562,31 @@ async function main() {
       console.log(c.grey(`  thinking display ${config.showThinking ? 'on' : 'off'}`));
       continue;
     }
+    if (input === '/agents') {
+      if (!config.subagents) {
+        console.log(c.grey('  delegation is off — drop --no-subagents / KRONK_SUBAGENTS=false'));
+        continue;
+      }
+      console.log(c.grey('\n  the model delegates with the task tool — one task, its own context,'));
+      console.log(c.grey('  and only its report comes back. You still approve its writes and commands.'));
+      for (const [name, a] of Object.entries(AGENTS)) {
+        console.log(`  ${c.green('●')} ${c.bold(name)} ${c.grey(`· ${a.tools.join(', ')}`)}`);
+        console.log(c.grey(`      for ${a.use}`));
+      }
+      console.log(c.grey(`  model: ${config.subagentModel ?? config.model} · `
+        + `cap ${config.subagentSteps} steps per task\n`));
+      continue;
+    }
+    if (input === '/theme' || input.startsWith('/theme ')) {
+      // Everything prints through src/ui.js, which reads the palette per call,
+      // so the next line drawn is already in the new one — nothing to redraw.
+      const want = input.slice(6).trim().toLowerCase();
+      const name = { d: 'dark', dark: 'dark', l: 'light', light: 'light' }[want];
+      if (want && !name) { console.log(c.yellow('  /theme dark | /theme light')); continue; }
+      if (name) useTheme({ name });
+      console.log(c.grey(`  ${theme()} palette`));
+      continue;
+    }
     if (input === '/models') { await showModels(); continue; }
     if (input === '/mcp') {
       if (!mcp || !mcp.routes.size) { console.log(c.grey('  no MCP servers attached — start with --mcp')); continue; }
@@ -538,8 +625,11 @@ async function main() {
                ?? subs.find((m) => m.endsWith('/AGENT'))
                ?? subs[0];
       if (!hit) { console.log(c.red(`  no model matching "${want}"`)); continue; }
-      config.model = hit;
+      await switchModel(hit);
       console.log(c.green(`  switched to ${hit}`));
+      console.log(c.grey(`  window ${config.contextWindow?.toLocaleString() ?? 'unknown'}`
+        + ` · output cap ${config.maxTokens.toLocaleString()}`
+        + `${config.maxTokensExplicit ? ' (yours)' : ' (from its profile)'}`));
       continue;
     }
     if (input.startsWith('/file ')) {

package/src/markdown.js

@@ -0,0 +1,136 @@
+/**
+ * Markdown, rendered for the terminal as it streams.
+ *
+ * The models write markdown whether or not anything is going to render it, so
+ * an answer arrived as `### The letter is a notification` and `**binding**`
+ * with the punctuation left in the reader's way. This turns the handful of
+ * constructs that actually show up in an answer — headings, emphasis, code,
+ * lists, quotes, rules, links — into the attributes a terminal already has.
+ *
+ * Deliberately not a markdown parser. It is a line renderer with one bit of
+ * state, whether a fenced code block is open, which is all that spans lines in
+ * the subset above. Anything it does not recognise is left exactly as written,
+ * which is the only safe answer for text that was never markdown to begin with.
+ *
+ * Line-buffered, because inline emphasis cannot be decided until the line is
+ * whole: `**` is bold or two asterisks depending on what comes next. Output
+ * therefore appears a line at a time rather than a token at a time. With colour
+ * off — piped, redirected, NO_COLOR — nothing is rewritten at all and the bytes
+ * are the model's own.
+ */
+import { c } from './ui.js';
+import { colorsOn } from './theme.js';
+
+const FENCE = /^\s*(?:```|~~~)\s*([\w+-]*)\s*$/;
+const HEADING = /^(#{1,6})\s+(.*)$/;
+const BULLET = /^(\s*)[-*+]\s+(.*)$/;
+const ORDERED = /^(\s*)(\d{1,9})([.)])\s+(.*)$/;
+const QUOTE = /^\s*>\s?(.*)$/;
+const RULE = /^\s*([-*_])(?:\s*\1){2,}\s*$/;
+
+/** How wide a `---` is drawn. Narrow enough to sit inside any terminal. */
+const RULE_WIDTH = 40;
+
+/**
+ * Inline spans, in one pass over the parts that are not code.
+ *
+ * Code first and separately: whatever is between backticks is content, not
+ * markup, and running the emphasis rules over it would eat the asterisks in a
+ * `**kwargs` or a glob.
+ */
+export function renderInline(text) {
+  return text
+    .split(/(`[^`]+`)/)
+    .map((part, i) => {
+      if (i % 2) return c.cyan(part.slice(1, -1));
+      return part
+        // Links before emphasis: the label can contain either.
+        .replace(/\[([^\]\n]+)\]\(([^)\s]+)\)/g, (_, label, url) => `${c.blue(label)} ${c.grey(url)}`)
+        .replace(/\*\*([^\s*][^*]*?)\*\*/g, (_, s) => c.bold(s))
+        .replace(/__([^\s_][^_]*?)__/g, (_, s) => c.bold(s))
+        .replace(/~~([^\s~][^~]*?)~~/g, (_, s) => c.strike(s))
+        // Emphasis last, and only where the marker is not part of a word:
+        // snake_case identifiers and 3 * 4 must survive unchanged.
+        .replace(/(^|[\s(])\*([^\s*][^*]*?)\*(?=$|[\s).,;:!?])/g, (_, pre, s) => `${pre}${c.italic(s)}`)
+        .replace(/(^|[\s(])_([^\s_][^_]*?)_(?=$|[\s).,;:!?])/g, (_, pre, s) => `${pre}${c.italic(s)}`);
+    })
+    .join('');
+}
+
+/**
+ * One line, given the state carried from the lines before it. Mutates `state`,
+ * which is what a fenced block needs and the only reason state exists.
+ */
+export function renderLine(line, state) {
+  const fence = FENCE.exec(line);
+  if (fence) {
+    if (state.fence) { state.fence = null; return c.grey('  ╰────'); }
+    state.fence = fence[1] || 'code';
+    return c.grey(`  ╭─ ${state.fence}`);
+  }
+  // Inside a fence every character is the code's own — no emphasis, no
+  // reflowing, just a gutter to show where the block runs.
+  if (state.fence) return `${c.grey('  │ ')}${line}`;
+
+  if (RULE.test(line)) return c.grey('─'.repeat(RULE_WIDTH));
+
+  const heading = HEADING.exec(line);
+  if (heading) {
+    const [, hashes, body] = heading;
+    const text = c.bold(renderInline(body));
+    return hashes.length <= 2 ? c.cyan(text) : text;
+  }
+
+  const quote = QUOTE.exec(line);
+  if (quote) return `${c.grey('│ ')}${c.grey(renderInline(quote[1]))}`;
+
+  const bullet = BULLET.exec(line);
+  if (bullet) return `${bullet[1]}${c.grey('•')} ${renderInline(bullet[2])}`;
+
+  const ordered = ORDERED.exec(line);
+  if (ordered) {
+    const [, indent, n, , rest] = ordered;
+    return `${indent}${c.grey(`${n}.`)} ${renderInline(rest)}`;
+  }
+
+  return renderInline(line);
+}
+
+/**
+ * A renderer for streamed text: feed it deltas, write what comes back, and
+ * call `flush` when the stream ends to get the last partial line.
+ *
+ * `enabled` defaults to whether colour is on at all, so the piped and
+ * NO_COLOR paths hand back exactly what the model wrote.
+ */
+export function markdownStream({ enabled = colorsOn() } = {}) {
+  const state = { fence: null };
+  let held = '';
+  return {
+    write(chunk) {
+      if (!enabled) return chunk;
+      held += chunk;
+      let out = '';
+      let at;
+      while ((at = held.indexOf('\n')) !== -1) {
+        out += `${renderLine(held.slice(0, at), state)}\n`;
+        held = held.slice(at + 1);
+      }
+      return out;
+    },
+    flush() {
+      if (!enabled || !held) { const rest = enabled ? '' : held; held = ''; return rest; }
+      const out = renderLine(held, state);
+      held = '';
+      return out;
+    },
+    /** Whether a fenced block is still open — the tail of a truncated answer. */
+    get inCode() { return state.fence !== null; },
+  };
+}
+
+/** The whole thing at once. The streaming path is the one the REPL uses. */
+export function renderMarkdown(text, options) {
+  const md = markdownStream(options);
+  return md.write(text) + md.flush();
+}

package/src/prompt.js

@@ -0,0 +1,79 @@
+/**
+ * The line reader: opened only when something is waiting on a line, and never
+ * dropping one that arrives before then.
+ *
+ * `readline` starts consuming stdin the moment it is created and emits every
+ * line it parses, listener or no listener. Startup is not instant — the model
+ * list, a cold load that can run to tens of seconds, the project scan, the MCP
+ * connections — so creating the interface up front meant every line typed in
+ * that window was emitted into nothing: no echo left, no error, and a prompt
+ * that arrived as though you had typed nothing at all.
+ *
+ * Two things fix that, and both are needed. Creation is deferred to the first
+ * question, which leaves those keystrokes in the terminal's own input buffer
+ * until there is something to read them. And once the interface exists, lines
+ * are queued rather than answered directly by `rl.question`, because a paste
+ * or a fast typist can hand readline several lines in one read and only the
+ * first would have had a listener waiting for it.
+ *
+ * One interface is created and kept, so history, line editing and Ctrl-C are
+ * readline's own, exactly as before.
+ */
+import readline from 'node:readline';
+
+/** What a pending question rejects with when the reader closes under it. */
+export class PromptClosed extends Error {
+  constructor() { super('the prompt was closed'); this.name = 'PromptClosed'; }
+}
+
+export function deferredPrompt({ input, output, historySize = 500, onSigint } = {}) {
+  let rl = null;
+  let closed = false;
+  let waiting = null;              // the question currently unanswered, if any
+  const queued = [];               // lines that arrived with nobody asking
+
+  const open = () => {
+    if (rl) return rl;
+    rl = readline.createInterface({ input, output, historySize });
+    rl.on('line', (line) => {
+      if (waiting) { const w = waiting; waiting = null; w.resolve(line); }
+      else queued.push(line);
+    });
+    rl.on('close', () => {
+      closed = true;
+      if (waiting) { const w = waiting; waiting = null; w.reject(new PromptClosed()); }
+    });
+    // Registered with the interface rather than by the caller, so there is no
+    // moment in which the interface exists and Ctrl-C is unhandled.
+    if (onSigint) rl.on('SIGINT', () => onSigint());
+    return rl;
+  };
+
+  return {
+    /**
+     * Ask, opening the interface if this is the first time. A line that was
+     * typed ahead answers immediately — echoed after the prompt, so the
+     * transcript reads the way it would have if the timing had been kinder.
+     */
+    question(query) {
+      if (closed) return Promise.reject(new PromptClosed());
+      const reader = open();
+      if (queued.length) {
+        const line = queued.shift();
+        output.write(`${query}${line}\n`);
+        return Promise.resolve(line);
+      }
+      // setPrompt rather than a bare write: readline needs to know the prompt
+      // to redraw the line correctly when it is edited.
+      reader.setPrompt(query);
+      reader.prompt();
+      return new Promise((resolve, reject) => { waiting = { resolve, reject }; });
+    },
+    /** Closing one that was never opened is not an error, it is a no-op. */
+    close() { closed = true; rl?.close(); },
+    /** For tests, and for anything that wants to know without opening one. */
+    get open() { return rl !== null; },
+    /** Lines typed ahead that no question has taken yet. */
+    get pending() { return queued.length; },
+  };
+}