agent-from-zero 0.35.4 → 0.35.6

package/README.md

@@ -115,6 +115,12 @@ 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（比如一个在后端仓库、一个在前端仓库），它们会自动互相发现，不用配置。
@@ -127,17 +133,34 @@ export MINI_AGENT_MODEL=gpt-4.1-mini
 
 所有数据都存在 `~/.config/mini-agent/sessions/` 下，只在本机，不经过网络。
 
+### 目标模式 /goal
+
+普通对话里，模型觉得做完了就停。`/goal` 把"做完没有"的判断从模型手里拿走：只要目标还没验证完成，模型每次停下，mini-agent 都会自动开下一轮让它接着干。
+
+```
+/goal 让 npm test 全部通过 --check "npm test"
+```
+
+- 模型只能用 `update_goal` 工具结束目标：`blocked` 表示需要你介入，`complete` 表示宣布完成。宣布完成要过两关：先跑你写的 `--check` 命令，退出码必须是 0，这条命令模型改不了；再由一次独立的模型调用对照最近的工具输出核对它的说法，拿不准就算没完成。
+- 不设费用上限，靠"有没有进展"兜底：一轮目标回合里一个工具都没调，立刻暂停；连续 3 轮工作区毫无变化，也暂停。按 Esc 同样会暂停。
+- 你随时可以插话，你的消息永远优先，处理完目标再继续。plan 模式下不会自动续跑。
+- `/goal` 查看状态，`/goal pause`、`/goal resume`、`/goal clear` 管理生命周期。
+- 目标存在会话文件里，`--resume` 或 `/resume` 回来以后，没做完的目标会接着跑。
+
 ### 非交互模式
 
 ```bash
 npx agent-from-zero -p "总结当前改动"
 cat error.log | npx agent-from-zero -p "分析这份日志"
 npx agent-from-zero -p "总结当前改动" --output-format json
+npx agent-from-zero -p "修一下这个 bug" --output-format stream-json
 ```
 
+`stream-json` 和 `claude -p --output-format stream-json` 同一格式：每行一个 JSON 事件，依次是 `system/init`、`assistant`（text / thinking / tool_use 块）、`user`（tool_result）、最后一行 `result`。为了兼容 Claude 的脚本，`--verbose` 也能传，不影响输出。
+
 ## 常用命令
 
-在会话里输入 `/help` 可以看到全部命令，比较常用的有：`/model` `/effort` `/plan` `/auto` `/skills` `/mcp` `/peers` `/memory` `/compact` `/diff` `/undo` `/resume` `/status` `/cost`。
+在会话里输入 `/help` 可以看到全部命令，比较常用的有：`/goal` `/model` `/effort` `/plan` `/auto` `/skills` `/mcp` `/peers` `/memory` `/compact` `/diff` `/undo` `/resume` `/status` `/cost`。
 
 ## 开发
 

package/dist/agent.js

@@ -5,7 +5,7 @@ import chalk from "chalk"; // terminal colors
 import readline from "node:readline/promises"; // promise-based terminal input
 import { createRequire } from "node:module"; // to read package.json for --version
 import { CONFIG, requireApiKey, saveGlobalSetting, PROJECT_SETTINGS_PATH, GLOBAL_SETTINGS_PATH } from "./config.js"; // provider-agnostic settings (.env loaded there)
-import { runLoop, TerminateReason, MAX_RETRIES, killAllSubAgents } from "./loop.js"; // the state machine
+import { runLoop, TerminateReason, MAX_RETRIES, killAllSubAgents, topLevelToolNames } from "./loop.js"; // the state machine
 import { buildSystemMessage, readProjectInstructions } from "./prompt.js"; // the constitution + optional AGENT.md project memory
 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
@@ -18,7 +18,7 @@ import { Judge } from "./judge.js"; // optional LLM permission classifier
 import { AutoMode } from "./auto.js";
 import { effortMenu, setEffort, selectedEffort } from "./effort.js";
 import { parseCli, applyCliOptions, readPrintPrompt, CliUsageError } from "./cli.js";
-import { reservePrintOutput, formatPrintResult } from "./print.js";
+import { reservePrintOutput, formatPrintResult, streamJsonInit, streamJsonMessage } from "./print.js";
 import { FollowUpQueue } from "./follow-up.js";
 import { reviewDebugCommand } from "./auto-debug.js";
 import { isPlanMode, setPlanMode } from "./permissions.js"; // plan mode: research-only until the user approves a plan
@@ -41,6 +41,7 @@ import { launchInk } from "./ink/launch.js"; // the Ink REPL — the default fro
 import { listBackground, hasRunningBackground, killAllBackground } from "./background.js"; // background tasks: /bg view + kill-on-exit (Day 37)
 import { listTeam, resetTeam } from "./team.js"; // agent teams: /team view + reset on clear/resume (Day 38)
 import { boardSummary, resetBoard } from "./board.js"; // task board: /tasks view + reset on clear/resume (Day 40)
+import { goalCommand, getGoal, restoreGoal, clearGoal, startGoalTurn, settleGoalTurn } from "./goal.js"; // /goal (Day 41): keep working until the goal is verified done
 import { loadDurableJobs, startCronScheduler, stopCronScheduler, listJobs } from "./cron.js"; // cron scheduler (Day s14)
 // package.json sits one level above both src/ (dev) and dist/ (built) — same path either way.
 const pkg = createRequire(import.meta.url)("../package.json");
@@ -59,7 +60,7 @@ Usage:
   --effort <level>           supported effort for this model, or default
   --permission-mode <mode>  default | auto | bypassPermissions (this run only)
   --dangerously-skip-permissions  alias for --permission-mode bypassPermissions
-  --output-format text|json  final answer or a JSON result (print mode only)
+  --output-format text|json|stream-json  final answer, a JSON result, or Claude-style NDJSON events (print mode only)
   mini-agent --auto          review tool actions automatically (Jev or your current vendor)
   mini-agent -v | --version  print the version
   mini-agent -h | --help     this text
@@ -108,6 +109,7 @@ const SESSION_HELP = `commands:
   /bg        list background tasks this session (run_bash_background) and their status
   /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
+  /goal <objective> [--check <cmd>]  keep working, turn after turn, until the goal is verified done (/goal alone shows it; pause | resume | clear)
   /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
@@ -181,6 +183,8 @@ async function main() {
             sessionId = prev.id; // keep appending to the same session file
             initialTitle = prev.title;
             console.log(chalk.dim(`(resumed session ${prev.id} — ${prev.messages.length} messages; files must be re-read before editing)`));
+            if (printTask === null)
+                restoreGoal(prev.goal); // Day 41: the goal comes back with its session (print mode doesn't run goals)
         }
         else {
             console.log(chalk.dim("(no previous session here — starting fresh)")); // resume with nothing to resume is not an error
@@ -216,6 +220,15 @@ async function main() {
     // The optional LLM permission judge, built once if a settings file enabled it.
     const judge = CONFIG.judge.enabled && !CONFIG.bypassPermissions ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
     const autoMode = new AutoMode(client, { projectInstructions });
+    // A restored ACTIVE goal (Day 41) starts running before the first prompt —
+    // say so loudly. Its /goal line was a genuine human request: auto mode re-learns it.
+    const restoredGoal = getGoal();
+    if (restoredGoal?.status === "active") {
+        autoMode.recordRequest(`/goal ${restoredGoal.objective}`);
+        console.log(chalk.cyan(`(◎ resumed an ACTIVE goal — the agent continues it now; Esc pauses: ${restoredGoal.objective.slice(0, 80)})`));
+    }
+    else if (restoredGoal)
+        console.log(chalk.dim(`(◎ goal restored [${restoredGoal.status}] — /goal to see it, /goal resume to continue)`));
     for (const notice of autoMode.startupNotices())
         console.log(chalk.dim(notice));
     if (judge)
@@ -264,7 +277,21 @@ async function main() {
         });
         messages.push({ role: "user", content: printTask }); // the single task
         autoMode.recordRequest(printTask);
+        // stream-json: an init line now (MCP is connected, so statuses are real),
+        // then every assistant turn / tool result as it enters history.
+        const streaming = cli.outputFormat === "stream-json";
+        const startedAt = Date.now();
+        let numTurns = 0;
+        if (streaming)
+            printOutput.write(streamJsonInit({ sessionId, model: CONFIG.model, tools: topLevelToolNames(),
+                mcpServers: listMcpServers().map((s) => ({ name: s.name, status: s.status })),
+                permissionMode: CONFIG.bypassPermissions ? "bypassPermissions" : CONFIG.autoMode.enabled ? "auto" : "default" }));
         const result = await runLoop(messages, {
+            onMessage: streaming ? (m) => {
+                if (m.role === "assistant")
+                    numTurns++;
+                printOutput.write(streamJsonMessage(sessionId, CONFIG.model, m));
+            } : undefined,
             client,
             model: CONFIG.model,
             quiet: true, // final result only; no spinner, reasoning or intermediate prose
@@ -289,6 +316,7 @@ async function main() {
         emit("agent_session_end"); // close the books
         printOutput.write(formatPrintResult(cli.outputFormat, {
             sessionId, model: CONFIG.model, effort: selectedEffort(CONFIG.model), result, usage: costMeter.snapshot(),
+            durationMs: Date.now() - startedAt, numTurns,
         }));
         if (result.reason !== TerminateReason.Done) {
             console.error(chalk.yellow(EXIT_NOTES[result.reason])); // human note on stderr
@@ -569,6 +597,13 @@ async function main() {
             console.log(await statusCommand(line, costMeter));
             return true;
         }
+        if (line === "/goal" || line.startsWith("/goal ")) {
+            const { message, request } = goalCommand(line.slice(5));
+            if (request)
+                autoMode.recordRequest(request); // the /goal you typed is the authorization; automatic goal turns never are
+            console.log(chalk.cyan(message)); // setting or resuming: the goal turns start before the next prompt
+            return true;
+        }
         if (line.startsWith("/skills "))
             line = `/skill ${line.slice(8).trim()}`;
         if (line === "/effort" || line.startsWith("/effort ")) {
@@ -662,6 +697,7 @@ async function main() {
                 return true;
             case "/clear":
                 autoMode.clearRequests();
+                clearGoal(); // the goal belonged to the old conversation (Day 41)
                 messages = [{ role: "system", content: systemMessage }]; // drop everything but the constitution
                 forgetFilesExcept([]); // the file read-state belongs to the conversation — clear it too
                 clearUndo(); // a fresh conversation should not undo the previous one's writes
@@ -805,6 +841,15 @@ async function main() {
                 resetTeam(); // a resumed conversation starts with no live team
                 resetBoard(); // ...and an empty task board (Day 40)
                 console.log(chalk.dim(`(resumed ${chosen.id} — ${chosen.messages.length} messages; files must be re-read before editing)`));
+                // Unlike the todos and the board, the goal comes BACK with its session (Day 41).
+                restoreGoal(chosen.goal);
+                const goal = getGoal();
+                if (goal?.status === "active") {
+                    autoMode.recordRequest(`/goal ${goal.objective}`);
+                    console.log(chalk.cyan(`◎ resumed an ACTIVE goal — the agent continues it now (Esc pauses): ${goal.objective.slice(0, 80)}`));
+                }
+                else if (goal)
+                    console.log(chalk.dim(`(◎ goal restored [${goal.status}] — /goal to see it, /goal resume to continue)`));
                 return true;
             }
             case "/diff": {
@@ -884,7 +929,46 @@ async function main() {
             }
         });
     }
+    // /goal (Day 41): the readline prompt blocks on your input, so it can't poll
+    // like the Ink REPL's idle processor. Instead, goal turns run HERE, before each
+    // prompt, one after another until the goal stops being active — verified
+    // complete, blocked, or paused by Esc / a failed turn / no progress. Plan mode
+    // never continues a goal: plan-only work can't move it forward.
+    const runGoalTurns = async () => {
+        for (let content = isPlanMode() ? null : startGoalTurn(); content; content = isPlanMode() ? null : startGoalTurn()) {
+            console.log(chalk.cyan(`\n◎ goal · turn ${getGoal().continuations}: ${getGoal().objective.slice(0, 70)}`));
+            messages.push({ role: "user", content }); // the goal turn (restates the objective — it survives compaction)
+            clearReasoning();
+            clearToolCalls();
+            running = true;
+            interrupted = false;
+            controller = new AbortController();
+            setSessionState("busy", CONFIG.model);
+            let reason = "error";
+            try {
+                const result = await runLoop(messages, {
+                    client, model: CONFIG.model, signal: controller.signal, isInterrupted: () => interrupted, confirm, askUser, followUps,
+                    onFollowUp: (text) => console.log(sentMessage(text)), subAgentModel: CONFIG.subAgentModel, judge, autoMode, canPrompt: !!process.stdin.isTTY,
+                });
+                reason = result.reason;
+                if (result.reason !== TerminateReason.Done)
+                    console.log(chalk.yellow(`\n⚠️ ${EXIT_NOTES[result.reason]}`));
+            }
+            catch (err) {
+                console.log(chalk.red(`[error] ${err.message}`));
+            }
+            finally {
+                running = false;
+                setSessionState("idle");
+            }
+            const goalNote = settleGoalTurn(reason, true);
+            if (goalNote)
+                console.log(chalk.yellow(goalNote));
+            saveSession(sessionId, CONFIG.model, messages, pendingTitle); // the goal's progress is saved turn by turn
+        }
+    };
     while (true) {
+        await runGoalTurns(); // an active /goal keeps going before you're asked for input
         // 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
@@ -985,6 +1069,9 @@ async function main() {
         });
         running = false; // back at the prompt — Ctrl+C means "exit" again
         setSessionState("idle"); // other sessions see this one as free again
+        const goalNote = settleGoalTurn(result.reason, false); // Day 41: Esc on your own turn pauses an active goal too
+        if (goalNote)
+            console.log(chalk.yellow(goalNote));
         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/cli.js

@@ -21,6 +21,7 @@ export function parseCli(args) {
                 help: { type: "boolean", short: "h" },
                 version: { type: "boolean", short: "v" },
                 "output-format": { type: "string" },
+                verbose: { type: "boolean" }, // accepted for Claude compatibility: its stream-json requires --verbose; ours always streams
             } });
     }
     catch (error) {
@@ -35,8 +36,8 @@ export function parseCli(args) {
     // Match Claude's precedence: the explicit skip flag wins over a mode flag.
     const permissionMode = values["dangerously-skip-permissions"] ? "bypassPermissions" : requestedMode;
     const outputFormat = values["output-format"] ?? "text";
-    if (outputFormat !== "text" && outputFormat !== "json")
-        throw new CliUsageError("--output-format must be text or json");
+    if (outputFormat !== "text" && outputFormat !== "json" && outputFormat !== "stream-json")
+        throw new CliUsageError("--output-format must be text, json, or stream-json");
     for (const flag of ["model", "effort", "prompt"]) {
         if (typeof values[flag] === "string" && !values[flag].trim())
             throw new CliUsageError(`--${flag} cannot be empty`);

package/dist/completion.js

@@ -19,6 +19,7 @@ export const COMMANDS = [
     { value: "/bg", description: "Show background tasks" },
     { value: "/team", description: "Show teammates and status" },
     { value: "/tasks", description: "Show the shared task board" },
+    { value: "/goal", description: "Keep working until a goal is verified done", children: true },
     { 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 },

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/goal.js

@@ -0,0 +1,365 @@
+import crypto from "node:crypto"; // fingerprint the working tree between goal turns
+import fs from "node:fs"; // stat untracked files for the fingerprint
+import { execFileSync, spawn } from "node:child_process"; // git for the fingerprint, sh for the --check command
+import { sessionChanges } from "./undo.js"; // files the agent's own tools changed this session
+import { emit } from "./telemetry.js"; // observe goal lifecycle + verifier decisions
+export const MAX_STALLED_TURNS = 3; // goal turns in a row with an unchanged working tree → pause
+const CHECK_TIMEOUT_MS = 10 * 60_000; // a test suite may be slow — but not forever
+const CHECK_OUTPUT_TAIL = 4_000; // chars of check output fed back (the END is where failures are)
+const OBSERVATION_CHARS = 1_200; // per tool result shown to the verifier
+const OBSERVATIONS_BUDGET = 12_000; // total chars of recent tool results shown to the verifier
+const VERIFIER_MAX_TOKENS = 200; // one tag + one sentence
+// ---- session state ------------------------------------------------------------
+// One goal per session, in process memory like the todo list — but unlike the
+// todo list it is written into the session file (session.ts), so `--resume`
+// picks up a half-finished goal and keeps going.
+let current = null;
+let inFlight = null; // the goal turn now running
+let toolCalls = 0; // top-level tool calls this process (loop.ts counts them) — survives compaction, unlike message indexes
+export function getGoal() {
+    return current;
+}
+export function clearGoal() {
+    current = null;
+    inFlight = null;
+}
+// Adopt a goal loaded from a session file (or none). A malformed one is dropped.
+export function restoreGoal(goal) {
+    inFlight = null;
+    current = goal && typeof goal.objective === "string" && goal.objective.trim() ? { ...goal, stalls: goal.stalls ?? 0, continuations: goal.continuations ?? 0 } : null;
+}
+function setStatus(status, note) {
+    if (!current)
+        return;
+    current.status = status;
+    current.note = note;
+    emit("agent_goal_status", { status });
+}
+export function countGoalToolCall() {
+    toolCalls++;
+}
+export function parseGoalCommand(args) {
+    const text = args.trim();
+    if (!text)
+        return { kind: "show" };
+    if (text === "pause" || text === "resume" || text === "clear")
+        return { kind: text };
+    const m = text.match(/^([\s\S]*?)\s*--check\s+([\s\S]+)$/);
+    let objective = text;
+    let check;
+    if (m) {
+        objective = m[1].trim();
+        check = m[2].trim().replace(/^(["'])([\s\S]*)\1$/, "$2").trim(); // strip one pair of matching quotes
+        if (!check)
+            return { kind: "error", message: "--check needs a command, e.g. --check \"npm test\"" };
+    }
+    else if (/(^|\s)--check\s*$/.test(text)) {
+        return { kind: "error", message: "--check needs a command, e.g. --check \"npm test\"" };
+    }
+    if (!objective)
+        return { kind: "error", message: "usage: /goal <objective> [--check <command>]" };
+    return { kind: "set", objective, check };
+}
+// ---- pure: render the goal for /goal -------------------------------------------
+export function describeGoal(goal) {
+    if (!goal)
+        return "(no goal — set one with /goal <objective> [--check <command>])";
+    const lines = [
+        `goal [${goal.status}]: ${goal.objective}`,
+        goal.check ? `  check: ${goal.check}` : "  check: (none — the verifier judges from evidence alone)",
+        `  turns: ${goal.continuations}${goal.stalls ? ` · no progress in the last ${goal.stalls}` : ""}`,
+    ];
+    if (goal.note)
+        lines.push(`  note: ${goal.note}`);
+    if (goal.status === "paused" || goal.status === "blocked")
+        lines.push("  /goal resume to continue · /goal clear to drop it");
+    return lines.join("\n");
+}
+// ---- the /goal command (shared by both REPLs) ----------------------------------
+// Returns the line to show, plus `request`: the human text to record as a user
+// request for auto mode. Only the /goal line the human typed authorizes work —
+// the automatic continuation turns never do, or each one would widen what the
+// reviewer thinks was approved.
+export function goalCommand(args) {
+    const cmd = parseGoalCommand(args);
+    switch (cmd.kind) {
+        case "error":
+            return { message: cmd.message };
+        case "show":
+            return { message: describeGoal(current) };
+        case "clear":
+            if (!current)
+                return { message: "(no goal to clear)" };
+            clearGoal();
+            emit("agent_goal_status", { status: "cleared" });
+            return { message: "(goal cleared)" };
+        case "pause":
+            if (current?.status !== "active")
+                return { message: `(no active goal to pause${current ? ` — it is ${current.status}` : ""})` };
+            setStatus("paused", "paused by you");
+            return { message: "(goal paused — /goal resume to continue)" };
+        case "resume":
+            if (!current)
+                return { message: "(no goal to resume)" };
+            if (current.status === "complete")
+                return { message: "(that goal is already complete — set a new one with /goal <objective>)" };
+            if (current.status === "active")
+                return { message: "(the goal is already active)" };
+            setStatus("active");
+            current.stalls = 0; // a fresh start after you stepped in
+            return { message: `(goal resumed: ${current.objective})`, request: `/goal ${current.objective}` };
+        case "set": {
+            const replaced = current && current.status !== "complete";
+            current = { objective: cmd.objective, check: cmd.check, status: "active", continuations: 0, stalls: 0, setAt: new Date().toISOString() };
+            inFlight = null;
+            emit("agent_goal_status", { status: "set", check: cmd.check ? 1 : 0 });
+            return { message: `${replaced ? "(replaced the previous goal) " : ""}goal set: ${cmd.objective}${cmd.check ? `\n  check: ${cmd.check}` : ""}\n  the agent keeps working until it is verified done — Esc pauses, /goal clear drops it`, request: `/goal ${args.trim()}` };
+        }
+    }
+}
+// ---- turn bookkeeping -----------------------------------------------------------
+// The REPL calls startGoalTurn when it is idle. It returns the text of the next
+// goal turn (or null if there is nothing to do), and snapshots the working tree
+// so settleGoalTurn can tell whether the turn moved anything.
+export function startGoalTurn() {
+    if (current?.status !== "active" || inFlight)
+        return null;
+    inFlight = { fingerprint: workFingerprint(), toolCalls };
+    current.continuations++;
+    return goalTurnContent(current);
+}
+// The goal turn text. It restates the FULL objective every time: after a few
+// compactions the original /goal message may be long gone from history, and
+// this is what keeps the model aimed at the same target for hours.
+export function goalTurnContent(goal) {
+    const head = goal.continuations <= 1 ? "[goal] A goal was just set. Work toward it until it is verified done." : `[goal] Continuation #${goal.continuations} — the goal is not verified done yet. Pick up where you left off.`;
+    return [
+        head,
+        `Objective: ${goal.objective}`,
+        goal.check ? `Completion check: \`${goal.check}\` must exit 0 — the harness runs it when you claim completion.` : "",
+        "Inspect, change, run and verify. Each time you stop you will be sent back here, until you call update_goal:",
+        '  - update_goal({status: "complete", report}) — only after checking the objective against concrete evidence (commands you ran, their output, files you changed). An independent verifier re-checks against your recent tool results; an unsupported claim is rejected.',
+        '  - update_goal({status: "blocked", report}) — when no valid path remains or you need the user: what you tried, the blocker, and the input you need.',
+        "Do not stop just to summarize progress: a goal turn that makes no tool calls pauses the goal.",
+    ].filter(Boolean).join("\n");
+}
+// After ANY turn ends. Returns a line for the screen, or null. `goalTurn` says
+// whether this was a goal turn (vs. the user's own message); `reason` is the
+// loop's TerminateReason (or "error" if the turn threw); `followUp` is true when
+// the turn was interrupted only to deliver a queued message — that is the user
+// steering, not stopping, so it must not pause the goal.
+export function settleGoalTurn(reason, goalTurn, followUp = false) {
+    const turn = inFlight;
+    if (goalTurn)
+        inFlight = null;
+    if (current?.status !== "active")
+        return null; // update_goal finished it mid-turn (it announced that itself)
+    if (reason === "user_interrupt") {
+        if (followUp)
+            return null;
+        setStatus("paused", "interrupted by you");
+        return "◎ goal paused (interrupted) — /goal resume to continue";
+    }
+    if (!goalTurn || !turn)
+        return null; // your own message ended normally — the goal simply continues next
+    if (reason !== "done") {
+        setStatus("paused", `a goal turn ended with ${reason}`);
+        return `◎ goal paused — the turn ended with ${reason}. /goal resume to try again`;
+    }
+    if (toolCalls === turn.toolCalls) {
+        setStatus("paused", "a goal turn made no tool calls");
+        return "◎ goal paused — the agent stopped without doing anything. Reply to steer it, then /goal resume";
+    }
+    current.stalls = workFingerprint() === turn.fingerprint ? current.stalls + 1 : 0;
+    if (current.stalls >= MAX_STALLED_TURNS) {
+        setStatus("paused", `no file changes in ${current.stalls} goal turns in a row`);
+        return `◎ goal paused — no progress in ${current.stalls} turns in a row. Reply to steer it, then /goal resume`;
+    }
+    return null;
+}
+// Did anything change? The agent's own writes (undo.ts tracks their current
+// content, so rewriting the same file counts) plus git's view, which also sees
+// what run_bash changed (sed, codegen, npm install). `git diff` is blind to
+// untracked files, so their size + mtime go in too. Not in a git repo → the
+// agent's writes alone.
+const MAX_UNTRACKED = 2_000; // stat at most this many untracked files per fingerprint
+function workFingerprint() {
+    const h = crypto.createHash("sha1");
+    for (const c of sessionChanges())
+        h.update(c.path).update("\0").update(c.current).update("\0");
+    const git = (args) => execFileSync("git", args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], maxBuffer: 64 * 1024 * 1024 });
+    try {
+        // Our own bookkeeping (.mini-agent/: the session file, logs, spilled output)
+        // churns every turn and is rarely gitignored — counting it as "progress"
+        // would reset the stall count every turn and disarm the fuse.
+        const lines = git(["status", "--porcelain", "-uall"]).split("\n").filter((l) => l && !/^.. "?\.mini-agent\//.test(l));
+        h.update(lines.join("\n")).update(git(["diff"]));
+        const untracked = lines.filter((l) => l.startsWith("?? ")).slice(0, MAX_UNTRACKED);
+        for (const line of untracked) {
+            try {
+                const st = fs.statSync(line.slice(3));
+                h.update(`${line}\0${st.size}\0${st.mtimeMs}\0`);
+            }
+            catch {
+                /* vanished between status and stat — the next fingerprint sees it */
+            }
+        }
+    }
+    catch {
+        /* not a git repo, or git missing — the agent's own writes still count */
+    }
+    return h.digest("hex");
+}
+// ---- update_goal: the model's only way to END a goal ----------------------------
+export const updateGoalTool = {
+    type: "function",
+    function: {
+        name: "update_goal",
+        description: `End the active /goal, as "complete" or "blocked". While a goal is active you are sent back to work every time you stop, so this is how you finish.
+complete: only after you checked the objective against concrete evidence — tests you ran and their output, files you changed, results you saw. The user's completion check (if any) is run, then an independent verifier compares your report with your recent tool results. If either fails you get the reason back and the goal stays active.
+blocked: when no valid path remains or you need something only the user can give. Report what you tried, the blocker, and the exact input you need.`,
+        parameters: {
+            type: "object",
+            properties: {
+                status: { type: "string", enum: ["complete", "blocked"], description: "complete = the objective is achieved and evidenced; blocked = you need the user" },
+                report: { type: "string", description: "complete: the evidence (what you ran/changed and what it showed). blocked: what you tried, the blocker, the input you need." },
+            },
+            required: ["status", "report"],
+        },
+    },
+};
+// Run update_goal. Never throws; every outcome is text for the model.
+export async function runUpdateGoal(rawArgs, ctx) {
+    if (current?.status !== "active")
+        return "[error] There is no active goal. update_goal is only for ending a goal the user set with /goal.";
+    let status = "", report = "";
+    try {
+        const a = JSON.parse(rawArgs);
+        status = a.status ?? "";
+        report = (a.report ?? "").trim();
+    }
+    catch {
+        /* fall through */
+    }
+    if (status !== "complete" && status !== "blocked")
+        return '[error] update_goal needs status "complete" or "blocked".';
+    if (!report)
+        return "[error] update_goal needs a non-empty report — the evidence (complete) or the blocker (blocked).";
+    if (status === "blocked") {
+        setStatus("blocked", report.slice(0, 300));
+        ctx.note(`◎ goal blocked — ${report.slice(0, 160)}`);
+        return "Goal marked blocked; no more automatic turns. Stop now and tell the user what you tried, the blocker, and the input you need.";
+    }
+    // 1. The hard gate: the user's own --check command. It was typed by the human
+    //    in /goal, so it does not go through the permission gate — and the model
+    //    has no way to change it. Nonzero exit → not done, no verifier call.
+    let checkLine = "";
+    if (current.check) {
+        ctx.note(`◎ goal check: ${current.check}`);
+        const r = await runCheck(current.check, ctx.signal);
+        if (r.code !== 0) {
+            emit("agent_goal_claim", { accepted: 0, by: "check" });
+            ctx.note(`◎ goal check failed (${r.code === null ? "timed out / killed" : `exit ${r.code}`}) — not done`);
+            return `[goal] Not complete: the completion check \`${current.check}\` ${r.code === null ? "timed out or was killed" : `exited ${r.code}`}. The goal stays active — fix it and claim again.\nCheck output (tail):\n${r.output || "(no output)"}`;
+        }
+        checkLine = `The completion check \`${current.check}\` passed (exit 0). Output tail:\n${r.output || "(no output)"}`;
+    }
+    // 2. The independent verifier: a separate model call that sees what the tools
+    //    actually returned, not just what the model says about them.
+    ctx.note("◎ goal verifier: checking the claim against the evidence…");
+    const verdict = await verifyGoal(ctx, current, report, checkLine);
+    emit("agent_goal_claim", { accepted: verdict.done ? 1 : 0, by: "verifier" });
+    if (!verdict.done) {
+        ctx.note(`◎ goal verifier: not done — ${verdict.reason.slice(0, 160)}`);
+        return `[goal] Not complete — the verifier rejected the claim: ${verdict.reason}\nThe goal stays active. Close the gap (or gather the missing evidence), then claim again.`;
+    }
+    setStatus("complete", verdict.reason.slice(0, 300));
+    ctx.note(`◎ goal complete ✓ — ${verdict.reason.slice(0, 160)}`);
+    return "Goal verified complete. Give the user a short final report: what was done and the evidence.";
+}
+// Run the user's check command. Output is capped to its TAIL — test runners
+// print the failures (and the summary) last.
+function runCheck(command, signal) {
+    return new Promise((resolve) => {
+        let out = "";
+        const child = spawn(command, { shell: true, stdio: ["ignore", "pipe", "pipe"] });
+        const keep = (b) => {
+            out = (out + b.toString("utf8")).slice(-CHECK_OUTPUT_TAIL * 4); // bounded memory, trimmed properly below
+        };
+        child.stdout.on("data", keep);
+        child.stderr.on("data", keep);
+        const kill = () => child.kill("SIGKILL");
+        const timer = setTimeout(kill, CHECK_TIMEOUT_MS);
+        signal.addEventListener("abort", kill, { once: true });
+        const done = (code) => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", kill);
+            resolve({ code, output: out.slice(-CHECK_OUTPUT_TAIL).trim() });
+        };
+        child.on("error", (e) => {
+            out += `\n${e.message}`;
+            done(null);
+        });
+        child.on("close", (code) => done(code));
+    });
+}
+// The verifier's prompt is blunt for the same reason as the permission judge's:
+// a rigid tag is unambiguous to parse, and "doubt → no" is the load-bearing line.
+const VERIFIER_SYSTEM = `You verify whether a coding agent has ACHIEVED a goal. You are given the goal's objective, the agent's completion report, the result of the user's completion check (if any), and the agent's most recent tool calls with what they actually returned.
+Judge from the tool results — they are observations. The agent's report is a claim, not evidence. Every part of the objective must be demonstrably satisfied by the observations; if something is missing, unverified, or contradicted, the goal is NOT done.
+Err on the side of NO.
+Respond with exactly two lines:
+<done>yes</done> or <done>no</done>
+one sentence: why — if no, what is missing.`;
+// PURE: parse the verifier reply. Fail closed — only a clean yes is done.
+export function interpretVerdict(text) {
+    const m = text.match(/<done>\s*(yes|no)\s*<\/done>/i);
+    const reason = text.replace(/<done>[\s\S]*?<\/done>/i, "").trim().replace(/\s+/g, " ") || "(no reason given)";
+    if (!m)
+        return { done: false, reason: `unparseable verifier reply: ${text.trim().slice(0, 120) || "(empty)"}` };
+    return { done: m[1].toLowerCase() === "yes", reason };
+}
+// PURE: the agent's most recent tool calls with their results, newest last,
+// each capped, within a total budget — the verifier's evidence.
+export function recentObservations(messages) {
+    const results = new Map();
+    for (const m of messages)
+        if (m.role === "tool")
+            results.set(m.tool_call_id, typeof m.content === "string" ? m.content : "");
+    const items = [];
+    let used = 0;
+    for (let i = messages.length - 1; i >= 0 && used < OBSERVATIONS_BUDGET; i--) {
+        const m = messages[i];
+        if (m.role !== "assistant" || !m.tool_calls)
+            continue;
+        for (const call of [...m.tool_calls].reverse()) {
+            if (call.type !== "function" || call.function.name === "update_goal" || !results.has(call.id))
+                continue;
+            const result = results.get(call.id);
+            const item = `$ ${call.function.name} ${call.function.arguments.slice(0, 300)}\n${result.length > OBSERVATION_CHARS ? result.slice(0, OBSERVATION_CHARS) + " …(truncated)" : result}`;
+            if (used + item.length > OBSERVATIONS_BUDGET)
+                break;
+            items.unshift(item);
+            used += item.length;
+        }
+    }
+    return items.length ? items.join("\n\n") : "(no tool calls in the conversation)";
+}
+async function verifyGoal(ctx, goal, report, checkLine) {
+    try {
+        const res = await ctx.client.chat.completions.create({
+            model: ctx.model,
+            max_tokens: VERIFIER_MAX_TOKENS,
+            temperature: 0,
+            messages: [
+                { role: "system", content: VERIFIER_SYSTEM },
+                { role: "user", content: [`Objective:\n${goal.objective}`, `Agent's completion report:\n${report}`, checkLine || "No completion check was configured.", `Recent tool calls and results (oldest first):\n${recentObservations(ctx.transcript)}`].join("\n\n") },
+            ],
+        }, { signal: ctx.signal });
+        return interpretVerdict(res.choices[0]?.message?.content ?? "");
+    }
+    catch (e) {
+        // A verifier that errors must never accidentally complete a goal.
+        return { done: false, reason: `the verifier call failed (${e.message}) — claim again` };
+    }
+}

package/dist/ink/app.js

@@ -10,6 +10,8 @@ import { initFormState, reduceForm, renderForm, collectAnswers } from "../form.j
 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
@@ -18,6 +20,7 @@ import { clearUndo } from "../undo.js";
 import { clearTodos } from "../todos.js";
 import { resetTeam } from "../team.js";
 import { resetBoard } from "../board.js";
+import { goalCommand, getGoal, restoreGoal, clearGoal, startGoalTurn, settleGoalTurn } from "../goal.js"; // /goal (Day 41): keep starting turns until the goal is verified done
 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
@@ -178,6 +181,8 @@ 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([]);
@@ -225,6 +230,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);
@@ -244,7 +251,7 @@ export function App({ session, runTurn, clipboard }) {
     // as the prompt (a user highlight bar, or a note for /skill); the loop appends
     // `content` to `messages` itself. The permission menu + ask_user form raise a
     // `pending` prompt that returns a promise the loop awaits.
-    const runConversationTurn = (content, display, attachments = []) => {
+    const runConversationTurn = (content, display, attachments = [], goalTurn = false) => {
         setDetails(null);
         setDetailOffset(0);
         if (display)
@@ -253,6 +260,11 @@ export function App({ session, runTurn, clipboard }) {
         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();
@@ -293,8 +305,17 @@ export function App({ session, runTurn, clipboard }) {
                 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 (CONFIG.memory.autoExtract && result.reason === TerminateReason.Done) {
+            const goalNote = settleGoalTurn(result.reason, goalTurn, result.reason === TerminateReason.UserInterrupt && followUps.size > 0); // Day 41: pause on Esc / failure / no progress
+            if (goalNote)
+                note(chalk.yellow(goalNote));
+            saveSession(sessionId, model, messages, pendingTitle.current); // snapshot after every turn — crash-safe by construction (the goal's state rides along)
+            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 && !goalTurn) { // not after every automatic goal turn — that would bill an extraction per continuation
                 try {
                     const got = await extractMemories(client, CONFIG.subAgentModel || model, messages);
                     if (got.length)
@@ -305,7 +326,12 @@ export function App({ session, runTurn, clipboard }) {
                 }
             }
         })
-            .catch((e) => note(chalk.red(`[error] ${e.message}`)))
+            .catch((e) => {
+            note(chalk.red(`[error] ${e.message}`));
+            const goalNote = settleGoalTurn("error", goalTurn); // a crashed goal turn pauses the goal instead of retrying forever
+            if (goalNote)
+                note(chalk.yellow(goalNote));
+        })
             .finally(() => {
             turn.current = null;
             setSessionState("idle");
@@ -343,6 +369,27 @@ export function App({ session, runTurn, clipboard }) {
         return () => clearInterval(id);
         // eslint-disable-next-line react-hooks/exhaustive-deps
     }, [busy, pending]);
+    // The GOAL idle processor (Day 41): while a /goal is active and the REPL is
+    // idle — no turn, no menu, no queued message — start the next goal turn. This
+    // is the whole "keep going" mechanism: the model can stop as often as it
+    // likes, but it is sent straight back until update_goal ends the goal, or
+    // settleGoalTurn pauses it (Esc, a failed turn, no progress). Plan mode never
+    // continues: plan-only work can't move a goal forward.
+    useEffect(() => {
+        if (busy || pending || followUps.size || planMode)
+            return; // human input first; plan mode is read-only
+        const id = setInterval(() => {
+            if (turn.current || followUps.size)
+                return;
+            const content = startGoalTurn();
+            if (!content)
+                return;
+            const goal = getGoal();
+            runConversationTurn(content, { kind: "note", text: chalk.cyan(`◎ goal · turn ${goal.continuations}: ${goal.objective.slice(0, 70)}`) }, [], true); // a note, not a user bar — you didn't type it
+        }, 500);
+        return () => clearInterval(id);
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [busy, pending, planMode]);
     // 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
@@ -713,9 +760,17 @@ export function App({ session, runTurn, clipboard }) {
             runConversationTurn(userSkillMessages(s, args), { kind: "note", text: chalk.dim(`(running skill: ${s.name})`) });
             return true;
         }
+        if (line === "/goal" || line.startsWith("/goal ")) {
+            const { message, request } = goalCommand(line.slice(5));
+            if (request)
+                autoMode.recordRequest(request); // the /goal you typed is the authorization; automatic goal turns never are
+            note(chalk.cyan(message)); // setting or resuming a goal: the idle processor starts the turn
+            return true;
+        }
         switch (line) {
             case "/clear":
                 autoMode.clearRequests();
+                clearGoal(); // the goal belonged to the old conversation
                 messages.length = 0; // mutate in place — same array ref the loop holds
                 messages.push({ role: "system", content: systemMessage });
                 forgetFilesExcept([]);
@@ -787,6 +842,15 @@ export function App({ session, runTurn, clipboard }) {
                     resetTeam();
                     resetBoard();
                     note(chalk.dim(`(resumed ${chosen.id} — ${chosen.messages.length} messages; files must be re-read before editing)`));
+                    // Unlike the todos and the board, the goal comes BACK with its session (Day 41).
+                    restoreGoal(chosen.goal);
+                    const goal = getGoal();
+                    if (goal?.status === "active") {
+                        autoMode.recordRequest(`/goal ${goal.objective}`);
+                        note(chalk.cyan(`◎ resumed an ACTIVE goal — the agent continues it now (Esc pauses): ${goal.objective.slice(0, 80)}`));
+                    }
+                    else if (goal)
+                        note(chalk.dim(`(◎ goal restored [${goal.status}] — /goal to see it, /goal resume to continue)`));
                 });
                 return true;
             }
@@ -952,6 +1016,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);
@@ -1193,7 +1264,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));
                             });

package/dist/ink/commands.js

@@ -35,6 +35,7 @@ export const SESSION_HELP = `commands:
   /bg        list background tasks this session (run_bash_background) and their status
   /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
+  /goal <objective> [--check <cmd>]  keep working, turn after turn, until the goal is verified done (/goal alone shows it; pause | resume | clear)
   /cron      list scheduled cron jobs (schedule_cron) and their expressions
   /peers     pick another mini-agent session on this machine: talk to it from this box (Esc to come back), or make it flash its tab so you know which window it is
   /rename <name>  rename this session — the name other sessions use to reach it
@@ -46,6 +47,7 @@ export const SESSION_HELP = `commands:
   exit       leave (Ctrl+C does the same)
 
 keys (during or after a turn):
+  Tab / →    accept the predicted next message (the dim placeholder after a turn); Enter sends it
   /          show command suggestions below the input (while idle)
   ↑↓ / Tab   choose / complete a suggestion; Enter selects; Esc closes
   Enter      while working, queue a follow-up for the next tool boundary

package/dist/ink/setup.js

@@ -8,6 +8,7 @@ import { initCostMeter, DEFAULT_PRICING } from "../cost.js";
 import { gitBranch } from "../tui.js";
 import { listPeers, registerSession, unregisterSession } from "../peers.js"; // peer sessions: other mini-agent processes on this machine
 import { newSessionId, latestSession } from "../session.js";
+import { getGoal, restoreGoal } from "../goal.js"; // /goal (Day 41): a resumed session keeps working toward its goal
 import { initTelemetry, emit } from "../telemetry.js";
 import { runHooks } from "../hooks.js";
 import { connectMcpServers, watchMcpConfig } from "../mcp.js";
@@ -46,6 +47,7 @@ export async function buildInkSession(opts = {}) {
             sessionId = prev.id; // keep appending to the same file
             initialTitle = prev.title;
             notices.push(`(resumed session ${prev.id} — ${prev.messages.length} messages; files must be re-read before editing)`);
+            restoreGoal(prev.goal);
         }
         else {
             notices.push("(no previous session here — starting fresh)");
@@ -71,6 +73,16 @@ export async function buildInkSession(opts = {}) {
     const judge = CONFIG.judge.enabled && !CONFIG.bypassPermissions ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
     const autoMode = new AutoMode(client, { projectInstructions });
     notices.push(...autoMode.startupNotices());
+    // A restored ACTIVE goal starts running as soon as the prompt is up — no
+    // keystroke — so say so loudly. Its /goal line was a genuine human request,
+    // so auto mode re-learns it (a paused goal is re-learned on /goal resume).
+    const goal = getGoal();
+    if (goal?.status === "active") {
+        autoMode.recordRequest(`/goal ${goal.objective}`);
+        notices.push(`(◎ resumed an ACTIVE goal — the agent continues it now; Esc pauses: ${goal.objective.slice(0, 80)})`);
+    }
+    else if (goal)
+        notices.push(`(◎ goal restored [${goal.status}] — /goal to see it, /goal resume to continue)`);
     if (judge)
         notices.push(`(permission judge on — ${autoMode.backend})`);
     // The remember tool flows through the same permission gate as any tool.

package/dist/loop.js

@@ -22,6 +22,7 @@ import { todoNag, getTodos, renderTodos } from "./todos.js"; // the agent's plan
 import { currentSkills, skillBodyMessages, skillListingReminder, syncSkillTool } from "./skills.js"; // skill listing reminders + launched skill bodies
 import { pendingNotifications } from "./background.js"; // background tasks (Day 37): surface finished jobs as a turn
 import { consumeCronQueue, cronItemsPending, cronTriggerContent } from "./cron.js"; // cron scheduler (Day s14): scheduled, recurring work
+import { getGoal, updateGoalTool, runUpdateGoal, countGoalToolCall } from "./goal.js"; // /goal (Day 41): the model ends a durable goal with update_goal
 export const MAX_RETRIES = 10; // total failed API calls per query, across all rounds
 export const MAX_RATE_LIMIT_RETRIES = 3; // 429s get their own, much smaller budget
 export const MAX_CONSECUTIVE_FAILURES = 3; // the circuit breaker
@@ -44,6 +45,26 @@ export var TerminateReason;
     TerminateReason["FatalApiError"] = "fatal_api_error";
     TerminateReason["UserInterrupt"] = "user_interrupt";
 })(TerminateReason || (TerminateReason = {}));
+// The tool list of the last TOP-LEVEL model call. The next-prompt suggestion
+// (suggestion.ts) resends the same tools so its request shares the main
+// conversation's prefix — and the provider's prompt cache with it.
+let lastTopLevelTools = [];
+export const lastRequestTools = () => lastTopLevelTools;
+function rememberTools(opts, tools) {
+    if (!opts.subAgent)
+        lastTopLevelTools = tools;
+    return tools;
+}
+// Append a model turn or tool result to history AND tell the observer (stream-json).
+// Only these two kinds are streamed: injected user notes are the agent's own
+// plumbing, and compaction rewrites the array wholesale (context.ts) — tapping
+// messages.push itself would replay the entire history mid-stream. Sub-agents
+// inherit opts by spread, so they are filtered here: their turns are not ours.
+function record(messages, opts, message) {
+    messages.push(message);
+    if (!opts.subAgent && !opts.teammate)
+        opts.onMessage?.(message);
+}
 // Resolve the output sink for a loop: the caller's sink, or stdout (the old
 // behaviour) when none was passed. Centralised so every site reads the same way.
 function sink(opts) {
@@ -295,8 +316,13 @@ function toolsFor(opts) {
         return builtins.filter((t) => !(t.type === "function" && t.function.name === "todo_write"));
     }
     // The Lead can do everything: orchestration, the protocols, and authoring +
-    // watching the board (it lays out tasks; teammates pull from it).
-    return [...builtins, taskTool, askUserTool, spawnTeammateTool, sendMessageTool, requestShutdownTool, requestPlanTool, reviewPlanTool, createTaskTool, listTasksTool, ...(currentSession() ? [listPeersTool] : [])];
+    // watching the board (it lays out tasks; teammates pull from it). update_goal
+    // (Day 41) appears only once the user has set a /goal — no goal, nothing to end.
+    return [...builtins, taskTool, askUserTool, spawnTeammateTool, sendMessageTool, requestShutdownTool, requestPlanTool, reviewPlanTool, createTaskTool, listTasksTool, ...(currentSession() ? [listPeersTool] : []), ...(getGoal() ? [updateGoalTool] : [])];
+}
+// The names the top-level agent would be offered right now — stream-json's init line.
+export function topLevelToolNames() {
+    return toolsFor({}).flatMap((t) => (t.type === "function" ? [t.function.name] : []));
 }
 const pendingSubAgents = new Map();
 let subAgentSeq = 0;
@@ -456,7 +482,7 @@ opts) {
         // The tool manual depends on the agent kind (Lead / teammate / sub-agent)
         // — see toolsFor(). This is also where nested spawning is prevented: a
         // teammate's manual simply omits spawn_teammate and task.
-        { model: opts.model, messages: effortMessages(opts.model, messages), ...effortParameters(opts.model), tools: toolsFor(opts), stream: true, stream_options: { include_usage: true } }, { signal });
+        { model: opts.model, messages: effortMessages(opts.model, messages), ...effortParameters(opts.model), tools: rememberTools(opts, toolsFor(opts)), stream: true, stream_options: { include_usage: true } }, { signal });
         let content = ""; // accumulated answer text
         const calls = []; // tool calls under assembly, indexed by delta.index
         // Stash thinking without appending one indicator per model round. The live
@@ -571,6 +597,8 @@ async function runOneCall(call, opts) {
     const spinner = !opts.quiet && !opts.subAgent ? sink(opts).spinner(status()) : null;
     const timer = spinner ? setInterval(() => spinner.set(status()), 1000) : undefined;
     emit("agent_tool_call", { tool: call.name });
+    if (!opts.subAgent)
+        countGoalToolCall(); // a goal turn with zero tool calls pauses the goal (Day 41)
     try {
         const refusal = await authorizeCall(call, opts);
         const content = refusal ?? await runWithHooks(call, opts);
@@ -781,6 +809,14 @@ async function execute(call, opts) {
         return runClaimTask(call, opts);
     if (call.name === "complete_task")
         return runCompleteTask(call, opts);
+    // /goal (Day 41): loop-level because the verifier is a model call (needs the
+    // client) and reads the conversation. The goal is the user's — top-level only.
+    if (call.name === "update_goal") {
+        if (opts.subAgent || !opts.transcript)
+            return "[error] Only the top-level agent can end the goal.";
+        return runUpdateGoal(call.args, { client: opts.client, model: subAgentModelFor(opts), signal: opts.signal, transcript: opts.transcript, note: (line) => { if (!opts.quiet)
+                sink(opts).note(chalk.cyan(`  ${line}`)); } });
+    }
     if (call.name !== "task")
         return dispatch(call.name, call.args, opts.signal); // ordinary tools go through the registry (signal lets Ctrl+C kill run_bash)
     if (opts.subAgent)
@@ -1306,7 +1342,7 @@ export async function runLoop(messages, // conversation history (mutated in plac
 opts) {
     // Children inherit this snapshot. Later human turns cannot silently grant
     // broader authorization to already-running background work.
-    opts = { ...opts, reviewBudget: opts.reviewBudget ?? new AutoReviewBudget(), autoRequests: opts.autoRequests ?? opts.autoMode?.snapshot(), followUps: opts.subAgent ? undefined : opts.followUps };
+    opts = { ...opts, reviewBudget: opts.reviewBudget ?? new AutoReviewBudget(), autoRequests: opts.autoRequests ?? opts.autoMode?.snapshot(), followUps: opts.subAgent ? undefined : opts.followUps, transcript: opts.subAgent ? undefined : messages };
     const recordHumanInput = (text) => {
         opts.autoMode?.recordRequest(text);
         opts.autoRequests = [...(opts.autoRequests ?? []), text];
@@ -1428,13 +1464,13 @@ opts) {
             // partial text in history (clearly marked) so the next turn makes sense.
             if (opts.isInterrupted()) {
                 if (out.content)
-                    messages.push({ role: "assistant", content: out.content + "\n[interrupted by user]" }); // text only — partial tool calls must NOT go in (they would need paired results)
+                    record(messages, opts, { role: "assistant", content: out.content + "\n[interrupted by user]" }); // text only — partial tool calls must NOT go in (they would need paired results)
                 return { reason: TerminateReason.UserInterrupt };
             }
             attempts.consecutive = 0; // success resets the breaker — but never the total budget
             // Rebuild the assistant message from the assembled stream and add it to
             // history — tool results must stay paired with their calls.
-            messages.push({
+            record(messages, opts, {
                 role: "assistant", // the model's turn
                 content: out.content || null, // null when the turn was tool calls only
                 ...(out.reasoning !== undefined ? { reasoning_content: out.reasoning } : {}),
@@ -1498,7 +1534,7 @@ opts) {
                     // Resolve every outstanding tool ID BEFORE adding a user message.
                     // Unstarted actions came from the old intent and must be replanned.
                     for (const call of out.toolCalls.slice(i))
-                        messages.push({ role: "tool", tool_call_id: call.id, content: "[follow-up] Not executed: new user input arrived. Reconsider this action using the latest instructions." });
+                        record(messages, opts, { role: "tool", tool_call_id: call.id, content: "[follow-up] Not executed: new user input arrived. Reconsider this action using the latest instructions." });
                     receiveFollowUps();
                     break;
                 }
@@ -1509,12 +1545,12 @@ opts) {
                     // Run the whole read-only batch at once, preserving result order.
                     const results = await Promise.all(batch.map((c) => runOneCall(c, { ...opts, autoHistory: reviewHistory(messages, opts.autoHistory) })));
                     for (const r of results)
-                        messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
+                        record(messages, opts, { role: "tool", tool_call_id: r.id, content: r.content });
                     continue; // back to the top — the next call is non-read-only
                 }
                 // A single non-read-only call: gate, maybe ask, execute — all serial.
                 const r = await runOneCall(out.toolCalls[i++], { ...opts, autoHistory: reviewHistory(messages, opts.autoHistory) });
-                messages.push({ role: "tool", tool_call_id: r.id, content: r.content });
+                record(messages, opts, { role: "tool", tool_call_id: r.id, content: r.content });
             }
             // A launched skill's body arrives as its own user message, after ALL of
             // this round's tool results (the tool result itself only says "Launching

package/dist/permissions.js

@@ -617,6 +617,10 @@ function basePermission(toolName, argsJson, auto) {
             // Task board (Day 40) — bookkeeping on the internal board, not the user's
             // project. The actual work a claimed task drives still passes this gate.
             return { decision: "allow", reason: "task board, no project side effects", summary: toolName };
+        case "update_goal":
+            // /goal (Day 41) — ends the user's goal. Bookkeeping; the only command it
+            // runs is the user's own /goal --check, which the model cannot change.
+            return { decision: "allow", reason: "goal bookkeeping, runs only the user's own --check", summary: toolName };
         case "ask_user":
             // Asking the user a question has no side effects — it's the safest thing
             // the model can do. Never gate it behind an approval prompt.

package/dist/print.js

@@ -1,11 +1,79 @@
+import { randomUUID } from "node:crypto";
 export function formatPrintResult(format, data) {
     if (format === "text")
         return data.result.finalText ? `${data.result.finalText}\n` : "";
+    if (format === "stream-json")
+        return streamJsonResult(data);
     return JSON.stringify({ type: "result", is_error: data.result.reason !== "done", reason: data.result.reason,
         result: data.result.finalText ?? "", session_id: data.sessionId, model: data.model, effort: data.effort,
         usage: { input_tokens: data.usage.inputUncached + data.usage.inputCached, cached_input_tokens: data.usage.inputCached,
             output_tokens: data.usage.output, model_calls: data.usage.calls }, estimated_cost_usd: data.usage.cost }) + "\n";
 }
+// ---- stream-json: Claude Code's NDJSON event protocol -----------------------------
+// `claude -p --output-format stream-json` prints one JSON object per line:
+//   system/init  →  assistant / user (tool_result)  …  →  result
+// Tools that parse Claude's stream (SDK wrappers, CI dashboards, log viewers)
+// can read ours unchanged. Our history is OpenAI-shaped, so each message is
+// translated at the boundary: tool_calls become tool_use blocks, role:"tool"
+// becomes a user message carrying a tool_result, reasoning_content becomes a
+// thinking block. Tool NAMES stay ours (run_bash, not Bash) — they are what the
+// model actually called. Sub-agent turns are not streamed, so every event has
+// parent_tool_use_id: null.
+// Every line carries a fresh uuid and the session id, like Claude's.
+const event = (sessionId, body) => JSON.stringify({ ...body, session_id: sessionId, uuid: randomUUID() }) + "\n";
+// The first line: what this run is equipped with, before any model call.
+export function streamJsonInit(data) {
+    return event(data.sessionId, { type: "system", subtype: "init", cwd: process.cwd(), tools: data.tools,
+        mcp_servers: data.mcpServers, model: data.model, permissionMode: data.permissionMode });
+}
+// Our tool results mark failure with a bracketed prefix, not a flag.
+const TOOL_ERROR = /^\[(?:error|permission|hook|follow-up)\]/;
+// One history message → zero or more events. Claude emits one assistant event
+// per content block (sharing the message id), so consumers can render each
+// block as it lands; we do the same.
+export function streamJsonMessage(sessionId, model, message) {
+    if (message.role === "tool") {
+        const content = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
+        return event(sessionId, { type: "user", parent_tool_use_id: null, message: { role: "user",
+                content: [{ type: "tool_result", tool_use_id: message.tool_call_id, content, is_error: TOOL_ERROR.test(content) }] } });
+    }
+    if (message.role !== "assistant")
+        return "";
+    const blocks = [];
+    const reasoning = message.reasoning_content;
+    if (reasoning)
+        blocks.push({ type: "thinking", thinking: reasoning });
+    if (typeof message.content === "string" && message.content)
+        blocks.push({ type: "text", text: message.content });
+    for (const call of message.tool_calls ?? []) {
+        if (call.type !== "function")
+            continue;
+        // The model can emit malformed arguments; the stream must never throw over it.
+        let input;
+        try {
+            input = JSON.parse(call.function.arguments || "{}");
+        }
+        catch {
+            input = call.function.arguments;
+        }
+        blocks.push({ type: "tool_use", id: call.id, name: call.function.name, input });
+    }
+    const id = `msg_${randomUUID()}`;
+    const stopReason = message.tool_calls?.length ? "tool_use" : "end_turn";
+    return blocks.map((block) => event(sessionId, { type: "assistant", parent_tool_use_id: null, message: {
+            id, type: "message", role: "assistant", model, content: [block], stop_reason: stopReason, stop_sequence: null
+        } })).join("");
+}
+// The last line. Usage follows Anthropic's split (uncached input vs cache
+// reads), which differs from our `json` format's input_tokens (the total).
+function streamJsonResult(data) {
+    const ok = data.result.reason === "done";
+    return event(data.sessionId, { type: "result", subtype: ok ? "success" : "error_during_execution", is_error: !ok,
+        duration_ms: data.durationMs ?? 0, num_turns: data.numTurns ?? 0, result: data.result.finalText ?? "",
+        total_cost_usd: data.usage.cost, usage: { input_tokens: data.usage.inputUncached, cache_creation_input_tokens: 0,
+            cache_read_input_tokens: data.usage.inputCached, output_tokens: data.usage.output },
+        permission_denials: [], reason: data.result.reason });
+}
 // stdout is a protocol in print mode, even when an MCP startup or hook helper
 // logs directly. Reserve the original writer for the result and route all
 // incidental output to stderr. Only the CLI entry point installs this guard.

package/dist/session.js

@@ -1,5 +1,6 @@
 import fs from "node:fs"; // session files live on disk
 import path from "node:path"; // path joining
+import { getGoal } from "./goal.js"; // the /goal rides along in the session file (Day 41)
 // Sessions are project-local: .mini-agent/sessions/<id>.json under the cwd.
 // Project-local (not global) because a conversation is about a codebase —
 // resuming a refactor of project A from inside project B makes no sense.
@@ -27,6 +28,7 @@ export function saveSession(id, model, messages, title) {
         model, // informational — resume does not force the same model
         title: title ?? existing?.title, // a generated title sticks across saves
         messages: messages.filter((m) => m.role !== "system"), // the constitution is rebuilt fresh on resume (AGENT.md may have changed)
+        goal: getGoal() ?? undefined, // the live goal, snapshotted with the conversation it belongs to
     };
     const tmp = `${file}.tmp`; // write next to the destination (same filesystem → rename is atomic)
     fs.writeFileSync(tmp, JSON.stringify(data)); // the new snapshot
@@ -93,6 +95,7 @@ export function sessionTitle(messages) {
     const firstUser = messages.find((m) => m.role === "user");
     let text = typeof firstUser?.content === "string" ? firstUser.content : "";
     text = text.split("\n\n[Referenced files")[0]; // drop the @file attachment the REPL appended (Day 26)
+    text = text.match(/^\[goal\][^\n]*\nObjective: ([^\n]*)/)?.[1] ?? text; // a session started with /goal is named after its objective (Day 41)
     const line = text.replace(/\s+/g, " ").trim(); // flatten to one line
     return line || "(no prompt)";
 }

package/dist/suggestion.js

@@ -0,0 +1,55 @@
+import { effortMessages, effortProfile } from "./effort.js"; // same message shape as the main loop sends
+import { recordUsage } from "./cost.js"; // the suggestion call shows up in /cost like any other
+// ---- Next-prompt suggestion (Claude Code's prompt suggestion) -------------------
+// When a turn ends, guess what you'll type next and show it as a dim placeholder
+// in the empty input box: Tab turns it into real text, Enter sends it. It's
+// most useful at the obvious moments — "run the tests", "commit it", "yes, do
+// the same for the other file" — so the guess must be short and concrete, or
+// nothing at all.
+//
+// Cost: the request is the SAME history plus the SAME tools as the main call
+// that just finished, with one instruction appended. That shared prefix is
+// what the provider's prompt cache keys on (DeepSeek caches automatically),
+// so almost all of the input is billed at the cached rate. tool_choice "none"
+// keeps the tools in the prompt (cache) without letting the model call one.
+const SUGGESTION_TIMEOUT_MS = 15_000;
+const MAX_CHARS = 120;
+const SUGGESTION_PROMPT = `[Next-prompt suggestion — this message is from the app, not the user]
+Predict the user's NEXT message in this conversation: what they would most likely type now, given what just happened.
+- Write it AS THE USER, addressed to the assistant (e.g. "run the tests", "commit and push", "也改一下另一个文件").
+- Short and concrete: at most 12 words, or 30 characters for Chinese/Japanese. Same language the user writes in.
+- Only a natural next step the user would actually want. No questions about preferences, no thanks, no pleasantries.
+- If there is no clear next step, reply exactly: NONE
+Reply with ONLY the message text — no quotes, no explanation.`;
+// Keep only something that reads like a user's short next message. Anything
+// else — an answer, a plan, the assistant's own voice — is worse than nothing.
+export function cleanSuggestion(raw) {
+    let s = raw.trim().replace(/^["'“”「」`]+|["'“”「」`]+$/g, "").trim();
+    if (!s || /^none\.?$/i.test(s) || s.includes("\n"))
+        return null;
+    if (s.length > MAX_CHARS)
+        return null;
+    if (/^(i'll|i will|i've|i have|let me|sure|okay,? i|here's|the user)\b/i.test(s))
+        return null; // the assistant talking, not the user
+    if (/^(好的|我来|我会|我已经|用户)/.test(s))
+        return null;
+    s = s.replace(/\s+/g, " ");
+    return s;
+}
+export async function generatePromptSuggestion(client, model, messages, tools = [], signal) {
+    try {
+        const res = await client.chat.completions.create({
+            model, // the conversation's model: its cache holds this prefix
+            messages: [...effortMessages(model, messages), { role: "user", content: SUGGESTION_PROMPT }],
+            ...(tools.length ? { tools, tool_choice: "none" } : {}),
+            ...(effortProfile(model)?.parameter === "deepseek" ? { thinking: { type: "disabled" } } : {}), // a one-line guess needs no reasoning
+            max_tokens: 60,
+            stream: false,
+        }, { timeout: SUGGESTION_TIMEOUT_MS, signal });
+        recordUsage(res.usage);
+        return cleanSuggestion(res.choices?.[0]?.message?.content ?? "");
+    }
+    catch {
+        return null; // a failed guess is simply no guess
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-from-zero",
-  "version": "0.35.4",
+  "version": "0.35.6",
   "type": "module",
   "bin": {
     "mini-agent": "dist/agent.js"
@@ -17,7 +17,7 @@
     "auto:report": "tsx eval/auto-report.ts",
     "build": "tsc -p tsconfig.build.json",
     "prepare": "npm run build",
-    "test": "export MINI_AGENT_REVIEW_DEBUG=0 && tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/auto.test.ts && tsx tests/auto-context.test.ts && tsx tests/auto-providers.test.ts && tsx tests/auto-cascade.test.ts && tsx tests/auto-rules.test.ts && tsx tests/auto-rule-cascade.test.ts && tsx tests/auto-debug.test.ts && tsx tests/auto-report.test.ts && tsx tests/auto-clarification.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/cli.test.ts && tsx tests/print.test.ts && tsx tests/status.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/mcp-oauth.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/title.test.ts && tsx tests/ui.test.ts && tsx tests/activity.test.ts && tsx tests/follow-up.test.ts && tsx tests/follow-up-ui.test.tsx && tsx tests/agents.test.ts && tsx tests/images.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/effort.test.ts && tsx tests/completion.test.ts && tsx tests/pasted-text.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/peers.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts && tsx tests/cron.test.ts"
+    "test": "export MINI_AGENT_REVIEW_DEBUG=0 && tsx tests/tools.test.ts && tsx tests/permissions.test.ts && tsx tests/context.test.ts && tsx tests/hooks.test.ts && tsx tests/mcp.test.ts && tsx tests/judge.test.ts && tsx tests/auto.test.ts && tsx tests/auto-context.test.ts && tsx tests/auto-providers.test.ts && tsx tests/auto-cascade.test.ts && tsx tests/auto-rules.test.ts && tsx tests/auto-rule-cascade.test.ts && tsx tests/auto-debug.test.ts && tsx tests/auto-report.test.ts && tsx tests/auto-clarification.test.ts && tsx tests/memory.test.ts && tsx tests/cost.test.ts && tsx tests/cli.test.ts && tsx tests/print.test.ts && tsx tests/status.test.ts && tsx tests/validate.test.ts && tsx tests/plan.test.ts && tsx tests/diff.test.ts && tsx tests/undo.test.ts && tsx tests/tiering.test.ts && tsx tests/mcp-http.test.ts && tsx tests/mcp-oauth.test.ts && tsx tests/changes.test.ts && tsx tests/mentions.test.ts && tsx tests/session.test.ts && tsx tests/title.test.ts && tsx tests/ui.test.ts && tsx tests/activity.test.ts && tsx tests/follow-up.test.ts && tsx tests/follow-up-ui.test.tsx && tsx tests/agents.test.ts && tsx tests/images.test.ts && tsx tests/approval.test.ts && tsx tests/form.test.ts && tsx tests/model.test.ts && tsx tests/reasoning.test.ts && tsx tests/effort.test.ts && tsx tests/completion.test.ts && tsx tests/pasted-text.test.ts && tsx tests/skills.test.ts && tsx tests/markdown.test.ts && tsx tests/editor.test.ts && tsx tests/todos.test.ts && tsx tests/background.test.ts && tsx tests/team.test.ts && tsx tests/peers.test.ts && tsx tests/suggestion.test.ts && tsx tests/board.test.ts && tsx tests/drop.test.ts && tsx tests/editline.test.ts && tsx tests/cron.test.ts && tsx tests/goal.test.ts"
   },
   "engines": {
     "node": ">=20.6"