agent-from-zero 0.35.2 → 0.35.4

package/README.md

@@ -107,7 +107,7 @@ export MINI_AGENT_MODEL=gpt-4.1-mini
 
 ### 上下文和自动压缩
 
-上下文大小用的是 API 每次返回的真实 `prompt_tokens`，再加上之后新增消息的估算值，所以基本是准的。快满时自动压缩：触发点是窗口减去给回复预留的 20k 和 13k 安全余量（约 1M 的窗口大概在 97% 左右）。状态栏的 `ctx N%` 表示离自动压缩还有多远，到 100% 时下一次调用模型前就会先压缩。也可以随时手动 `/compact`。
+上下文大小用的是 API 每次返回的真实 `prompt_tokens`，再加上之后新增消息的估算值，所以基本是准的。快满时自动压缩：触发点是窗口减去给回复预留的 20k 和 13k 安全余量（约 1M 的窗口大概在 97% 左右）。状态栏的 `ctx N%` 表示离自动压缩还有多远，到 100% 时下一次调用模型前就会先压缩。也可以随时手动 `/compact`。不管是手动还是自动，压缩时都会像 Claude Code 一样显示 `Compacting conversation…` 和进度条。
 
 ### 配置 MCP
 
@@ -115,6 +115,18 @@ export MINI_AGENT_MODEL=gpt-4.1-mini
 
 输入 `/mcp` 选一个服务器，会看到和 Claude Code 一样的详情（状态、登录、协议版本、URL、配置文件位置、能力、工具数）和操作：View tools、Re-authenticate、Clear authentication、Reconnect、Disable。也可以直接敲 `/mcp tools|auth|clear-auth|reconnect|disable|enable <名字>`。
 
+### 多开实例互相通信
+
+在几个终端里各开一个 mini-agent（比如一个在后端仓库、一个在前端仓库），它们会自动互相发现，不用配置。
+
+- `/peers` 列出本机其他实例：名字、空闲/忙、目录和分支、在哪个终端（比如 `iTerm2 · ttys003`，tmux 里会显示 pane）、正在做什么。选一个之后可以：
+  - **Talk to**：输入框变成 `→ web ❯`，你打的字直接发给那个实例，它处理完会把回答发回你这个窗口。按 Esc 回到当前 agent。
+  - **Identify**：让那个实例响铃、刷一条横幅、让标签页标题闪几秒，用来确认它是哪个窗口。
+- 实例名跟着它在做的事走：发出第一条消息后会生成会话标题（比如 “Fix login bug”），实例名随之变成 `fix-login-bug`，标签页标题就是 `✳ Fix login bug`，和 `/peers` 里看到的一致。还没有标题时用目录名。`/rename <名字>` 可以手动指定名字，指定后标签页显示 `✳ 名字 · 标题`，之后不会再跟着标题变。
+- agent 之间也能自己沟通：模型有 `list_peers` 工具，`send_message` 可以直接发给其他实例。对方空闲时会自动开一轮处理；忙的话，在它当前这一步工具调用结束后插进对话。你在 Talk 模式里打的字则会等对方这一轮结束再处理，因为回答要发回给你。另一个 agent 发来的消息不算用户的授权。为了防止两个 agent 互相回复停不下来，连续自动处理 5 轮之后会暂停，等你输入任何内容再继续。
+
+所有数据都存在 `~/.config/mini-agent/sessions/` 下，只在本机，不经过网络。
+
 ### 非交互模式
 
 ```bash
@@ -125,7 +137,7 @@ npx agent-from-zero -p "总结当前改动" --output-format json
 
 ## 常用命令
 
-在会话里输入 `/help` 可以看到全部命令，比较常用的有：`/model` `/effort` `/plan` `/auto` `/skills` `/mcp` `/memory` `/compact` `/diff` `/undo` `/resume` `/status` `/cost`。
+在会话里输入 `/help` 可以看到全部命令，比较常用的有：`/model` `/effort` `/plan` `/auto` `/skills` `/mcp` `/peers` `/memory` `/compact` `/diff` `/undo` `/resume` `/status` `/cost`。
 
 ## 开发
 

package/dist/agent.js

@@ -10,7 +10,7 @@ import { buildSystemMessage, readProjectInstructions } from "./prompt.js"; // th
 import { forgetFilesExcept, registerExternalTool } from "./tools.js"; // file-state reset + tool registration
 import { compactHistory, compactThreshold, contextPercent, contextWindowFor } from "./context.js"; // /compact, /model info, the ctx % in the status line
 import { newSessionId, saveSession, latestSession, listSessions, loadSession, setSessionTitle } from "./session.js"; // conversation persistence (project-local) + the /resume picker
-import { generateSessionTitle, setTerminalTitle } from "./title.js"; // concise session name, generated after the first message + the terminal tab that shows it
+import { generateSessionTitle, setTerminalTitle, refreshTerminalTitle } from "./title.js"; // concise session name, generated after the first message + the terminal tab that shows it
 import { initTelemetry, emit, statsReport } from "./telemetry.js"; // local-only event log + /stats
 import { runHooks } from "./hooks.js"; // SessionStart lifecycle hook
 import { connectMcpServers, listMcpServers, MCP_SUBCOMMANDS, mcpActionsFor, mcpServerDetails, reloadMcpServers, runMcpAction, watchMcpConfig } from "./mcp.js"; // external tool servers (MCP) + /mcp
@@ -28,12 +28,14 @@ import { renderDiff } from "./diff.js"; // show what /undo put back / what /diff
 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, sentMessage } from "./ui.js"; // welcome box, prompt, model labels, status line, sent-message echo
+import { SCREEN_KINDS, listPeers, peerInboxPending, peerMessageContent, peersCommand, readPeerInbox, registerSession, setSessionState, unregisterSession } from "./peers.js"; // peer sessions: other mini-agent processes on this machine
+import { STDOUT_OUTPUT } from "./output.js"; // /compact draws its progress bar with the same ora spinner the loop uses
 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 { currentSkills, findSkill, userSkillMessages } from "./skills.js"; // Markdown-as-plugin skills
+import { allSkills, currentSkills, findSkill, recordSkillUsage, skillLocked, skillMode, userSkillMessages } from "./skills.js"; // Markdown-as-plugin skills
 import { initCostMeter, DEFAULT_PRICING } from "./cost.js"; // token & cost accounting for /cost
 import { launchInk } from "./ink/launch.js"; // the Ink REPL — the default front-end for interactive sessions
 import { listBackground, hasRunningBackground, killAllBackground } from "./background.js"; // background tasks: /bg view + kill-on-exit (Day 37)
@@ -107,10 +109,12 @@ const SESSION_HELP = `commands:
   /team      list the agent team (spawn_teammate): each teammate's role, status, and pending inbox
   /tasks     show the shared task board (create_task/claim_task): each task's status, owner, and dependencies
   /cron      list scheduled cron jobs (schedule_cron) and their expressions
+  /peers     list other mini-agent sessions on this machine (the agent can message them with send_message)
+  /rename <name>  rename this session — the name other sessions use to reach it
   /undo      revert the most recent file write (write_file / edit_file) this session
   /diff      show every file changed this session, as a diff from where it started
   /resume    list recent sessions in this project and continue one of them
-  /skills    list the reusable skills available in this project
+  /skills    manage skills: turn each on, off, or user-only (search with /, sort with t)
   /skill <name> [args]  run a skill yourself (works even for user-only skills); /<name> [args] works too
   exit       leave (Ctrl+C at the prompt does the same)
 
@@ -297,6 +301,14 @@ async function main() {
     // ---- Interactive session (REPL) -------------------------------------------------
     // The welcome box: who am I, which model and host am I on, and the basics.
     console.log(banner(pkg.version, CONFIG.model, new URL(CONFIG.baseURL).host));
+    // Peer sessions: join the machine-wide registry (interactive sessions only —
+    // a one-shot -p run is gone before anyone could answer it).
+    const me = registerSession({ cwd: process.cwd(), branch: gitBranch(), model: CONFIG.model });
+    process.on("exit", unregisterSession);
+    const otherSessions = listPeers().length;
+    refreshTerminalTitle(); // the tab now carries this session's name
+    if (otherSessions)
+        console.log(chalk.dim(`(peers: this session is "${me.name}"; ${otherSessions} other session${otherSessions === 1 ? "" : "s"} online — /peers)`));
     // ONE readline interface for the whole session — the task prompt and the
     // permission prompts share it. Two interfaces on one stdin fight each other.
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
@@ -547,6 +559,12 @@ async function main() {
     };
     // Handle a /slash command. Returns true if the line was a command.
     const handleCommand = async (line) => {
+        const peers = peersCommand(line); // /peers, /rename <name>
+        if (peers !== null) {
+            console.log(chalk.dim(peers));
+            refreshTerminalTitle();
+            return true;
+        }
         if (line === "/status" || line.startsWith("/status ")) {
             console.log(await statusCommand(line, costMeter));
             return true;
@@ -607,6 +625,7 @@ async function main() {
             for (const content of userSkillMessages(s, args))
                 messages.push({ role: "user", content });
             autoMode.recordRequest(`/${s.name}${args ? ` ${args}` : ""}`);
+            recordSkillUsage(s.name); // feeds the "/" typeahead's most-used ranking
             console.log(chalk.dim(`(running skill: ${s.name})`));
             running = true;
             interrupted = false;
@@ -625,14 +644,15 @@ async function main() {
         }
         switch (line) {
             case "/skills": {
-                const skills = currentSkills();
+                const skills = allSkills(); // every skill, with its on / user-only / off state (toggle them in the Ink UI's /skills)
                 if (!skills.length) {
                     console.log(chalk.dim("(no skills — add one at .mini-agent/skills/<name>/SKILL.md or ~/.config/mini-agent/skills/)"));
                     return true;
                 }
                 console.log(chalk.dim(`skills in this project:`));
                 for (const s of skills) {
-                    const who = s.disableModelInvocation ? chalk.yellow("user-only") : chalk.green("model+user");
+                    const mode = skillMode(s);
+                    const who = mode === "on" ? chalk.green("on") : mode === "off" ? chalk.dim("off") : chalk.yellow(skillLocked(s) ? "user-only (locked)" : "user-only");
                     console.log(chalk.dim(`  ${s.name} [${who}${chalk.dim("]")} — ${(s.whenToUse || s.description).slice(0, 70)}`));
                 }
                 return true;
@@ -824,7 +844,7 @@ async function main() {
                     return true;
                 }
                 try {
-                    await compactHistory(messages, client, CONFIG.model, new AbortController().signal); // same machinery as automatic compaction
+                    await compactHistory(messages, client, CONFIG.model, new AbortController().signal, undefined, STDOUT_OUTPUT); // same machinery (and progress bar) as automatic compaction
                 }
                 catch (err) {
                     console.log(chalk.yellow(`compaction failed: ${err.message}`)); // report, don't crash
@@ -923,6 +943,25 @@ async function main() {
                     .catch(() => { });
             }
         }
+        // The readline prompt blocks on your input, so it cannot start a turn by
+        // itself: peer messages that arrived while you were typing ride along now.
+        for (const m of readPeerInbox(SCREEN_KINDS)) {
+            // Replies and "which window?" pings are for you, not the model.
+            if (m.kind === "identify") {
+                process.stdout.write("\x07");
+                console.log(chalk.bgMagenta.white.bold(` 👋 This window is session "${m.text}" — the "${m.from.name}" window was looking for it `));
+            }
+            else
+                console.log(chalk.magenta(`↩ ${m.from.name} replied:\n`) + m.text);
+        }
+        if (peerInboxPending()) {
+            const got = readPeerInbox();
+            if (got.length) {
+                messages.push({ role: "user", content: peerMessageContent(got) });
+                console.log(chalk.magenta(`✉ ${got.length} message${got.length > 1 ? "s" : ""} from ${[...new Set(got.map((m) => m.from.name))].join(", ")}`));
+            }
+        }
+        setSessionState("busy", CONFIG.model);
         messages.push({ role: "user", content: augmented + injected }); // the new turn (with any attached files + hook context) joins the shared history
         autoMode.recordRequest(line); // original human text, before file/hook attachments
         clearReasoning(); // Ctrl+R should reveal THIS turn's thinking, not the previous answer's
@@ -945,6 +984,7 @@ async function main() {
             canPrompt: !!process.stdin.isTTY,
         });
         running = false; // back at the prompt — Ctrl+C means "exit" again
+        setSessionState("idle"); // other sessions see this one as free again
         saveSession(sessionId, CONFIG.model, messages, pendingTitle); // snapshot after every turn — crash-safe by construction
         // Auto-extract memories (opt-in: settings.memory.autoExtract). A cheap pass
         // that saves durable facts — especially user corrections — so memory

package/dist/completion.js

@@ -1,8 +1,9 @@
+import Fuse from "fuse.js"; // the fuzzy matcher Claude Code's "/" typeahead uses
 import { effortMenu } from "./effort.js";
 export const COMMANDS = [
     { value: "/model", description: "Switch the model for this session", children: true },
     { value: "/effort", description: "Choose this model's reasoning effort", children: true },
-    { value: "/skills", description: "Browse and run available skills", children: true },
+    { value: "/skills", description: "Turn skills on, off, or user-only" },
     { value: "/skill", description: "Run a skill by name", children: true },
     { value: "/help", description: "Show commands and keyboard shortcuts" },
     { value: "/clear", description: "Start a fresh conversation" },
@@ -19,10 +20,92 @@ export const COMMANDS = [
     { value: "/team", description: "Show teammates and status" },
     { value: "/tasks", description: "Show the shared task board" },
     { value: "/cron", description: "Show scheduled jobs" },
+    { value: "/peers", description: "Talk to another mini-agent session, or find its window" },
+    { value: "/rename", description: "Rename this session for other sessions", children: true },
     { value: "/undo", description: "Revert the most recent file write" },
     { value: "/diff", description: "Show file changes this session" },
     { value: "/resume", description: "Choose a previous session" },
 ];
+// Every "/<command>" token in the text that names a real command or skill, as
+// [start, end) code-unit ranges — the input box paints these. Claude Code's
+// rule (findSlashCommandPositions): a "/" at the start or after whitespace,
+// then a letter and [A-Za-z0-9:_-]*, anywhere in the text; it lights up only
+// if that name exists. So "/grill-me," lights up, "/grill" and "a/grill-me" don't.
+export function commandTokenRanges(text, names) {
+    const known = new Set(names.map((n) => n.toLowerCase()));
+    const out = [];
+    for (const m of text.matchAll(/(^|\s)(\/[a-zA-Z][a-zA-Z0-9:\-_]*)/g)) {
+        const start = (m.index ?? 0) + m[1].length;
+        if (known.has(m[2].slice(1).toLowerCase()))
+            out.push([start, start + m[2].length]);
+    }
+    return out;
+}
+// Names a "/" can reach: built-in commands, then skills (a built-in wins a clash — it is what runs).
+export function commandNames(ctx) {
+    const builtins = COMMANDS.map((c) => c.value.slice(1));
+    return [...builtins, ...ctx.skills.map((s) => s.name).filter((n) => !builtins.includes(n))];
+}
+function typeaheadItems(ctx) {
+    const builtins = new Set(COMMANDS.map((c) => c.value));
+    const skills = ctx.skills
+        .filter((s) => !builtins.has(`/${s.name}`))
+        .map((s) => ({
+        value: `/${s.name}`,
+        name: s.name,
+        // Claude Code's formatDescriptionWithSource: "desc (User)" / "desc (Project)", plus the argument names.
+        description: `${s.description || s.whenToUse}${s.source ? ` (${s.source === "project" ? "Project" : "User"})` : ""}${s.argNames?.length ? ` (arguments: ${s.argNames.join(", ")})` : ""}`,
+        children: Boolean(s.argNames?.length), // takes arguments → Enter fills it in; none → Enter runs it
+        group: s.source ?? "user",
+        usage: ctx.usage?.(s.name) ?? 0,
+    }));
+    return [...COMMANDS.map((c) => ({ ...c, name: c.value.slice(1), group: "builtin", usage: 0 })), ...skills];
+}
+// The "/" typeahead, Claude Code's generateCommandSuggestions:
+//   bare "/"  → your 5 most-used skills, then built-ins, then user skills, then
+//               project skills, each group alphabetical
+//   "/query"  → Fuse.js over name (weight 3), name parts split on :_- (2) and
+//               description words (0.5), threshold 0.3; then re-sorted: exact
+//               name, then name prefix (shorter first), then fuzzy score (when
+//               it differs by > 0.1), then usage
+function commandTypeahead(input, ctx) {
+    const items = typeaheadItems(ctx);
+    const q = input.slice(1).toLowerCase();
+    const alpha = (a, b) => a.name.localeCompare(b.name);
+    if (!q) {
+        const top = items.filter((i) => i.usage > 0).sort((a, b) => b.usage - a.usage).slice(0, 5);
+        const rest = (group) => items.filter((i) => i.group === group && !top.includes(i)).sort(alpha);
+        return [...top, ...rest("builtin"), ...rest("user"), ...rest("project")];
+    }
+    const docs = items.map((item) => {
+        const parts = item.name.split(/[:_-]/);
+        return { item, commandName: item.name.toLowerCase(), partKey: parts.length > 1 ? parts.map((p) => p.toLowerCase()) : undefined, descriptionKey: item.description.toLowerCase().split(/\s+/).map((w) => w.replace(/[^a-z0-9]/g, "")).filter(Boolean) };
+    });
+    const fuse = new Fuse(docs, { includeScore: true, threshold: 0.3, location: 0, distance: 100, keys: [{ name: "commandName", weight: 3 }, { name: "partKey", weight: 2 }, { name: "descriptionKey", weight: 0.5 }] });
+    const rank = (name) => (name === q ? 0 : name.startsWith(q) ? 1 : 2);
+    return fuse.search(q).sort((a, b) => {
+        const an = a.item.commandName, bn = b.item.commandName;
+        if (rank(an) !== rank(bn))
+            return rank(an) - rank(bn);
+        if (rank(an) === 1 && an.length !== bn.length)
+            return an.length - bn.length;
+        const ds = (a.score ?? 0) - (b.score ?? 0);
+        if (Math.abs(ds) > 0.1)
+            return ds;
+        return b.item.item.usage - a.item.item.usage;
+    }).map((r) => r.item.item);
+}
+// A "/" in the middle of the text gets no list — just ghost text: the rest of
+// the best prefix match, dim, after the cursor; Tab accepts it as "/name ".
+// (Claude Code: getBestCommandMatch on /\s\/([a-zA-Z0-9_:-]*)$/ before the cursor.)
+export function inlineCommandGhost(beforeCursor, ctx) {
+    const m = beforeCursor.match(/\s\/([a-zA-Z0-9_:-]+)$/);
+    if (!m)
+        return null;
+    const partial = m[1].toLowerCase();
+    const best = commandNames(ctx).filter((n) => n.toLowerCase().startsWith(partial) && n.length > partial.length).sort((a, b) => a.length - b.length || a.localeCompare(b))[0];
+    return best ? { start: beforeCursor.length - m[1].length - 1, suffix: best.slice(partial.length), full: best } : null;
+}
 export function slashCompletions(input, ctx) {
     if (!input.startsWith("/") || /[\r\n]/.test(input))
         return null;
@@ -33,7 +116,7 @@ export function slashCompletions(input, ctx) {
         const menu = effortMenu(ctx.model);
         return { items: filter(menu.values.map((value, i) => ({ value: `/effort ${value}`, description: menu.labels[i] }))), hint: menu.header };
     }
-    if (command === "/skills" || command === "/skill") {
+    if ((command === "/skills" && parts.length) || command === "/skill") { // bare "/skills" opens the manager; "/skills <name>" still runs one
         return { items: ctx.skills.filter((s) => s.name.toLowerCase().startsWith(arg)).map((s) => ({ value: `/skill ${s.name}`, description: s.whenToUse || s.description })), hint: ctx.skills.length ? "Choose a skill to run" : "No skills found in project or user skill directories" };
     }
     if (command === "/model") {
@@ -61,5 +144,14 @@ export function slashCompletions(input, ctx) {
         const items = [{ value: "/mcp", description: "Open MCP server menu" }, { value: "/mcp reload", description: "Re-read MCP servers from settings.json" }, ...["tools", "auth", "clear-auth", "reconnect", "enable", "disable"].flatMap((action) => ctx.servers.map((name) => ({ value: `/mcp ${action} ${name}`, description: `${action} ${name}` })))];
         return { items: filter(items, input.trimEnd()) };
     }
+    if (!/\s/.test(input))
+        return { items: commandTypeahead(input, ctx), hint: "No matching commands or skills" };
+    // "/<skill> args…": the user is typing arguments now — no list, just the
+    // skill's argument hint while it has one (Claude Code's argumentHint).
+    const skill = ctx.skills.find((s) => `/${s.name.toLowerCase()}` === command.toLowerCase());
+    if (skill) {
+        const hint = skill.argumentHint || (skill.argNames?.length ? skill.argNames.map((a) => `<${a}>`).join(" ") : "");
+        return hint && !arg ? { items: [], hint } : null;
+    }
     return { items: filter(COMMANDS), hint: "Commands" };
 }

package/dist/config.js

@@ -90,6 +90,8 @@ export const CONFIG = {
     // a cheap/fast one for grunt work (reading many files, broad search), or a
     // strong one as an "advisor" to double-check. undefined → use the main model.
     subAgentModel: process.env.MINI_AGENT_SUBAGENT_MODEL || projectSettings.subAgentModel || globalSettings.subAgentModel || undefined,
+    // /skills on/off/user-only choices. Project entries override global ones.
+    skillOverrides: { ...(globalSettings.skillOverrides ?? {}), ...(projectSettings.skillOverrides ?? {}) },
     // Per-model windows (context.ts contextWindowFor): project entries override global ones.
     contextWindows: { ...(globalSettings.contextWindows ?? {}), ...(projectSettings.contextWindows ?? {}) },
     contextWindow: Number(process.env.MINI_AGENT_CONTEXT_WINDOW) || // env override first

package/dist/context.js

@@ -1,6 +1,7 @@
 import { effortMessages } from "./effort.js";
 import fs from "node:fs"; // re-reading files from disk during recovery
 import chalk from "chalk"; // status lines
+import { compactingText } from "./ui.js"; // the progress bar
 import { CONFIG } from "./config.js"; // the resolved context window (env > settings files > default)
 import { recentFiles, forgetFilesExcept, toolDefinitions } from "./tools.js"; // session file state (what was read/edited, and when) + the tool manuals we send
 // ---- The context window ------------------------------------------------------
@@ -120,6 +121,22 @@ export function recoverFileState() {
         return null; // nothing worth recovering
     return `[Recovered file state after compaction — most recently used files, re-read fresh from disk:]\n\n${blocks.join("\n\n")}`;
 }
+// ---- Compaction progress ----------------------------------------------------------
+// A summary call takes tens of seconds, and a frozen screen reads as a hang. We
+// cannot know the true progress (nobody knows the summary's length in advance),
+// so we estimate it from two signals and never let it go backwards:
+//   - time: before the first token (the model reading a huge prompt, or
+//     thinking) the bar creeps toward 15%, so it visibly moves;
+//   - output: streamed tokens against an expected summary size. The curve is
+//     asymptotic and capped at 95% — only the finished summary says 100%.
+export function expectedSummaryTokens(historyTokens) {
+    return Math.max(800, Math.min(4000, Math.round(historyTokens * 0.05))); // the 6-section summary grows with the history, within bounds
+}
+export function compactProgress(elapsedMs, outTokens, expected) {
+    const waiting = 15 * (1 - Math.exp(-elapsedMs / 10_000));
+    const writing = 95 * (1 - Math.exp(-(outTokens / expected) * 1.6));
+    return Math.min(95, Math.max(waiting, writing));
+}
 // ---- Compaction itself -----------------------------------------------------------
 // Replace the whole history with a structured summary + recovered file state.
 // Throws on failure — the loop decides what a failure means.
@@ -127,17 +144,47 @@ export async function compactHistory(messages, // the history, mutated in place
 client, // the same client the loop uses
 model, // the same model summarizes its own conversation
 signal, // Ctrl+C must abort compaction too
-log = (s) => console.log(s)) {
+log = (s) => console.log(s), // where the result line goes — stdout by default; the Ink REPL routes it through its sink so it doesn't corrupt the live region
+output) {
     const before = contextTokens(messages); // for the log line — measured, not just estimated
-    log(chalk.magenta(`📦 compacting context (~${before} tokens)...`)); // automatic behavior must be visible
-    const res = await client.chat.completions.create({
-        model, // same model — no need for a fancier one to summarize
-        messages: [...effortMessages(model, messages), { role: "user", content: SUMMARY_PROMPT }], // full history + the summary instruction
-        // Deliberately NO `tools` parameter: with no tools declared, the API
-        // cannot accept a tool call — that is the hard guarantee. The CRITICAL
-        // lines in the prompt are the soft second layer of the same defense.
-    }, { signal });
-    const summary = res.choices[0].message.content ?? ""; // the structured summary text
+    const spin = output?.spinner(compactingText(0));
+    if (!spin)
+        log(chalk.magenta(`📦 compacting context (~${before} tokens)...`)); // automatic behavior must be visible
+    const expected = expectedSummaryTokens(before);
+    const started = Date.now();
+    let outChars = 0; // content + reasoning streamed so far (~4 chars a token)
+    let shown = 0; // the bar only moves forward
+    const paint = () => {
+        shown = Math.max(shown, compactProgress(Date.now() - started, outChars / 4, expected));
+        spin?.set(compactingText(shown));
+    };
+    const timer = spin ? setInterval(paint, 200) : null; // time alone moves the bar while no token arrives
+    let summary = "";
+    try {
+        // Streamed only so the bar has something to measure; the result is the same text.
+        const res = (await client.chat.completions.create({
+            model, // same model — no need for a fancier one to summarize
+            messages: [...effortMessages(model, messages), { role: "user", content: SUMMARY_PROMPT }], // full history + the summary instruction
+            stream: true,
+            // Deliberately NO `tools` parameter: with no tools declared, the API
+            // cannot accept a tool call — that is the hard guarantee. The CRITICAL
+            // lines in the prompt are the soft second layer of the same defense.
+        }, { signal }));
+        if ("choices" in res)
+            summary = res.choices[0]?.message.content ?? ""; // a provider (or test double) that ignored stream: true
+        else {
+            for await (const chunk of res) {
+                const delta = chunk.choices[0]?.delta;
+                summary += delta?.content ?? "";
+                outChars += (delta?.content?.length ?? 0) + (delta?.reasoning_content?.length ?? 0); // thinking is work too
+            }
+        }
+    }
+    finally {
+        if (timer)
+            clearInterval(timer);
+        spin?.stop();
+    }
     if (!summary.trim())
         throw new Error("compaction returned an empty summary"); // empty summary = failed compaction
     // The constitution survives compaction: keep the leading system message and