agent-from-zero 0.35.3 → 0.35.5

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,24 @@ 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 <名字>`。
 
+### 下一句预测
+
+和 Claude Code 一样，每轮对话结束后，mini-agent 会猜你下一句大概要说什么（比如 “跑一下测试”、“提交并推送”），灰色显示在空的输入框里。按 Tab（或 →）变成真正的输入，可以改，也可以直接 Enter 发送。开始打字它就消失。
+
+生成预测要多调一次模型，但请求内容和刚结束的主调用相同，只在最后加了一条指令，所以基本都能命中 DeepSeek 的前缀缓存，费用很低，也会算进 `/cost`。定时任务和其他实例发来的消息触发的回合不做预测。不想要可以在 `settings.json` 里设 `"promptSuggestions": false`，或者单次运行时设环境变量 `MINI_AGENT_PROMPT_SUGGESTIONS=0`。
+
+### 多开实例互相通信
+
+在几个终端里各开一个 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 +143,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,6 +28,8 @@ 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)
@@ -107,6 +109,8 @@ 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
@@ -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;
@@ -826,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
@@ -925,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
@@ -947,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

@@ -20,6 +20,8 @@ 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" },

package/dist/config.js

@@ -136,6 +136,10 @@ export const CONFIG = {
     memory: {
         autoExtract: projectSettings.memory?.autoExtract ?? globalSettings.memory?.autoExtract ?? false,
     },
+    // Next-prompt suggestions (Claude Code's placeholder you accept with Tab). On
+    // by default: the call reuses the main conversation's cached prefix, so it is
+    // cheap. MINI_AGENT_PROMPT_SUGGESTIONS=0 turns it off for one run.
+    promptSuggestions: process.env.MINI_AGENT_PROMPT_SUGGESTIONS === "0" ? false : (projectSettings.promptSuggestions ?? globalSettings.promptSuggestions ?? true),
 };
 // Persist a single key to the global settings file, preserving all other keys.
 // Used by /model to remember the user's last choice across sessions.

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

package/dist/ink/app.js

@@ -4,12 +4,14 @@ import { statusCommand } from "../status.js";
 import React, { useState, useEffect, useRef } from "react";
 import { Box, Text, Static, useInput, useApp } from "ink";
 import chalk from "chalk";
-import { formatElapsed, renderMenu, MENU_HINT, formatModelChoices } from "../ui.js"; // status format + the SAME pure menu renderer the readline REPL uses
+import { COMPACTING_VERB, formatElapsed, renderMenu, MENU_HINT, formatModelChoices } from "../ui.js"; // status format + the SAME pure menu renderer the readline REPL uses
 import { renderMarkdown } from "../markdown.js"; // model speaks markdown → ANSI, same as the non-Ink REPL
 import { initFormState, reduceForm, renderForm, collectAnswers } from "../form.js"; // the ask_user form: pure state machine + renderer
 import { CONFIG, saveGlobalSetting } from "../config.js"; // session allowlist + /model save
 import { effortMenu, setEffort } from "../effort.js";
 import { useSlashCompletion } from "./completion.js";
+import { generatePromptSuggestion } from "../suggestion.js"; // the predicted next message (Claude Code's prompt suggestion)
+import { lastRequestTools } from "../loop.js"; // resend the main call's tools so the guess hits the prompt cache
 import { commandNames, commandTokenRanges, inlineCommandGhost } from "../completion.js"; // which /command tokens to paint + the mid-text ghost suggestion
 import { TerminateReason, listAgentViews } from "../loop.js"; // how a turn can end
 import { compactHistory, compactThreshold, contextWindowFor } from "../context.js"; // /compact + /model info
@@ -21,9 +23,10 @@ import { resetBoard } from "../board.js";
 import { clearReasoning, clearToolCalls, getReasoning, getToolCalls, getToolActivity, getToolCallCount, cleanup as tuiCleanup } from "../tui.js";
 import { expandMentions } from "../mentions.js"; // @file mentions → attach file contents
 import { normalizeDroppedPaths } from "../drop.js"; // drag-and-drop a file → its absolute path in the input
+import { currentSession, peerInboxPending, readPeerInbox, peerMessageContent, peersCommand, setSessionState, setSessionInfo, listPeers, findPeer, peerRow, sendPeerMessage, SCREEN_KINDS, MAX_PEER_TURNS } from "../peers.js"; // peer sessions: messages from other mini-agent windows start a turn while idle
 import { cronItemsPending, consumeCronQueue, cronTriggerContent } from "../cron.js"; // cron scheduler (Day s14): fire scheduled jobs autonomously while idle
 import { newSessionId, saveSession, listSessions, loadSession, setSessionTitle } from "../session.js";
-import { generateSessionTitle, setTerminalTitle } from "../title.js"; // concise session name, generated after the first message + the terminal tab that shows it
+import { generateSessionTitle, setTerminalTitle, refreshTerminalTitle, flashTerminalTitle } from "../title.js"; // concise session name, generated after the first message + the terminal tab that shows it
 import { isPlanMode, setPlanMode } from "../permissions.js";
 import { findSkill, recordSkillUsage, skillSource, skillUsageScores, userSkillMessages } from "../skills.js";
 import { SkillsPanel } from "./skills-panel.js"; // /skills: Claude Code's on / user-only / off manager
@@ -49,6 +52,7 @@ const SPINNER_FRAMES = ["·", "✢", "✶", "✻", "✽", "✻", "✶", "✢"];
 const SPINNER_COLOR = "#D77757"; // Claude Code's orange
 const SKILL_COLOR = "#B1B9F9"; // Claude Code's lavender for a recognised /skill in the input
 const SHIMMER_PEAK = "#FFD2BD"; // the highlight that sweeps across the verb
+const COMPACT_PEAK = "#E4E8FF"; // the same sweep over the lavender "Compacting conversation…"
 const SHIMMER_TICK_MS = 100; // one animation clock for glyph + shimmer → one repaint per tick
 const SHIMMER_RADIUS = 3; // how many cells the highlight fades over on each side
 // Cap the live streaming preview to a terminal-aware tail. THIS IS LOAD-BEARING:
@@ -78,8 +82,8 @@ function useTick() {
 }
 // The glyph lives in a fixed two-cell box: whatever the frame, the text after it
 // starts in the same column.
-function Glyph({ tick }) {
-    return (_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: SPINNER_COLOR, children: SPINNER_FRAMES[Math.floor(tick / 2) % SPINNER_FRAMES.length] }) }));
+function Glyph({ tick, color = SPINNER_COLOR }) {
+    return (_jsx(Box, { width: 2, flexShrink: 0, children: _jsx(Text, { color: color, children: SPINNER_FRAMES[Math.floor(tick / 2) % SPINNER_FRAMES.length] }) }));
 }
 function Spinner() {
     return _jsx(Glyph, { tick: useTick() });
@@ -92,10 +96,10 @@ function mix(a, b, t) {
 // The light sweep: each character is coloured by its distance from a moving
 // highlight. Only COLOUR changes between frames — never a character, never a
 // width — so the line shimmers without a single cell moving.
-export function shimmer(text, pos) {
+export function shimmer(text, pos, base = SPINNER_COLOR, peak = SHIMMER_PEAK) {
     return [...text].map((c, i) => {
         const glow = Math.max(0, 1 - Math.abs(i - pos) / SHIMMER_RADIUS);
-        return chalk.hex(mix(SPINNER_COLOR, SHIMMER_PEAK, glow))(c);
+        return chalk.hex(mix(base, peak, glow))(c);
     }).join("");
 }
 // "✶ Thinking… (3s · ↓ 281 tokens · thought for 1s)": the verb (everything up to
@@ -103,12 +107,14 @@ export function shimmer(text, pos) {
 // between sweeps (the highlight travels past the end) keeps it calm.
 function SpinnerLine({ text }) {
     const tick = useTick();
-    const plain = stripVTControlCharacters(text);
+    const [head, ...below] = text.split("\n"); // a status may carry extra lines (the compaction progress bar)
+    const plain = stripVTControlCharacters(head);
     const cut = plain.indexOf("…");
-    const verb = cut >= 0 && text.startsWith(plain.slice(0, cut + 1)) ? plain.slice(0, cut + 1) : ""; // shimmer only an unstyled verb
+    const verb = cut >= 0 && head.startsWith(plain.slice(0, cut + 1)) ? plain.slice(0, cut + 1) : ""; // shimmer only an unstyled verb
     const period = verb.length + SHIMMER_RADIUS * 2 + 8;
     const pos = (tick % period) - SHIMMER_RADIUS;
-    return (_jsxs(Box, { children: [_jsx(Glyph, { tick: tick }), _jsxs(Text, { color: SPINNER_COLOR, wrap: "truncate-end", children: [verb ? shimmer(verb, pos) : "", text.slice(verb.length)] })] }));
+    const [base, peak] = verb === COMPACTING_VERB ? [SKILL_COLOR, COMPACT_PEAK] : [SPINNER_COLOR, SHIMMER_PEAK]; // Claude Code draws compaction in lavender
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Glyph, { tick: tick, color: base }), _jsxs(Text, { color: base, wrap: "truncate-end", children: [verb ? shimmer(verb, pos, base, peak) : "", head.slice(verb.length)] })] }), below.map((line, i) => _jsxs(Text, { wrap: "truncate-end", children: ["  ", line] }, i))] }));
 }
 // One committed line of conversation. `user` is a highlight bar; `answer` is a
 // finished reply rendered as markdown; `note` is already-formatted narration.
@@ -174,6 +180,10 @@ export function App({ session, runTurn, clipboard }) {
     const [detailOffset, setDetailOffset] = useState(0);
     const [live, setLive] = useState(null); // the streaming answer
     const [input, setInput] = useState(""); // the current input buffer
+    const [suggestion, setSuggestion] = useState(null); // the predicted next message: a dim placeholder, Tab accepts it
+    const suggestionSeq = useRef(0); // bumped by every new turn, so a late guess for an old turn is dropped
+    const [talkTo, setTalkTo] = useState(null); // /peers → talk: the input box sends to another session instead of this agent
+    const replyTo = useRef([]); // who gets this turn's final answer (the senders of "user" peer messages)
     const [images, setImages] = useState([]);
     const pasting = useRef(false);
     const imageSeq = useRef(0);
@@ -219,6 +229,8 @@ export function App({ session, runTurn, clipboard }) {
     }, rows - 10, columns);
     // A "/" later in the text: no list, just the rest of the best match as dim ghost text (Tab accepts).
     const ghost = completing && cursor === input.length ? inlineCommandGhost(input, { skills: typeaheadSkills }) : null;
+    // The predicted next message, shown only in an empty box while nothing else wants attention.
+    const placeholder = suggestion && !input && !busy && !pending && !talkTo && !details && subAgentFocus === null ? suggestion : null;
     useEffect(() => {
         const id = setInterval(() => setTick((t) => t + 1), 1000);
         return () => clearInterval(id);
@@ -245,7 +257,15 @@ export function App({ session, runTurn, clipboard }) {
             pushItem(display);
         clearReasoning(); // Ctrl+R should reveal THIS turn's thinking
         clearToolCalls(); // ...and Ctrl+T THIS turn's tool calls
+        const senders = replyTo.current; // taken now, so a failed turn can't leak them into the next one
+        replyTo.current = [];
+        // Guess the next message only after turns YOU started — not cron, not
+        // another agent's message, not your message relayed from another window.
+        const suggestAfter = CONFIG.promptSuggestions && !senders.length && (content === null || display?.kind === "user");
+        const seq = ++suggestionSeq.current;
+        setSuggestion(null);
         setBusy(true);
+        setSessionState("busy", CONFIG.model); // other sessions see "busy" in list_peers
         const controller = new AbortController();
         const tstate = { controller, interrupted: false };
         turn.current = tstate; // expose it so Esc can interrupt this turn
@@ -279,9 +299,18 @@ export function App({ session, runTurn, clipboard }) {
         };
         runTurn(content, hooks)
             .then(async (result) => {
+            // A turn started by the user from another window: show them the answer there.
+            for (const to of senders)
+                sendPeerMessage(to, result.finalText?.trim() || `(finished: ${result.reason})`, "reply");
             if (result.reason !== TerminateReason.Done && !(result.reason === TerminateReason.UserInterrupt && followUps.size))
                 note(chalk.yellow(`⚠️ ${EXIT_NOTES[result.reason] ?? result.reason}`));
             saveSession(sessionId, model, messages, pendingTitle.current); // snapshot after every turn — crash-safe by construction
+            if (suggestAfter && result.reason === TerminateReason.Done) {
+                void generatePromptSuggestion(client, CONFIG.model, messages, lastRequestTools()).then((guess) => {
+                    if (guess && seq === suggestionSeq.current)
+                        setSuggestion(guess); // no newer turn started meanwhile (the box shows it only while idle)
+                });
+            }
             if (CONFIG.memory.autoExtract && result.reason === TerminateReason.Done) {
                 try {
                     const got = await extractMemories(client, CONFIG.subAgentModel || model, messages);
@@ -296,6 +325,7 @@ export function App({ session, runTurn, clipboard }) {
             .catch((e) => note(chalk.red(`[error] ${e.message}`)))
             .finally(() => {
             turn.current = null;
+            setSessionState("idle");
             setBusy(false);
             setStatus(null);
             setLive(null);
@@ -330,13 +360,131 @@ export function App({ session, runTurn, clipboard }) {
         return () => clearInterval(id);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [busy, pending]);
+    // The PEER idle processor: another mini-agent session messaged this one while
+    // it sat at the prompt. Like cron, start a turn so the agent answers on its
+    // own. Two agents answering each other could run forever (and bill for every
+    // hop), so after MAX_PEER_TURNS auto-started turns with no human input in
+    // between, messages wait in the inbox until you type something.
+    const peerTurns = useRef(0);
+    const peerHoldNoted = useRef(false);
+    useEffect(() => {
+        if (busy || pending || followUps.size)
+            return; // human follow-ups take priority
+        const id = setInterval(() => {
+            const waiting = peerInboxPending();
+            if (!waiting || turn.current)
+                return;
+            const fromUser = peerInboxPending(["user"]);
+            if (fromUser) {
+                // You, typing in another window: never held by the agent-to-agent cap.
+                const got = readPeerInbox(["user"]);
+                peerTurns.current = 0;
+                peerHoldNoted.current = false;
+                replyTo.current = [...new Set(got.map((m) => m.from.id))];
+                runConversationTurn(peerMessageContent(got), { kind: "user", text: `${got.map((m) => m.text).join("\n")}   ${chalk.magenta(`(from your "${got[0].from.name}" window)`)}` });
+                return;
+            }
+            if (peerTurns.current >= MAX_PEER_TURNS) {
+                if (!peerHoldNoted.current)
+                    note(chalk.yellow(`✉ ${waiting} peer message${waiting > 1 ? "s" : ""} waiting — paused after ${MAX_PEER_TURNS} automatic turns in a row; send anything to continue`));
+                peerHoldNoted.current = true;
+                return;
+            }
+            const got = readPeerInbox();
+            if (!got.length)
+                return;
+            peerTurns.current++;
+            const from = [...new Set(got.map((m) => `${m.from.name} (${m.from.cwd})`))].join(", ");
+            runConversationTurn(peerMessageContent(got), { kind: "note", text: chalk.magenta(`✉ message from ${from}`) });
+        }, 1000);
+        return () => clearInterval(id);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [busy, pending]);
+    // Replies and "which window are you?" pings are for the SCREEN, not the model:
+    // handled even mid-turn, never starting a model call.
+    useEffect(() => {
+        const id = setInterval(() => {
+            if (!peerInboxPending(SCREEN_KINDS))
+                return;
+            for (const m of readPeerInbox(SCREEN_KINDS)) {
+                if (m.kind === "identify") {
+                    flashTerminalTitle();
+                    note(chalk.bgMagenta.white.bold(` 👋 This window is session "${m.text}" — the "${m.from.name}" window is looking for it `));
+                }
+                else {
+                    note(chalk.magenta(`↩ ${m.from.name} replied:`));
+                    pushItem({ kind: "answer", text: m.text });
+                }
+            }
+        }, 1000);
+        return () => clearInterval(id);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, []);
+    // /peers: pick another session, then talk to it (the input box addresses it)
+    // or make it identify itself (bell + flashing tab) so you know which window it is.
+    const openPeers = () => {
+        const peers = listPeers();
+        if (!peers.length)
+            return note(chalk.dim(peersCommand("/peers")));
+        openSelect(`Other mini-agent sessions — pick one · this one is "${currentSession()?.name ?? "?"}" (/rename <name> to change)`, [...peers.map(peerRow), "Cancel"], (i) => {
+            const p = peers[i];
+            if (!p)
+                return;
+            openSelect(`${p.name} · ${p.terminal}`, [`Talk to ${p.name} — type in this box, Esc to come back`, "Identify it — ring its bell and flash its tab title", "Cancel"], (j) => {
+                if (j === 0) {
+                    setTalkTo(p);
+                    note(chalk.magenta(`→ talking to "${p.name}" (${p.terminal}). What you type goes there; its answer comes back here. Esc returns to this agent.`));
+                }
+                else if (j === 1) {
+                    const sent = sendPeerMessage(p.id, p.name, "identify");
+                    note(sent.startsWith("[error]") ? chalk.yellow(sent) : chalk.dim(`(asked "${p.name}" to flash its tab — look for 👋 ${p.name} — HERE)`));
+                }
+            }, peerRow(p));
+        });
+    };
     // A normal (non-command) prompt: run UserPromptSubmit hooks, expand @file
     // mentions, then start the turn. Mirrors agent.ts's submit path.
     const submitLine = async (draft, attachments = [], immediate = false) => {
+        peerTurns.current = 0; // a human is here: peers may start turns again
+        peerHoldNoted.current = false;
+        // Talk mode: plain text goes to the chosen session, even while this agent works.
+        if (talkTo && !pending && !draft.startsWith("/")) {
+            const text = pastedTexts.expand(draft);
+            const alive = findPeer(talkTo.id);
+            if (!alive) {
+                setTalkTo(null);
+                return note(chalk.yellow(`"${talkTo.name}" is no longer running — back to this agent`));
+            }
+            const sent = sendPeerMessage(alive.id, text, "user");
+            if (sent.startsWith("[error]"))
+                return note(chalk.yellow(sent));
+            pushItem({ kind: "user", text: `→ ${alive.name}: ${draft}` });
+            if (alive.state === "busy")
+                note(chalk.dim(`("${alive.name}" is busy — it answers when its current turn ends)`));
+            return;
+        }
+        if (!draft.startsWith("/"))
+            setSessionInfo({ lastPrompt: draft });
         if (!pending && turn.current && (draft.startsWith("/") || draft === "exit" || draft === "quit")) {
             note(chalk.dim("Commands are available when the agent is idle; use Esc to interrupt."));
             return;
         }
+        // A /command typed while a menu is up is a command, never a message for the
+        // model (a second "/peers" into the /peers picker used to become the
+        // conversation's first prompt). Close the menu, then run it — when idle.
+        if (pending && /^\/[\w:-]+(\s|$)/.test(draft)) {
+            if (turn.current)
+                return note(chalk.dim("Commands are available when the agent is idle; use Esc to interrupt."));
+            setPending(null);
+            setFormState(null);
+            if (pending.kind === "form")
+                pending.resolve(null);
+            else if (pending.kind === "select")
+                pending.onChoose(-1);
+            if (await handleCommand(draft))
+                return;
+            return note(chalk.dim(`unknown command: ${draft} — try /help`));
+        }
         if (!pending && (draft === "exit" || draft === "quit"))
             return doExit();
         if (!pending && await handleCommand(draft))
@@ -502,6 +650,16 @@ export function App({ session, runTurn, clipboard }) {
             setAutoEnabled(autoMode.enabled);
             return true;
         }
+        if (line === "/peers") {
+            openPeers();
+            return true;
+        }
+        const peers = peersCommand(line); // /rename <name>
+        if (peers !== null) {
+            note(chalk.dim(peers));
+            refreshTerminalTitle();
+            return true;
+        }
         const info = runInfoCommand(line, { skills: liveSkills(), costMeter }); // /help /cost /memory /stats /todos /bg /team /tasks /skills /undo /diff
         if (info !== null) {
             note(info);
@@ -610,7 +768,7 @@ export function App({ session, runTurn, clipboard }) {
                 }
                 setBusy(true);
                 try {
-                    await compactHistory(messages, client, CONFIG.model, new AbortController().signal, note);
+                    await compactHistory(messages, client, CONFIG.model, new AbortController().signal, note, sink); // the same progress bar as automatic compaction
                 }
                 catch (err) {
                     note(chalk.yellow(`compaction failed: ${err.message}`));
@@ -747,6 +905,11 @@ export function App({ session, runTurn, clipboard }) {
             statusRequest.current.abort();
             return;
         }
+        if (key.escape && talkTo && !pending && !input) {
+            setTalkTo(null);
+            note(chalk.dim(`(back to this agent — no longer talking to "${talkTo.name}")`));
+            return;
+        }
         if (key.escape && busy && !pending) {
             if (followUps.size) {
                 interruptForFollowUp();
@@ -806,6 +969,13 @@ export function App({ session, runTurn, clipboard }) {
                 return;
             }
         }
+        if ((key.tab || (key.rightArrow && !input)) && placeholder) { // Tab (or →) turns the predicted next message into real text; Enter then sends it
+            setInput(placeholder);
+            setCursor(placeholder.length);
+            setHistIdx(null);
+            setSuggestion(null);
+            return;
+        }
         if (key.tab && ghost) { // accept the inline suggestion as "/name "
             const next = input.slice(0, ghost.start) + `/${ghost.full} `;
             setInput(next);
@@ -953,9 +1123,9 @@ export function App({ session, runTurn, clipboard }) {
     const agentDetailView = detailPage(selectedAgent?.transcript || "(Waiting for activity…)", agentPage, Math.max(1, Math.min(10, rows - 10)), Math.max(1, columns - 4));
     const detailView = detailPage(details === "tools" ? getToolCalls() ?? "No tool calls this turn." : details === "reasoning" ? getReasoning() ?? "No thinking recorded this turn." : "", detailOffset, Math.max(1, Math.min(12, rows - 9)), Math.max(1, columns - 4));
     const activity = rows >= 20 && busy && !details && !pending && !subAgentDetail && !followUps.size ? summarizeActivity(getToolActivity(), Date.now(), rows >= 30 && !agents.length ? 2 : 1) : [];
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item, i) => _jsx(ItemView, { item: item }, i) }), _jsxs(Box, { flexDirection: "column", height: !pending && (details || selectedAgent) ? Math.max(1, rows - 1) : undefined, overflow: "hidden", children: [live !== null && !details && !pending && !selectedAgent && (_jsxs(Box, { marginTop: rows >= 20 ? 1 : 0, flexDirection: "row", children: [_jsx(Text, { color: "green", children: "\u23FA " }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: live === "" ? chalk.dim("…") : liveTail(live, rows, columns, followUps.size > 0) }) })] })), activity.map((group, i) => (_jsxs(Box, { flexDirection: "column", marginTop: i === 0 ? 1 : 0, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: group.failed ? "yellow" : group.running ? "cyan" : "green", children: "\u25CF " }), _jsx(Text, { bold: true, children: group.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u23BF ", group.detail] })] }, i))), !details && !pending && !selectedAgent && (status !== null || busy) && (_jsx(Box, { marginTop: rows >= 20 ? 1 : 0, children: _jsx(SpinnerLine, { text: status?.replace("Ctrl+C to interrupt", "Esc to interrupt") ?? (live !== null ? "Writing…" : "Working…") }) })), rows >= 20 && !details && !selectedAgent && !pending && (busy || getToolCallCount() > 0) && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  ", getToolCallCount(), " tool calls \u00B7 Ctrl+T details \u00B7 Ctrl+R thinking", busy ? " · Esc interrupt" : ""] })), details && !pending && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [details === "tools" ? "Tool details" : "Thinking", " \u00B7 ", detailView.pages - detailView.page, "/", detailView.pages, " \u00B7 \u2191\u2193 page \u00B7 Esc close", followUps.size ? ` · ${followUps.size} queued` : ""] }), _jsx(Text, { children: detailView.text })] })), selectedAgent && !pending && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "blue", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "cyan", wrap: "truncate-end", children: [selectedAgent.name, " \u00B7 ", selectedAgent.model, " \u00B7 ", selectedAgent.status, " \u00B7 Esc main"] }), _jsxs(Box, { children: [selectedAgent.status === "running" && _jsx(Spinner, {}), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [" ", selectedAgent.activity, " \u00B7 ", selectedAgent.toolCalls, " tools \u00B7 PgUp/PgDn details"] })] }), _jsx(Text, { children: agentDetailView.text })] })), pending?.kind === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: pending.header }), pending.body && _jsx(Box, { marginY: 1, children: _jsx(Text, { children: pending.body }) }), _jsx(Text, { children: renderMenu(pending.options, menuSel) }), _jsx(Text, { children: MENU_HINT })] })), pending?.kind === "skills" && (_jsx(SkillsPanel, { skills: everySkill(), maxRows: Math.max(3, rows - 14), onClose: (summary) => { setPending(null); note(chalk.dim(summary)); } })), pending?.kind === "form" && formState && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: renderForm(pending.questions, formState) }) })), pending && pending.kind !== "skills" && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: "Type a follow-up \u00B7 Enter sends text; empty input selects \u00B7 Esc cancels" }), !details && !selectedAgent && !pending && followUps.size > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: rows >= 20 ? 1 : 0, children: [_jsx(Text, { dimColor: true, wrap: "truncate-end", children: "Messages queued for the next tool boundary \u00B7 Esc / Ctrl+Enter interrupt and send" }), followUps.pending.slice(rows >= 20 ? -2 : -1).map((message, i) => _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u21B3 ", message.displayText ?? message.text] }, i)), followUps.size > 2 && _jsxs(Text, { dimColor: true, children: ["  \u2026 ", followUps.size - 2, " earlier messages queued"] })] })), pending?.kind !== "skills" && (_jsx(Box, { borderStyle: "round", borderColor: planMode ? "magenta" : CONFIG.bypassPermissions ? "red" : autoEnabled ? "yellow" : "cyan", paddingX: 1, marginTop: rows >= 20 ? 1 : 0, flexDirection: "column", flexShrink: 0, children: (() => {
-                            const prompt = "❯ ";
-                            const promptColor = planMode ? "magenta" : CONFIG.bypassPermissions ? "red" : autoEnabled ? "yellow" : "cyan";
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Static, { items: items, children: (item, i) => _jsx(ItemView, { item: item }, i) }), _jsxs(Box, { flexDirection: "column", height: !pending && (details || selectedAgent) ? Math.max(1, rows - 1) : undefined, overflow: "hidden", children: [live !== null && !details && !pending && !selectedAgent && (_jsxs(Box, { marginTop: rows >= 20 ? 1 : 0, flexDirection: "row", children: [_jsx(Text, { color: "green", children: "\u23FA " }), _jsx(Box, { flexGrow: 1, children: _jsx(Text, { children: live === "" ? chalk.dim("…") : liveTail(live, rows, columns, followUps.size > 0) }) })] })), activity.map((group, i) => (_jsxs(Box, { flexDirection: "column", marginTop: i === 0 ? 1 : 0, children: [_jsxs(Text, { wrap: "truncate-end", children: [_jsx(Text, { color: group.failed ? "yellow" : group.running ? "cyan" : "green", children: "\u25CF " }), _jsx(Text, { bold: true, children: group.title })] }), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u23BF ", group.detail] })] }, i))), !details && !pending && !selectedAgent && (status !== null || busy) && (_jsx(Box, { marginTop: rows >= 20 ? 1 : 0, children: _jsx(SpinnerLine, { text: status?.replace("Ctrl+C to interrupt", "Esc to interrupt") ?? (live !== null ? "Writing…" : "Working…") }) })), rows >= 20 && !details && !selectedAgent && !pending && (busy || getToolCallCount() > 0) && (_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  ", getToolCallCount(), " tool calls \u00B7 Ctrl+T details \u00B7 Ctrl+R thinking", busy ? " · Esc interrupt" : ""] })), details && !pending && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "gray", paddingX: 1, children: [_jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [details === "tools" ? "Tool details" : "Thinking", " \u00B7 ", detailView.pages - detailView.page, "/", detailView.pages, " \u00B7 \u2191\u2193 page \u00B7 Esc close", followUps.size ? ` · ${followUps.size} queued` : ""] }), _jsx(Text, { children: detailView.text })] })), selectedAgent && !pending && (_jsxs(Box, { flexDirection: "column", borderStyle: "single", borderColor: "blue", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "cyan", wrap: "truncate-end", children: [selectedAgent.name, " \u00B7 ", selectedAgent.model, " \u00B7 ", selectedAgent.status, " \u00B7 Esc main"] }), _jsxs(Box, { children: [selectedAgent.status === "running" && _jsx(Spinner, {}), _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [" ", selectedAgent.activity, " \u00B7 ", selectedAgent.toolCalls, " tools \u00B7 PgUp/PgDn details"] })] }), _jsx(Text, { children: agentDetailView.text })] })), pending?.kind === "select" && (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { color: "yellow", children: pending.header }), pending.body && _jsx(Box, { marginY: 1, children: _jsx(Text, { children: pending.body }) }), _jsx(Text, { children: renderMenu(pending.options, menuSel) }), _jsx(Text, { children: MENU_HINT })] })), pending?.kind === "skills" && (_jsx(SkillsPanel, { skills: everySkill(), maxRows: Math.max(3, rows - 14), onClose: (summary) => { setPending(null); note(chalk.dim(summary)); } })), pending?.kind === "form" && formState && (_jsx(Box, { marginTop: 1, children: _jsx(Text, { children: renderForm(pending.questions, formState) }) })), pending && pending.kind !== "skills" && _jsx(Text, { dimColor: true, wrap: "truncate-end", children: "Type a follow-up \u00B7 Enter sends text; empty input selects \u00B7 Esc cancels" }), !details && !selectedAgent && !pending && followUps.size > 0 && (_jsxs(Box, { flexDirection: "column", marginTop: rows >= 20 ? 1 : 0, children: [_jsx(Text, { dimColor: true, wrap: "truncate-end", children: "Messages queued for the next tool boundary \u00B7 Esc / Ctrl+Enter interrupt and send" }), followUps.pending.slice(rows >= 20 ? -2 : -1).map((message, i) => _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: ["  \u21B3 ", message.displayText ?? message.text] }, i)), followUps.size > 2 && _jsxs(Text, { dimColor: true, children: ["  \u2026 ", followUps.size - 2, " earlier messages queued"] })] })), pending?.kind !== "skills" && (_jsx(Box, { borderStyle: "round", borderColor: talkTo || planMode ? "magenta" : CONFIG.bypassPermissions ? "red" : autoEnabled ? "yellow" : "cyan", paddingX: 1, marginTop: rows >= 20 ? 1 : 0, flexDirection: "column", flexShrink: 0, children: (() => {
+                            const prompt = talkTo ? `→ ${talkTo.name} ❯ ` : "❯ ";
+                            const promptColor = talkTo ? "magenta" : planMode ? "magenta" : CONFIG.bypassPermissions ? "red" : autoEnabled ? "yellow" : "cyan";
                             const cols = columns;
                             const innerWidth = Math.max(10, cols - 4); // border(2) + paddingX(2)
                             const promptW = displayWidth(prompt);
@@ -1047,7 +1217,7 @@ export function App({ session, runTurn, clipboard }) {
                                     const at = line.slice(cuOff, cuOff + 1) || " ";
                                     const after = line.slice(cuOff + 1);
                                     const base = lineStarts[i] ?? 0;
-                                    return (_jsxs(Box, { children: [i === 0 && _jsx(Text, { color: promptColor, children: prompt }), _jsx(Text, { children: paint(before, base, "b") }), _jsx(Text, { inverse: true, color: isLit(base + cuOff) ? SKILL_COLOR : undefined, children: ghost ? ghost.suffix[0] : at }), _jsx(Text, { children: paint(after, base + cuOff + at.length, "a") }), ghost && _jsx(Text, { dimColor: true, children: ghost.suffix.slice(1) })] }, i));
+                                    return (_jsxs(Box, { children: [i === 0 && _jsx(Text, { color: promptColor, children: prompt }), _jsx(Text, { children: paint(before, base, "b") }), _jsx(Text, { inverse: true, color: isLit(base + cuOff) ? SKILL_COLOR : undefined, children: ghost ? ghost.suffix[0] : placeholder && i === 0 ? [...placeholder][0] : at }), _jsx(Text, { children: paint(after, base + cuOff + at.length, "a") }), ghost && _jsx(Text, { dimColor: true, children: ghost.suffix.slice(1) }), placeholder && i === 0 && _jsxs(Text, { dimColor: true, wrap: "truncate-end", children: [[...placeholder].slice(1).join(""), _jsx(Text, { dimColor: true, children: "  ⇥ tab" })] })] }, i));
                                 }
                                 return (_jsxs(Box, { children: [i === 0 && _jsx(Text, { color: promptColor, children: prompt }), _jsx(Text, { children: paint(line, lineStarts[i] ?? 0, "l") })] }, i));
                             });