amness 0.1.2 → 0.1.4

package/dist/cli/tui/cards.js

@@ -123,7 +123,8 @@ export function renderBlock(b, c) {
     // ---------------------------------------------------------------- tool card
     const sub = !!b.agent && b.agent !== "lead", failed = b.status === "fail", edit = b.edit;
     const hue = failed ? t.err : ({ read_file: t.tool.read, list_files: t.tool.read, grep: t.tool.read, write_file: t.tool.edit, edit_file: t.tool.edit, apply_patch: t.tool.edit, sh: t.tool.shell, web_search: t.tool.web, fetch_url: t.tool.web, memory_save: t.tool.memory, memory_forget: t.tool.memory, memory_search: t.tool.read, todo_write: t.tool.plan, exit_plan_mode: t.tool.plan, task: t.tool.explore })[b.name] ?? (b.name.includes("__") ? t.tool.web : t.tool.generic);
-    const expanded = c.expandAll ? true : b.expanded ?? (!!edit || failed);
+    const expanded = c.expandAll ? true : b.expanded ?? (!!edit || failed || (!!c.last && !sub && b.name !== "read_file" && b.name !== "task"));
+    const preview = !c.expandAll && b.expanded === undefined && !edit && !failed && !!c.last && b.name !== "read_file" && b.name !== "task"; // opened automatically, not by the user: show a short preview only
     const bg = failed ? mix(t.surface, t.err, 0.14) : t.surface, spinner = SPIN[c.frame % SPIN.length];
     const label = BOLD(F(failed ? t.err : t.text, toolLabel(b.name))), args = F(t.dim, argSummary(b.name, b.args));
     const status = b.status === "running"
@@ -163,7 +164,7 @@ export function renderBlock(b, c) {
         }
         else {
             const res = b.result ?? "", hl = (k, s) => F(k === "plain" ? t.syn.plain : t.syn[k], s);
-            let lines = res.split("\n"), cap = c.expandAll ? 200 : 60;
+            let lines = res.split("\n"), cap = c.expandAll ? 200 : preview ? 20 : 60;
             if (b.name === "sh") {
                 let cmd = "";
                 try {
@@ -191,7 +192,7 @@ export function renderBlock(b, c) {
                         body(w); // only the lines that look like errors are red
             }
             if (lines.length > cap)
-                body(F(t.faint, `… ${lines.length - cap} more lines (ctrl+o expands everything)`));
+                body(F(t.faint, `… ${lines.length - cap} more line${lines.length - cap === 1 ? "" : "s"} · /output shows all of it${preview ? "" : " · ctrl+o expands everything"}`));
         }
     }
     return done();

package/dist/cli/tui/commands.js

@@ -3,8 +3,10 @@ import { relatives } from "./session.js";
 import { SHELL_CHOICES, STRATEGIES, chooseShell, currentShell, loadPrompts, setShell, shellFallbackNote } from "../../src/index.js";
 import { join, resolve } from "node:path";
 import { collectFiles, effortsFor, loadMcp, readBundle, writeBundle } from "../../src/index.js";
-import { CLAUDE_MODELS, OPENAI_MODELS, PROVIDERS } from "../config.js";
-import { where } from "../keystore.js";
+import { CLAUDE_MODELS, OPENAI_MODELS, PROVIDERS, connections, keyFor, storeKey } from "../config.js";
+import { noStore, where } from "../keystore.js";
+import { fetchModels } from "../models.js";
+import { STAGE_GLYPH, roundOf, stagesOf } from "./looppanel.js";
 import { bold, cyan, dim, green, red, yellow } from "../ui.js";
 import { estimateCost, fmtCost, fmtDuration, fmtTokens } from "./pricing.js";
 import { codeBlocks } from "./clipboard.js";
@@ -16,6 +18,29 @@ import { THEMES, getTheme, themeNames } from "./themes.js";
 import { helpLines, renderDiff, toolCall, todoList } from "./view.js";
 const INIT_PROMPT = "Explore this repository and write an AGENTS.md at the repo root for future coding sessions: what the project is, how to build/test/run it (exact commands), the code layout, conventions you can verify from the code, and gotchas. Keep it under 80 lines and do not invent anything you cannot confirm from the files.";
 const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+const keyStatus = (c) => !c.needsKey ? "local, no key needed" : c.source === "env" ? `connected · from ${c.env}` : c.source === "saved" ? `connected · ${noStore() ? "this session only" : where()}` : "not connected";
+/** Make `id` the active provider, using its saved key (or asking for one). Returns false if the user gave up. */
+async function switchProvider(a, id) {
+    let apiKey = keyFor(id).key;
+    if (PROVIDERS[id].needsKey && !apiKey) {
+        apiKey = await a.askText(`${PROVIDERS[id].label} API key (hidden; ${where()})`, { secret: true });
+        if (!apiKey)
+            return false;
+    }
+    Object.assign(a.cfg, { provider: id, baseUrl: PROVIDERS[id].baseUrl, model: PROVIDERS[id].model, apiKey });
+    if (id === "custom" || id === "ollama") {
+        const m = await a.askText("Model id", { initial: a.cfg.model });
+        if (m)
+            a.cfg.model = m;
+        const u = await a.askText("Base URL", { initial: a.cfg.baseUrl });
+        if (u)
+            a.cfg.baseUrl = u;
+    }
+    a.saveConfig();
+    a.buildAgent();
+    a.say(`provider → ${cyan(PROVIDERS[id].label)}, model ${cyan(a.cfg.model)}`, dim);
+    return true;
+}
 export function buildCommands() {
     return [
         { name: "help", alias: "?", help: "keys and commands", live: true, run: (a) => a.openPager(helpLines(a.cmds, (a.io.output.columns || 80) - 1), "help") },
@@ -23,7 +48,10 @@ export function buildCommands() {
                 let id = arg;
                 if (!id) {
                     const list = a.cfg.provider === "anthropic" ? CLAUDE_MODELS : a.cfg.provider === "openai" ? OPENAI_MODELS : [{ id: a.cfg.model, hint: "current" }];
-                    const known = list.map((m) => ({ label: m.id, value: m.id, hint: m.hint }));
+                    const have = new Set(list.map((m) => m.id));
+                    a.note("asking your provider for its models…", 7000);
+                    const extra = (await fetchModels({ provider: a.cfg.provider, baseUrl: a.cfg.baseUrl, apiKey: a.cfg.apiKey })).filter((m) => !have.has(m)).map((m) => ({ id: m, hint: "from your provider" }));
+                    const known = [...list, ...extra].map((m) => ({ label: m.id, value: m.id, hint: m.hint }));
                     id = await a.pick("Model", [...known, { label: "Other…", value: "" }], Math.max(0, known.findIndex((m) => m.value === a.cfg.model)));
                     if (id === undefined)
                         return;
@@ -42,29 +70,54 @@ export function buildCommands() {
                 a.buildAgent();
                 a.say(`model → ${cyan(id)}`, dim);
             } },
-        { name: "provider", help: "switch provider (OpenAI, Claude, Ollama…)", run: async (a) => {
-                const id = await a.pick("Provider", Object.keys(PROVIDERS).map((k) => ({ label: PROVIDERS[k].label, value: k, hint: PROVIDERS[k].baseUrl })));
-                if (!id)
-                    return;
-                const key = id === "anthropic" ? process.env.ANTHROPIC_API_KEY : process.env.OPENAI_API_KEY;
-                let apiKey = key;
-                if (PROVIDERS[id].needsKey && !apiKey) {
-                    apiKey = await a.askText(`${PROVIDERS[id].label} API key (hidden; ${where()})`, { secret: true });
-                    if (!apiKey)
+        { name: "provider", help: "switch provider (OpenAI, Claude, Ollama…); each provider keeps its own saved key", run: async (a) => {
+                const list = connections();
+                const id = await a.pick("Provider", list.map((c) => ({ label: `${!c.needsKey || c.source !== "none" ? "●" : "○"} ${c.label}${c.id === a.cfg.provider ? "  (in use)" : ""}`, value: c.id, hint: keyStatus(c) })));
+                if (id)
+                    await switchProvider(a, id);
+            } },
+        { name: "connect", alias: "keys", help: "add, replace or remove API keys for several providers and see which are connected", run: async (a) => {
+                for (;;) {
+                    const list = connections();
+                    const id = await a.pick("Providers   ● connected   ○ not connected", list.map((c) => ({ label: `${!c.needsKey || c.source !== "none" ? "●" : "○"} ${c.label}${c.id === a.cfg.provider ? "  (in use)" : ""}`, value: c.id, hint: keyStatus(c) })));
+                    if (!id)
                         return;
+                    const c = list.find((x) => x.id === id);
+                    if (!c.needsKey) {
+                        a.say(`${c.label} needs no key. Use /provider to switch to it.`, dim);
+                        continue;
+                    }
+                    const act = c.source === "none" ? "add" : await a.pick("What do you want to do?", [
+                        ...(id === a.cfg.provider ? [] : [{ label: "Use this provider now", value: "use" }]),
+                        { label: c.source === "env" ? `Also save a key (${c.env} still wins while it is set)` : "Replace the key", value: "add" },
+                        ...(c.source === "saved" ? [{ label: "Remove the saved key", value: "remove" }] : []),
+                    ]);
+                    if (!act)
+                        continue;
+                    if (act === "use") {
+                        await switchProvider(a, id);
+                        continue;
+                    }
+                    if (act === "add") {
+                        const key = await a.askText(`${c.label} API key (hidden; ${where()})`, { secret: true });
+                        if (!key)
+                            continue;
+                        storeKey(id, key);
+                        if (id === a.cfg.provider) {
+                            a.cfg.apiKey = keyFor(id).key;
+                            a.buildAgent();
+                        }
+                        a.say(`${green("✓")} ${c.label} connected (${noStore() ? "this session only" : where()})`, dim);
+                    }
+                    else {
+                        storeKey(id, undefined);
+                        if (id === a.cfg.provider) {
+                            a.cfg.apiKey = keyFor(id).key;
+                            a.buildAgent();
+                        }
+                        a.say(`${c.label}: saved key removed`, dim);
+                    }
                 }
-                Object.assign(a.cfg, { provider: id, baseUrl: PROVIDERS[id].baseUrl, model: PROVIDERS[id].model, apiKey });
-                if (id === "custom" || id === "ollama") {
-                    const m = await a.askText("Model id", { initial: a.cfg.model });
-                    if (m)
-                        a.cfg.model = m;
-                    const u = await a.askText("Base URL", { initial: a.cfg.baseUrl });
-                    if (u)
-                        a.cfg.baseUrl = u;
-                }
-                a.saveConfig();
-                a.buildAgent();
-                a.say(`provider → ${cyan(PROVIDERS[id].label)}, model ${cyan(a.cfg.model)}`, dim);
             } },
         { name: "effort", help: "reasoning effort for the current model", args: "[level]", run: async (a, arg) => {
                 const levels = a.cfg.provider === "anthropic" ? [...EFFORTS] : effortsFor(a.cfg.model);
@@ -106,6 +159,23 @@ export function buildCommands() {
                     return void a.say(`unknown mode "${m}"`, red);
                 a.setMode(m);
             } },
+        { name: "output", alias: "last", help: "the full output of the last tool call in a pager (/output 2 for the one before)", args: "[n]", live: true, run: (a, arg) => {
+                const calls = a.blocks.blocks.filter((b) => b.kind === "tool" && (!b.agent || b.agent === "lead") && !!b.result && b.name !== "todo_write");
+                if (!calls.length)
+                    return void a.say("no tool output yet", dim);
+                const n = Math.max(1, Math.floor(Number(arg) || 1)), b = calls[calls.length - n];
+                if (!b)
+                    return void a.say(`only ${calls.length} tool call${calls.length === 1 ? "" : "s"} so far`, dim);
+                const body = b.result.split("\n");
+                let head = toolCall(b.name, b.args);
+                if (b.name === "sh") {
+                    try {
+                        head = `$ ${JSON.parse(b.args).cmd}`;
+                    }
+                    catch { /* keep the generic header */ }
+                }
+                a.openPager([head, "", ...body], "output");
+            } },
         { name: "plan", help: "enter plan mode (read-only)", run: (a) => a.setMode("plan") },
         { name: "clear", help: "start a fresh conversation", alias: "new", run: (a) => {
                 a.newConversation();
@@ -249,10 +319,12 @@ export function buildCommands() {
                     return a.say(dim("no loop activity yet: send a task first"));
                 const tot = T.reduce((n, s) => n + s.completion + s.prompt, 0), ms = T.reduce((n, s) => n + s.ms, 0);
                 const waste = cacheWaste(a.tracer?.turns ?? []), wasteCost = waste ? estimateCost(a.cfg.model, waste, 0) : null, wasteNote = waste > 500 ? `${fmtTokens(waste)} tokens re-read at full price after cache breaks${wasteCost !== null ? ` (≈ ${fmtCost(wasteCost - estimateCost(a.cfg.model, waste, 0, waste))} wasted)` : ""} · ` : "";
-                const out = ["", bold(`Agent loop · ${T.length} turn${T.length === 1 ? "" : "s"} · ${fmtDuration(ms)} · ${fmtTokens(tot)} tokens`), dim(`${wasteNote}${a.trimmed ? `trimmed ~${fmtTokens(Math.round(a.trimmed / 4))} tokens of stale or noisy output · ` : ""}${a.cacheBreaks ? `${a.cacheBreaks} cache break${a.cacheBreaks === 1 ? "" : "s"} · ` : ""}each turn: the model answers, its tool calls run, results go back; guards are shown where they fired`), ""];
+                const rounds = roundOf(T.map((s) => ({ ...s })));
+                const out = ["", bold(`Agent loop · ${T.length} turn${T.length === 1 ? "" : "s"} · ${rounds} round${rounds === 1 ? "" : "s"} · ${fmtDuration(ms)} · ${fmtTokens(tot)} tokens`), dim("◉ gather: read, search · ✎ act: edit, run · ✓ verify: test, build · guessed from the tool calls"), dim(`${wasteNote}${a.trimmed ? `trimmed ~${fmtTokens(Math.round(a.trimmed / 4))} tokens of stale or noisy output · ` : ""}${a.cacheBreaks ? `${a.cacheBreaks} cache break${a.cacheBreaks === 1 ? "" : "s"} · ` : ""}each turn: the model answers, its tool calls run, results go back; guards are shown where they fired`), ""];
                 for (const s of T) {
                     const pad = String(s.n).padStart(2);
-                    out.push(`${cyan(`${pad} ●`)} ${bold("model")} ${dim(`${fmtDuration(s.ms)} · ${fmtTokens(s.prompt)} in · ${fmtTokens(s.completion)} out${s.cached ? ` · ${fmtTokens(s.cached)} cached` : ""}`)}`);
+                    const st = stagesOf(s.tools);
+                    out.push(`${cyan(`${pad} ●`)} ${bold("model")}${st.length ? " " + cyan(st.map((x) => `${STAGE_GLYPH[x]} ${x}`).join(" + ")) : ""} ${dim(`${fmtDuration(s.ms)} · ${fmtTokens(s.prompt)} in · ${fmtTokens(s.completion)} out${s.cached ? ` · ${fmtTokens(s.cached)} cached` : ""}`)}`);
                     s.tools.forEach((x, i) => out.push(`     ${dim(i === s.tools.length - 1 && !s.notes.length ? "└─" : "├─")} ${x.ok ? green("✓") : red("✗")} ${toolCall(x.name, x.args)} ${dim(fmtDuration(x.ms))}${s.parallel && s.parallel > 1 && i === 0 ? dim(`  (${s.parallel} calls this turn)`) : ""}`));
                     s.notes.forEach((n, i) => out.push(`     ${dim(i === s.notes.length - 1 ? "└─" : "├─")} ${yellow("⚑")} ${dim(n)}`));
                     if (!s.tools.length && !s.notes.length)

package/dist/cli/tui/complete.d.ts

@@ -1,16 +1,25 @@
 export type Suggestion = {
     label: string;
     insert: string;
-    detail?: string;
+    detail?: string; /** arg suggestions: more words are expected, so do not submit on Enter */
+    more?: boolean; /** arg suggestions: any value is allowed, so Enter runs what was typed unless the user moved into the list */
+    open?: boolean; /** category header shown above the first item of each group (only when the list is not filtered) */
+    group?: string;
 };
 export type Token = {
-    kind: "slash" | "file";
+    kind: "slash" | "file" | "arg";
     query: string;
     start: number;
-    end: number;
+    end: number; /** arg tokens: the command, and the words already typed after it */
+    cmd?: string;
+    words?: string[];
 };
 /** What is the user completing right now? A slash command (first word of the input) or an @file mention. */
 export declare function tokenAtCursor(text: string, cursor: number): Token | null;
+/** Categories of the built-in commands, in the order the menu shows them. A command that is not listed (yours, or a plugin's) goes under "Custom". */
+export declare const GROUP_ORDER: readonly ["Conversation", "Model & keys", "Safety", "Quality", "Project", "Extend", "Interface", "Custom"];
+export declare const groupOf: (name: string) => string;
+/** All matching commands. With no query they come grouped by category (in GROUP_ORDER, A to Z inside a group); with a query, best match first. */
 export declare function rankCommands(query: string, cmds: {
     name: string;
     help: string;
@@ -37,3 +46,14 @@ export declare class FileIndex {
     private load;
     private walk;
 }
+export type MenuRow = {
+    head: string;
+} | {
+    item: number;
+};
+/** The rows to draw for a suggestion list: a window of `win` rows that keeps the selected item in view, with a header row above each new group (headers cannot be selected). */
+export declare function menuRows(items: Suggestion[], sel: number, win: number): {
+    rows: MenuRow[];
+    above: number;
+    below: number;
+};

package/dist/cli/tui/complete.js

@@ -8,17 +8,37 @@ export function tokenAtCursor(text, cursor) {
     const slash = before.match(/^\/(\S*)$/);
     if (slash)
         return { kind: "slash", query: slash[1], start: 0, end: cursor };
+    const arg = before.match(/^\/(\S+)((?:\s+\S+)*)\s+(\S*)$/); // "/model gp": the command, the words before the last one, the word being typed
+    if (arg)
+        return { kind: "arg", cmd: arg[1], words: arg[2].trim() ? arg[2].trim().split(/\s+/) : [], query: arg[3], start: cursor - arg[3].length, end: cursor };
     const file = before.match(/(?:^|\s)@([^\s@]*)$/);
     if (file)
         return { kind: "file", query: file[1], start: cursor - file[1].length - 1, end: cursor };
     return null;
 }
-export function rankCommands(query, cmds, limit = 8) {
+/** Categories of the built-in commands, in the order the menu shows them. A command that is not listed (yours, or a plugin's) goes under "Custom". */
+export const GROUP_ORDER = ["Conversation", "Model & keys", "Safety", "Quality", "Project", "Extend", "Interface", "Custom"];
+const GROUP_MEMBERS = {};
+for (const [g, names] of Object.entries({
+    Conversation: "output clear compact resume branch branches export import undo rewind copy todos exit",
+    "Model & keys": "model provider connect effort api models router keepwarm budget tokens",
+    Safety: "mode plan permissions policy sandbox approver hooks",
+    Quality: "verify check review reviewer lsp report loop diff",
+    Project: "init pr tools procs shell status live",
+    Extend: "memory mcp skills agents plugins reload-plugins prompt strategy profile",
+    Interface: "help theme sidebar details diffmode mouse ui",
+}))
+    for (const n of names.split(" "))
+        GROUP_MEMBERS[n] = g;
+export const groupOf = (name) => GROUP_MEMBERS[name] ?? "Custom";
+/** All matching commands. With no query they come grouped by category (in GROUP_ORDER, A to Z inside a group); with a query, best match first. */
+export function rankCommands(query, cmds, limit = 500) {
     const q = query.toLowerCase();
     const score = (c) => (c.name.startsWith(q) ? 3 : c.alias?.startsWith(q) ? 2 : c.name.includes(q) || c.alias?.includes(q) ? 1 : 0);
+    const gi = (n) => GROUP_ORDER.indexOf(groupOf(n));
     return cmds.map((c) => ({ c, score: score(c) }))
-        .filter((x) => x.score > 0 || !q).sort((a, b) => b.score - a.score || a.c.name.localeCompare(b.c.name)).slice(0, limit)
-        .map(({ c }) => ({ label: "/" + c.name, insert: "/" + c.name + " ", detail: c.help + (c.alias && !c.name.includes(query.toLowerCase()) && c.alias.includes(query.toLowerCase()) ? ` (also /${c.alias})` : "") }));
+        .filter((x) => x.score > 0 || !q).sort((a, b) => (q ? b.score - a.score : gi(a.c.name) - gi(b.c.name)) || a.c.name.localeCompare(b.c.name)).slice(0, limit)
+        .map(({ c }) => ({ group: q ? undefined : groupOf(c.name), label: "/" + c.name, insert: "/" + c.name + " ", detail: c.help + (c.alias && !c.name.includes(query.toLowerCase()) && c.alias.includes(query.toLowerCase()) ? ` (also /${c.alias})` : "") }));
 }
 /** Subsequence fuzzy match. Tries the greedy alignment and the exact-substring alignments and keeps the best. null = no match. */
 export function fuzzyScore(query, path) {
@@ -111,3 +131,18 @@ export class FileIndex {
         return out;
     }
 }
+/** The rows to draw for a suggestion list: a window of `win` rows that keeps the selected item in view, with a header row above each new group (headers cannot be selected). */
+export function menuRows(items, sel, win) {
+    const all = [];
+    let selRow = 0, last;
+    items.forEach((it, i) => { if (it.group && it.group !== last)
+        all.push({ head: it.group }); last = it.group; if (i === sel)
+        selRow = all.length; all.push({ item: i }); });
+    win = Math.max(1, win);
+    let top = Math.max(0, Math.min(selRow - Math.floor(win / 2), all.length - win));
+    if (selRow - 1 >= 0 && "head" in all[selRow - 1] && top > selRow - 1)
+        top = selRow - 1; // keep the group title with its first command
+    const rows = all.slice(top, top + win);
+    const count = (r) => r.filter((x) => "item" in x).length;
+    return { rows, above: count(all.slice(0, top)), below: count(all.slice(top + win)) };
+}

package/dist/cli/tui/full.d.ts

@@ -59,6 +59,10 @@ export declare class FullView {
     /** Keep a toggled block's header where it is on screen. */
     private pin;
     private drawEmpty;
+    /** Steps the user opened in the LOOP section by clicking. */
+    private openSteps;
+    private openFor;
+    private loopData;
     private drawSidebar;
     private drawStatus;
     private editorRows;

package/dist/cli/tui/full.js

@@ -1,5 +1,7 @@
 // The full-screen UI: header, scrollable transcript, sidebar, input panel, modals, toasts and mouse handling, drawn on a cell canvas.
 import { copyToClipboard } from "./clipboard.js";
+import { menuRows } from "./complete.js";
+import { capNote } from "./looppanel.js";
 import { basename } from "node:path";
 import { A, mix } from "./ansi.js";
 import { brandOfModel } from "./brand.js";
@@ -162,6 +164,7 @@ export class FullView {
         const live = new Set();
         const blocks = app.blocks.blocks.filter((b) => !(b.kind === "tool" && (b.name === "todo_write" || (b.parent && b.agent && b.agent !== "lead")))); // todos live in the sidebar; a subagent's steps are drawn inside its card
         let prevTool = false;
+        const lastTool = [...blocks].reverse().find((b) => b.kind === "tool" && (!b.agent || b.agent === "lead"))?.id; // its output stays open
         for (let i = 0; i < blocks.length; i++) {
             const b = blocks[i];
             live.add(b.id);
@@ -169,7 +172,7 @@ export class FullView {
             if (isQuiet(b))
                 while (i + run < blocks.length && isQuiet(blocks[i + run]))
                     run++;
-            const tctx = { ...ctx, tight: prevTool };
+            const tctx = { ...ctx, tight: prevTool, last: b.id === lastTool };
             if (run >= 2) {
                 const members = blocks.slice(i, i + run), open = this.expandAll || this.groupOpen.has(b.id);
                 const key = `g|${tctx.tight}|${open}|${ctx.theme.name}|${ctx.width}|` + members.map((m) => `${m.id}:${m.status}:${m.ms ?? 0}`).join(",") + (members.some((m) => m.status === "running") ? `|${ctx.frame}` : ""), hit = this.cache.get(b.id);
@@ -182,7 +185,7 @@ export class FullView {
                 prevTool = r.rows.length <= 2;
                 continue;
             }
-            const key = this.sig(b, tctx) + (tctx.tight ? "|t" : ""), hit = this.cache.get(b.id);
+            const key = this.sig(b, tctx) + (tctx.tight ? "|t" : "") + (tctx.last ? "|last" : ""), hit = this.cache.get(b.id);
             const r = hit && hit.key === key ? hit.r : (() => { const rr = renderBlock(b, tctx); this.cache.set(b.id, { key, r: rr }); return rr; })();
             this.items.push({ b, r, start: total });
             total += r.rows.length;
@@ -330,6 +333,21 @@ export class FullView {
         c.ansi(x0 + Math.max(0, Math.floor((w - cellWidth(TIPS[this.tipIdx]) - 5) / 2)), Math.min(y0 + h - 2, ry + 2), tip);
     }
     // ------------------------------------------------------------------ sidebar
+    /** Steps the user opened in the LOOP section by clicking. */
+    openSteps = new Set();
+    openFor = 0;
+    loopData(now) {
+        const app = this.app, steps = app.trace.filter((s) => s.t0 >= app.runStart - 50); // this run's steps (the trace spans the whole session)
+        if (!steps.length)
+            return undefined;
+        if (this.openFor !== app.runStart) {
+            this.openFor = app.runStart;
+            this.openSteps.clear();
+        } // step numbers start again in a new run
+        return { live: app.running, phase: app.phase?.phase ?? "model", cap: app.phase?.max ?? 30, now, frame: app.frame, steps,
+            elapsedMs: app.running ? now - app.runStart : Math.max(...steps.map((s) => s.t0 + s.ms)) - app.runStart,
+            inflight: [...app.inflight.values()].map((x) => ({ label: toolVerb(x.name, x.args), ms: now - x.t0, agent: x.agent, name: x.name, args: x.args })), open: [...this.openSteps] };
+    }
     drawSidebar(c, t, x0, y0, w, h) {
         const app = this.app, u = app.session.usage, win = contextWindow(app.cfg.model), now = Date.now();
         const mkey = `${app.session.messages.length}|${app.lastPrompt}`;
@@ -353,15 +371,19 @@ export class FullView {
             sandbox: app.cfg.sandbox,
             procs: app.agent.procs?.list().map((p) => ({ id: p.id, name: p.name, status: p.status, secs: Math.round((now - p.startedAt) / 1000) })),
             running: app.running, elapsedMs: now - this.startedAt, tip: TIPS[this.tipIdx],
-            run: app.running ? { phase: app.phase?.phase ?? "model", step: app.phase?.step ?? 0, max: app.phase?.max ?? 30, elapsedMs: now - app.runStart, frame: app.frame,
-                live: [...app.inflight.values()].map((x) => ({ label: toolVerb(x.name, x.args), ms: now - x.t0, agent: x.agent })), done: app.activity.map((x) => ({ label: toolVerb(x.name, x.args, true), ok: x.ok, ms: x.ms })) } : undefined,
+            loop: this.loopData(now),
         }, t, w, h);
         rows.forEach((r, i) => c.put(x0 + 1, y0 + i, r, w - 1));
         for (let i = 0; i < h; i++)
             c.text(x0, y0 + i, "│", { fg: t.border, bg: t.surface });
         for (const hh of hits)
             if (hh.row < h)
-                this.regions.push({ x: x0, y: y0 + hh.row, w, h: 1, kind: "change", click: () => hh.blockId !== undefined && this.scrollToBlock(hh.blockId) });
+                this.regions.push({ x: x0, y: y0 + hh.row, w, h: 1, kind: "change", click: () => { if (hh.kind === "step" && hh.step !== undefined) {
+                        this.openSteps.has(hh.step) ? this.openSteps.delete(hh.step) : this.openSteps.add(hh.step);
+                        this.invalidate();
+                    }
+                    else if (hh.blockId !== undefined)
+                        this.scrollToBlock(hh.blockId); } });
     }
     // ------------------------------------------------------------------ status line, input, footer
     drawStatus(c, t, x, y, w, now) {
@@ -372,7 +394,7 @@ export class FullView {
                 : app.mode === "plan" ? "Planning" : app.thinkBuf.trim() ? "Thinking" : app.streamBuf ? "Writing" : "Working", chars = [...clipWidth(verb, Math.max(8, w - 44)) + "…"];
             const shim = chars.map((ch, i) => F(mix(t.accent, 0xffffff, Math.max(0, 1 - Math.abs(i - ((f * 0.9) % (chars.length + 8) - 4)) / 3)), ch)).join("");
             const spark = app.runSeries.length > 1 ? " " + F(t.accent2, app.runSeries.slice(-10).map((v) => BARS[Math.min(7, Math.round((v / Math.max(1, ...app.runSeries)) * 7))]).join("")) : "";
-            c.ansi(x + 1, y, F(mix(t.accent, t.accent2, (f % 20) / 20), glyph) + " " + BOLD(shim) + F(t.dim, ` ${fmtDuration(now - app.runStart)} · ↓ ${fmtTokens(app.runTokens)}`) + (app.phase ? F(t.faint, ` · step ${app.phase.step + 1}/${app.phase.max}`) : "") + spark + F(t.faint, "   esc to interrupt"), {}, w - 2);
+            c.ansi(x + 1, y, F(mix(t.accent, t.accent2, (f % 20) / 20), glyph) + " " + BOLD(shim) + F(t.dim, ` ${fmtDuration(now - app.runStart)} · ↓ ${fmtTokens(app.runTokens)}`) + (app.phase ? (() => { const n = app.phase.step + 1, cap = capNote(n, app.phase.max); return F(cap.level === "warn" ? t.warn : t.faint, ` · step ${n}${cap.level === "none" ? "" : cap.level === "dim" ? ` of ${app.phase.max}` : ` of ${app.phase.max}, near the limit`}`); })() : "") + spark + F(t.faint, "   esc to interrupt"), {}, w - 2);
             if (app.thinkBuf.trim() && app.queued.length === 0) { /* reasoning summary lives in the transcript's thinking block */ }
         }
         app.queued.slice(0, 2).forEach((q, i) => c.ansi(x + 1, y + (app.running ? 1 : 0) + i, F(t.warn, "▸ queued ") + F(t.dim, clipWidth(q.text.replace(/\s+/g, " "), w - 14)), {}, w - 2));
@@ -406,13 +428,19 @@ export class FullView {
         const s = this.app.sugg;
         if (!s || !s.items.length || this.app.overlay)
             return;
-        const rows = Math.min(8, s.items.length), w = Math.min(70, mainW), top = Math.max(0, Math.min(s.sel - 3, s.items.length - rows)), y = inputY - rows - 2;
-        if (y < 1)
+        const w = Math.min(86, mainW), room = inputY - 4; // rows between the top of the screen and the box
+        if (room < 3)
             return;
-        c.box(x + 1, y, w, rows + 2, { border: t.border, bg: t.surface, style: "round", title: s.kind === "slash" ? "commands" : "files", titleFg: t.dim });
-        s.items.slice(top, top + rows).forEach((it, i) => {
-            const idx = top + i, on = idx === s.sel, bg = on ? t.selection : t.surface;
-            const label = s.kind === "file" ? (() => { const n = it.label.split("/").pop(), d = it.label.slice(0, it.label.length - n.length); return F(t.faint, d) + BOLD(F(t.text, n)); })() : BOLD(F(t.accent2, it.label));
+        const { rows, above, below } = menuRows(s.items, s.sel, Math.min(14, room)), y = inputY - rows.length - 2;
+        const pos = s.items.length > rows.filter((r) => "item" in r).length ? `  ${s.sel + 1}/${s.items.length}${above ? " ↑" : ""}${below ? " ↓" : ""}` : "";
+        c.box(x + 1, y, w, rows.length + 2, { border: t.border, bg: t.surface, style: "round", title: (s.kind === "slash" ? "commands" : s.kind === "arg" ? `/${s.token.cmd} options` : "files") + pos, titleFg: t.dim });
+        rows.forEach((r, i) => {
+            if ("head" in r) {
+                c.ansi(x + 2, y + 1 + i, fit(" " + F(t.faint, "── ") + BOLD(F(t.dim, r.head)) + " " + F(t.faint, "─".repeat(Math.max(2, 24 - r.head.length))), w - 2, t.surface), {}, w - 2);
+                return;
+            }
+            const idx = r.item, it = s.items[idx], on = idx === s.sel, bg = on ? t.selection : t.surface;
+            const label = s.kind === "file" ? (() => { const n = it.label.split("/").pop(), d = it.label.slice(0, it.label.length - n.length); return F(t.faint, d) + BOLD(F(t.text, n)); })() : BOLD(F(t.accent2, it.label.padEnd(16)));
             c.ansi(x + 2, y + 1 + i, fit((on ? F(t.accent, "▌") : " ") + " " + label + (it.detail ? "  " + F(t.faint, it.detail) : ""), w - 2, bg), {}, w - 2);
             this.regions.push({ x: x + 2, y: y + 1 + i, w: w - 2, h: 1, kind: "sugg", click: () => { s.sel = idx; this.app.acceptSuggPublic(true); } });
         });
@@ -588,6 +616,8 @@ export class FullView {
     } return false; }
     /** Scroll keys; returns whether the key was used. */
     key(name, ctrl) {
+        if (this.app.sugg && (name === "pageup" || name === "pagedown"))
+            return false; // the open menu pages through its list instead
         const page = Math.max(3, Math.floor(this.viewH / 2));
         if (name === "pageup") {
             this.scrollBy(page);

package/dist/cli/tui/looppanel.d.ts

@@ -0,0 +1,71 @@
+import type { Theme } from "./themes.ts";
+export type LoopStep = {
+    n: number;
+    t0: number;
+    ms: number;
+    tools: {
+        name: string;
+        args: string;
+        ms: number;
+        ok: boolean;
+    }[];
+    notes: string[];
+    parallel?: number;
+};
+export type LoopData = {
+    /** the run is still going */ live: boolean;
+    phase: string;
+    cap: number;
+    now: number;
+    frame: number;
+    elapsedMs: number;
+    /** this run's steps, oldest first; while live, the last one is the current step */ steps: LoopStep[];
+    /** tool calls in flight right now (name and args let the panel tell which stage they belong to) */ inflight: {
+        label: string;
+        ms: number;
+        agent?: string;
+        name?: string;
+        args?: string;
+    }[];
+    /** steps the user opened by clicking */ open: number[];
+};
+export type LoopHit = {
+    line: number;
+    step: number;
+};
+/** Notes that mean "the harness stepped in" (shown in the warning colour, and kept visible); everything else (cache, routing, trimming) is background. */
+export declare const isIntervention: (note: string) => boolean;
+/** "Read ×2 → Edit → Run": neighbouring calls of one kind merge, so a burst of reads is one short phrase. */
+export declare function stepSummary(tools: {
+    name: string;
+}[]): string;
+/** Wall time of a step: the model call, then its tools (they overlap when run in parallel). */
+export declare const stepMs: (s: LoopStep) => number;
+/** The cap is a safety stop, not a goal, so say nothing about it until it could matter. */
+export declare function capNote(step: number, cap: number): {
+    text: string;
+    level: "none" | "dim" | "warn";
+};
+export type Stage = "gather" | "act" | "verify";
+export declare const STAGES: Stage[];
+export declare const STAGE_GLYPH: Record<Stage, string>;
+/** Which part of the cycle a tool call belongs to. A guess from the tool and, for shell commands, the command line; undefined for planning and bookkeeping tools. */
+export declare function stageOfTool(name: string, args?: string): Stage | undefined;
+/** The stages a step touched, in cycle order. */
+export declare const stagesOf: (tools: {
+    name: string;
+    args: string;
+}[]) => Stage[];
+/** How many times the agent has come back round: a new round starts when it gathers or acts again after verifying. */
+export declare function roundOf(steps: LoopStep[]): number;
+/** Which stages to light: those running now, and (while the model is thinking and nothing runs) the last one used, dimmed. */
+export declare function litStages(d: LoopData): {
+    now: Set<Stage>;
+    recent: Set<Stage>;
+};
+export declare function renderLoop(d: LoopData, t: Theme, inner: number, maxRows: number): {
+    lines: string[];
+    hits: LoopHit[];
+    title: string;
+    right: string;
+};