kronk-cli 0.3.1 → 0.5.0

package/README.md

@@ -595,6 +595,7 @@ same way this run did.
 | `-a`, `--auto` | off | Autonomous: auto-approve tools **and** run until the task is done. Implies `--yes` |
 | `-y`, `--yes` | off | Auto-approve `write_file` and `bash` without the autonomous prompt |
 | `--no-think` | off | Disable the model's reasoning pass server-side. Much faster |
+| `--no-subagents` | off | Remove the `task` tool, so the model cannot delegate — see [Sub-agents](#sub-agents) |
 | `--steps <n>` | unlimited | Cap tool calls per task. `0`, `off`, `none`, `inf`, `unlimited` all mean no cap |
 | `-h`, `--help` | — | Print all options and exit |
 | `--` | — | End option parsing; everything after it is prompt text, dashes and all |
@@ -625,6 +626,46 @@ yellow past 70%, red past 90%. Toggling `/auto`, `/think` or `/steps` updates it
 
 The per-turn usage line still prints after each response; this one is the running picture.
 
+### It follows your terminal's background
+
+That grey is the one colour the whole line depends on, and the sixteen-colour palette has exactly
+one of them — bright black, which most terminals render around `#555`. On a light background it
+reads; on a dark one the status line was the hardest thing on screen to see.
+
+So the palette is chosen per background, from the 256-colour cube: a lighter grey on a dark
+terminal, a darker one on a light terminal, and every other colour shifted the same way. Which
+background you have is settled once, at startup, in this order:
+
+1. `KRONK_THEME`, or `"theme"` in `~/.kronk-cli.json` — `dark` or `light` pins it
+2. `COLORFGBG`, when the terminal exports it
+3. the terminal's own answer to an `OSC 11` background query, waited on for 100 ms
+4. failing all of that, dark — what most terminals ship as
+
+`/theme dark` or `/theme light` switches it mid-session, for when step 3 guessed wrong. `NO_COLOR`
+still turns every escape off, and a terminal that advertises no 256-colour support gets a
+sixteen-colour palette picked the same way.
+
+---
+
+## Markdown in answers
+
+The models write markdown whether or not anything renders it, so an answer used to arrive with the
+punctuation still in your way — `### The letter is a notification`, `**binding**`, backticks around
+every identifier. Those constructs are rendered into the attributes the terminal already has:
+headings lose their hashes and gain bold, emphasis becomes bold or italic, code spans and fenced
+blocks get their own colour and a gutter, lists get a `•`, quotes a `│`, and `---` a rule.
+
+It is a line renderer, not a markdown parser — one bit of state, whether a fenced block is open —
+and anything it does not recognise is left exactly as written. Prose that only looks like markup
+survives: `snake_case`, `3 * 4`, a lone asterisk, `**kwargs` inside backticks.
+
+Two consequences worth knowing:
+
+- **Output appears a line at a time**, not a token at a time, because `**` is bold or two
+  asterisks depending on what follows it. At local speeds that is still a line every half second.
+- **With colour off the bytes are the model's own.** Piped, redirected, or `NO_COLOR` — nothing is
+  rewritten, so anything parsing kronk-cli's output sees exactly what it saw before.
+
 ---
 
 ## REPL commands
@@ -633,14 +674,16 @@ The per-turn usage line still prints after each response; this one is the runnin
 |---|---|
 | `/help` | list these commands |
 | `/models` | what Kronk is serving, with sizes and what is resident |
-| `/model <id>` | switch model — substring match, `/AGENT` preferred |
+| `/model <id>` | switch model — substring match, `/AGENT` preferred; re-reads that model's window and caps |
 | `/file <path>` | add a file to the conversation as context |
 | `/auto` | toggle autonomous mode (auto-approve + run to completion) |
 | `/steps [n\|off]` | show or set the tool-call cap |
 | `/thinking` | show or hide the model's reasoning |
 | `/think` | turn reasoning off entirely — much faster |
+| `/agents` | the sub-agents `task` can delegate to, and what each may touch |
 | `/mcp` | list attached MCP servers and their tools |
 | `/context` | how much of the context window is used |
+| `/theme [dark\|light]` | show or pin the palette, for when the terminal was read wrong |
 | `/compact` | replace the conversation with a summary of itself |
 | `/clear` | reset the conversation, keep the model |
 | `/exit`, `/quit` | quit |
@@ -655,7 +698,7 @@ The per-turn usage line still prints after each response; this one is the runnin
 | `KRONK_TOKEN` | `kronk` | Any non-empty value while Kronk runs open; a real JWT when protected |
 | `KRONK_MODEL` | `unsloth/Qwen3.6-35B-A3B-UD-Q4_K_M/AGENT` | Model id |
 | `KRONK_MODEL_CONFIG` | `~/.kronk/models/model_config.yaml` | Kronk's per-model config, the file `kronk-cli setup` writes |
-| `KRONK_MAX_TOKENS` | `8192` | Output cap per response |
+| `KRONK_MAX_TOKENS` | the model's profile | Output cap per response. Unset, the selected model's own `max_tokens` decides — `8192` only when its profile sets none |
 | `KRONK_MAX_STEPS` | unlimited | Cap on tool calls per task |
 | `KRONK_THINKING` | `true` | `false` hides reasoning but still generates it |
 | `KRONK_NO_THINK` | — | `1` disables reasoning server-side |
@@ -668,10 +711,15 @@ The per-turn usage line still prints after each response; this one is the runnin
 | `KRONK_CONFIG` | `~/.kronk-cli.json` | Path to the config file, so tests and throwaway runs stay off the real one |
 | `KRONK_DISTILL` | `true` | `false` disables tool-output distillation |
 | `KRONK_DISTILL_AT` | `8000` | Characters of output that trigger distillation |
+| `KRONK_SUBAGENTS` | `true` | `false` removes the `task` tool |
+| `KRONK_SUBAGENT_MODEL` | the main model | Model sub-agents run on — substring match, same as `KRONK_MODEL` |
+| `KRONK_SUBAGENT_STEPS` | `40` | Tool-call cap for one delegated task |
 | `KRONK_WARM` | `true` | `false` skips the boot-time model preload |
 | `KRONK_AUTO_COMPACT` | `true` | `false` disables automatic compaction |
 | `KRONK_COMPACT_AT` | `0.85` | Fraction of the window that triggers compaction |
+| `KRONK_THEME` | `auto` | `dark` or `light` pins the palette; `auto` reads the terminal's background |
 | `NO_COLOR` | — | Any value disables colour |
+| `FORCE_COLOR` | — | `0` disables colour; any other value keeps it on through a pipe |
 
 ### Config file
 
@@ -685,11 +733,14 @@ The per-turn usage line still prints after each response; this one is the runnin
   "maxTokens": 16384,
   "maxSteps": 200,
   "showThinking": false,
+  "theme": "auto",
   "autoCompact": true,
   "compactAt": 0.85,
   "noThink": true,
   "preserveThinking": true,
   "replayReasoning": true,
+  "subagentModel": "Qwen3.6-4B",
+  "subagentSteps": 40,
   "sandboxReadable": ["~/Library/Keychains"]
 }
 ```
@@ -851,6 +902,13 @@ not read `reasoning_content` either and would discard the blocks.
 Kronk reports the **effective** window for whichever model id you selected — that comes from
 `context-window` in `model_config.yaml`, so a `/AGENT` profile and its base model can differ.
 
+Every limit is read from the selected model's profile, and re-read when the selection changes:
+the window, the output cap (`sampling-parameters.max_tokens`), whether the chat template
+understands `preserve_thinking`, and the model's native maximum. `/model` mid-session moves all
+of them, and a sub-agent running on `KRONK_SUBAGENT_MODEL` compacts against *its* window rather
+than the main model's. The one number that is not taken from the profile is a `KRONK_MAX_TOKENS`
+you set yourself — yours always wins.
+
 Three places surface it:
 
 **The banner**
@@ -962,10 +1020,15 @@ Disable with `--no-compact` or `KRONK_AUTO_COMPACT=false` if you would rather se
 | `write_file` | ✋ | Create or overwrite; shows a diff preview first |
 | `bash` | ✋ | Run a command; shows it first |
 | `set_plan` | — | Record the task checklist; replaces the stored one |
+| `task` | — | Delegate one job to a [sub-agent](#sub-agents) with its own context |
 
 `set_plan` writes nothing and runs nothing — it hands the harness a list, which is why it is
 never gated. See [Autonomous mode](#autonomous-mode) for what the harness then does with it.
 
+`task` is not gated either, because it cannot do anything by itself: every write and every
+command a sub-agent asks for comes back to the same prompt you would have seen had the main
+agent asked for it.
+
 `--yes` and `--auto` skip the prompts. Paths resolve against the session directory and cannot
 escape the launch root — including through a symlink. `bash` additionally runs under an OS
 sandbox where one is available; see [Scope](#scope) for exactly what that covers. `bash` keeps its working directory **between calls**, so a bare `cd`
@@ -1166,6 +1229,127 @@ same way.
 
 ---
 
+## Sub-agents
+
+The model can hand one job to a **sub-agent**: a fresh agent with its own context window, its
+own tool loop, and no memory of your conversation. It runs the task, and the only thing that
+ever comes back is its report.
+
+```console
+› which tools in this repo need approval, and where is that decided?
+
+  1 ⚙ task explore: list every tool definition in src/, say which are gated and where
+   │   1/40 ⚙ search /def\(/ in src
+   │   ✓ 9 lines
+   │   2/40 ⚙ read src/tools.js
+   │   ✓ 587 lines
+   │   3/40 ⚙ read src/subagent.js
+   │   ✓ 211 lines
+   │   2104→380 tok · 58.1 tok/s · 1980 cached
+   Six built-in tools. write_file and bash are gated, by NEEDS_APPROVAL at
+   src/tools.js:261. MCP tools are gated by name, mcpNeedsApproval at :270.
+   read_file, list_dir, search, set_plan and task are not gated.
+  ✓ 3 lines
+
+  `write_file` and `bash`, from the `NEEDS_APPROVAL` set in src/tools.js:246…
+```
+
+`│` marks the sub-agent's own loop; the unprefixed lines are its report, which is what the main
+agent receives as the tool result.
+
+Three files were read. None of them is in your conversation: the 800-odd lines they cost were
+spent in a context that no longer exists, and all that is left in your window is the four-line
+answer. That is the whole point, and it is the trade [distillation](#distillation) makes for
+command output, one level up.
+
+Both agents run against the same Kronk server, so nothing leaves the machine that was not
+already leaving it.
+
+### It is not parallelism
+
+Kronk holds one resident copy of the model, so two sub-agents at once queue behind each other
+and finish no sooner than two in sequence. Delegation here buys **context**, not wall-clock:
+give away the work that is expensive to read and cheap to conclude.
+
+### What it costs, measured
+
+The same survey of `src/` — one table row per module, its responsibility and the gotcha its own
+comments call out, plus three facts quoted with `file:line` — run twice per model on this
+machine, once with `--no-subagents` and once told to orchestrate. `main ctx peak` is the largest
+prompt the *main* conversation ever sent, which is the number the feature exists to move:
+
+| model | mode | wall | main ctx peak | tokens generated | answer |
+|---|---|---|---|---|---|
+| Qwen3.6-35B-A3B `/AGENT` | plain | 143s | 30.8k | 5.5k | 23/23 |
+| Qwen3.6-35B-A3B `/AGENT` | orchestrated, 5 sub-agents | 352s | **12.9k** | 16.2k | 22/23 |
+| Ornith-1.5-35B `/AGENT` | plain | 154s | 34.4k | 5.8k | 23/23 |
+| Ornith-1.5-35B `/AGENT` | orchestrated, 5 sub-agents | 357s | **5.9k** | 16.5k | 23/23 |
+
+Delegation cut the main conversation's high-water mark by 58% and 83%, and cost roughly 2.4×
+the wall clock and 3× the generated tokens to do it. That is the trade in one line: **you are
+buying window, and paying for it in time and tokens.** It is worth it when the conversation has
+to keep going afterwards, and not worth it for a question you were going to ask once.
+
+The one answer that got worse is worth reading too. Qwen's orchestrated run scored 22/23 because
+the sub-agent it asked for "the constant that caps a tool result" came back with a plausible
+wrong one from a different module, and the orchestrator had no way to know: it never read the
+file. The plain run made the same mistake, spent three rounds re-reading `tools.js`, and caught
+it. **A sub-agent's report is evidence you cannot cross-examine** — ask for `file:line` and
+verbatim quotes in the prompt, and check the ones that matter.
+
+### The two agents
+
+| Agent | Tools | For |
+|---|---|---|
+| `explore` | `read_file`, `list_dir`, `search` | Reading, searching, tracing how something works |
+| `code` | those plus `write_file`, `bash` | Making a change, running a build, reproducing a failure |
+
+`/agents` prints this in the REPL, with the model and step cap in force.
+
+Two roles rather than a directory of them, because every extra one is a line the model has to
+read and choose between on each call, and a local model asked to pick between eight
+near-synonyms picks badly. The split that changes what can actually happen is whether it may
+touch anything, so that is the split.
+
+### What it cannot do
+
+- **Ask you anything.** There is nobody in its loop. It is told to take the most reasonable
+  reading of the task, act, and say what it assumed.
+- **Delegate further.** The `task` tool is only ever offered at the top level, which is the
+  entire recursion guard.
+- **Get a command past you.** Its `write_file` and `bash` calls arrive at the same prompt the
+  main agent's do, nested under the call that started them. `--yes` and `--auto` skip them
+  exactly as they always did.
+- **Touch the checklist.** `set_plan` belongs to the task you asked for; a sub-agent has no
+  access to it.
+- **Reach MCP servers.** Its tool list is deliberately the short one.
+
+It also runs under a step cap — 40 by default, where the main agent's is unlimited — because
+nobody is watching it, and a report is worth less than the window a runaway loop would spend
+earning it.
+
+### Knobs
+
+```bash
+kronk-cli --no-subagents             # remove the task tool entirely
+KRONK_SUBAGENT_MODEL=<id> kronk-cli  # run the grunt work on a different model
+KRONK_SUBAGENT_STEPS=80 kronk-cli    # a longer leash per task
+```
+
+A sub-agent gets the same startup scan of your project the main agent got, so it starts knowing
+what the repo is instead of spending its first two steps finding out.
+
+`KRONK_SUBAGENT_MODEL` needs a model that can actually drive a tool loop, and "smaller" is not
+the same thing as "cheaper" here. Measured on the survey task below with `qwen2.5-coder-1.5b`
+as the sub-agent model: every sub-agent returned prose without calling a single tool, the main
+agent noticed, read all eighteen modules itself, and finished with **47.1k** of context against
+the 30.8k it uses when you never delegate at all. A sub-agent that cannot do the work costs you
+the delegation *and* the work.
+
+> A small model will not delegate unprompted as often as a frontier one does. Asking for it
+> works — *"use a sub-agent to survey the test suite first"* — and is usually how you will
+> drive this.
+
 ## Autonomous mode
 
 `--auto`, or `/auto` in the REPL, swaps in a system prompt that tells the model to finish the
@@ -1245,10 +1429,14 @@ previous prompt prefix — watch `cached` climb in the usage line.
 | `src/context.js` | startup scan: git, layout, `AGENTS.md` |
 | `src/compact.js` | summarizing the conversation when the window fills |
 | `src/plan.js` | the task checklist and the snapshot the model sees |
+| `src/subagent.js` | delegation: agent roles, their tools, the report that comes back |
 | `src/mcp.js` | MCP client: stdio + HTTP transports, tool routing |
 | `src/distill.js` | summarizing large tool output in a throwaway context |
 | `src/config.js` | precedence of flags, env, config file |
 | `src/ui.js` | colour, spinner, usage formatting |
+| `src/theme.js` | which palette to print in, and how the background is worked out |
+| `src/markdown.js` | rendering the model's markdown for the terminal, as it streams |
+| `src/prompt.js` | the line reader: opened on the first question, keeping what was typed before it |
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kronk-cli",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "A Claude-Code-style terminal agent for local models served by Kronk.",
   "license": "Apache-2.0",
   "type": "module",

package/src/agent.js

@@ -6,11 +6,13 @@ import {
 import { config, shouldPreserveThinking } from './config.js';
 import { forRequest } from './reasoning.js';
 import { c, fmtUsage, spinner, liveLine, toolResultLines } from './ui.js';
+import { markdownStream } from './markdown.js';
 import { compact, isOverflow, report } from './compact.js';
 import { maybeDistill } from './distill.js';
 import {
   carryChecklist, clearPlan, openItems, outstandingLines, planLines, pushNudge,
 } from './plan.js';
+import { runTask, taskTools, TASK_TOOL } from './subagent.js';
 
 export const SYSTEM = `You are kronk-cli, a terse coding assistant running fully offline on the user's machine.
 
@@ -50,11 +52,11 @@ const thought = (reasoning) => (reasoning ? { reasoning_content: reasoning } : {
  * 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; }
+async function compactInto(messages, { out = console.log, ...opts }) {
+  const res = await compact(messages, opts);
+  if (res.failed || res.skipped) { out(report(res)); return false; }
   messages.splice(0, messages.length, ...res.messages);
-  console.log(report(res));
+  out(report(res));
   return true;
 }
 
@@ -68,8 +70,8 @@ const MAX_NUDGES = 2;
  * 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));
+function endTurn(messages, { out = console.log, plan = true } = {}) {
+  if (plan) outstandingLines().forEach((l) => out(l));
   return messages;
 }
 
@@ -86,8 +88,14 @@ function endTurn(messages) {
  */
 export async function runTurn({
   messages, model, signal, approve, grant, mcp, auto = false, maxSteps = config.maxSteps,
+  tools: toolset = TOOLS, plan: usePlan = true, out = console.log, stream = true, depth = 0,
+  // The window and the output cap belong to `model`, not to the session: a
+  // sub-agent may be running on a different model with a different profile.
+  window = config.contextWindow, maxTokens = config.maxTokens,
 }) {
-  const tools = mcp ? [...TOOLS, ...mcp.toolDefs()] : TOOLS;
+  // `taskTools` is empty below the top level, which is the whole recursion
+  // guard: a sub-agent is never handed the tool that spawns one.
+  const tools = [...toolset, ...taskTools(depth), ...(mcp ? mcp.toolDefs() : [])];
   let totalUsage = null;
   let step = 0;
   let compacted = false;
@@ -97,22 +105,30 @@ export async function runTurn({
   // 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();
+  if (usePlan) clearPlan();
 
   for (;;) {
     step += 1;
     if (Number.isFinite(maxSteps) && step > 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 endTurn(messages);
+      out(c.yellow(`  ⛔ step cap reached (${maxSteps}). Stopping.`));
+      out(c.grey(depth
+        ? '     raise it with KRONK_SUBAGENT_STEPS'
+        : '     raise it with --steps N, or /steps N in the REPL'));
+      messages.push({ role: 'assistant',
+        content: depth
+          ? `(stopped: the sub-agent reached its step cap of ${maxSteps} before finishing)`
+          : '(stopped: step cap reached)' });
+      return endTurn(messages, { out, plan: usePlan });
     }
-    let sp = spinner('thinking');
+    let sp = spinner(depth ? 'sub-agent' : 'thinking');
     let text = '';
     let reasoning = '';
     let calls = [];
     let wroteAnything = false;
     let inReasoning = false;
+    // One renderer per step: a fence left open by one answer must not colour
+    // the next one as code.
+    const md = markdownStream();
 
     try {
       for await (const ev of streamChat({
@@ -122,7 +138,7 @@ export async function runTurn({
         messages: forRequest(messages, auto),
         tools,
         signal,
-        maxTokens: config.maxTokens,
+        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.
@@ -132,7 +148,9 @@ export async function runTurn({
           // 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;
+          // A sub-agent's reasoning is not the answer, and a second stream
+          // interleaved with the caller's is unreadable. See runTask.
+          if (!stream || !config.showThinking) continue;
           if (sp) { sp.stop(); sp = null; }
           if (!inReasoning) { process.stdout.write(c.grey('\n  ┄ thinking ┄\n  ')); inReasoning = true; }
           process.stdout.write(c.grey(ev.value.replace(/\n/g, '\n  ')));
@@ -140,10 +158,14 @@ export async function runTurn({
         }
 
         else if (ev.type === 'text') {
+          text += ev.value;
+          if (!stream) continue;
           if (sp) { sp.stop(); sp = null; }
           if (inReasoning) { process.stdout.write(c.grey('\n  ┄─────────┄\n\n')); inReasoning = false; }
-          text += ev.value;
-          process.stdout.write(ev.value);
+          // Rendered a line at a time — see src/markdown.js. `text` keeps the
+          // model's own copy: what goes back in the conversation is never the
+          // screen's version of it.
+          process.stdout.write(md.write(ev.value));
           wroteAnything = true;
         }
 
@@ -159,13 +181,13 @@ export async function runTurn({
       if (sp) { sp.stop(); sp = null; }
       if (isOverflow(e) && !compacted) {
         compacted = true;
-        console.log(c.yellow('\n  context full — compacting and retrying'));
+        out(c.yellow('\n  context full — compacting and retrying'));
         // 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)) {
+        if (await compactInto(messages, { model, signal, auto, out, window, maxTokens })) {
           step -= 1;
           continue;
         }
@@ -176,17 +198,26 @@ export async function runTurn({
     }
 
     if (inReasoning) process.stdout.write(c.grey('\n  ┄─────────┄\n'));
+    // The last line has no newline to trigger it: an answer that ends mid-line
+    // would otherwise be held in the renderer and never printed.
+    if (stream) process.stdout.write(md.flush());
     if (wroteAnything) process.stdout.write('\n');
     if (totalUsage) {
-      console.log(fmtUsage(totalUsage, config.contextWindow));
-      config.lastUsed = (totalUsage.prompt_tokens ?? 0) + (totalUsage.completion_tokens ?? 0);
+      out(fmtUsage(totalUsage, window));
+      // The status line reports the conversation the user is typing into. A
+      // sub-agent's window is its own and is thrown away with it.
+      if (!depth) {
+        config.lastUsed = (totalUsage.prompt_tokens ?? 0) + (totalUsage.completion_tokens ?? 0);
+      }
     }
 
-    if (config.autoCompact && config.contextWindow && totalUsage) {
+    if (config.autoCompact && window && totalUsage) {
       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, auto)) config.autoCompact = false;
+      if (used / window >= config.compactAt) {
+        out(c.yellow(`  context ${Math.round((used / window) * 100)}% full — compacting`));
+        if (!await compactInto(messages, { model, signal, auto, out, window, maxTokens })) {
+          config.autoCompact = false;
+        }
       }
     }
 
@@ -195,7 +226,7 @@ export async function runTurn({
       if (!text.trim()) {
         // 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)'));
+        out(c.yellow('  (model produced no answer — raise KRONK_MAX_TOKENS or /thinking off)'));
         messages.push({ role: 'assistant', content: '(no answer produced)', ...thought(reasoning) });
       } else {
         messages.push({ role: 'assistant', content: text, ...thought(reasoning) });
@@ -205,13 +236,13 @@ export async function runTurn({
       // 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) {
+      if (usePlan && auto && openItems().length && nudges < MAX_NUDGES) {
         nudges += 1;
         pushNudge(messages);
-        console.log(c.yellow(`  ⚠ ${openItems().length} checklist items still open — continuing`));
+        out(c.yellow(`  ⚠ ${openItems().length} checklist items still open — continuing`));
         continue;
       }
-      return endTurn(messages);
+      return endTurn(messages, { out, plan: usePlan });
     }
 
     messages.push({
@@ -239,17 +270,21 @@ export async function runTurn({
 
       const at = Number.isFinite(maxSteps) ? `${step}/${maxSteps}` : `${step}`;
       const isMcp = Boolean(mcp?.has(call.name));
+      // The same list the model was offered, not just the name it used: with
+      // delegation off, or below the top level, a `task` call is a call to a
+      // tool that does not exist and falls through to runTool saying so.
+      const isTask = !isMcp && call.name === 'task' && tools.includes(TASK_TOOL);
       const label = isMcp
         ? `${c.magenta('⚙')} ${call.name} ${c.grey(JSON.stringify(args).slice(0, 120))}`
         : `${c.blue(`⚙ ${describe(call.name, args)}`)}`;
-      console.log(`${c.grey(`  ${at}`)} ${label}`);
+      out(`${c.grey(`  ${at}`)} ${label}`);
 
       if (isMcp ? mcpNeedsApproval(call.name) : NEEDS_APPROVAL.has(call.name)) {
         const body = preview(call.name, args);
-        if (body) console.log(body.split('\n').map((l) => `    ${l}`).join('\n'));
+        if (body) out(body.split('\n').map((l) => `    ${l}`).join('\n'));
         const ok = await approve(call.name, args);
         if (!ok) {
-          console.log(c.red('  ✗ denied'));
+          out(c.red('  ✗ denied'));
           messages.push({ role: 'tool', tool_call_id: call.id,
             content: 'error: the user denied this action. Ask what to do instead.' });
           continue;
@@ -276,11 +311,11 @@ export async function runTurn({
           if (answer === 'yes' || answer === 'always') {
             try {
               const wrote = rememberGrants(needed, { persist: answer === 'always' });
-              if (wrote) console.log(c.grey(`  remembered in ${wrote}`));
+              if (wrote) out(c.grey(`  remembered in ${wrote}`));
             } catch (e) {
               // Failing to persist must not fail the command. The grant is
               // already in force for this session either way.
-              console.log(c.yellow(`  ${e.message}`));
+              out(c.yellow(`  ${e.message}`));
             }
           } else {
             declineGrants(needed);
@@ -288,35 +323,51 @@ export async function runTurn({
         }
       }
 
-      const live = liveLine();
       let result;
-      try {
-        result = isMcp
-          ? await mcp.call(call.name, args)
-          : await runTool(call.name, args, {
-              onProgress: (info) => live.update({ ...info, window: config.contextWindow }),
-            });
-      } finally {
-        live.done();
+      if (isTask) {
+        // No `liveLine` around this one. It rewrites the current line every
+        // 120 ms, which would erase the sub-agent's own output as fast as it
+        // is printed.
+        try {
+          result = await runTask(args, { run: runTurn, model, signal, approve, grant, out });
+        } catch (e) {
+          // Errors are data here exactly as they are in `runTool`: a
+          // sub-agent that died does not take the turn that delegated to it
+          // down with it.
+          result = `error: the sub-agent failed — ${e.message}`;
+        }
+      } else {
+        const live = liveLine();
+        try {
+          result = isMcp
+            ? await mcp.call(call.name, args)
+            : await runTool(call.name, args, {
+                onProgress: (info) => live.update({ ...info, window }),
+              });
+        } finally {
+          live.done();
+        }
       }
 
       // 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') {
+      // A sub-agent's report is already the distillation of everything it
+      // read; paying a second model call to summarise a summary is waste.
+      if (call.name !== 'set_plan' && !isTask) {
         result = await maybeDistill(result, {
-          model, signal, command: args.cmd ?? describe(call.name, args),
+          model, signal, out, command: args.cmd ?? describe(call.name, args),
         });
       }
       const failed = result.startsWith('error:');
-      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`));
+      if (failed) toolResultLines(result).forEach((l) => out(l));
+      else if (call.name === 'set_plan') planLines().forEach((l) => out(l));
+      else out(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);
+    if (usePlan) carryChecklist(messages);
     // loop: the model now sees the tool output
   }
 }

package/src/argv.js

@@ -24,6 +24,7 @@ const SPECS = [
   { names: ['--no-compact'], kind: 'flag', key: 'noCompact' },
   { names: ['--no-warm'], kind: 'flag', key: 'noWarm' },
   { names: ['--no-think'], kind: 'flag', key: 'noThink' },
+  { names: ['--no-subagents'], kind: 'flag', key: 'noSubagents' },
   { names: ['-a', '--auto'], kind: 'flag', key: 'auto' },
   { names: ['-y', '--yes'], kind: 'flag', key: 'yes' },
   { names: ['--dry-run'], kind: 'flag', key: 'dryRun' },
@@ -102,6 +103,7 @@ export function parseArgv(argv) {
     error: null,
     help: false, models: false, mcpList: false,
     noContext: false, noCompact: false, noWarm: false, noThink: false,
+    noSubagents: false,
     auto: false, yes: false, dryRun: false,
     model: null,
     context: null,