amness 0.1.2 → 0.1.3

package/README.md

@@ -28,13 +28,13 @@ Give Amness the key once, in whichever way suits you:
 
 | How | Command or step | Saved? |
 |---|---|---|
-| **Paste it on first start** | run `amness`, choose a provider, paste the key (hidden). Change it later in the settings or with `/provider`. | Yes, in your system's secure store: the macOS Keychain, the Linux keyring, or Windows DPAPI. The prompt tells you which. |
+| **Paste it on first start** | run `amness`, choose a provider, paste the key (hidden). Add more providers any time with `/connect`, and switch with `/provider`. | Yes, in your system's secure store: the macOS Keychain, the Linux keyring, or Windows DPAPI. The prompt tells you which. |
 | **Environment variable** | `export ANTHROPIC_API_KEY=sk-ant-...` or `export OPENAI_API_KEY=sk-...` (PowerShell: `$env:OPENAI_API_KEY="sk-..."`) | No. Used for that shell only, and never written to disk. It wins over a saved key. |
 | **Secret file** (Docker, Kubernetes) | `ANTHROPIC_API_KEY_FILE=/run/secrets/anthropic` (also `OPENAI_API_KEY_FILE`, `TAVILY_API_KEY_FILE`) | No. Read from the file each run. |
 | **Docker** | `docker run -it --rm -v "$PWD":/work -e ANTHROPIC_API_KEY amness` | No. Inside a container nothing is saved. |
 | **Library or CI** | pass `apiKey` in code, or set the variable as a CI secret | No. |
 
-`OPENAI_API_KEY` is used for every provider except Anthropic, including OpenRouter. To remove a saved key, clear "API key" in the settings. A Linux server with no keyring falls back to `~/.amness/config.json` (mode 600, **not encrypted**), so use an environment variable or your platform's secret manager there. Details: [Safety](docs/safety.md).
+Each provider keeps its own saved key, so you can connect several and switch with `/provider`; `/connect` shows which are connected. `OPENAI_API_KEY` is used for every provider except Anthropic (OpenRouter prefers `OPENROUTER_API_KEY`). To remove a saved key, clear "API key" in the settings. A Linux server with no keyring falls back to `~/.amness/config.json` (mode 600, **not encrypted**), so use an environment variable or your platform's secret manager there. Details: [Safety](docs/safety.md).
 
 More ways to start:
 

package/dist/cli/amness.js

@@ -15,7 +15,7 @@ import { runPlugin } from "./plugincli.js";
 import { runSchedule } from "./schedulecli.js";
 import { ACP_HELP, runAcp } from "./acpcli.js";
 import { runEval, runTune } from "./evalcli.js";
-import { CLAUDE_MODELS, OPENAI_MODELS, PROVIDERS, home, loadConfig, mask, ready, saveConfig } from "./config.js";
+import { CLAUDE_MODELS, OPENAI_MODELS, PROVIDERS, home, keyFor, loadConfig, mask, ready, saveConfig } from "./config.js";
 import { where } from "./keystore.js";
 import { DEMO_TASK, explain, runDemo } from "./demo.js";
 import { formatEvent } from "./format.js";
@@ -91,7 +91,7 @@ async function ensureReady() {
         cfg.model = (await ask("Model", cfg.model)) || cfg.model;
     }
     if (PROVIDERS[id].needsKey)
-        cfg.apiKey = (await ask(`API key (hidden; ${where()})`, "", { secret: true })) || undefined;
+        cfg.apiKey = keyFor(id).key ?? ((await ask(`API key (hidden; ${where()})`, "", { secret: true })) || undefined);
     saveConfig(cfg);
     if (!ready(cfg))
         return false;
@@ -432,7 +432,7 @@ async function settings() {
             if (what === "provider") {
                 const id = await select("Provider", Object.keys(PROVIDERS).map((k) => ({ label: PROVIDERS[k].label, value: k, hint: PROVIDERS[k].baseUrl })));
                 if (id)
-                    Object.assign(cfg, { provider: id, baseUrl: PROVIDERS[id].baseUrl, model: PROVIDERS[id].model });
+                    Object.assign(cfg, { provider: id, baseUrl: PROVIDERS[id].baseUrl, model: PROVIDERS[id].model, apiKey: keyFor(id).key });
             }
             else if (what === "model") {
                 if (cfg.provider === "anthropic" || cfg.provider === "openai") {

package/dist/cli/config.d.ts

@@ -35,7 +35,8 @@ export type Config = {
     provider: ProviderId;
     baseUrl: string;
     model: string;
-    apiKey?: string;
+    apiKey?: string; /** saved keys for the other providers, only where there is no OS store */
+    apiKeys?: Partial<Record<ProviderId, string>>;
     tavilyKey?: string;
     maxTokens: number;
     effort?: "none" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max"; /** OpenAI wire API: auto (default) picks Responses for reasoning models and self-corrects */
@@ -65,6 +66,26 @@ export type Config = {
 };
 export declare const home: () => string;
 export declare const defaults: () => Config;
+/** The variable that holds a provider's key. Anthropic has its own; OpenRouter may have its own; every other provider uses OPENAI_API_KEY. */
+export declare const envNameFor: (p: ProviderId) => "ANTHROPIC_API_KEY" | "OPENROUTER_API_KEY" | "OPENAI_API_KEY";
+export declare const envKeyFor: (p: ProviderId) => string | undefined;
+export type KeyState = {
+    key?: string;
+    source: "env" | "saved" | "none";
+};
+/** The key to use for a provider: an environment variable wins over a saved key. */
+export declare function keyFor(p: ProviderId): KeyState;
+/** Save (or, with no key, remove) a provider's key. Uses the OS store; else config.json (mode 600); in a container, memory only. */
+export declare function storeKey(p: ProviderId, key?: string): void;
+export type Connection = {
+    id: ProviderId;
+    label: string;
+    needsKey: boolean;
+    source: KeyState["source"];
+    env: string;
+};
+/** Every provider and whether it is ready to use. */
+export declare function connections(): Connection[];
 export declare function loadConfig(): Config;
 export declare function saveConfig(c: Config): void;
 export declare const ready: (c: Config) => boolean;

package/dist/cli/config.js

@@ -12,7 +12,11 @@ export const PROVIDERS = {
 export const home = () => process.env.AMNESS_HOME ?? join(homedir(), ".amness");
 const file = () => join(home(), "config.json");
 export const defaults = () => ({ provider: "openai", baseUrl: PROVIDERS.openai.baseUrl, model: PROVIDERS.openai.model, maxTokens: 300_000 });
-const SECRETS = ["apiKey", "tavilyKey"];
+// ---- keys. One saved key per provider (account "apiKey-<provider>" in the OS store), so you can be connected to several at once. `cfg.apiKey` is always the active provider's key.
+const acct = (p) => `apiKey-${p}`;
+let fileKeys = {}, fileKeysLoaded = false; // only where there is no OS store (a Linux server): kept in config.json, mode 600
+const sessionKeys = {}; // in a container: this run only
+const persisted = {}; // what is stored now, so a save does not rewrite an unchanged key
 /** An environment variable, or the file NAME_FILE points to (Docker and Kubernetes secrets are mounted as files, for example /run/secrets/openai). */
 const envSecret = (name) => {
     const v = process.env[name];
@@ -28,7 +32,58 @@ const envSecret = (name) => {
         return undefined;
     }
 };
-let fromEnv = {};
+/** The variable that holds a provider's key. Anthropic has its own; OpenRouter may have its own; every other provider uses OPENAI_API_KEY. */
+export const envNameFor = (p) => (p === "anthropic" ? "ANTHROPIC_API_KEY" : p === "openrouter" && envSecret("OPENROUTER_API_KEY") ? "OPENROUTER_API_KEY" : "OPENAI_API_KEY");
+export const envKeyFor = (p) => envSecret(envNameFor(p));
+const loadFileKeys = () => { if (!fileKeysLoaded) {
+    fileKeysLoaded = true;
+    fileKeys = { ...readFileCfg().apiKeys };
+} };
+const savedKey = (p) => { loadFileKeys(); return getSecret(acct(p)) ?? fileKeys[p] ?? sessionKeys[p]; };
+/** The key to use for a provider: an environment variable wins over a saved key. */
+export function keyFor(p) {
+    const e = envKeyFor(p);
+    if (e)
+        return { key: e, source: "env" };
+    const s = savedKey(p);
+    if (s) {
+        persisted[p] = s;
+        return { key: s, source: "saved" };
+    }
+    return { source: "none" };
+}
+/** Save (or, with no key, remove) a provider's key. Uses the OS store; else config.json (mode 600); in a container, memory only. */
+export function storeKey(p, key) {
+    loadFileKeys();
+    persisted[p] = key;
+    if (!key) {
+        deleteSecret(acct(p));
+        delete fileKeys[p];
+        delete sessionKeys[p];
+        writeConfigFile(readFileCfg());
+        return;
+    }
+    if (setSecret(acct(p), key)) {
+        delete fileKeys[p];
+        delete sessionKeys[p];
+    }
+    else if (noStore())
+        sessionKeys[p] = key;
+    else
+        fileKeys[p] = key;
+    writeConfigFile(readFileCfg());
+}
+/** Every provider and whether it is ready to use. */
+export function connections() {
+    return Object.keys(PROVIDERS).map((id) => ({ id, label: PROVIDERS[id].label, needsKey: PROVIDERS[id].needsKey, source: PROVIDERS[id].needsKey ? keyFor(id).source : "saved", env: envNameFor(id) }));
+}
+const readFileCfg = () => { try {
+    return { ...defaults(), ...JSON.parse(readFileSync(file(), "utf8")) };
+}
+catch {
+    return defaults();
+} };
+let tavilyEnv;
 export function loadConfig() {
     let c = defaults(), onDisk = {};
     try {
@@ -37,33 +92,40 @@ export function loadConfig() {
         c = { ...c, ...onDisk };
     }
     catch { /* corrupt config: start fresh */ }
-    // keys live in the OS credential store when there is one; a key still in the file (an older version wrote it there) is moved over, and removed from the file only after it reads back
-    let migrated = false;
-    for (const k of SECRETS) {
-        const stored = getSecret(k);
-        if (stored) {
-            c[k] = stored;
-            if (onDisk[k]) {
-                delete onDisk[k];
-                migrated = true;
-            }
-        }
-        else if (onDisk[k] && setSecret(k, onDisk[k])) {
-            delete onDisk[k];
-            migrated = true;
+    fileKeys = { ...onDisk.apiKeys };
+    fileKeysLoaded = true;
+    delete c.apiKeys;
+    let dirty = false;
+    // older versions kept ONE key (account "apiKey", or a field in the file) for whichever provider was active: give it to that provider
+    const legacy = [getSecret("apiKey"), onDisk.apiKey].find(Boolean);
+    if (legacy && !savedKey(c.provider)) {
+        fileKeys[c.provider] = legacy;
+        dirty = true;
+    }
+    if (getSecret("apiKey"))
+        deleteSecret("apiKey");
+    if (onDisk.apiKey) {
+        delete onDisk.apiKey;
+        dirty = true;
+    }
+    // keys still in the file move to the OS store, and leave the file only after they read back
+    for (const p of Object.keys(fileKeys))
+        if (fileKeys[p] && setSecret(acct(p), fileKeys[p])) {
+            delete fileKeys[p];
+            dirty = true;
         }
+    const tv = getSecret("tavilyKey") ?? onDisk.tavilyKey;
+    if (onDisk.tavilyKey && setSecret("tavilyKey", onDisk.tavilyKey)) {
+        delete onDisk.tavilyKey;
+        dirty = true;
     }
-    if (migrated)
-        writeConfigFile({ ...defaults(), ...onDisk, ...Object.fromEntries(SECRETS.map((k) => [k, undefined])) });
-    // environment wins, so CI and one-off runs work without touching the saved key. It is never written back (see saveConfig).
+    if (dirty)
+        writeConfigFile({ ...defaults(), ...onDisk, apiKey: undefined, tavilyKey: onDisk.tavilyKey });
     const claude = c.provider === "anthropic";
-    fromEnv = {};
-    const key = envSecret(claude ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY");
-    if (key)
-        c.apiKey = fromEnv.apiKey = key;
-    const tavily = envSecret("TAVILY_API_KEY");
-    if (tavily)
-        c.tavilyKey = fromEnv.tavilyKey = tavily;
+    c.apiKey = keyFor(c.provider).key;
+    // environment wins, so CI and one-off runs work without touching the saved key. It is never written back (see saveConfig).
+    tavilyEnv = envSecret("TAVILY_API_KEY");
+    c.tavilyKey = tavilyEnv ?? tv;
     if (process.env.OPENAI_BASE_URL && !claude)
         c.baseUrl = process.env.OPENAI_BASE_URL;
     if (process.env.AMNESS_MODEL)
@@ -72,25 +134,25 @@ export function loadConfig() {
 }
 function writeConfigFile(c) {
     mkdirSync(home(), { recursive: true });
-    writeFileSync(file(), JSON.stringify(c, null, 2), { mode: 0o600 }); // owner-only from the first byte
+    const out = { ...c, apiKeys: Object.keys(fileKeys).length ? fileKeys : undefined };
+    writeFileSync(file(), JSON.stringify(out, null, 2), { mode: 0o600 }); // owner-only from the first byte
     chmodSync(file(), 0o600); // and for a file that already existed
 }
 export function saveConfig(c) {
     const out = { ...c };
-    for (const k of SECRETS) {
-        const v = c[k];
-        if (v && v === fromEnv[k]) {
-            delete out[k];
-            continue;
-        } // this value came from an environment variable: do not store it
-        if (!v) {
-            deleteSecret(k);
-            delete out[k];
-            continue;
-        }
-        if (setSecret(k, v) || noStore())
-            delete out[k]; // stored in the OS credential store; otherwise it stays in the file (mode 600), except in a container, where it is kept in memory only
+    delete out.apiKey;
+    delete out.apiKeys;
+    if (c.apiKey !== persisted[c.provider] && !(c.apiKey && c.apiKey === envKeyFor(c.provider)))
+        storeKey(c.provider, c.apiKey); // a key from an environment variable is never stored
+    const tv = c.tavilyKey;
+    if (tv && tv === tavilyEnv)
+        delete out.tavilyKey;
+    else if (!tv) {
+        deleteSecret("tavilyKey");
+        delete out.tavilyKey;
     }
+    else if (setSecret("tavilyKey", tv) || noStore())
+        delete out.tavilyKey;
     writeConfigFile(out);
 }
 export const ready = (c) => !PROVIDERS[c.provider].needsKey || !!c.apiKey;

package/dist/cli/models.d.ts

@@ -0,0 +1,8 @@
+export type ModelProbe = {
+    provider: string;
+    baseUrl: string;
+    apiKey?: string;
+};
+export declare function fetchModels(p: ModelProbe, fetchImpl?: typeof fetch): Promise<string[]>;
+/** For tests. */
+export declare const clearModelCache: () => void;

package/dist/cli/models.js

@@ -0,0 +1,31 @@
+const cache = new Map();
+const TTL = 10 * 60_000;
+const NOT_CHAT = /embed|whisper|tts|dall-e|moderation|davinci|babbage|transcribe|realtime|audio|image|rerank/i;
+export async function fetchModels(p, fetchImpl = fetch) {
+    if (!p.apiKey && p.provider !== "ollama" && p.provider !== "custom")
+        return []; // a hosted provider refuses a request with no key: do not even try
+    const key = `${p.provider}|${p.baseUrl}|${(p.apiKey ?? "").slice(-6)}`, hit = cache.get(key);
+    if (hit && Date.now() - hit.at < TTL)
+        return hit.ids;
+    const base = p.baseUrl.replace(/\/+$/, "");
+    const anthropic = p.provider === "anthropic";
+    try {
+        const res = await fetchImpl(anthropic ? `${base}/v1/models?limit=100` : `${base}/models`, {
+            headers: anthropic ? { "x-api-key": p.apiKey ?? "", "anthropic-version": "2023-06-01" } : p.apiKey ? { authorization: `Bearer ${p.apiKey}` } : {},
+            signal: AbortSignal.timeout(6000),
+        });
+        if (!res.ok)
+            return [];
+        const body = (await res.json());
+        const ids = [...(body.data ?? []).map((m) => m.id), ...(body.models ?? []).map((m) => m.model ?? m.name)] // Ollama's native shape uses `models`
+            .filter((x) => typeof x === "string" && !!x && !NOT_CHAT.test(x));
+        const uniq = [...new Set(ids)].sort();
+        cache.set(key, { at: Date.now(), ids: uniq });
+        return uniq;
+    }
+    catch {
+        return [];
+    }
+}
+/** For tests. */
+export const clearModelCache = () => cache.clear();

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

@@ -131,9 +131,11 @@ export declare class App {
         items: Suggestion[];
         sel: number;
         token: Token;
-        kind: Token["kind"];
+        kind: Token["kind"]; /** the user moved into the list with the arrow keys */
+        nav?: boolean;
     } | null;
     suggOff: string;
+    private argPending;
     private builtin;
     private customAt;
     private customCmds;

package/dist/cli/tui/app.js

@@ -15,7 +15,8 @@ import { BlockStore } from "./blocks.js";
 import { buildCommands } from "./commands.js";
 import { FullView } from "./full.js";
 import { loadCustomCommands } from "./custom.js";
-import { FileIndex, applySuggestion, rankCommands, rankFiles, tokenAtCursor } from "./complete.js";
+import { argOptions } from "./argcomplete.js";
+import { FileIndex, fuzzyScore, applySuggestion, menuRows, rankCommands, rankFiles, tokenAtCursor } from "./complete.js";
 import { Editor } from "./editor.js";
 import { KeyParser, PASTE_OFF, PASTE_ON } from "./keys.js";
 import { renderMarkdown, takeCompleteBlocks } from "./markdown.js";
@@ -80,6 +81,7 @@ export class App {
     pager = null;
     sugg = null;
     suggOff = "";
+    argPending = new Set();
     builtin;
     customAt = 0;
     customCmds = [];
@@ -370,11 +372,16 @@ export class App {
     setTitle(t) { if (this.io.output.isTTY !== false)
         this.io.output.write(`\x1b]0;${t}\x07`); }
     suggLines(w) {
-        const s = this.sugg, win = 8, top = Math.max(0, Math.min(s.sel - 3, s.items.length - win));
-        return s.items.slice(top, top + win).map((it, i) => {
-            const on = top + i === s.sel, label = s.kind === "file" ? it.label : it.label.padEnd(12);
+        const s = this.sugg, { rows, above, below } = menuRows(s.items, s.sel, Math.min(12, Math.max(4, this.screen.rows - 8)));
+        const lines = rows.map((r) => {
+            if ("head" in r)
+                return dim(`  ── ${r.head} ${"─".repeat(Math.max(2, 20 - r.head.length))}`);
+            const it = s.items[r.item], on = r.item === s.sel, label = s.kind === "file" ? it.label : it.label.padEnd(16);
             return (on ? cyan("❯ ") + bold(cyan(label)) : "  " + label) + (it.detail ? "  " + (on ? gray(it.detail) : dim(it.detail)) : "");
         }).map((l) => (cellWidth(l) > w ? l.slice(0, w + 12) : l));
+        if (above || below)
+            lines.push(dim(`  ${s.sel + 1}/${s.items.length}  ${above ? "↑" : " "}${below ? "↓" : " "}  ↑↓ move · PgUp/PgDn page`));
+        return lines;
     }
     tick = () => { this.frame++; this.render(); };
     ensureTimer() { if (!this.timer)
@@ -451,7 +458,7 @@ export class App {
         if (k.name === "enter" && !k.alt && !k.shift) {
             if (this.sugg && this.sugg.items.length) {
                 const it = this.sugg.items[this.sugg.sel];
-                if (!(this.sugg.kind === "slash" && ed.text.trim() === it.label))
+                if (!(this.sugg.kind === "slash" && ed.text.trim() === it.label) && !(this.sugg.kind === "arg" && (this.sugg.items.some((x) => x.label === this.sugg.token.query) || (it.open && !this.sugg.nav))))
                     return this.acceptSugg(true);
             }
             if (ed.text.slice(0, ed.cursorIndex).endsWith("\\")) {
@@ -461,10 +468,16 @@ export class App {
             }
             return void this.submit();
         }
+        if (this.sugg && (k.name === "pageup" || k.name === "pagedown")) {
+            const n = this.sugg.items.length;
+            this.sugg.sel = Math.max(0, Math.min(n - 1, this.sugg.sel + (k.name === "pageup" ? -8 : 8)));
+            return this.render();
+        }
         if (k.name === "up" || k.name === "down") {
             if (this.sugg) {
                 const n = this.sugg.items.length;
                 this.sugg.sel = (this.sugg.sel + (k.name === "up" ? n - 1 : 1)) % n;
+                this.sugg.nav = true;
                 return this.render();
             }
             if (!ed.vertical(k.name === "up" ? -1 : 1))
@@ -492,13 +505,25 @@ export class App {
         let items = [];
         if (tok.kind === "slash")
             items = rankCommands(tok.query, this.cmds);
+        else if (tok.kind === "arg") {
+            const cmd = this.cmds.find((c) => c.name === tok.cmd || c.alias === tok.cmd);
+            if (cmd) {
+                const r = argOptions(this, cmd.name, tok.words ?? []), pk = `${cmd.name}|${(tok.words ?? []).join(" ")}`;
+                if (r.pending && !this.argPending.has(pk)) {
+                    this.argPending.add(pk);
+                    void r.pending.catch(() => { }).then(() => { this.argPending.delete(pk); this.updateSugg(); this.render(); });
+                }
+                items = r.options.map((o) => ({ o, s: fuzzyScore(tok.query, o.value) })).filter((x) => x.s !== null)
+                    .sort((x, y) => (tok.query ? y.s - x.s : 0)).map(({ o }) => ({ label: o.value, insert: o.value + (o.more ? " " : ""), detail: o.detail, more: o.more, open: r.open }));
+            }
+        }
         else {
             if (!this.files.fresh())
                 void this.files.ensure().then(() => this.updateSugg(), () => { }); // list still loading: fill the popup in once it arrives
             items = rankFiles(tok.query, this.files.files);
         }
-        const keep = this.sugg && this.sugg.kind === tok.kind && this.sugg.token.query === tok.query ? this.sugg.sel : 0;
-        this.sugg = items.length ? { items, sel: Math.min(keep, items.length - 1), token: tok, kind: tok.kind } : null;
+        const same = this.sugg && this.sugg.kind === tok.kind && this.sugg.token.query === tok.query, keep = same ? this.sugg.sel : 0;
+        this.sugg = items.length ? { items, sel: Math.min(keep, items.length - 1), token: tok, kind: tok.kind, nav: same ? this.sugg.nav : false } : null;
         if (!this.sugg)
             return;
         this.schedule();
@@ -512,6 +537,8 @@ export class App {
         this.suggOff = "";
         if (fromEnter && s.kind === "slash" && !this.cmds.find((c) => "/" + c.name === s.items[s.sel].label)?.args)
             return void this.submit();
+        if (fromEnter && s.kind === "arg" && !s.items[s.sel].more)
+            return void this.submit(); // a finished value: run the command
         this.updateSugg();
         this.render();
     }

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

@@ -0,0 +1,12 @@
+import type { App } from "./app.ts";
+export type ArgOption = {
+    value: string;
+    detail?: string; /** more words are expected after this one: insert a space and do not submit */
+    more?: boolean;
+};
+export type ArgResult = {
+    options: ArgOption[];
+    pending?: Promise<unknown>; /** any value is allowed (a number, a model id, a command): Enter runs what you typed unless you moved into the list; Tab still completes */
+    open?: boolean;
+};
+export declare function argOptions(a: App, cmd: string, words: string[]): ArgResult;

package/dist/cli/tui/argcomplete.js

@@ -0,0 +1,55 @@
+// Completion for the words after a slash command: `/mode ` lists the modes, `/model ` the models your provider offers, `/theme ` the themes, and so on.
+// A completer returns its options now and, when it needs the network, a promise that settles when the list has been filled in (the menu refreshes then).
+import { effortsFor, loadPrompts, SANDBOX_MODES, SHELL_CHOICES, STRATEGIES } from "../../src/index.js";
+import { CLAUDE_MODELS, OPENAI_MODELS } from "../config.js";
+import { fetchModels } from "../models.js";
+import { themeNames, THEMES } from "./themes.js";
+const onOff = [{ value: "on" }, { value: "off" }];
+const opts = (...xs) => xs.map(([value, detail]) => ({ value, detail }));
+/** Known models with their hints first, then any other model the provider reports. The provider is asked once per ten minutes; until it answers, only the known models show. */
+const fetched = new Map();
+function modelOptions(a, extra = []) {
+    const known = a.cfg.provider === "anthropic" ? CLAUDE_MODELS : a.cfg.provider === "openai" ? OPENAI_MODELS : [];
+    const key = `${a.cfg.provider}|${a.cfg.baseUrl}`, have = fetched.get(key), fresh = have && Date.now() - have.at < 10 * 60_000;
+    const seen = new Set(known.map((m) => m.id));
+    const options = [...extra, ...known.map((m) => ({ value: m.id, detail: m.hint })), ...(have?.ids ?? []).filter((id) => !seen.has(id)).map((id) => ({ value: id, detail: "from your provider" }))];
+    if (fresh)
+        return { options, open: true };
+    return { options, open: true, pending: fetchModels({ provider: a.cfg.provider, baseUrl: a.cfg.baseUrl, apiKey: a.cfg.apiKey }).then((ids) => { fetched.set(key, { at: Date.now(), ids }); }) };
+}
+export function argOptions(a, cmd, words) {
+    const first = words.length === 0;
+    const ok = (options) => ({ options });
+    switch (cmd) {
+        case "mode": return first ? ok(opts(["default", "ask before edits and non-trivial commands"], ["acceptEdits", "edits are automatic, commands still ask"], ["plan", "read-only: investigate and propose a plan"], ["yolo", "never ask (dangerous)"])) : ok([]);
+        case "api": return first ? ok(opts(["auto", "pick Responses for reasoning models, self-correct"], ["responses", "OpenAI Responses API"], ["chat", "Chat Completions API"])) : ok([]);
+        case "effort": return first ? ok([{ value: "default", detail: "let the model decide" }, ...(a.cfg.provider === "anthropic" ? ["low", "medium", "high", "xhigh", "max"] : effortsFor(a.cfg.model)).map((e) => ({ value: e }))]) : ok([]);
+        case "model": return first ? modelOptions(a) : ok([]);
+        case "models": return first ? ok([...["explore", "compact", "review", "cheap"].map((r) => ({ value: r, detail: `model for ${r} steps`, more: true })), { value: "fallback", detail: "answer from this model when the main one is down", more: true }])
+            : words.length === 1 ? modelOptions(a, [{ value: "off", detail: "use the main model" }]) : ok([]);
+        case "theme": return first ? ok(themeNames().map((n) => ({ value: n, detail: THEMES[n].label }))) : ok([]);
+        case "shell": return first ? ok(SHELL_CHOICES.map((n) => ({ value: n, detail: n === "auto" ? "detect from your system" : undefined }))) : ok([]);
+        case "strategy": return first ? ok([...Object.keys(STRATEGIES).map((n) => ({ value: n })), { value: "off", detail: "the default loop" }]) : ok([]);
+        case "prompt": return first ? ok([...loadPrompts(a.cwd).map((p) => ({ value: p.id, detail: "from .amness/prompts" })), { value: "list" }, { value: "off", detail: "the built-in prompt" }]) : ok([]);
+        case "sandbox": return first ? ok(SANDBOX_MODES.map((m) => ({ value: m, detail: m === "off" ? "no isolation" : m === "workspace" ? "writes only in the project" : "no network, caches read-only" }))) : ok([]);
+        case "diffmode": return first ? ok(opts(["auto"], ["stacked"], ["split"])) : ok([]);
+        case "ui": return first ? ok(opts(["full", "full-screen"], ["inline", "scrolls with the terminal"])) : ok([]);
+        case "mouse":
+        case "keepwarm":
+        case "lsp":
+        case "approver":
+        case "reviewer":
+        case "router": return first ? ok(onOff) : ok([]);
+        case "copy": return first ? ok(opts(["code", "the last code block"], ["all", "the whole conversation"])) : ok([]);
+        case "memory": return first ? ok([...["forget", "add"].map((v) => ({ value: v, more: true })), ...["stale", "prune", "consolidate", "graph", "embeddings"].map((v) => ({ value: v }))]) : ok([]);
+        case "permissions": return first ? ok([{ value: "list" }, ...["allow", "ask", "deny"].map((v) => ({ value: v, detail: `e.g. /permissions ${v} sh(npm test*)`, more: true }))]) : ok([]);
+        case "branch": return first ? ok(a.session.turns.map((t, i) => ({ value: String(i + 1), detail: t.text.replace(/\s+/g, " ").slice(0, 60) }))) : ok([]);
+        case "pr": return first ? ok(opts(["draft", "create it as a draft"])) : ok([]);
+        case "report": return first ? ok([{ value: "case", detail: "turn the last request into an eval task", more: true }]) : ok([]);
+        case "mcp": return first ? ok([{ value: "list" }, { value: "off" }]) : ok([]);
+        case "budget": return first ? { options: opts(["100k"], ["300k", "the default"], ["500k"], ["1m"], ["2m"]), open: true } : ok([]);
+        case "check":
+        case "verify": return first ? { options: [{ value: "off", detail: "switch it off" }], open: true } : ok([]);
+        default: return ok([]);
+    }
+}

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

@@ -16,6 +16,8 @@ export type RenderCtx = {
     diffMode: "auto" | "stacked" | "split";
     /** The block above is also a tool call: draw no blank line between them, so a run of tool calls reads as one unit. */
     tight?: boolean;
+    /** this is the most recent tool call of the lead agent: its output stays open (a short preview) until the next one starts */
+    last?: boolean;
 };
 export type Hit = {
     row: number;

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,9 @@ 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 { bold, cyan, dim, green, red, yellow } from "../ui.js";
 import { estimateCost, fmtCost, fmtDuration, fmtTokens } from "./pricing.js";
 import { codeBlocks } from "./clipboard.js";
@@ -16,6 +17,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 +47,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 +69,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 +158,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();

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

@@ -1,5 +1,6 @@
 // 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 { basename } from "node:path";
 import { A, mix } from "./ansi.js";
 import { brandOfModel } from "./brand.js";
@@ -162,6 +163,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 +171,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 +184,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;
@@ -406,13 +408,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 +596,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/docs/providers.md

@@ -69,6 +69,17 @@ The model list in `/model` (with prices per million tokens as shown in the picke
 - If the chat says "check your key with /provider", the provider answered with an authentication error (401 or 403).
 - The test call checks that the model replies. It does not check that the model can call tools.
 
+## Connect several providers
+
+You can keep a key for every provider at the same time. Each key is saved on its own (in the Keychain, the Linux keyring or DPAPI), so switching provider never overwrites another key.
+
+1. In the chat, type `/connect`. You see every provider with `●` (connected) or `○` (not connected), and where the key comes from: a saved key, or an environment variable.
+2. Choose a provider. If it has no key, Amness asks for one (hidden). If it has one, you can use it now, replace the key, or remove the saved key.
+3. The menu stays open, so you can add the next provider. Press `Esc` when you are done.
+4. Switch between them with `/provider`. Amness uses the saved key of the provider you pick, and asks only if there is none.
+
+An environment variable wins over a saved key for its own provider: `ANTHROPIC_API_KEY` for Claude, `OPENROUTER_API_KEY` (or `OPENAI_API_KEY`) for OpenRouter, and `OPENAI_API_KEY` for the others. Environment keys are never saved. **Limit:** a key from an older version moves to the provider that was active when you first start the new version, so check `/connect` once.
+
 ## Switch provider, model or effort
 
 **How to switch in the chat.**
@@ -152,7 +163,8 @@ In `auto` mode Amness fixes these cases for you:
 
 | Variable | What it does |
 |---|---|
-| `OPENAI_API_KEY` | The key for every provider except `anthropic`. |
+| `OPENAI_API_KEY` | The key for every provider except `anthropic` (and for OpenRouter when `OPENROUTER_API_KEY` is not set). |
+| `OPENROUTER_API_KEY` | The key for `openrouter`. |
 | `ANTHROPIC_API_KEY` | The key for `anthropic`. |
 | `OPENAI_BASE_URL` | The base URL for non-Claude providers. |
 | `AMNESS_MODEL` | The model id. It wins over the saved config. |

package/docs/safety.md

@@ -40,15 +40,15 @@ Notes about the provider:
 
   | System | Where the key is saved | Protection |
   |---|---|---|
-  | macOS | the login Keychain (service `amness`) | encrypted by macOS |
+  | macOS | the login Keychain (service `amness`, one entry per provider, for example `apiKey-anthropic`) | encrypted by macOS |
   | Linux with a desktop keyring | the secret service, through `secret-tool` | encrypted by the keyring |
-  | Windows | `~/.amness/secrets/apiKey.dpapi` | encrypted with DPAPI: only your Windows user on this machine can decrypt it |
+  | Windows | `~/.amness/secrets/apiKey-<provider>.dpapi` | encrypted with DPAPI: only your Windows user on this machine can decrypt it |
   | Docker or Kubernetes | nowhere: kept in memory for that run | nothing is written to the image or a volume. Pass the key as an environment variable or a secret file (`ANTHROPIC_API_KEY_FILE=/run/secrets/anthropic`). |
   | Linux server with no keyring | `~/.amness/config.json` with mode 600 | **not encrypted**, only your user can read it. Prefer an environment variable or your platform's secret manager. |
 
 - Amness passes the key to the system tool on standard input, never on the command line, where other users could see it in the process list.
 - A key that an older version saved in `config.json` is moved to the key store the next time you start Amness, and removed from the file once the move is checked.
-- To remove a saved key, open the settings and clear "API key", or on macOS run `security delete-generic-password -s amness -a apiKey`.
+- To remove a saved key, open the settings and clear "API key", or on macOS run `security delete-generic-password -s amness -a apiKey-anthropic` (use `apiKey-openai` and so on for the others).
 - The environment variable wins over the saved key.
 - Amness does not write keys into a project folder.
 - Commands the agent runs do not get your Amness keys. The variables `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, `TAVILY_API_KEY`, `OPENROUTER_API_KEY` and `AMNESS_OTLP` are removed from their environment (`childEnv` in `src/secrets.ts`).

package/docs/usage.md

@@ -92,7 +92,9 @@ amness --inline
 - Set the environment variable `AMNESS_UI=inline`.
 - Type `/ui inline` in the chat. `/ui full` goes back.
 
-**What you see.** Each tool call is one line, for example `● Read(src/a.ts)`, with a short result. `Ctrl+O` shows everything. Each edit shows a diff with line numbers. A live todo list, a status line (elapsed time and tokens) and a footer (permission mode, git branch, model, context gauge, estimated cost) stay visible. Tool bullets have a colour for each kind and turn red when the tool fails. With `NO_COLOR=1`, or when the output is piped, Amness uses plain text.
+**What you see.** Each tool call is one line, for example `● Read(src/a.ts)`, with a short result. `Ctrl+O` shows everything. Each edit shows a diff with line numbers.
+
+In the full-screen view, the **most recent** tool call stays open. A shell command shows `$ the command` and its output, up to 20 lines. When the next tool call starts, the earlier one folds to one line again. Click a line to open or close it yourself. If the output is longer than 20 lines, the card says how many are hidden. Type `/output` to read all of it in a pager (`/output 2` for the call before). A lone file read does not open itself. A live todo list, a status line (elapsed time and tokens) and a footer (permission mode, git branch, model, context gauge, estimated cost) stay visible. Tool bullets have a colour for each kind and turn red when the tool fails. With `NO_COLOR=1`, or when the output is piped, Amness uses plain text.
 
 ## Type in the input box
 
@@ -204,14 +206,36 @@ The file is attached to your message. In the transcript you see a note such as "
 
 ## Slash commands
 
-Type `/` in the input box to see the popup. `/help` lists the commands in the chat.
+Type `/` in the input box to see the popup. It lists **every** command, grouped under titles: Conversation, Model & keys, Safety, Quality, Project, Extend and Interface. Your own and plugin commands go under Custom.
+
+- Move with `↑` and `↓`. `PgUp` and `PgDn` jump eight at a time. The top of the box shows where you are, for example `12/60 ↓`.
+- Keep typing to filter. The titles disappear and the best match comes first.
+- `Tab` or `Enter` picks the command. `Esc` closes the popup.
+
+**Completion after the command.** Type a command and a space, and the popup lists the values it accepts, each with a short explanation:
+
+| You type | The popup shows |
+|---|---|
+| `/mode ` | `default`, `acceptEdits`, `plan`, `yolo` |
+| `/model ` | the known models with their hints, then every other model your provider reports (OpenAI, Claude, OpenRouter, Ollama and other OpenAI-compatible servers). Amness asks the provider once and remembers the answer for ten minutes. If the provider cannot be reached, you still see the known models. |
+| `/models ` | the roles (`explore`, `compact`, `review`, `cheap`, `fallback`), then the models |
+| `/effort `, `/api `, `/theme `, `/shell `, `/strategy `, `/prompt `, `/sandbox `, `/diffmode `, `/ui ` | their choices |
+| `/keepwarm `, `/lsp `, `/approver `, `/reviewer `, `/router `, `/mouse ` | `on`, `off` |
+| `/branch ` | your turns, numbered, with the first words of each |
+| `/memory `, `/permissions `, `/copy `, `/pr `, `/report `, `/mcp `, `/budget `, `/check `, `/verify ` | their sub-commands or common values |
+
+`Enter` picks the highlighted value and runs the command. For commands that take free text or a number (`/model`, `/budget`, `/check`, `/verify`), `Enter` runs exactly what you typed unless you moved into the list with the arrow keys, so a model id that is not in the list still works. `Tab` always completes. Commands that need more words (`/memory add`, `/permissions allow`) add a space and wait.
+
+`/help` lists the commands in the chat.
 
 ### Models and providers
 
 | Command | What it does |
 |---|---|
 | `/model [id]` | Switches the model. Without an id, it opens a picker. |
-| `/provider` | Switches the provider (OpenAI, Claude, OpenRouter, Ollama, custom). The choice is saved. |
+| `/output [n]` (alias `/last`) | Shows the full output of the last tool call in a pager. `/output 2` shows the one before. |
+| `/provider` | Switches the provider (OpenAI, Claude, OpenRouter, Ollama, custom). The list shows `●` for providers that are connected and `○` for those that are not. Each provider uses its own saved key. |
+| `/connect` (alias `/keys`) | Opens the key manager. See which providers are connected, add a key for any of them, replace or remove one, or switch to it. Add as many as you want. |
 | `/effort [level]` | Sets the reasoning effort. Levels depend on the model. `default` lets the model decide. |
 | `/api [auto\|responses\|chat]` | Chooses the OpenAI wire API. It does not apply to Claude. |
 | `/models [role model]` | Uses another model for `explore`, `compact`, `review` or `cheap`. `/models fallback <model>` sets a model for when the main one is overloaded or not reachable. Use `off` to clear a role. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amness",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "type": "module",
   "description": "A terminal coding agent for any model: streaming chat TUI, permission modes, plan mode, undo, memory, MCP, with a small reliability harness underneath. OpenAI (Responses API), Claude, and local models.",
   "license": "MIT",