kronk-cli 0.5.1 → 0.6.1

package/README.md

@@ -681,6 +681,7 @@ Two consequences worth knowing:
 | `/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 |
+| `/tasks [n]` | sub-agent runs this session; with `n`, that one in full |
 | `/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 |
@@ -714,6 +715,8 @@ Two consequences worth knowing:
 | `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_TASK_LOG` | `true` | `false` stops writing sub-agent transcripts, and `/tasks` says so |
+| `KRONK_TASK_LOG_DIR` | the temp dir | Where transcripts are written |
 | `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 |
@@ -1239,6 +1242,7 @@ ever comes back is its report.
 › 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
+   ┌ explore · list every tool definition in src/, say which are gated…
    │   1/40 ⚙ search /def\(/ in src
    │   ✓ 9 lines
    │   2/40 ⚙ read src/tools.js
@@ -1249,13 +1253,15 @@ ever comes back is its report.
    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 steps · 11.4s · /tmp/kronk-cli/mfa1k2-8817/task-001.json
   ✓ 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.
+agent receives as the tool result. `┌` and `└` fence one run, so two in a row are told apart in
+scrollback, and the closing line says what it cost and where the rest of it went.
 
 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
@@ -1265,6 +1271,51 @@ command output, one level up.
 Both agents run against the same Kronk server, so nothing leaves the machine that was not
 already leaving it.
 
+### Reading a run back
+
+The report on screen is dimmed and capped at fourteen lines. That used to be the end of it: what
+the sub-agent read, what it ran, and any line fifteen of its report went out of scope with its
+context. Delegating is supposed to cost the *conversation* nothing — it was never supposed to
+cost you the ability to check.
+
+So each run is written to a file as it goes, and `/tasks` reads them back.
+
+```console
+› /tasks
+
+  ●  1  explore 6 steps · 11.4s      list every tool definition in src/, say whi…
+  ●  2  code    23 steps · 1m4s       reproduce the compaction failure in test/co…
+  ●  3  explore 2 steps · stopped     trace where the sandbox root is decided
+
+  /tasks <n> for one in full · /tmp/kronk-cli/mfa1k2-8817
+```
+
+Green finished, yellow stopped before it reported, blue still running.
+
+`/tasks 2` prints that run whole: the prompt as it was delegated, every tool call with its
+arguments, every result in full, and the untruncated report. Nothing is cut — the bounded report
+is what sent you looking, so a second ceiling would only move the wall.
+
+It is **printed, not re-injected**. Looking at what a sub-agent did costs the window nothing,
+which is what keeps the trade above intact.
+
+One thing it is not: a record of what the sub-agent's tools *returned*. A transcript is the
+sub-agent's own context, and [distillation](#distillation) rewrites a large tool result before it
+enters that context — so a `read_file` that came back as 24k of source appears here as the
+summary the sub-agent actually worked from, marked as distilled. That is the honest rendering:
+the raw text was never in its conversation either, and the line says so.
+
+Run 3 is the case this exists for. A run that was interrupted, that threw, or that ran out of
+steps never reaches a tidy end at which to write a transcript, so the file is rewritten after
+every step instead of once at the finish, and the record says how it ended rather than only that
+it did. The run that went wrong is the one you want to read.
+
+Transcripts live in the system temp directory, one directory per session, `0700` with `0600`
+files — they hold your project's file contents and command output. A clean exit removes the
+session's own; startup sweeps anything older than a day, which is what catches the sessions a
+crash left behind. Fifty runs are kept per session, oldest dropped first, so a long autonomous
+run cannot fill the disk. `KRONK_TASK_LOG=false` writes nothing at all.
+
 ### It is not parallelism
 
 Kronk holds one resident copy of the model, so two sub-agents at once queue behind each other
@@ -1334,6 +1385,7 @@ earning it.
 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
+KRONK_TASK_LOG=false kronk-cli       # keep no transcripts of what sub-agents did
 ```
 
 A sub-agent gets the same startup scan of your project the main agent got, so it starts knowing

package/package.json

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

package/src/agent.js

@@ -89,6 +89,11 @@ function endTurn(messages, { out = console.log, plan = true } = {}) {
 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,
+  // Called with the transcript so far after every round. Only src/subagent.js
+  // passes one: a delegated run is the transcript nobody would otherwise keep,
+  // and the round that ends it may be a throw or a step cap rather than a
+  // return, so it has to be written as it happens.
+  onStep = null,
   // 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,
@@ -368,6 +373,7 @@ export async function runTurn({
     // 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.
     if (usePlan) carryChecklist(messages);
+    onStep?.(messages, step);
     // loop: the model now sees the tool output
   }
 }

package/src/config.js

@@ -79,6 +79,13 @@ export const config = {
   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),
+  // Each sub-agent run is written to a file as it goes, so `/tasks` can show
+  // what a delegated task actually did — see src/tasklog.js. It costs a few
+  // small files under the temp dir and nothing in the window: a transcript is
+  // never read back into a conversation, only printed.
+  taskLog: (process.env.KRONK_TASK_LOG ?? String(file.taskLog ?? 'true')) !== 'false',
+  // Same reason as modelConfigPath: so tests never go near the real one.
+  taskLogDir: process.env.KRONK_TASK_LOG_DIR ?? file.taskLogDir ?? null,
   // 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,

package/src/index.js

@@ -16,6 +16,7 @@ import { resolveSandbox, sandbox } from './tools.js';
 import { parseArgv } from './argv.js';
 import { deferredPrompt } from './prompt.js';
 import { AGENTS } from './subagent.js';
+import { runLines, transcriptLines, sweep, cleanup } from './tasklog.js';
 import { runSetup } from './setup.js';
 
 // ---- argv -------------------------------------------------------------
@@ -290,6 +291,7 @@ const HELP = `
   ${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('/tasks [n]')}       sub-agent runs this session; with n, one in full
   ${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
@@ -392,6 +394,11 @@ async function main() {
   // Before anything reaches the network, on every path through the program.
   warnIfInsecure();
 
+  // At startup, not only at exit: the transcripts worth sweeping are the ones
+  // a crash left behind, and the exit path that would have removed them is the
+  // path that did not run.
+  sweep();
+
   // Subcommands are dispatched before the one-shot path below, so `setup` is
   // never mistaken for a one-word prompt and sent to the model.
   if (args.words[0] === 'setup') {
@@ -588,6 +595,14 @@ async function main() {
       continue;
     }
     if (input === '/models') { await showModels(); continue; }
+    if (input === '/tasks' || input.startsWith('/tasks ')) {
+      const raw = input.split(/\s+/)[1];
+      // Printed, never pushed into `messages`. Reading what a sub-agent did
+      // must not cost the window the delegation just saved.
+      const lines = raw === undefined ? runLines() : transcriptLines(Number(raw));
+      lines.forEach((l) => console.log(l));
+      continue;
+    }
     if (input === '/mcp') {
       if (!mcp || !mcp.routes.size) { console.log(c.grey('  no MCP servers attached — start with --mcp')); continue; }
       for (const [name, server] of mcp.servers) {
@@ -659,6 +674,10 @@ async function main() {
 
   rl.close();
   mcp?.close();
+  // Transcripts are disposable by construction; a session that ends tidily
+  // takes its own with it. `sweep` at startup is what catches the ones a crash
+  // left behind, because this line is exactly what a crash skips.
+  cleanup();
   console.log(c.grey('  bye'));
 }
 

package/src/subagent.js

@@ -1,6 +1,7 @@
 import { def, TOOLS } from './tools.js';
 import { config } from './config.js';
-import { c } from './ui.js';
+import { c, elapsed } from './ui.js';
+import { startRun } from './tasklog.js';
 
 /**
  * Sub-agents: one delegated task, one throwaway context.
@@ -129,6 +130,39 @@ export function systemFor(agent) {
 const nest = (line) => String(line).split('\n')
   .map((l) => `${c.grey('   │')} ${l}`).join('\n');
 
+/** How much of the prompt fits on the opening line. */
+const GIST = 60;
+
+/**
+ * The line that says a run has started.
+ *
+ * Without it a delegated run is an unlabelled block of nested tool calls, and
+ * two of them in a row are indistinguishable in scrollback. The gist is the
+ * prompt's first line, cut: enough to recognise which task this was, never
+ * enough to be worth reading instead of the report.
+ */
+export function openLine(agent, prompt) {
+  const first = String(prompt).split('\n')[0].trim();
+  const gist = first.length > GIST ? `${first.slice(0, GIST - 1)}…` : first;
+  return `${c.grey('   ┌')} ${c.bold(agent)} ${c.grey(`· ${gist}`)}`;
+}
+
+/**
+ * The line that closes one, and the only place the transcript is advertised.
+ *
+ * This is what makes `reportLines`' "…N more lines" actionable: the report on
+ * screen is bounded, and now there is somewhere to go for the rest of it and
+ * for everything the sub-agent read on the way.
+ */
+export function closeLine({ ms, steps, path, ok }) {
+  // A run that threw or was interrupted is the one worth reading, so the line
+  // that points at its transcript must not read like a clean finish.
+  const bits = [`${steps} step${steps === 1 ? '' : 's'}`, elapsed(ms), ...(ok ? [] : ['stopped'])];
+  if (path) bits.push(path);
+  const line = `   └ ${bits.join(' · ')}`;
+  return ok ? c.grey(line) : c.yellow(line);
+}
+
 const MAX_REPORT_LINES = 14;
 
 /** The report on screen, dimmed and bounded — the caller received all of it. */
@@ -185,34 +219,54 @@ export async function runTask(args, {
   // means never compacting it at all.
   const own = config.subagentModel ? config.subagentLimits : null;
 
-  const done = await run({
-    messages,
-    // A smaller model for the grunt work is the whole reason this is a knob:
-    // the survey is reading and grepping, the synthesis is not.
-    model: config.subagentModel ?? model,
-    window: own ? own.contextWindow : config.contextWindow,
-    maxTokens: own?.maxTokens ?? config.maxTokens,
-    signal,
-    approve,
-    grant,
-    // No MCP: a local model already struggles past ~25 tools, and the
-    // sub-agent's list is meant to be the short one.
-    mcp: null,
-    tools: subagentTools(agent),
-    // The checklist is module state belonging to the task the user asked for.
-    // A sub-agent that called set_plan would clear it out from under the agent
-    // that delegated to it.
-    plan: false,
-    // Its reasoning and prose are not printed: they are not the answer, and a
-    // second stream interleaved with the caller's is unreadable. Tool calls
-    // still show, indented, so the run is not a black box.
-    stream: false,
-    out: (line) => out(nest(line)),
-    maxSteps,
-    depth: 1,
-  });
-
-  const report = reportFrom(done);
-  reportLines(report).forEach((l) => out(l));
-  return report;
+  // Recorded from here, not from the first step: a run that dies in its first
+  // model call still leaves a file saying which task was asked for.
+  const log = startRun({ agent, prompt, model: config.subagentModel ?? model });
+  const started = Date.now();
+  out(openLine(agent, prompt));
+
+  let steps = 0;
+  let report;
+  try {
+    const done = await run({
+      messages,
+      // A smaller model for the grunt work is the whole reason this is a knob:
+      // the survey is reading and grepping, the synthesis is not.
+      model: config.subagentModel ?? model,
+      window: own ? own.contextWindow : config.contextWindow,
+      maxTokens: own?.maxTokens ?? config.maxTokens,
+      signal,
+      approve,
+      grant,
+      // No MCP: a local model already struggles past ~25 tools, and the
+      // sub-agent's list is meant to be the short one.
+      mcp: null,
+      tools: subagentTools(agent),
+      // The checklist is module state belonging to the task the user asked for.
+      // A sub-agent that called set_plan would clear it out from under the agent
+      // that delegated to it.
+      plan: false,
+      // Its reasoning and prose are not printed: they are not the answer, and a
+      // second stream interleaved with the caller's is unreadable. Tool calls
+      // still show, indented, so the run is not a black box.
+      stream: false,
+      out: (line) => out(nest(line)),
+      maxSteps,
+      depth: 1,
+      // Written as it goes rather than at the end. The runs worth reading are
+      // the ones that were interrupted, threw, or ran out of steps, and none
+      // of those reach the line below.
+      onStep: (msgs, n) => { steps = n; log?.step(msgs, n); },
+    });
+
+    report = reportFrom(done);
+    reportLines(report).forEach((l) => out(l));
+    return report;
+  } finally {
+    // In `finally` so an abort or a throw still closes the record and still
+    // tells the user where the partial transcript is — that is the case the
+    // transcript exists for.
+    const path = log?.finish({ report, steps });
+    out(closeLine({ ms: Date.now() - started, steps, path, ok: report !== undefined }));
+  }
 }

package/src/tasklog.js

@@ -0,0 +1,274 @@
+import { mkdirSync, writeFileSync, readFileSync, readdirSync, rmSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { config } from './config.js';
+import { c, elapsed } from './ui.js';
+
+/**
+ * Sub-agent transcripts: the one part of a session you could not go back to.
+ *
+ * src/subagent.js is built on throwing context away, and it should be — a
+ * survey that reads thirty files costs the conversation one report instead of
+ * thirty files. But "the caller's window must not hold it" and "the user may
+ * never see it" are two different claims, and the code used to make both:
+ * `runTask` took the last assistant message and let the rest go out of scope.
+ *
+ * So the transcript goes to a file instead of the window. Nothing here is ever
+ * read back into a conversation on its own — `/tasks` prints, it does not
+ * re-inject — which is what keeps the context economy intact. The user gets to
+ * look; the model still pays one report.
+ *
+ * Temp, not $HOME. These are disposable by construction: a transcript is
+ * interesting for as long as you are still wondering what that sub-agent did,
+ * which is the session it ran in and maybe the morning after. Somewhere that
+ * gets swept is the honest place for that, and it needs no new dotfile.
+ */
+
+/** Everything this module writes lives under one directory, so cleanup is one call. */
+const ROOT = () => config.taskLogDir ?? join(tmpdir(), 'kronk-cli');
+
+/**
+ * One directory per session, named so two sessions cannot collide and a stale
+ * one can be aged out by its own timestamp rather than by stat'ing it.
+ */
+const SESSION = `${Date.now().toString(36)}-${process.pid}`;
+
+/** Sessions older than this are swept at startup. */
+const KEEP_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Runs kept per session.
+ *
+ * An autonomous run that delegates forty times should not quietly fill the
+ * temp dir with forty 40-step transcripts. The oldest go first: the run you
+ * want to read is almost always a recent one, and the alternative — refusing
+ * to write past the cap — loses exactly the transcripts most likely to matter.
+ */
+const MAX_RUNS = 50;
+
+let counter = 0;
+
+/** Where this session's transcripts go. Created on first write, not at import. */
+export const sessionDir = () => join(ROOT(), SESSION);
+
+const file = (n) => join(sessionDir(), `task-${String(n).padStart(3, '0')}.json`);
+
+/**
+ * 0700 and 0600 throughout.
+ *
+ * A transcript holds file contents and command output from the user's project,
+ * which is the same material `~/.kronk-cli.json` guards, in a directory that on
+ * a shared machine is world-readable by default.
+ */
+function ensureDir() {
+  mkdirSync(sessionDir(), { recursive: true, mode: 0o700 });
+}
+
+/** Drop the oldest transcripts once the cap is exceeded. */
+function trim() {
+  const files = readdirSync(sessionDir()).filter((f) => /^task-\d+\.json$/.test(f)).sort();
+  for (const f of files.slice(0, Math.max(0, files.length - MAX_RUNS))) {
+    try { rmSync(join(sessionDir(), f)); } catch { /* already gone */ }
+  }
+}
+
+/**
+ * A run in progress.
+ *
+ * `step` is called as the sub-agent works and rewrites the whole record, which
+ * is the point: a run that is interrupted, that throws, or that hits its step
+ * cap is exactly the run whose transcript is worth having, and it never reaches
+ * a tidy end at which to write one. Rewriting a small JSON file a few dozen
+ * times costs nothing next to the model call that produced each step.
+ */
+class Run {
+  constructor(n, meta) {
+    this.n = n;
+    this.path = file(n);
+    this.record = { n, ...meta, startedAt: new Date().toISOString(), endedAt: null, state: 'running', steps: 0, messages: [], report: null };
+  }
+
+  /** Never throw into the sub-agent: a full disk must not fail a delegated task. */
+  #flush() {
+    try {
+      ensureDir();
+      writeFileSync(this.path, `${JSON.stringify(this.record, null, 2)}\n`, { mode: 0o600 });
+    } catch { /* the transcript is a convenience, not the work */ }
+  }
+
+  step(messages, steps) {
+    this.record.messages = messages;
+    this.record.steps = steps;
+    this.#flush();
+  }
+
+  finish({ report, steps }) {
+    this.record.endedAt = new Date().toISOString();
+    // No report means the run threw or was interrupted: runTask closes the
+    // record from a `finally`, so this is the only signal that it did not end
+    // on its own terms.
+    this.record.state = report === undefined ? 'stopped' : 'done';
+    if (report !== undefined) this.record.report = report;
+    if (steps !== undefined) this.record.steps = steps;
+    this.#flush();
+    try { trim(); } catch { /* nothing worth reporting */ }
+    return this.path;
+  }
+}
+
+/**
+ * Begin recording one delegated task, or don't.
+ *
+ * Returns null when logging is off, and every caller is written to treat that
+ * as ordinary rather than as an error — the feature switching off should not
+ * put a branch in the middle of the delegation path.
+ */
+export function startRun(meta) {
+  if (!config.taskLog) return null;
+  counter += 1;
+  const run = new Run(counter, meta);
+  run.step([], 0);
+  return run;
+}
+
+/** Every run this session recorded, oldest first. Summaries only — not the messages. */
+export function listRuns() {
+  let names;
+  try { names = readdirSync(sessionDir()); } catch { return []; }
+  return names.filter((f) => /^task-\d+\.json$/.test(f)).sort()
+    .map((f) => {
+      try {
+        const r = JSON.parse(readFileSync(join(sessionDir(), f), 'utf8'));
+        return {
+          n: r.n,
+          agent: r.agent,
+          prompt: r.prompt ?? '',
+          model: r.model ?? null,
+          steps: r.steps ?? 0,
+          ms: r.endedAt ? Date.parse(r.endedAt) - Date.parse(r.startedAt) : null,
+          state: r.state ?? (r.endedAt ? 'done' : 'running'),
+          path: join(sessionDir(), f),
+        };
+      } catch { return null; }   // a half-written file is not a crash
+    })
+    .filter(Boolean);
+}
+
+/** One run in full, or null if there is no such run. */
+export function readRun(n) {
+  try { return JSON.parse(readFileSync(file(n), 'utf8')); }
+  catch { return null; }
+}
+
+/**
+ * Remove this session's transcripts, and any session that has aged out.
+ *
+ * Called at startup rather than only at exit, because the transcripts worth
+ * sweeping are precisely the ones a crash left behind — the exit path that
+ * would have cleaned them is the path that did not run.
+ */
+export function sweep({ all = false } = {}) {
+  const root = ROOT();
+  let dirs;
+  try { dirs = readdirSync(root); } catch { return 0; }
+  let removed = 0;
+  for (const d of dirs) {
+    const full = join(root, d);
+    if (!all) {
+      if (d === SESSION) continue;
+      try { if (Date.now() - statSync(full).mtimeMs < KEEP_MS) continue; } catch { continue; }
+    }
+    try { rmSync(full, { recursive: true, force: true }); removed += 1; } catch { /* in use */ }
+  }
+  return removed;
+}
+
+/** Drop this session's own directory on a clean exit. */
+export function cleanup() {
+  try { rmSync(sessionDir(), { recursive: true, force: true }); } catch { /* nothing to do */ }
+}
+
+/** `4.2s`, or an em dash for a run with no end time yet. */
+const took = (ms) => (ms === null ? '\u2014' : elapsed(ms));
+
+const gist = (prompt, width) => {
+  const first = String(prompt).split('\n')[0].trim();
+  return first.length > width ? `${first.slice(0, width - 1)}\u2026` : first;
+};
+
+/**
+ * `/tasks` — one line per run this session.
+ *
+ * Numbered, because the number is how the next command names one. A run that
+ * never finished says so rather than reporting a duration it does not have:
+ * "still running" and "died three steps in" are the two states where the
+ * transcript is worth the most, and both would otherwise render as a blank.
+ */
+export function runLines() {
+  if (!config.taskLog) {
+    return [c.grey('  transcripts are off \u2014 drop KRONK_TASK_LOG=false')];
+  }
+  const runs = listRuns();
+  if (!runs.length) {
+    return [c.grey('  no sub-agent runs yet \u2014 the model starts one with the task tool')];
+  }
+  const lines = runs.map((r) => {
+    const how = { done: took(r.ms), stopped: 'stopped', running: 'running' }[r.state] ?? took(r.ms);
+    const state = `${r.steps} step${r.steps === 1 ? '' : 's'} \u00b7 ${how}`.padEnd(20);
+    const dot = { done: c.green('\u25cf'), stopped: c.yellow('\u25cf'), running: c.blue('\u25cf') }[r.state] ?? c.grey('\u25cf');
+    return `  ${dot} ${c.bold(String(r.n).padStart(2))}  ${r.agent.padEnd(7)} ${c.grey(state)} ${c.grey(gist(r.prompt, 44))}`;
+  });
+  lines.push(c.grey(`\n  /tasks <n> for one in full \u00b7 ${sessionDir()}`));
+  return lines;
+}
+
+/**
+ * `/tasks <n>` — one run, whole.
+ *
+ * Nothing is cut here, and that is the point: the bounded report on screen is
+ * what sent the user looking, so a second ceiling would only move the wall.
+ * This is printed, never pushed back into the conversation — looking at what a
+ * sub-agent did must not cost the window the delegation just saved.
+ */
+export function transcriptLines(n) {
+  const r = readRun(n);
+  if (!r) return [c.red(`  no run ${n} \u2014 /tasks to list them`)];
+
+  const ms = r.endedAt ? Date.parse(r.endedAt) - Date.parse(r.startedAt) : null;
+  const out = [
+    '',
+    `  ${c.bold(`task ${r.n}`)} ${c.grey(`\u00b7 ${r.agent} \u00b7 ${r.model ?? 'session model'} \u00b7 ${r.steps} step${r.steps === 1 ? '' : 's'} \u00b7 ${took(ms)}${r.state === 'done' ? '' : ` \u00b7 ${r.state}`}`)}`,
+    '',
+    c.grey('  \u2500\u2500 prompt \u2500\u2500'),
+    ...String(r.prompt ?? '').split('\n').map((l) => `  ${l}`),
+  ];
+
+  // The system prompt is the contract in src/subagent.js and the same every
+  // time; the user message is the prompt already printed above.
+  const body = (r.messages ?? []).slice(2);
+  // The last assistant message *is* the report — `reportFrom` takes it. It gets
+  // its own heading below, so printing it here too would only be twice.
+  if (r.report != null && body.at(-1)?.role === 'assistant') body.pop();
+
+  for (const m of body) {
+    if (m.role === 'assistant') {
+      for (const t of m.tool_calls ?? []) {
+        out.push('', `  ${c.blue(`\u2699 ${t.function?.name}`)} ${c.grey(t.function?.arguments ?? '')}`);
+      }
+      const text = String(m.content ?? '').trim();
+      if (text && !(m.tool_calls ?? []).length) {
+        out.push('', ...text.split('\n').map((l) => `  ${l}`));
+      }
+    } else if (m.role === 'tool') {
+      out.push(...String(m.content ?? '').split('\n').map((l) => c.grey(`  \u2502 ${l}`)));
+    }
+  }
+
+  if (r.report != null) {
+    out.push('', c.grey('  \u2500\u2500 report \u2500\u2500'), ...String(r.report).split('\n').map((l) => `  ${l}`));
+  } else if (r.state === 'stopped') {
+    out.push('', c.yellow('  \u2500\u2500 stopped before it reported \u2500\u2500'));
+  }
+  out.push('', c.grey(`  ${join(sessionDir(), `task-${String(r.n).padStart(3, '0')}.json`)}`));
+  return out;
+}

package/src/tools.js

@@ -561,13 +561,31 @@ export async function runTool(name, args, opts = {}) {
         // Went straight to ripgrep unchecked, so `search` with an absolute path
         // read anything on the machine while read_file was busy refusing to.
         const where = safe(args.path ?? '.');
+        // Both tools exit 1 to mean "nothing matched", which is an answer and
+        // not a failure. Reported as an error the model stops believing the
+        // tool, and spends its step budget re-phrasing and re-reading rather
+        // than using the fact it was just handed.
+        const NOTHING = '(no matches)';
         try {
           const { stdout } = await exec('rg', ['-n', '--no-heading', '-m', '200', args.pattern, where]);
-          return clip(stdout) || '(no matches)';
+          return clip(stdout) || NOTHING;
         } catch (e) {
-          if (e.code === 1) return '(no matches)';
-          const { stdout } = await exec('grep', ['-rn', '-m', '200', args.pattern, where]);
-          return clip(stdout) || '(no matches)';
+          if (e.code === 1) return NOTHING;
+          // No ripgrep on this machine, or it refused the pattern. grep is the
+          // floor, and it needs the same exit-1 reading the call above has —
+          // this is the branch CI never reaches, because its images ship rg.
+          try {
+            // -E because this tool advertises ripgrep-style patterns, and basic
+            // grep reads `a|b` as the three literal characters. -H because GNU
+            // grep drops the filename when it is given exactly one file, and
+            // this tool promises `file:line` prefixes — BSD grep prints them
+            // either way, which is why a macOS-only check would not see it.
+            const { stdout } = await exec('grep', ['-rn', '-H', '-E', '-m', '200', args.pattern, where]);
+            return clip(stdout) || NOTHING;
+          } catch (err) {
+            if (err.code === 1) return NOTHING;
+            throw err;
+          }
         }
       }
 

package/src/ui.js

@@ -33,6 +33,11 @@ ${c.cyan('  ██ kronk-cli')}  ${c.grey('· local agent, no network')}
 
 const k = (n) => (n >= 1000 ? `${(n / 1000).toFixed(n >= 10000 ? 0 : 1)}k` : String(n));
 
+/** `4.2s` under a minute, `1m4s` above it. */
+export const elapsed = (ms) => (ms < 60000
+  ? `${(ms / 1000).toFixed(1)}s`
+  : `${Math.floor(ms / 60000)}m${Math.round((ms % 60000) / 1000)}s`);
+
 /** `18k/131k 14% ▓▓░░░░░░░░` — how full the window is after this turn. */
 export function fmtContext(used, window) {
   if (!window || !used) return '';