agent-from-zero 0.28.0 → 0.30.0

package/dist/agent.js

@@ -19,10 +19,11 @@ import { clearTodos, getTodos, renderTodos } from "./todos.js"; // the agent's p
 import { renderDiff } from "./diff.js"; // show what /undo put back / what /diff changed, reusing the Day 21 diff renderer
 import path from "node:path"; // shorten paths for the /diff summary
 import { expandMentions } from "./mentions.js"; // @file mentions: pull referenced files into context (secret files refused)
-import { banner, framedPrompt, formatModelChoices, statusLine, inputRule } from "./ui.js"; // welcome box, prompt, model labels, status line
-import { gitBranch, toggleLastCollapsed, cleanup as tuiCleanup } from "./tui.js"; // git branch for the status line + collapsible output
+import { banner, framedPrompt, formatModelChoices, statusLine } from "./ui.js"; // welcome box, prompt, model labels, status line
+import { gitBranch, toggleLastCollapsed, revealReasoning, clearReasoning, revealToolCalls, clearToolCalls, cleanup as tuiCleanup } from "./tui.js"; // git branch + collapsible output + collapsed reasoning (Ctrl+R) + folded tool-call trace (Ctrl+T)
 import { promptSelect, promptForm } from "./menu.js"; // arrow-key approval menu + multi-question form
 import { editLine } from "./editor.js"; // our own line editor (keeps the status footer pinned even when input wraps)
+import { normalizeDroppedPaths } from "./drop.js"; // drag-and-drop: a dropped file's path → a clean absolute path in the input
 import { rememberTool, readMemory, readMemoryTyped, extractMemories, MEMORY_PATH } from "./memory.js"; // long-term project memory + auto-extract
 import { loadSkills, buildSkillTool, findSkill, skillInstructions } from "./skills.js"; // Markdown-as-plugin skills
 import { initCostMeter, DEFAULT_PRICING } from "./cost.js"; // token & cost accounting for /cost
@@ -78,7 +79,12 @@ const SESSION_HELP = `commands:
   /resume    list recent sessions in this project and continue one of them
   /skills    list the reusable skills available in this project
   /skill <name>  run a skill yourself (works even for user-only skills)
-  exit       leave (Ctrl+C at the prompt does the same)`;
+  exit       leave (Ctrl+C at the prompt does the same)
+
+keys (at the prompt):
+  Ctrl+R     reveal the model's thinking for the last answer (collapsed behind a spinner by default)
+  Ctrl+T     reveal the folded tool-call trace for the last answer (read_file/search/… shown as a tally)
+  Tab        expand/collapse the most recent tool output`;
 // Injected when the user turns plan mode on, so the model knows the rules of the
 // mode it now lives in (the permission gate enforces them regardless).
 const PLAN_MODE_NOTICE = `[plan mode ON] Investigate this request using only read-only tools — read_file, search, and safe read-only shell (ls, cat, git status). Do NOT write files, edit, or run mutating commands; the permission gate will block them. When you have a concrete, ordered plan, call the exit_plan_mode tool with that plan. The user reviews and approves it before you make any change.`;
@@ -253,7 +259,7 @@ async function main() {
             // so the status bar stays pinned below however the line wraps.
             editing = true;
             try {
-                const res = await editLine(rl, { prompt, footer, history, onTab: () => toggleLastCollapsed() });
+                const res = await editLine(rl, { prompt, footer, history, onTab: () => toggleLastCollapsed(), onReveal: () => revealReasoning(), onTools: () => revealToolCalls(), transformPaste: normalizeDroppedPaths });
                 if (res.type === "line") {
                     if (res.value.trim())
                         history.push(res.value); // remember non-empty entries for ↑/↓
@@ -437,6 +443,8 @@ async function main() {
                 clearTodos(); // the plan belonged to the old task — drop it
                 resetTeam(); // the team belonged to the old task — forget it (mailboxes re-wipe on next use)
                 resetBoard(); // and the shared task board (Day 40)
+                clearReasoning(); // drop the collapsed thinking too
+                clearToolCalls(); // ...and the folded tool-call trace
                 sessionId = newSessionId(); // a fresh conversation is a fresh session file
                 console.log(chalk.dim("(history cleared)")); // confirm the reset
                 return true;
@@ -629,16 +637,16 @@ async function main() {
         });
     }
     while (true) {
-        // The input area, Claude-Code style: a top rule, the "❯" you type on, then a
-        // bottom rule + status line (model · 📁 dir · 🌿 branch · ctx% · $ · time)
-        // pinned BELOW the input. readUserLine draws the footer under the prompt and
-        // keeps the cursor on the ❯ line, so the status reads like a real bottom bar.
-        // Only in a TTY; piped input stays clean.
+        // The input area: a blank line for breathing room, the "❯" you type on, then
+        // a single status line (model · 📁 dir · 🌿 branch · ctx% · $ · time) pinned
+        // BELOW the input. We dropped the old top/bottom horizontal rules — two bare
+        // lines around an empty prompt just looked like noise. Only in a TTY; piped
+        // input stays clean.
         let footer;
         if (process.stdin.isTTY) {
             const ctxPct = Math.min(100, Math.round((estimateHistoryTokens(messages) / CONFIG.contextWindow) * 100));
-            console.log("\n" + inputRule()); // top rule above the prompt
-            footer = inputRule() + "\n" + statusLine(CONFIG.model, path.basename(process.cwd()), gitBranch(), ctxPct, costMeter.cost(), Date.now() - sessionStartedAt); // bottom rule + status, pinned below
+            console.log(""); // one blank line separates the previous answer from the prompt
+            footer = statusLine(CONFIG.model, path.basename(process.cwd()), gitBranch(), ctxPct, costMeter.cost(), Date.now() - sessionStartedAt); // status pinned below the prompt
         }
         const line = (await readUserLine(framedPrompt(isPlanMode()), footer)).trim(); // next input, or "exit" on EOF
         if (!line)
@@ -670,6 +678,8 @@ async function main() {
         if (refused.length)
             console.log(chalk.yellow(`(refused secret file${refused.length === 1 ? "" : "s"}: ${refused.join(", ")})`));
         messages.push({ role: "user", content: augmented + injected }); // the new turn (with any attached files + hook context) joins the shared history
+        clearReasoning(); // Ctrl+R should reveal THIS turn's thinking, not the previous answer's
+        clearToolCalls(); // ...and Ctrl+T should reveal THIS turn's tool calls
         running = true; // Ctrl+C now means "interrupt the task"
         interrupted = false; // fresh interrupt state for this task
         controller = new AbortController(); // fresh abort signal for this task

package/dist/drop.js

@@ -0,0 +1,104 @@
+// Drag-and-drop a file onto the terminal and it pastes the file's path into the
+// input — but as a SHELL token: backslash-escaped spaces (/Users/me/my\ file.txt)
+// or wrapped in quotes, and usually with a trailing space. That's noisy to read
+// and clumsy to hand to the agent. This turns a dropped path (or several) into
+// clean ABSOLUTE paths, so the user never types a long path by hand.
+//
+// It is deliberately conservative: it only rewrites text that is, after
+// unescaping, one or more EXISTING ABSOLUTE paths (that's exactly what a terminal
+// drag produces). Anything else — ordinary pasted prose, a relative snippet — is
+// returned untouched, so this can run on every paste without surprising anyone.
+import fs from "node:fs"; // confirm the tokens are real paths (the drag signal)
+import os from "node:os"; // expand a leading ~
+import path from "node:path"; // resolve + normalize to absolute
+// Terminals with "bracketed paste" wrap the text in these markers; strip them so
+// a drop still parses if the mode happens to be on.
+const BRACKET_PASTE = /\x1b\[20[01]~/g;
+// Split a dropped string into path tokens, honoring the escaping a terminal adds:
+// backslash escapes (\<space>, \( …) and single/double quotes. Whitespace OUTSIDE
+// a quote/escape separates tokens (so several dropped files become several paths).
+function splitTokens(raw) {
+    const s = raw.replace(BRACKET_PASTE, "").trim();
+    const tokens = [];
+    let cur = "";
+    let started = false; // did the current token get any character? (distinguishes "" from absent)
+    let i = 0;
+    while (i < s.length) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            cur += s[i + 1];
+            i += 2;
+            started = true;
+            continue;
+        } // \x → literal x
+        if (c === "'") { // single quotes: everything literal until the next '
+            i++;
+            while (i < s.length && s[i] !== "'")
+                cur += s[i++];
+            i++;
+            started = true;
+            continue;
+        }
+        if (c === '"') { // double quotes: backslash still escapes inside
+            i++;
+            while (i < s.length && s[i] !== '"') {
+                if (s[i] === "\\" && i + 1 < s.length) {
+                    cur += s[i + 1];
+                    i += 2;
+                }
+                else
+                    cur += s[i++];
+            }
+            i++;
+            started = true;
+            continue;
+        }
+        if (c === " " || c === "\t" || c === "\n" || c === "\r") { // a separator between tokens
+            if (started) {
+                tokens.push(cur);
+                cur = "";
+                started = false;
+            }
+            i++;
+            continue;
+        }
+        cur += c;
+        i++;
+        started = true;
+    }
+    if (started)
+        tokens.push(cur);
+    return tokens;
+}
+// A drop produces ABSOLUTE paths (macOS/Linux terminals). Treat a leading ~ as
+// home. Anything not absolute-ish is not a drop — we leave it alone.
+const looksAbsolute = (t) => t.startsWith("/") || t === "~" || t.startsWith("~/");
+const expandTilde = (t) => (t === "~" || t.startsWith("~/") ? os.homedir() + t.slice(1) : t);
+// Quote a path that contains whitespace so several dropped paths stay separable
+// (and the whole thing survives being read as shell-ish tokens later). Prefer
+// single quotes; fall back to double if the path itself contains a single quote.
+function quoteIfNeeded(p) {
+    if (!/\s/.test(p))
+        return p;
+    return p.includes("'") ? `"${p}"` : `'${p}'`;
+}
+// The entry point: given a pasted string, return clean absolute path(s) if it is
+// a drop, otherwise the original text unchanged. A successful normalization ends
+// with a single trailing space, so the cursor lands ready to type the question.
+export function normalizeDroppedPaths(raw) {
+    if (!raw)
+        return raw;
+    const tokens = splitTokens(raw);
+    if (!tokens.length)
+        return raw;
+    const abs = [];
+    for (const t of tokens) {
+        if (!looksAbsolute(t))
+            return raw; // not a dragged absolute path → leave the paste as-is
+        const resolved = path.resolve(expandTilde(t)); // normalize (//, .., trailing /) → canonical absolute
+        if (!fs.existsSync(resolved))
+            return raw; // a path that doesn't exist isn't a real drop
+        abs.push(resolved);
+    }
+    return abs.map(quoteIfNeeded).join(" ") + " ";
+}

package/dist/editor.js

@@ -26,6 +26,10 @@ export function reduceEditor(s, str, key) {
                 return { state: { buffer, cursor: Math.max(0, cursor - 1) }, action: "edit" }; // back one char
             case "f":
                 return { state: { buffer, cursor: Math.min(buffer.length, cursor + 1) }, action: "edit" }; // forward one char
+            case "r":
+                return { state: s, action: "reveal" }; // Ctrl+R → reveal the model's collapsed thinking
+            case "t":
+                return { state: s, action: "tools" }; // Ctrl+T → reveal the folded tool-call trace
             default:
                 return { state: s, action: "none" };
         }
@@ -254,6 +258,12 @@ export function editLine(rl, opts) {
         const onKey = (str, key) => {
             if (done)
                 return;
+            // A drag-and-drop (or any paste) arrives as one multi-char string. Give the
+            // caller a chance to rewrite it — e.g. turn dropped file paths into clean
+            // absolute paths — before it lands in the buffer. No-op for normal text.
+            if (str && str.length > 1 && !key?.ctrl && !key?.meta && opts.transformPaste) {
+                str = opts.transformPaste(str);
+            }
             const next = reduceEditor(state, str, key || {});
             state = next.state;
             switch (next.action) {
@@ -282,6 +292,14 @@ export function editLine(rl, opts) {
                     opts.onTab?.(); // may print above us (e.g. expand a collapsed block) and scroll
                     first = true; // so the next paint lands fresh at the cursor, not a stale climb-up
                     return draw();
+                case "reveal":
+                    opts.onReveal?.(); // print the model's collapsed thinking above us, then repaint
+                    first = true; // the next paint lands fresh, not a stale climb-up
+                    return draw();
+                case "tools":
+                    opts.onTools?.(); // print the folded tool-call trace above us, then repaint
+                    first = true;
+                    return draw();
                 case "edit":
                     return draw();
                 case "none":

package/dist/loop.js

@@ -12,7 +12,7 @@ import { emit } from "./telemetry.js"; // local-only event log (no-op unless the
 import { runHooks } from "./hooks.js"; // user lifecycle hooks (PreToolUse / PostToolUse / Stop)
 import { recordUsage } from "./cost.js"; // meter token usage from the stream
 import { mark, thinkingWord, spinnerText } from "./ui.js"; // centralized terminal styling (markers, spinner)
-import { printToolSummary } from "./tui.js"; // collapsible tool output
+import { recordToolCall, recordReasoning } from "./tui.js"; // folded tool-call trace (Ctrl+T) + the model's hidden thinking (Ctrl+R)
 import { MarkdownStream } from "./markdown.js"; // render the streamed answer as terminal markdown
 import { todoNag, getTodos, renderTodos } from "./todos.js"; // the agent's plan: show it on screen + nag when it goes stale
 import { pendingNotifications } from "./background.js"; // background tasks (Day 37): surface finished jobs as a turn
@@ -328,6 +328,11 @@ opts) {
     const word = thinkingWord(modelCallSeq++); // a rotating "thinking" word for this call
     const startedAt = Date.now(); // for the spinner's live elapsed counter
     let streamedChars = 0; // bytes of content+reasoning streamed this call → a live token estimate
+    // Reasoning is COLLAPSED by default: while the model thinks, the spinner keeps
+    // spinning (with a 💭 hint) instead of dumping the trace; we stash it for Ctrl+R.
+    let reasoningBuf = ""; // the accumulated thinking, hidden behind the spinner
+    let reasoningActive = false; // true while reasoning tokens are arriving → spinner shows 💭
+    let reasoningShown = false; // have we printed the "thought for Ns" indicator yet?
     const spinner = opts.quiet
         ? null // the eval harness wants silence
         : ora({ text: spinnerText(word, 0, !!opts.subAgent, opts.model), discardStdin: false }).start(); // discardStdin:false — ora would otherwise eat Ctrl+C
@@ -338,8 +343,10 @@ opts) {
     // - stall (slow but alive for 30s) → log it and keep waiting
     // It also ticks the spinner: elapsed seconds + a live token estimate (~chars/4).
     const watchdog = setInterval(() => {
+        // While the model is reasoning, prefix the spinner with 💭 so "it's thinking"
+        // reads differently from "it's waiting on the first token".
         if (spinner?.isSpinning)
-            spinner.text = spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, opts.model, Math.round(streamedChars / 4));
+            spinner.text = (reasoningActive ? chalk.dim("💭 ") : "") + spinnerText(word, Math.floor((Date.now() - startedAt) / 1000), !!opts.subAgent, opts.model, Math.round(streamedChars / 4));
         const quietMs = Date.now() - lastEvent; // ms since the last event
         if (quietMs > IDLE_TIMEOUT_MS) {
             emit("agent_watchdog_idle"); // record the cut — these should be rare
@@ -364,9 +371,27 @@ opts) {
         { model: opts.model, messages, tools: toolsFor(opts), stream: true, stream_options: { include_usage: true } }, { signal });
         let content = ""; // accumulated answer text
         let printedPrefix = false; // have we printed the answer prefix yet?
-        let printedThinking = false; // have we started printing the reasoning trace yet?
         let md = null; // renders the streamed answer as markdown, block by block
         const calls = []; // tool calls under assembly, indexed by delta.index
+        // The model has finished thinking and is about to say/do something. Close out
+        // the spinner, stash the trace, and print a single one-line indicator with the
+        // shortcut to reveal it. Idempotent + collapses to nothing for sub-agents and
+        // the eval harness (they never show thinking).
+        const flushReasoning = () => {
+            if (!reasoningBuf || reasoningShown)
+                return;
+            reasoningShown = true;
+            reasoningActive = false;
+            if (spinner?.isSpinning)
+                spinner.stop();
+            if (opts.quiet || opts.subAgent)
+                return; // no UI for silent / nested runs
+            recordReasoning(reasoningBuf); // keep it for Ctrl+R (never goes into history)
+            const secs = Math.round((Date.now() - startedAt) / 1000);
+            const toks = Math.round(reasoningBuf.length / 4); // same ~chars/4 estimate as the spinner
+            const tokStr = toks >= 1000 ? `${(toks / 1000).toFixed(1)}k` : `${toks}`;
+            process.stdout.write(chalk.dim(`💭 thought for ${secs}s (~${tokStr} tokens) · Ctrl+R to view`) + "\n");
+        };
         for await (const chunk of stream) {
             lastEvent = Date.now(); // feed the watchdog
             stallWarned = false; // the stream spoke — reset the stall warning
@@ -376,31 +401,24 @@ opts) {
             if (!delta)
                 continue; // keep-alive or usage chunk — nothing to do
             // Reasoning models (e.g. deepseek-reasoner / R1) stream their thinking in a
-            // separate `reasoning_content` field BEFORE the answer. Show it dimly so a
-            // switch to a reasoning model is visibly different — but do NOT keep it:
-            // the reasoning is not the answer and must not be replayed in later turns.
+            // separate `reasoning_content` field BEFORE the answer. We do NOT print it
+            // (it buries the actual reply) and do NOT keep it (it must not be replayed
+            // in later turns): we let the spinner keep spinning, stash the trace, and
+            // surface it only behind Ctrl+R.
             const reasoning = delta.reasoning_content;
             if (reasoning) {
                 streamedChars += reasoning.length; // count reasoning toward the live token estimate
-                if (spinner?.isSpinning)
-                    spinner.stop();
-                if (!opts.quiet && !opts.subAgent) {
-                    if (!printedThinking) {
-                        process.stdout.write("\n" + chalk.dim("💭 thinking: ")); // label the trace once
-                        printedThinking = true;
-                    }
-                    process.stdout.write(chalk.dim(reasoning)); // stream the thinking, dimmed
-                }
+                reasoningBuf += reasoning; // stash it for Ctrl+R instead of streaming it
+                reasoningActive = true; // the spinner now shows 💭 (set by the watchdog)
             }
             if (delta.content) {
+                flushReasoning(); // thinking is over — show the one-line indicator first
                 streamedChars += delta.content.length; // count the answer toward the live token estimate
                 if (spinner?.isSpinning)
                     spinner.stop(); // first token: replace the spinner with real output
                 if (!opts.quiet && !opts.subAgent) {
                     // Only the top-level agent streams to the screen — a sub-agent's
                     // inner monologue would be mistaken for the answer.
-                    if (printedThinking && !printedPrefix)
-                        process.stdout.write("\n"); // end the thinking block before the answer
                     if (!printedPrefix) {
                         // Stream the answer through the markdown renderer: it buffers a block
                         // (paragraph / heading / list / table) and prints it formatted the
@@ -413,6 +431,8 @@ opts) {
                 }
                 content += delta.content; // always keep it for the history (the answer only, never the reasoning)
             }
+            if (delta.tool_calls?.length)
+                flushReasoning(); // thinking is over — indicator before the tool logs (which print after we return)
             for (const tc of delta.tool_calls ?? []) {
                 if (spinner?.isSpinning)
                     spinner.stop(); // tool call starting — spinner served its purpose
@@ -425,6 +445,7 @@ opts) {
                     slot.args += tc.function.arguments; // arguments stream in fragments — concatenate
             }
         }
+        flushReasoning(); // a reasoning-only turn (no content, no tools) still records + indicates
         if (md)
             md.end(); // flush the final (un-terminated) block through the renderer
         if (printedPrefix)
@@ -437,17 +458,25 @@ opts) {
             spinner.stop(); // and never leave a zombie spinner
     }
 }
+// How this agent's activity is prefixed on screen: teammate tagged by name,
+// plain sub-agent nested in blue, top-level flush-left. Shared by the per-call
+// recording and the per-round tally so they line up.
+function agentIndent(opts) {
+    return opts.teammate ? chalk.magenta(`  ⎿ [${opts.teammate.name}] `) : opts.subAgent ? chalk.blue("  ⎿ ") : "";
+}
 // Run one tool call end to end: log it, run it through the permission gate,
 // ask the human if needed, execute, and return the paired result. Read-only
 // calls (allow/deny only, never "ask") are safe to run via this from inside a
 // Promise.all batch; calls that can prompt must be awaited one at a time.
 async function runOneCall(call, opts) {
-    const indent = opts.teammate ? chalk.magenta(`  ⎿ [${opts.teammate.name}] `) : opts.subAgent ? chalk.blue("  ⎿ ") : ""; // teammate activity is tagged by name; plain sub-agent is nested in blue
+    const indent = agentIndent(opts);
     if (!opts.quiet) {
-        // Compact one-line summary — long args are hidden behind Tab.
-        const summary = indent + mark.tool(call.name, call.args.length > 60 ? call.args.slice(0, 57) + "..." : call.args);
-        const full = `tool: ${call.name}\nargs: ${call.args}`;
-        printToolSummary(summary, full);
+        // The announcement is FOLDED (Day-after-40 UI fix): instead of printing a
+        // line per call (which floods the screen on a big exploration), we record it
+        // for the per-round tally + Ctrl+T. Diffs / prompts / results below still
+        // print live. A generous slice keeps Ctrl+T readable without dumping megabytes.
+        const line = indent + mark.tool(call.name, call.args.length > 300 ? call.args.slice(0, 297) + "..." : call.args);
+        recordToolCall(line, `tool: ${call.name}\nargs: ${call.args}`);
     }
     // The permission gate sits between the model's intent and execution.
     const v = checkPermission(call.name, call.args);
@@ -1203,6 +1232,11 @@ opts) {
                 const r = await runOneCall(out.toolCalls[i++], opts);
                 messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
             }
+            // Fold this round's tool calls into ONE tally line instead of one line per
+            // call (the per-call announcements were recorded for Ctrl+T in runOneCall).
+            if (!opts.quiet && out.toolCalls.length) {
+                console.log(agentIndent(opts) + mark.toolTally(out.toolCalls.map((c) => c.name)) + chalk.dim(" · Ctrl+T"));
+            }
             // Background tasks (Day 37): if a job the model started has finished, slip
             // its <task_notification> in here, right after this round's tool results —
             // the model sees the outcome on the next round without ever having blocked

package/dist/markdown.js

@@ -75,8 +75,12 @@ export function renderMarkdown(md, width = termWidth()) {
     const w = Math.max(20, width);
     const m = new Marked();
     m.use(renderer(w));
-    // Override the table renderer AFTER marked-terminal so ours wins: render each
-    // cell's inline markdown to ANSI (parseInline), then lay the table out to fit w.
+    // Override the table AND list renderers AFTER marked-terminal so ours win.
+    // marked-terminal v7 predates marked v15's token-object renderer API, so its
+    // built-in table/list renderers receive tokens they don't understand and spit
+    // out the RAW markdown — literal `**bold**`, `` `code` ``, and `*` bullets
+    // inside list items (and unaligned tables). We render both ourselves, calling
+    // parseInline so the inline markup inside cells / list items actually renders.
     m.use({
         renderer: {
             table(token) {
@@ -84,6 +88,37 @@ export function renderMarkdown(md, width = termWidth()) {
                 const rows = token.rows.map((r) => r.map((c) => this.parser.parseInline(c.tokens)));
                 return renderTable(header, rows, w) + "\n";
             },
+            list(token) {
+                // Render items at a given nesting depth: a bullet (• / N.) + the item's
+                // inline content (bold/code/links parsed), wrapped to width with a hanging
+                // indent so continuation lines sit under the text. Nested lists recurse.
+                const parser = this.parser;
+                const render = (list, depth) => {
+                    const pad = "  ".repeat(depth);
+                    const lines = [];
+                    list.items.forEach((item, idx) => {
+                        const bullet = list.ordered ? `${(typeof list.start === "number" ? list.start : 1) + idx}.` : "•";
+                        const box = item.task ? (item.checked ? "[x] " : "[ ] ") : "";
+                        let inline = "";
+                        const nested = [];
+                        for (const t of item.tokens) {
+                            if (t.type === "list")
+                                nested.push(...render(t, depth + 1));
+                            else if (t.tokens)
+                                inline += parser.parseInline(t.tokens);
+                            else
+                                inline += t.text ?? "";
+                        }
+                        const head = `${pad}${bullet} ${box}`;
+                        const wrapped = wrapAnsi(head + inline.trim(), Math.max(10, w), { hard: true, trim: false }).split("\n");
+                        const hang = " ".repeat(displayWidth(head)); // align wrapped lines under the text
+                        lines.push(...wrapped.map((ln, i) => (i === 0 ? ln : hang + ln.replace(/^\s+/, ""))));
+                        lines.push(...nested);
+                    });
+                    return lines;
+                };
+                return render(token, 0).join("\n") + "\n\n";
+            },
         },
     });
     const out = m.parse(md, { async: false });

package/dist/tui.js

@@ -35,13 +35,6 @@ export function gitBranch() {
 }
 const collapsed = [];
 const MAX_COLLAPSED = 50; // bound the memory — old blocks fall off
-// Print the one-line summary now; stash the full text for Tab to reveal later.
-export function printToolSummary(summary, full) {
-    process.stdout.write(summary + "\n");
-    collapsed.push({ full, expanded: false });
-    if (collapsed.length > MAX_COLLAPSED)
-        collapsed.shift();
-}
 // Tab handler: reveal (or re-hide) the full text of the most recent tool block.
 // Returns false if there's nothing to toggle.
 export function toggleLastCollapsed() {
@@ -58,6 +51,62 @@ export function toggleLastCollapsed() {
     }
     return true;
 }
+// ---- collapsed reasoning (the model's thinking) ------------------------------
+// Reasoning models (deepseek-reasoner / R1) stream a long thinking trace before
+// the answer. Dumping it all to the screen buries the actual reply, so we hide
+// it behind a spinner and a one-line indicator, keeping the trace here for the
+// user to reveal with Ctrl+R (handled by the line editor, like Tab for tools).
+// Stored as one entry per model round; cleared when a new user turn begins, so
+// Ctrl+R always shows the thinking behind the LAST answer.
+const reasoningTrace = [];
+export function recordReasoning(text) {
+    const t = text.trim();
+    if (t)
+        reasoningTrace.push(t);
+}
+// Drop the current turn's thinking. Called when a new prompt is submitted (the
+// old thinking belonged to the old answer) and on /clear.
+export function clearReasoning() {
+    reasoningTrace.length = 0;
+}
+// Ctrl+R handler: print the stored thinking for the last answer, dimmed and
+// nested. Returns false (nothing to show) so the editor can ignore the key.
+export function revealReasoning() {
+    if (!reasoningTrace.length)
+        return false;
+    process.stdout.write(chalk.dim("💭 model's thinking:\n"));
+    process.stdout.write(chalk.dim(reasoningTrace.join("\n\n— — —\n\n").replace(/^/gm, "  ")) + "\n");
+    return true;
+}
+// ---- collapsed tool calls (the activity trace) -------------------------------
+// A long task fires dozens of read_file/search calls; printing one line each
+// floods the screen. Instead the loop prints a compact per-round tally and we
+// keep the full call lines here for Ctrl+T to reveal. Cleared per turn, so
+// Ctrl+T shows the calls behind the LAST answer. (Diffs, prompts, and results
+// still print live — only the one-line announcements are folded.)
+const toolCallLog = [];
+const MAX_TOOL_LOG = 500; // bound the memory
+// Record a tool call's full line for Ctrl+T, and stash its args for Tab.
+export function recordToolCall(line, full) {
+    toolCallLog.push(line);
+    if (toolCallLog.length > MAX_TOOL_LOG)
+        toolCallLog.shift();
+    collapsed.push({ full, expanded: false }); // Tab still reveals the most recent call's full args
+    if (collapsed.length > MAX_COLLAPSED)
+        collapsed.shift();
+}
+export function clearToolCalls() {
+    toolCallLog.length = 0;
+}
+// Ctrl+T handler: print every tool call behind the last answer. Returns false
+// (nothing to show) so the editor can ignore the key.
+export function revealToolCalls() {
+    if (!toolCallLog.length)
+        return false;
+    process.stdout.write(chalk.dim(`tool calls this turn (${toolCallLog.length}):\n`));
+    process.stdout.write(toolCallLog.join("\n") + "\n");
+    return true;
+}
 // ---- cleanup -----------------------------------------------------------------
 // Called on exit. Nothing fancy to restore now (we no longer hijack the bottom
 // of the screen), but keep the hook so callers don't have to change if that

package/dist/ui.js

@@ -52,6 +52,14 @@ export const mark = {
     teammateStart: (name, role) => chalk.magenta("  ⎿ teammate ") + chalk.bold(name) + chalk.magenta(` spawned`) + chalk.dim(` — ${role}`), // Day 38
     teammateDone: (name, ok) => (ok ? chalk.magenta("  ⎿ teammate ") + chalk.bold(name) + chalk.magenta(" finished") : chalk.yellow("  ⎿ teammate ") + chalk.bold(name) + chalk.yellow(" ended (not done)")),
     inbox: (n) => chalk.magenta("  ⎿ ") + chalk.magenta(`${n} team message${n === 1 ? "" : "s"} received`),
+    // A round's tool calls folded into one line: "⏺ 6 tools · read_file ×4 · search ×2" (Ctrl+T expands them).
+    toolTally: (names) => {
+        const counts = new Map();
+        for (const n of names)
+            counts.set(n, (counts.get(n) ?? 0) + 1);
+        const parts = [...counts.entries()].map(([n, c]) => `${n} ×${c}`).join(" · ");
+        return chalk.cyan("⏺ ") + chalk.dim(`${names.length} tool${names.length === 1 ? "" : "s"} · ${parts}`);
+    },
     note: (s) => chalk.dim(s), // dim asides (resumed, attached, cleared…)
     warn: (s) => chalk.yellow(s),
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-from-zero",
-  "version": "0.28.0",
+  "version": "0.30.0",
   "description": "Build a Claude Code-style CLI agent from scratch, with AI as your pair programmer — companion code for a 10-day tutorial (DeepSeek by default, any OpenAI-compatible model)",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "eval": "tsx --env-file=.env eval/run.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "npm run build",
-    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts"
+    "test": "tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/ui.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts"
   },
   "engines": {
     "node": ">=20.6"