agent-from-zero 0.37.0 → 0.39.1

package/README.md

@@ -49,7 +49,7 @@ export DEEPSEEK_API_KEY=sk-你的key
 
 ### 配置审核模型 judge.model
 
-开启 auto 模式（会话里输入 `/auto`，或启动时加 `--auto`）后，每个需要审批的工具调用会先交给一个审核模型判断：安全的直接执行，有风险或拿不准的仍然问你。审核模型只有两种选择：
+开启 auto 模式（会话里输入 `/auto`，或启动时加 `--auto`）后，每个需要审批的工具调用会先交给一个审核模型判断：安全的直接执行；看不出是你要求的，先退回给 agent，让它换个做法或用表单问你（同一个任务里连续 3 次、累计 20 次还卡住，才弹给你）；你要求了但做了就回不去的（比如删掉 git 恢复不了的文件），弹出来让你确认。审核模型只有两种选择：
 
 1. **主 agent 用的模型**（默认）：和主 agent 共用同一个 API key 和 base URL。没配 `judge.model` 就直接用主 agent 当前的模型。
 2. **Jev**：配好 Jev 的 key 后自动优先用它（见下一节）。
@@ -85,6 +85,18 @@ export TYPESAFE_API_KEY=你的key
 }
 ```
 
+### 信任项目外的目录
+
+auto 模式下，改当前项目、其他 git 仓库或临时目录里的文件不用审批，其他地方的文件每次都要你确认。经常要改的目录（比如全局 skills 目录）可以写进**全局** settings（`~/.config/mini-agent/settings.json`），写在项目级 settings 里不生效：
+
+```json
+{
+  "autoMode": { "trustedDirs": ["~/.config/mini-agent/skills"] }
+}
+```
+
+也可以在确认弹窗里选 "Yes, and trust …/ for this session"，只对本次会话有效。家目录本身和 `/` 不能被信任，`settings.json` 本身永远要你确认。
+
 ### 换别的模型
 
 和 API key 放在同一个地方，设置这三个变量就行，各家的 base URL 写在 [.env.example](.env.example) 里：
@@ -121,6 +133,21 @@ export MINI_AGENT_MODEL=gpt-4.1-mini
 
 生成预测要多调一次模型，但请求内容和刚结束的主调用相同，只在最后加了一条指令，所以基本都能命中 DeepSeek 的前缀缓存，费用很低，也会算进 `/cost`。定时任务和其他实例发来的消息触发的回合不做预测。不想要可以在 `settings.json` 里设 `"promptSuggestions": false`，或者单次运行时设环境变量 `MINI_AGENT_PROMPT_SUGGESTIONS=0`。
 
+### 结果汇报、定时任务和长任务
+
+每轮结束时，agent 都会给一段一眼能看懂的结果：第一行先说结论，没别的要说就到此为止（比如“没有告警，一切正常”）；有问题的话，分段列出要点，每个问题写清楚是什么、在哪、有什么影响，以及需要你决定的事。
+
+定时任务（直接跟 agent 说“每 30 分钟查一次 prod 告警”就能建，`/cron` 查看）每次执行完也按这个格式汇报。因为执行时你多半不在旁边，执行完终端会响一声，标签页会闪几下。
+
+长任务：
+
+- `run_bash` 前台命令默认 2 分钟超时，agent 预计会跑很久时可以把超时设到最多 10 分钟。
+- 更久的任务，或者不需要等它跑完的任务，交给后台（`run_bash_background`）或子 agent。它们跑完时如果 agent 已经停下来了，会自动开一轮，把结果交给 agent 接着处理，不用等你下一次发消息。`/bg` 可以查看后台任务。
+
+### 需要你选择时
+
+agent 需要你做决定时会弹出一个表单，和 Claude Code 的一样：每个问题一个标签页，←/→ 或 Tab 切换，↑/↓ 选择，Enter 确定。每个选项下面有说明；可以多选的问题用 `[✔]` 勾选；选项里没有合适的，选 “Type something” 直接输入；想先聊聊再决定，选 “Chat about this”。最后一页汇总所有回答，确认后提交。表单打开时也可以直接在输入框打字，按 Enter 就作为一条新消息发出去。
+
 ### 多开实例互相通信
 
 在几个终端里各开一个 mini-agent（比如一个在后端仓库、一个在前端仓库），它们会自动互相发现，不用配置。

package/dist/agent.js

@@ -21,7 +21,7 @@ import { parseCli, applyCliOptions, readPrintPrompt, CliUsageError } from "./cli
 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
+import { approvalMenu, isPlanMode, setPlanMode } from "./permissions.js"; // plan mode: research-only until the user approves a plan; the shared approval menu
 import { undoLast, clearUndo, sessionChanges } from "./undo.js"; // /undo + /diff: take back, or review, this session's writes
 import { clearTodos, getTodos, renderTodos } from "./todos.js"; // the agent's plan: /todos to view, cleared with the conversation
 import { renderDiff } from "./diff.js"; // show what /undo put back / what /diff changed, reusing the Day 21 diff renderer
@@ -442,7 +442,7 @@ async function main() {
     // Fail closed: in a non-interactive session nobody can say yes, so the
     // answer is no. MINI_AGENT_AUTO_APPROVE=1 bypasses the QUESTION, but hard
     // denies were already enforced in permissions.ts before we get here.
-    const confirm = async (question, toolName) => {
+    const confirm = async (question, toolName, trustDir) => {
         console.log(chalk.yellow(`\n⚠ approval needed — ${question}`)); // always show what is being asked
         if (!autoMode.enabled && process.env.MINI_AGENT_AUTO_APPROVE === "1") {
             console.log(chalk.dim("  auto-approved (MINI_AGENT_AUTO_APPROVE=1)")); // bypass mode — say so out loud
@@ -453,15 +453,12 @@ async function main() {
             return false; // fail closed
         }
         // Selecting beats typing: ↑/↓ + Enter instead of "type y/N". The middle
-        // option lets the user stop being asked about this tool for the session.
-        const allowLabel = toolName ? `Yes, and don't ask again for ${toolName} this session` : "Yes, and don't ask again this session";
-        const options = autoMode.enabled ? ["Yes, once", "No — let me tell the agent what to do instead"] : ["Yes", allowLabel, "No — let me tell the agent what to do instead"];
-        const choice = await select(options);
-        const approved = choice === 0 || (!autoMode.enabled && choice === 1);
-        if (!autoMode.enabled && choice === 1 && toolName) {
-            CONFIG.permissions.allow.push(`tool:${toolName}`); // remember the grant for the rest of the session
-            console.log(chalk.dim(`  won't ask again for ${toolName} this session`));
-        }
+        // option lets the user stop being asked about this tool (or, in auto mode,
+        // this outside directory) for the session.
+        const menu = approvalMenu(autoMode.enabled, toolName, trustDir);
+        const { approved, granted } = menu.choose(await select(menu.options));
+        if (granted)
+            console.log(chalk.dim(`  ${granted}`));
         console.log(approved ? chalk.green("  ✓ approved") : chalk.yellow("  ✗ declined"));
         return approved;
     };
@@ -535,6 +532,9 @@ async function main() {
         }
         apply(models[choice]); // picker is session-only too; "/model save <name>" to persist
     };
+    // The login link for /mcp auth. This REPL waits on the login, so a browser on
+    // another machine (SSH) gets its redirect here through curl, run on this one.
+    const showAuthUrl = (url) => console.log(chalk.dim(`authenticate in your browser: ${url}\n  browser on another machine (SSH)? after authorizing, run here in another terminal: curl '<the address it lands on>'`));
     // /mcp — list configured MCP servers + status, then manage one (like Claude Code).
     const mcpStatusText = (status) => status === "connected" ? chalk.green("connected") : status === "needs-auth" ? chalk.yellow("needs auth") : status === "failed" ? chalk.red("failed") : status === "pending" ? chalk.dim("connecting…") : chalk.dim("disabled");
     const handleMcpCommand = async (arg) => {
@@ -549,7 +549,7 @@ async function main() {
             const name = parts.slice(1).join(" ");
             const action = MCP_SUBCOMMANDS[parts[0]];
             try {
-                console.log(chalk.dim(await runMcpAction(name, action, (url) => console.log(chalk.dim(`authenticate in your browser: ${url}`)))));
+                console.log(chalk.dim(await runMcpAction(name, action, showAuthUrl)));
             }
             catch (err) {
                 console.log(chalk.yellow(err.message));
@@ -581,7 +581,7 @@ async function main() {
             return;
         }
         try {
-            console.log(chalk.dim(await runMcpAction(server.name, actions[actionChoice].action, (url) => console.log(chalk.dim(`authenticate in your browser: ${url}`)))));
+            console.log(chalk.dim(await runMcpAction(server.name, actions[actionChoice].action, showAuthUrl)));
         }
         catch (err) {
             console.log(chalk.yellow(err.message));

package/dist/auto-budget.js

@@ -1,14 +1,21 @@
 // One object per root task, shared by descendants and interrupt/resume. An
 // exhausted budget is sticky: a late successful worker cannot reopen the gate.
+// Claude Code's denial limits: 3 in a row or 20 per task. Rules-policy denials
+// stop the task there; score-policy doubts returned to the agent instead turn
+// back into human prompts (escalated) until an action executes again.
 export class AutoReviewBudget {
     consecutive = 0;
     total = 0;
     stopped = false;
     get exhausted() { return this.stopped; }
+    get escalated() { return this.consecutive >= 3 || this.total >= 20; }
     deny() {
+        this.block();
+        this.stopped ||= this.escalated;
+    }
+    block() {
         this.total++;
         this.consecutive++;
-        this.stopped ||= this.consecutive >= 3 || this.total >= 20;
     }
     executed() { if (!this.stopped)
         this.consecutive = 0; }

package/dist/auto-context.js

@@ -51,7 +51,7 @@ export function reviewHistory(messages, inherited) {
                 continue;
             const result = results.get(call.id);
             actions.push({ callId: call.id, tool: call.function.name, input: projectInput(call.function.name, call.function.arguments),
-                outcome: /^\[permission\] Auto-denied/.test(result) ? "auto_denied" : /^\[follow-up\]/.test(result) ? "skipped" : /^\[(?:permission|hook)\]/.test(result) ? "denied" : /^\[error\]/.test(result) ? "failed" : "returned", ...resultEvidence(result) });
+                outcome: /^\[permission\] Auto-(?:denied|blocked)/.test(result) ? "auto_denied" : /^\[follow-up\]/.test(result) ? "skipped" : /^\[(?:permission|hook)\]/.test(result) ? "denied" : /^\[error\]/.test(result) ? "failed" : "returned", ...resultEvidence(result) });
         }
     }
     let bytes = 0;

package/dist/auto-review.js

@@ -50,14 +50,19 @@ export function needsAuthorizationReview(assessment) {
 }
 // The ONLY semantic allow/ask decision. Boolean answers are categorical and keep
 // that representation in the UI. An invalid provider result can never approve.
+// Which dimension failed decides who hears the ask: a doubt about authorization
+// goes back to the agent (it can drop the step or ask the user), while risk with
+// clear authorization is irreversible work the user requested, so the human
+// confirms it.
 export function decideReview(assessment) {
     const { authorized, risky } = assessment;
     if (!valid(authorized) || !valid(risky))
         return { decision: "ask", reason: "Invalid review assessment" };
-    const allow = (typeof authorized === "boolean" ? authorized : authorized >= MIN_AUTHORIZATION)
-        && (typeof risky === "boolean" ? !risky : risky <= MAX_RISK);
+    const requested = typeof authorized === "boolean" ? authorized : authorized >= MIN_AUTHORIZATION;
+    const allow = requested && (typeof risky === "boolean" ? !risky : risky <= MAX_RISK);
     const format = (value) => typeof value === "boolean" ? (value ? "yes" : "no") : value.toFixed(3);
-    return { decision: allow ? "allow" : "ask", reason: `authorization=${format(authorized)}, risk=${format(risky)}${allow ? " — auto-approved" : " — human review required"}` };
+    const outcome = allow ? " — auto-approved" : requested ? " — human review required" : " — not clearly requested";
+    return { decision: allow ? "allow" : "ask", ...(requested ? {} : { unauthorized: true }), reason: `authorization=${format(authorized)}, risk=${format(risky)}${outcome}` };
 }
 // The score policy above remains a deliberate rollout fallback. Rules v1 has
 // no authorization/risk cutoffs: providers report facts, this resolver owns the

package/dist/auto.js

@@ -107,7 +107,8 @@ export class AutoMode {
     status() {
         if (CONFIG.bypassPermissions)
             return "(bypassPermissions — approvals and AI review skipped for this run; hard denies, plan restrictions and hooks still apply)";
-        return `(auto mode ${this.enabled ? "ON" : "OFF"} — ${this.backend}; ${this.enabled ? "uncertain or risky actions require approval" : "use /auto to enable"})`;
+        const enabled = this.policy === "rules" ? "uncertain or risky actions require approval" : "irreversible actions require approval; unrequested ones go back to the agent first";
+        return `(auto mode ${this.enabled ? "ON" : "OFF"} — ${this.backend}; ${this.enabled ? enabled : "use /auto to enable"})`;
     }
     async classify(tool, argsJson, userRequests, signal, options = {}) {
         if (this.policy === "rules")

package/dist/background.js

@@ -1,9 +1,9 @@
 // ============ Background tasks (Day 37) ============
-// The problem: run_bash blocks. A command that takes longer than its 30s
-// watchdog (npm install, a full test run, a build) is SIGKILLed before it
-// finishes, and even a 25s one freezes the agent — we sit idle, paying for
-// tokens we aren't using, while a child process churns. The model cannot think
-// and wait at the same time.
+// The problem: run_bash blocks. A command that takes longer than its watchdog
+// (2 minutes by default, 10 at most) is SIGKILLed before it finishes, and even
+// a shorter slow one (npm install, a full test run, a build) freezes the agent:
+// we sit idle, paying for tokens we aren't using, while a child process churns.
+// The model cannot think and wait at the same time.
 //
 // The fix, mirroring Claude Code: a command can be sent to the BACKGROUND. We
 // spawn it, hand the model a task id immediately, and let the loop keep going.
@@ -34,7 +34,7 @@ function append(task, chunk) {
 }
 // Start a command in the background. Returns its task id immediately — the
 // command keeps running after this returns. Note the deliberate omissions vs
-// run_bash: NO 30s timeout (the whole point is to outlive it) and NO turn
+// run_bash: NO timeout (the whole point is to outlive it) and NO turn
 // AbortSignal (Ctrl+C interrupts the current turn, but a background job is meant
 // to survive into later turns; only killAll, on session exit, stops them).
 export function startBackground(command) {
@@ -107,6 +107,11 @@ export function pendingNotifications() {
     // something it must echo. Tell it plainly that a job it started has finished.
     return `A background task you started has finished. Read the notification, then continue.\n\n${done.join("\n\n")}`;
 }
+// Has a task finished whose notification has not been delivered yet? Lets an
+// idle frontend wake the agent without consuming the notification itself.
+export function hasPendingNotifications() {
+    return [...tasks.values()].some((task) => task.status !== "running" && !task.notified);
+}
 // Read a background task's current state for the bash_output tool. Returns only
 // the output PRODUCED SINCE THE LAST POLL (like Claude Code's BashOutput), so
 // the model can watch a long job without re-reading the whole log each time.

package/dist/config.js

@@ -134,6 +134,11 @@ export const CONFIG = {
         policy: (process.env.MINI_AGENT_AUTO_POLICY ?? projectSettings.autoMode?.policy ?? globalSettings.autoMode?.policy ?? "scores") === "rules" ? "rules" : "scores",
         enabled: process.env.MINI_AGENT_AUTO_MODE !== undefined ? process.env.MINI_AGENT_AUTO_MODE === "1" : (projectSettings.autoMode?.enabled ?? globalSettings.autoMode?.enabled ?? false),
         model: projectSettings.autoMode?.model || globalSettings.autoMode?.model || "jev-1.13.0",
+        // GLOBAL settings only: a cloned repo's settings must never extend auto
+        // mode's write reach into your home. "Trust this directory" in the approval
+        // menu appends here for the rest of the session.
+        trustedDirs: (globalSettings.autoMode?.trustedDirs ?? []).filter((dir) => typeof dir === "string" && dir.trim())
+            .map((dir) => path.resolve(dir.replace(/^~(?=$|\/)/, os.homedir()))),
     },
     // Token prices for the /cost estimate (defaults applied in cost.ts). Project
     // overrides global; either may set just the fields it cares about.

package/dist/cron.js

@@ -162,15 +162,19 @@ export function listJobs() {
 // Shared by both consumers — the in-turn one (injectCronMessages in loop.ts, for
 // a job that fires mid-task) and the idle one (the REPL's idle processor, for a
 // job that fires while the user is at the prompt) — so they behave identically.
+// The report is the run's summary: the user was not watching, so a quiet run is
+// one line and anything wrong is laid out point by point (a prod-alert monitor:
+// "No alerts — all normal.", or each alert with what, where and impact).
 export function cronTriggerContent(job) {
     return [
         `[Cron job "${job.id}" triggered — ${job.cron}]`,
         ``,
         `${job.prompt}`,
         ``,
-        `Execute this now. When done, report the result directly to the user — make it visible and clear.`,
-        `If the task produces output (e.g. a shell command result, a file change, a value), show it.`,
-        `If there's nothing to show, confirm success with one line.`,
+        `Execute this now, then report to the user, who was not watching. Write the report in the language of the task above:`,
+        `- Nothing needs attention: ONE line that says so, e.g. "没有告警，一切正常。" / "No alerts — all normal."`,
+        `- Otherwise: first line the outcome, then bullet points under short bold labels — each problem with what, where and impact, then anything the user must decide or do.`,
+        `- Quote exact values (counts, names, error lines), never a raw log dump.`,
         ``,
         `After this, return to idle — do NOT start additional work unless the user asked for a chain of follow-ups.`,
     ].join("\n");

package/dist/form.js

@@ -1,80 +1,155 @@
 import chalk from "chalk"; // rendering only
-// The cursor walks a flat list of options. Multiple questions add a submit row;
-// with one question, explicitly choosing an option submits it immediately.
-export function formRowCount(questions) {
-    return questions.reduce((n, q) => n + q.options.length, 0) + (questions.length > 1 ? 1 : 0);
+export function formRows(questions, tab) {
+    const q = questions[tab];
+    if (!q)
+        return [{ kind: "submit" }, { kind: "cancel" }];
+    return [
+        ...q.options.map((_, index) => ({ kind: "option", index })),
+        { kind: "typed" },
+        ...(q.multiSelect ? [{ kind: "next" }] : []),
+        { kind: "chat" },
+    ];
 }
-// Map a flat cursor to either a question/option, or the submit row.
-export function rowAt(questions, cursor) {
-    let i = cursor;
-    for (let q = 0; q < questions.length; q++) {
-        if (i < questions[q].options.length)
-            return { q, opt: i };
-        i -= questions[q].options.length;
-    }
-    return { submit: true };
+export function initFormState(questions) {
+    return { tab: 0, cursor: 0, picked: questions.map(() => []), typed: questions.map(() => "") };
 }
-// The flat cursor position of a question's first option — used to jump the
-// cursor to the first unanswered question when the user tries to submit early.
-function cursorForQuestion(questions, q) {
-    let c = 0;
-    for (let i = 0; i < q; i++)
-        c += questions[i].options.length;
-    return c;
+// Is the cursor on a "Type something" row? The drivers route typed keys into
+// their line editor there (and load / clear it as the cursor arrives / leaves).
+export function onTypedRow(questions, state) {
+    return formRows(questions, state.tab)[state.cursor]?.kind === "typed";
 }
-export function initFormState(questions) {
-    return { cursor: 0, selections: questions.map(() => -1) }; // nothing chosen yet
+const answered = (state, q) => state.picked[q].length > 0;
+// Land on a tab with the cursor on its first chosen option, or at the top.
+function goToTab(state, tab) {
+    return { ...state, tab, cursor: Math.max(0, state.picked[tab]?.[0] ?? 0) };
 }
-// The one transition function. Returns the next state, and `done: true` only
-// when the user submits with every question answered.
-export function reduceForm(questions, state, action) {
-    const rows = formRowCount(questions);
-    if (action === "up")
-        return { state: { ...state, cursor: Math.max(0, state.cursor - 1) } };
-    if (action === "down")
-        return { state: { ...state, cursor: Math.min(rows - 1, state.cursor + 1) } };
-    // select (Enter / Space)
-    const row = rowAt(questions, state.cursor);
-    if ("submit" in row) {
-        const firstUnanswered = state.selections.findIndex((s) => s < 0);
-        if (firstUnanswered < 0)
-            return { state, done: true }; // all answered → submit for real
-        return { state: { ...state, cursor: cursorForQuestion(questions, firstUnanswered) } }; // nudge to the gap
+// The one transition function. `text` is what the driver's editor holds while
+// the cursor is on a "Type something" row; it is stored as that question's
+// typed answer before the action runs, so leaving the row keeps it. Returns the
+// next state, and an `outcome` when the form is finished.
+export function reduceForm(questions, state, action, text) {
+    const single = questions.length === 1; // no tabs, no review: picking submits
+    let s = { ...state, picked: state.picked.map((p) => p.slice()), typed: state.typed.slice() };
+    const q = questions[s.tab];
+    const typedIndex = q?.options.length ?? -1;
+    if (q && text !== undefined && onTypedRow(questions, s)) {
+        s.typed[s.tab] = text.trim();
+        // A multi-select typed answer counts as checked exactly while it has text.
+        if (q.multiSelect)
+            s.picked[s.tab] = s.picked[s.tab].filter((i) => i !== typedIndex).concat(s.typed[s.tab] ? [typedIndex] : []);
+    }
+    const rows = formRows(questions, s.tab);
+    const advance = () => single ? (answered(s, 0) ? { state: s, outcome: "submit" } : { state: s }) : { state: goToTab(s, s.tab + 1) };
+    switch (action) {
+        case "up":
+            return { state: { ...s, cursor: Math.max(0, s.cursor - 1) } };
+        case "down":
+            return { state: { ...s, cursor: Math.min(rows.length - 1, s.cursor + 1) } };
+        case "left":
+        case "right":
+            if (single)
+                return { state: s };
+            return { state: goToTab(s, Math.min(questions.length, Math.max(0, s.tab + (action === "left" ? -1 : 1)))) };
+        case "escape":
+            return { state: s, outcome: "cancel" };
     }
-    const selections = state.selections.slice();
-    selections[row.q] = row.opt; // set this question's answer (single-select)
-    return { state: { ...state, selections }, ...(questions.length === 1 ? { done: true } : {}) };
+    // enter
+    const row = rows[s.cursor];
+    switch (row?.kind) {
+        case "option":
+            if (q.multiSelect) {
+                const on = s.picked[s.tab].includes(row.index);
+                s.picked[s.tab] = on ? s.picked[s.tab].filter((i) => i !== row.index) : [...s.picked[s.tab], row.index].sort((a, b) => a - b);
+                return { state: s };
+            }
+            s.picked[s.tab] = [row.index];
+            return advance();
+        case "typed":
+            if (!s.typed[s.tab])
+                return { state: s }; // nothing typed yet
+            if (q.multiSelect)
+                return { state: { ...s, cursor: s.cursor + 1 } }; // checked by having text; move on to Next/Submit
+            s.picked[s.tab] = [typedIndex];
+            return advance();
+        case "next":
+            return advance();
+        case "chat":
+            return { state: s, outcome: "chat" };
+        case "submit": {
+            const gap = questions.findIndex((_, i) => !answered(s, i));
+            return gap < 0 ? { state: s, outcome: "submit" } : { state: goToTab(s, gap) }; // jump to what is still open
+        }
+        case "cancel":
+            return { state: s, outcome: "cancel" };
+    }
+    return { state: s };
+}
+// One question's answer: chosen labels in option order, the typed answer last.
+function answerText(q, state, i) {
+    return state.picked[i].map((p) => (p === q.options.length ? state.typed[i] : q.options[p]?.label ?? "")).filter(Boolean).join(", ");
 }
 // Turn a completed form into question→answer pairs for the model.
 export function collectAnswers(questions, state) {
-    return questions.map((q, i) => ({ question: q.question, answer: q.options[state.selections[i]] ?? "(unanswered)" }));
+    return questions.map((q, i) => ({ question: q.question, answer: answerText(q, state, i) || "(unanswered)" }));
 }
-const FORM_HINT = chalk.dim("↑↓ to move · Enter to choose / submit · Esc to cancel");
-// Render the whole form: each question with radio-style options, the cursor on
-// one row, then a submit row. Line count is constant for a given question set
-// (selections don't add/remove lines), which is what lets the driver redraw in
-// place by moving the cursor up a fixed number of lines.
-export function renderForm(questions, state) {
-    const lines = ["The agent needs your input:", ""];
-    let flat = 0;
-    questions.forEach((q, qi) => {
-        lines.push(chalk.bold(`${qi + 1}. ${q.question}`));
-        q.options.forEach((opt, oi) => {
-            const onCursor = state.cursor === flat;
-            const chosen = state.selections[qi] === oi;
-            const text = `${chosen ? "●" : "○"} ${opt}`; // filled radio = chosen
-            lines.push(onCursor ? chalk.cyan.bold(`❯ ${text}`) : chosen ? chalk.cyan(`  ${text}`) : chalk.dim(`  ${text}`));
-            flat++;
-        });
-        lines.push("");
-    });
-    const onSubmit = state.cursor === flat; // the submit row is last
-    const allAnswered = state.selections.every((s) => s >= 0);
-    const submitText = allAnswered ? "▶ Submit answers" : "▶ Submit answers (answer every question first)";
+// The footer: what the keys do right now.
+export function formHint(questions, state) {
+    if (onTypedRow(questions, state))
+        return "Type your answer · Enter to use it · ↑/↓ to move · Esc to cancel";
+    return `Enter to select · ↑/↓ to move${questions.length > 1 ? " · ←/→ or Tab to switch questions" : ""} · Esc to cancel`;
+}
+// Render the current tab. `live` is the driver's editor text, shown on the
+// "Type something" row while the cursor is on it.
+export function renderForm(questions, state, live) {
+    const lines = [];
     if (questions.length > 1) {
-        lines.push(onSubmit ? chalk.green.bold(`❯ ${submitText}`) : chalk.dim(`  ${submitText}`));
-        lines.push("");
+        const tabs = questions.map((q, i) => {
+            const label = ` ${answered(state, i) ? "☒" : "☐"} ${q.header || `Q${i + 1}`} `;
+            return i === state.tab ? chalk.inverse(label) : label;
+        });
+        const submit = state.tab === questions.length ? chalk.inverse(" ✔ Submit ") : " ✔ Submit ";
+        lines.push(`${chalk.dim("←")}${[...tabs, submit].join("")}${chalk.dim("→")}`, "");
+    }
+    const rows = formRows(questions, state.tab);
+    const mark = (i, text) => (i === state.cursor ? chalk.cyan(`❯ ${text}`) : `  ${text}`);
+    const q = questions[state.tab];
+    if (!q) {
+        // The review tab: every question with its answer, then Submit / Cancel.
+        lines.push(chalk.bold("Review your answers"), "");
+        questions.forEach((qq, i) => {
+            const answer = answerText(qq, state, i);
+            lines.push(` ● ${qq.question}`, answer ? chalk.green(`   → ${answer}`) : chalk.yellow("   → (not answered)"));
+        });
+        lines.push("", chalk.dim("Ready to submit your answers?"), "");
+        rows.forEach((row, i) => lines.push(mark(i, `${i + 1}. ${row.kind === "submit" ? "Submit answers" : "Cancel"}`)));
+    }
+    else {
+        lines.push(chalk.bold(q.question), "");
+        const typedIndex = q.options.length;
+        rows.forEach((row, i) => {
+            const box = (on) => (q.multiSelect ? (on ? chalk.green("[✔] ") : "[ ] ") : "");
+            if (row.kind === "option") {
+                const option = q.options[row.index];
+                const on = state.picked[state.tab].includes(row.index);
+                const label = !q.multiSelect && on ? chalk.green(`${option.label} ✔`) : option.label;
+                lines.push(mark(i, `${row.index + 1}. ${box(on)}${label}`));
+                if (option.description)
+                    lines.push(chalk.dim(`     ${q.multiSelect ? "    " : ""}${option.description}`));
+            }
+            else if (row.kind === "typed") {
+                const text = i === state.cursor && live !== undefined ? live : state.typed[state.tab];
+                const on = state.picked[state.tab].includes(typedIndex);
+                const shown = text ? (!q.multiSelect && on ? chalk.green(`${text} ✔`) : text) : chalk.dim("Type something");
+                lines.push(mark(i, `${typedIndex + 1}. ${box(on)}${shown}`));
+            }
+            else if (row.kind === "next") {
+                lines.push(mark(i, `   ${questions.length > 1 && state.tab < questions.length - 1 ? "Next" : "Submit"}`));
+            }
+            else if (row.kind === "chat") {
+                lines.push(chalk.dim("  ─────"), mark(i, `${typedIndex + 2}. Chat about this`));
+            }
+        });
     }
-    lines.push(FORM_HINT);
+    lines.push("", chalk.dim(formHint(questions, state)));
     return lines.join("\n");
 }