agent-from-zero 0.29.0 → 0.30.0

package/dist/agent.js

@@ -19,8 +19,8 @@ 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, revealReasoning, clearReasoning, cleanup as tuiCleanup } from "./tui.js"; // git branch for the status line + collapsible output + collapsed reasoning (Ctrl+R)
+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
@@ -83,6 +83,7 @@ const SESSION_HELP = `commands:
 
 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).
@@ -258,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(), onReveal: () => revealReasoning(), transformPaste: normalizeDroppedPaths });
+                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 ↑/↓
@@ -443,6 +444,7 @@ async function main() {
                 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;
@@ -635,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)
@@ -677,6 +679,7 @@ async function main() {
             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/editor.js

@@ -28,6 +28,8 @@ export function reduceEditor(s, str, key) {
                 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" };
         }
@@ -294,6 +296,10 @@ export function editLine(rl, opts) {
                     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, recordReasoning } from "./tui.js"; // collapsible tool output + the model's hidden thinking (Ctrl+R)
+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
@@ -458,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);
@@ -1224,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() {
@@ -85,6 +78,35 @@ export function revealReasoning() {
     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.29.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": {