@vigent/cli 0.3.1 → 0.3.3

package/README.md

@@ -4,7 +4,7 @@ A vim-style, lightweight terminal app for running several coding agents at once,
 
 **Website:** [vigent.farming-labs.dev](https://vigent.farming-labs.dev) · **Docs:** [vigent.farming-labs.dev/docs](https://vigent.farming-labs.dev/docs)
 
-![vigent running a Claude Code agent in its own worktree, with the sessions and engines sidebars](docs/screenshots/showcase.png)
+![vigent running a Claude Code agent in its own worktree, with the sessions and engines sidebars](https://vigent.farming-labs.dev/showcase.png)
 
 ## Install
 
@@ -85,6 +85,7 @@ Bump `version` in package.json, merge, then push a matching tag (`git tag v0.2.0
 | NORMAL | `i` / `a` / `o` | Enter INSERT and type a prompt for the focused agent (it waits in a queue if the agent is busy). With no agent yet, the prompt starts one |
 | NORMAL | `j` `k` `gg` `G` `Ctrl-d` `Ctrl-u` `{` `}` | Scroll the transcript, or jump between messages |
 | NORMAL | `]s` `[s` `1`–`9` `Ctrl-^` | Switch agents |
+| NORMAL | `<Space>e` | Move the cursor into the SESSIONS sidebar, like neo-tree: `j`/`k` (or `gg`/`G`, `1`–`9`) pick an agent and show it, Enter / Esc / `l` / `<Space>e` go back to the transcript |
 | NORMAL | `za` `zR` `zM` | Toggle, open or close tool-output folds |
 | NORMAL | `/pattern` `?pattern` `n` `N` | Search the transcript, forward or backward |
 | NORMAL | `V` / `v` | VISUAL: select lines with `j` `k`, `ib` for a code block, `y` to copy |
@@ -97,7 +98,7 @@ Copies go to the system clipboard through the terminal (OSC 52), so they work ov
 
 ## Engines: pi, Claude Code, Codex, OpenCode
 
-pi runs inside vigent. Claude Code, Codex and OpenCode are the CLIs you may already use: vigent runs them as installed, in the agent's worktree, so each one uses its own login and settings. vigent never reads their credentials; it only runs their version and sign-in status commands to show what's connected.
+pi runs inside vigent. Claude Code, Codex and OpenCode are the CLIs you may already use: vigent runs them as installed, in the agent's worktree, so each one uses its own login and settings. vigent never reads their credentials; it only runs their version and sign-in status commands to show what's connected. If `ANTHROPIC_API_KEY` is set and Claude Code is also signed in with a Claude account, vigent runs Claude Code without that variable, so it uses your account (a key that isn't scoped to a workspace, or is out of credit, would otherwise fail every request). `:checkhealth` says so: *signed in (Claude account; ANTHROPIC_API_KEY left out)*.
 
 ```vim
 :new fix the race --engine codex            " this agent runs Codex
@@ -113,10 +114,12 @@ The sidebar's ENGINES block shows each one: `●` signed in, `◐` installed but
 | `codex` | `codex exec --json` (`exec resume` to continue) | `-c sandbox_mode="workspace-write"` |
 | `opencode` | `opencode run --format json --dir <worktree>` | none |
 
-**Model and effort:** `:model` (`<Space>M`) opens a picker with the models the agent's engine offers (Claude Code's model names, Codex's own catalog from `codex debug models`, OpenCode's `opencode models`, or pi's for the providers you have a key for). In the picker, `j`/`k` move, `g`/`G` jump to the top or bottom, Enter picks and `q` or Esc closes. Press `/` to search, or to type any model name. `:effort` (`<Space>e`) sets the reasoning effort (pi: thinking level). Both apply from the next prompt, show in the winbar and survive a restart. With no agent open, they set the defaults for new agents.
+**Model and effort:** `:model` (`<Space>M`) opens a picker with the models the agent's engine offers (Claude Code's model names, Codex's own catalog from `codex debug models`, OpenCode's `opencode models`, or pi's for the providers you have a key for). In the picker, `j`/`k` move, `g`/`G` jump to the top or bottom, Enter picks and `q` or Esc closes. Press `/` to search, or to type any model name. `:effort` (`<Space>R`) sets the reasoning effort (pi: thinking level). Both apply from the next prompt, show in the winbar and survive a restart. With no agent open, they set the defaults for new agents.
 
 Change the arguments or the model per engine in `[engines.<id>]` ([docs/config.md](https://github.com/farming-labs/vigent/blob/main/docs/config.md#engines)).
 
+**Permissions:** with `-p`, Claude Code can't stop to ask before running a command it isn't allowed, so it refuses it (for example `gh` or `cargo` under `acceptEdits`). vigent shows what was refused. You can allow commands up front with `[engines.claude] allow = ["Bash(gh:*)"]`. Or opt in with `ask = true`: vigent then asks **allow once / always allow / no** and runs the agent again with the permission ([details](https://github.com/farming-labs/vigent/blob/main/docs/config.md#when-claude-code-is-refused-a-tool)).
+
 ### pi extensions, skills and prompt templates
 
 A pi agent loads what pi itself would load. That covers extensions from `~/.pi/agent/extensions/` and `.pi/extensions/`, and the packages you installed with pi. It also covers skills, prompt templates, and the project's `AGENTS.md`.

package/dist/app.js

@@ -19,6 +19,7 @@ import { dropPatch, parseDiff, restorePatch } from "./hunks.js";
 import { HunkReview } from "./hunk-review.js";
 import { listFiles, MENTION, mentionable } from "./attach.js";
 import { allTemplates, fillTemplate, needsTask } from "./templates.js";
+import { describeDenial } from "./cli-engines.js";
 import { startServer } from "./serve.js";
 import { didYouMean } from "./suggest.js";
 import { alertSequence, NOTIFY_MODES } from "./notify.js";
@@ -64,6 +65,7 @@ const ICONS = {
         here: "●",
         unread: "◆",
         serve: "⇄ ",
+        light: "✦",
         ok: "●",
         warn: "◐",
         off: "○",
@@ -87,6 +89,7 @@ const ICONS = {
         here: NERD.circle,
         unread: NERD.bell,
         serve: "\uf10b ",
+        light: "\uf0e7",
         ok: NERD.check,
         warn: NERD.warning,
         off: NERD.circleO,
@@ -110,6 +113,7 @@ const ICONS = {
         here: "*",
         unread: "!",
         serve: "~ ",
+        light: "*",
         ok: "+",
         warn: "~",
         off: "-",
@@ -125,6 +129,10 @@ export class App {
     mode = "NORMAL";
     sessions = [];
     focusIdx = 0;
+    /** <leader>e: the cursor is in the SESSIONS sidebar (j/k pick an agent, Enter / Esc / l go back) */
+    sidebarFocused = false;
+    /** a key typed in the sidebar that needs a second one (gg, <leader>e) */
+    sidebarPending = "";
     altIdx = 0;
     cmdBuf = "";
     inputBuf = "";
@@ -214,6 +222,8 @@ export class App {
     addSession(s, focus = true) {
         if ("extensionStatus" in s)
             s.uiHost = this.piUiHost(s);
+        if (s.engine === "claude" && "asksToAllow" in s)
+            s.approver = (blocked, rules) => this.askToAllow(s, blocked, rules);
         queueMicrotask(() => this.server?.sync());
         this.sessions.push(s);
         this.lastState.set(s, s.state);
@@ -363,6 +373,10 @@ export class App {
         const key = keyFromInput(data);
         if (!key)
             return;
+        if (this.sidebarFocused && this.sidebarKey(key)) {
+            this.tui.requestRender();
+            return;
+        }
         if (this.mode === "NORMAL" && this.seq.pendingKeys.length === 0)
             this.message = "";
         for (const k of this.splitEscape(key))
@@ -550,6 +564,8 @@ export class App {
                 return;
             case "session.alternate":
                 return this.focusSession(this.altIdx);
+            case "sidebar.focus":
+                return this.toggleSidebarFocus();
             case "session.goto": {
                 const n = Number(arg);
                 if (!Number.isInteger(n) || n < 1)
@@ -1478,7 +1494,7 @@ export class App {
                 this.refreshStorage();
             const by = s.engine !== "pi" ? ` · ${ENGINE_NAMES[s.engine]}` : "";
             if (wt?.path) {
-                const how = wt.riftri ? ` · riftri ${wt.riftri}` : wt.riftriSkipped ? " · full copy (riftri declined: :checkhealth)" : "";
+                const how = wt.riftri ? " · lightweight copy" : wt.riftriSkipped ? " · full copy (:checkhealth says why)" : "";
                 this.setMessage(`'${name}'${by} on ${wt.branch} in ${this.shortPath(wt.path)}${wt.base ? ` (from ${wt.base})` : ""}${how}`, wt.riftriSkipped ? "WarningMsg" : "ModeMsg");
             }
             else if (wt) {
@@ -1712,6 +1728,24 @@ export class App {
             setStatus: (key, text) => s.setExtensionStatus?.(key, text),
         };
     }
+    /**
+     * Claude Code refused an agent some tools ([engines.claude] ask = true):
+     * allow them for one retry, always (saved to config.toml), or leave them blocked.
+     */
+    askToAllow(s, blocked, rules) {
+        return new Promise((resolve) => {
+            if (s !== this.focusedSession || !this.terminalFocused)
+                this.alert(alertSequence(`vigent: '${s.name}' needs a permission`, this.ui.notify));
+            const what = [...new Set(blocked.map(describeDenial))].join(" · ");
+            const list = rules.join(", ");
+            this.openChoices(`'${s.name}' was blocked · ${what}`, [
+                { value: "allow once", note: `${list}, for this retry` },
+                { value: "always allow", note: `${list}, saved to [engines.claude] allow` },
+                { value: "no", note: "leave it blocked" },
+            ], "", false, (v) => resolve(v === "allow once" ? "once" : v === "always allow" ? "always" : undefined), { onCancel: () => resolve(undefined), rows: 3 });
+            this.tui.requestRender();
+        });
+    }
     /** `:pi`: what pi loaded for the focused agent. Enter on a command, skill or prompt starts a prompt with it. */
     openPiResources() {
         const s = this.focusedSession;
@@ -2549,7 +2583,7 @@ export class App {
         const s = this.focusedSession;
         const left = s ? ` ${this.icons.open_agent} ${s.name}` : ` ${this.icons.open_agent} [no agent]`;
         const model = s ? `  ${s.engine !== "pi" && s.model !== ENGINE_NAMES[s.engine] ? `${ENGINE_NAMES[s.engine]} · ` : ""}${s.model}${s.effort ? ` · ${s.effort}` : ""}` : "";
-        const where = s?.worktree?.path ? `${this.shortPath(s.worktree.path)}${s.worktree.riftri ? " · riftri" : ""}` : s ? "this checkout" : "";
+        const where = s?.worktree?.path ? `${this.shortPath(s.worktree.path)}${s.worktree.riftri ? ` ${this.icons.light}` : ""}` : s ? "this checkout" : "";
         const ext = s && "extensionStatus" in s ? [...s.extensionStatus.values()].join(" · ") : "";
         const status = (s?.state === "paused" ? "  paused" : s?.queue.length ? `  ${this.icons.queued}${s.queue.length} queued` : "") + (ext ? `  ${ext}` : "");
         // the path gives way first (from its start: the end names the worktree), always two spaces before it
@@ -2629,6 +2663,88 @@ export class App {
      *   winbar header, number column (session index, used by 1-9),
      *   tree guides, cursorline on the focused session, ~ filler rows.
      */
+    /** <leader>e, like neo-tree in Neovim: move the cursor into the SESSIONS sidebar, or back to the transcript. */
+    toggleSidebarFocus() {
+        if (this.sidebarFocused)
+            return this.leaveSidebar();
+        if (this.sessions.length === 0) {
+            this.setMessage("no agents yet (i or :new starts one)", "Comment");
+            return;
+        }
+        if (this.sidebarWidth(this.terminal.columns) === 0) {
+            // no room for the sidebar (or it's turned off): the same choice as a list
+            this.openDashboard();
+            return;
+        }
+        this.mode = "NORMAL";
+        this.sidebarFocused = true;
+        this.sidebarPending = "";
+        this.sidebarHint();
+    }
+    leaveSidebar() {
+        this.sidebarFocused = false;
+        this.sidebarPending = "";
+        this.message = "";
+    }
+    sidebarHint() {
+        const s = this.focusedSession;
+        this.setMessage(`-- SESSIONS -- ${s ? `${this.focusIdx + 1} ${s.name} · ` : ""}j/k move · Enter open · Esc back`, "ModeMsg");
+    }
+    /** A key while the sidebar has the cursor. Keys it doesn't use go back to the transcript and run there. */
+    sidebarKey(key) {
+        const n = this.sessions.length;
+        const pending = this.sidebarPending;
+        this.sidebarPending = "";
+        const go = (i) => {
+            if (n === 0)
+                return;
+            this.focusSession(Math.max(0, Math.min(n - 1, i)));
+            this.sidebarHint();
+        };
+        if (pending === this.keymap.leader && key === "e") {
+            this.leaveSidebar();
+            return true;
+        }
+        switch (key) {
+            case "j":
+            case "<Down>":
+                go(this.focusIdx + 1);
+                return true;
+            case "k":
+            case "<Up>":
+                go(this.focusIdx - 1);
+                return true;
+            case "G":
+                go(n - 1);
+                return true;
+            case "g":
+                if (pending === "g")
+                    go(0);
+                else
+                    this.sidebarPending = "g";
+                return true;
+            case "<CR>":
+            case "l":
+            case "o":
+            case "<Esc>":
+            case "q":
+                this.leaveSidebar();
+                return true;
+        }
+        if (/^[1-9]$/.test(key)) {
+            go(Number(key) - 1);
+            return true;
+        }
+        if (key === this.keymap.leader) {
+            this.sidebarPending = key;
+            return true;
+        }
+        // anything else (:, i, /, ...) works as usual, back in the transcript
+        this.leaveSidebar();
+        if (pending === this.keymap.leader)
+            this.seq.feed(pending);
+        return false;
+    }
     renderSidebar(w, h) {
         const P = this.painter;
         const base = P.attr("VigentSidebar");
@@ -2650,16 +2766,17 @@ export class App {
         // winbar
         const running = this.sessions.filter((x) => x.state === "running").length;
         const right = running > 0 ? `${running} running ` : `${this.sessions.length} `;
-        const title = " SESSIONS";
+        const title = this.sidebarFocused ? `${I.folded} SESSIONS` : " SESSIONS";
         lines.push(row([
-            ["WinBar", title],
+            [this.sidebarFocused ? "Title" : "WinBar", title],
             ["VigentSidebar", " ".repeat(Math.max(1, w - visibleWidth(title) - visibleWidth(right)))],
             ["Comment", right],
         ]));
         this.sessions.forEach((s, i) => {
             const last = i === this.sessions.length - 1;
             const focused = i === this.focusIdx;
-            const rowBg = focused ? clBg : bg;
+            // with the cursor in the sidebar, its row reads as a selection
+            const rowBg = focused ? (this.sidebarFocused ? (P.attr("PmenuSel").bg ?? P.attr("Visual").bg ?? clBg) : clBg) : bg;
             const glyphGroup = s.state === "running"
                 ? "String"
                 : s.state === "waiting"
@@ -2780,7 +2897,7 @@ export class App {
                 case "agent": {
                     push("", "");
                     const text = item.text + (item.streaming ? ` ${I.cursor}` : "");
-                    const md = renderMarkdown(text, paneW, P, I.bullet, nextBlock);
+                    const md = renderMarkdown(text, paneW, P, I.bullet, nextBlock, { ascii: this.ui.icons === "ascii" });
                     md.lines.forEach((l, i) => push(P.s("Normal") + l.text + RESET, l.plain, { item: n, start: i === 0, block: l.block, label: l.label }));
                     nextBlock += md.blocks;
                     break;

package/dist/cli-engines.js

@@ -29,6 +29,7 @@ export const claudeAdapter = {
             "--verbose",
             "--include-partial-messages",
             ...(o.extraArgs ?? this.defaultArgs),
+            ...(o.allowedTools?.length ? ["--allowedTools", ...o.allowedTools] : []),
             ...(o.model ? ["--model", o.model] : []),
             ...(o.effort ? ["--effort", o.effort] : []),
             ...(o.resumeId ? ["--resume", o.resumeId] : []),
@@ -82,6 +83,14 @@ export const claudeAdapter = {
                         out.push({ type: "usage", tokens, ...(cost !== undefined ? { cost } : {}) });
                     if (e.session_id)
                         out.push({ type: "session", id: e.session_id });
+                    if (Array.isArray(e.permission_denials) && e.permission_denials.length) {
+                        out.push({
+                            type: "denied",
+                            tools: e.permission_denials
+                                .filter((d) => d && typeof d.tool_name === "string")
+                                .map((d) => ({ name: d.tool_name, input: d.tool_input })),
+                        });
+                    }
                     const ok = !e.is_error && e.subtype === "success";
                     out.push({ type: "done", ok, ...(ok ? {} : { error: String(e.result ?? e.errors?.join?.("; ") ?? e.subtype ?? "failed") }) });
                     break;
@@ -270,6 +279,8 @@ export class CliSession extends Session {
     aborted = false;
     /** the model the user asked for; undefined = the CLI's own default */
     requestedModel;
+    /** asks you whether to allow tools the CLI refused (set by the app when [engines.claude] ask is on) */
+    approver;
     constructor(name, engine, model, opts) {
         super(name, model ?? ENGINE_NAMES[engine], opts.worktree);
         this.opts = opts;
@@ -304,6 +315,14 @@ export class CliSession extends Session {
     }
     send(text) {
         this.pushUser(text);
+        this.run(text);
+    }
+    /** whether a refused tool can be asked about (opt-in, and only Claude Code reports them) */
+    get asksToAllow() {
+        return !!this.opts.ask && this.engine === "claude";
+    }
+    /** One run of the CLI; `once` are permission rules for this run only. */
+    run(text, once = []) {
         this.setState("running");
         this.aborted = false;
         const attached = expandPrompt(text, this.adapter.id, this.cwd);
@@ -316,12 +335,13 @@ export class CliSession extends Session {
             effort: this.effort,
             resumeId: this.resumeId,
             extraArgs: this.opts.extraArgs,
+            allowedTools: [...new Set([...(this.opts.allow?.() ?? []), ...once])],
         });
         let child;
         try {
             child = spawn(this.opts.bin ?? this.adapter.bin, args, {
                 cwd: this.cwd,
-                env: this.opts.env ?? process.env,
+                env: typeof this.opts.env === "function" ? this.opts.env() : (this.opts.env ?? process.env),
                 stdio: ["ignore", "pipe", "pipe"],
             });
         }
@@ -335,6 +355,7 @@ export class CliSession extends Session {
         let stderr = "";
         let result;
         let lastError;
+        let denied = [];
         const tools = new Map();
         const handle = (ev) => {
             switch (ev.type) {
@@ -396,6 +417,9 @@ export class CliSession extends Session {
                 case "error":
                     lastError = ev.message;
                     break;
+                case "denied":
+                    denied = ev.tools;
+                    break;
                 case "done":
                     result = ev;
                     break;
@@ -442,6 +466,8 @@ export class CliSession extends Session {
                 return;
             }
             const ok = result ? result.ok : code === 0 && !lastError;
+            if (denied.length && this.blocked(denied))
+                return;
             if (ok) {
                 this.setState("idle");
                 return;
@@ -453,6 +479,35 @@ export class CliSession extends Session {
             this.fail(`${this.engineName}: ${why}`);
         });
     }
+    /**
+     * The CLI refused some tools. Say which; with [engines.claude] ask on, ask
+     * whether to allow them and run again. True when it's now asking you.
+     */
+    blocked(denied) {
+        const what = [...new Set(denied.map((d) => this.relative(describeDenial(d))))];
+        const rules = [...new Set(denied.map(allowRule))];
+        this.pushInfo(`blocked by ${this.engineName}'s permissions: ${what.join(" · ")}`);
+        if (!this.asksToAllow || !this.approver) {
+            if (this.engine === "claude")
+                this.pushInfo(`to allow it, in config.toml: [engines.claude] allow = ${JSON.stringify(rules)} (or ask = true, to be asked each time)`);
+            return false;
+        }
+        this.setState("waiting");
+        this.approver(denied, rules).then((choice) => {
+            if (this.state !== "waiting")
+                return; // aborted, or a new prompt was sent meanwhile
+            if (!choice) {
+                this.pushInfo("left blocked");
+                this.setState("idle");
+                return;
+            }
+            if (choice === "always")
+                this.opts.onAlwaysAllow?.(rules);
+            this.pushInfo(`${choice === "always" ? "always allowed" : "allowed once"}: ${rules.join(", ")} · retrying`);
+            this.run(`You now have permission to use ${rules.join(", ")}. Retry what was blocked, then carry on with the task.`, rules);
+        }, () => this.setState("idle"));
+        return true;
+    }
     /** paths inside the agent's folder, shown relative to it */
     relative(text) {
         let out = text;
@@ -507,6 +562,29 @@ function safeRealpath(p) {
         return undefined;
     }
 }
+/** A refused tool call, short: the command for Bash, the tool name and its target otherwise. */
+export function describeDenial(d) {
+    if (d.name === "Bash" && typeof d.input?.command === "string")
+        return d.input.command.replace(/\s+/g, " ").trim().slice(0, 80);
+    const s = summarize(d.input);
+    return s ? `${d.name} ${s}`.slice(0, 80) : d.name;
+}
+/**
+ * The Claude Code permission rule that allows a refused call: `Bash(gh:*)`
+ * for a command (its program, any arguments), the tool's name otherwise.
+ */
+export function allowRule(d) {
+    if (d.name === "Bash" && typeof d.input?.command === "string") {
+        // skip leading VAR=value assignments; the program is the first word
+        const words = d.input.command.trim().split(/\s+/).filter((w) => w);
+        const prog = words.find((w) => !/^[A-Za-z_][A-Za-z0-9_]*=/.test(w));
+        const m = prog && /^[^\s;&|()<>`$'"]+/.exec(prog);
+        if (m)
+            return `Bash(${m[0]}:*)`;
+        return "Bash";
+    }
+    return d.name;
+}
 function contentOf(message) {
     return Array.isArray(message?.content) ? message.content : [];
 }

package/dist/cli.js

@@ -9,8 +9,9 @@ import { App } from "./app.js";
 import { FOCUS_REPORTING_OFF, FOCUS_REPORTING_ON } from "./notify.js";
 import { staleBuild, VERSION_TEXT } from "./version.js";
 import { CliSession } from "./cli-engines.js";
-import { defaultEngine, detectEngines, ENGINE_BINS, isEngineId, onPath, piConnected, quickEngines } from "./engines.js";
+import { defaultEngine, detectEngines, ENGINE_BINS, isEngineId, onPath, piConnected, quickEngines, engineEnv } from "./engines.js";
 import { CONFIG_TEMPLATE, configPath, loadConfig } from "./config.js";
+import { setTomlValue } from "./config-edit.js";
 import { createDemoSessions } from "./demo.js";
 import { buildKeymap, KEY_MODES } from "./keys.js";
 import { formatBytes, prepareViews, riftriBackends, riftriGc, riftriHealth, riftriStateDir } from "./riftri.js";
@@ -299,6 +300,22 @@ async function main() {
     detectEngines()
         .then((engines) => app.setEngines(engines))
         .catch(() => { });
+    /** "always allow": add the rules to [engines.<id>] allow, here and in config.toml. Returns why it couldn't save. */
+    const alwaysAllow = (engine, rules) => {
+        const e = (config.engines[engine] ??= {});
+        e.allow = [...new Set([...(e.allow ?? []), ...rules])];
+        const file = configPath();
+        try {
+            const text = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : CONFIG_TEMPLATE;
+            const list = `[${e.allow.map((r) => JSON.stringify(r)).join(", ")}]`;
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, setTomlValue(text, `engines.${engine}`, "allow", list));
+            return undefined;
+        }
+        catch (err) {
+            return `allowed for now, but couldn't save to ${file}: ${err.message}`;
+        }
+    };
     /** A Claude Code / Codex / OpenCode agent; its conversation id is saved so it survives a restart. */
     const cliSession = (name, engine, requested, cwd, wt, resumeId, effort) => new CliSession(name, engine, requested, {
         cwd,
@@ -306,6 +323,16 @@ async function main() {
         resumeId,
         effort,
         extraArgs: config.engines[engine]?.args,
+        // e.g. Claude Code without ANTHROPIC_API_KEY when it has a Claude account (see detectClaude)
+        env: () => engineEnv(app.engines?.find((e) => e.id === engine)),
+        // Claude Code's permission rules: [engines.claude] allow, and ask (opt-in) to allow a refused tool and retry
+        allow: () => config.engines[engine]?.allow,
+        ask: config.engines[engine]?.ask,
+        onAlwaysAllow: (rules) => {
+            const why = alwaysAllow(engine, rules);
+            if (why)
+                app.notify(why);
+        },
         onResumeId: (id) => {
             if (!wt?.path)
                 return;

package/dist/config.js

@@ -99,6 +99,16 @@ export function loadConfig(file = configPath()) {
                             e.model = v;
                         else if (k === "effort" && typeof v === "string" && EFFORTS[id].includes(v))
                             e.effort = v;
+                        else if ((k === "allow" || k === "ask") && id !== "claude")
+                            warnings.push(`config [engines.${id}]: '${k}' is for [engines.claude] (Claude Code's permission rules)`);
+                        else if (k === "allow" && Array.isArray(v) && v.every((a) => typeof a === "string"))
+                            e.allow = v;
+                        else if (k === "ask" && typeof v === "boolean")
+                            e.ask = v;
+                        else if (k === "allow")
+                            warnings.push(`config [engines.${id}]: 'allow' should be a list of permission rules, e.g. ["Bash(gh:*)"]`);
+                        else if (k === "ask")
+                            warnings.push(`config [engines.${id}]: 'ask' should be true or false`);
                         else if (k === "effort")
                             warnings.push(`config [engines.${id}]: 'effort' should be one of ${EFFORTS[id].join(", ")}`);
                         else
@@ -347,6 +357,8 @@ engine = "auto"
 # [engines.claude]
 # args = ["--permission-mode", "acceptEdits"]   # the default
 # model = "sonnet"
+# allow = ["Bash(gh:*)", "Bash(cargo:*)"]   # commands Claude Code may run without asking
+# ask = true   # when it's refused a command: allow once / always / no, then retry
 # [engines.codex]
 # args = ["-c", 'sandbox_mode="workspace-write"']  # the default
 # [engines.opencode]

package/dist/engines.js

@@ -12,6 +12,15 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { PI_INSTALL, piInstalled } from "./pi-sdk.js";
 export const ENGINE_IDS = ["pi", "claude", "codex", "opencode"];
+/** The environment to run an engine's CLI with: everything but what detection said to leave out. */
+export function engineEnv(engine, env = process.env) {
+    if (!engine?.dropEnv?.length)
+        return env;
+    const out = { ...env };
+    for (const k of engine.dropEnv)
+        delete out[k];
+    return out;
+}
 export const ENGINE_NAMES = {
     pi: "pi",
     claude: "Claude Code",
@@ -127,8 +136,33 @@ async function detectClaude(env, timeoutMs) {
     try {
         const st = JSON.parse(s.stdout);
         if (st.loggedIn) {
-            const how = st.authMethod === "api_key" || st.apiKeySource ? "API key" : "Claude account";
-            return { ...base, installed: true, connected: true, version, detail: `signed in (${how})`, connect: undefined };
+            const usesKey = st.authMethod === "api_key" || !!st.apiKeySource;
+            // ANTHROPIC_API_KEY wins over a signed-in Claude account. When there is an account too,
+            // leave the key out, so Claude Code runs on the login you use it with (an unscoped or
+            // spent key otherwise fails every request, e.g. "not scoped to a workspace")
+            if (usesKey && env.ANTHROPIC_API_KEY) {
+                const without = { ...env };
+                delete without.ANTHROPIC_API_KEY;
+                const account = await run("claude", ["auth", "status", "--json"], timeoutMs, without);
+                try {
+                    const a = JSON.parse(account.stdout);
+                    if (a.loggedIn && a.authMethod !== "api_key" && !a.apiKeySource) {
+                        return {
+                            ...base,
+                            installed: true,
+                            connected: true,
+                            version,
+                            detail: "signed in (Claude account; ANTHROPIC_API_KEY left out)",
+                            connect: undefined,
+                            dropEnv: ["ANTHROPIC_API_KEY"],
+                        };
+                    }
+                }
+                catch {
+                    // no account to fall back to: the key it is
+                }
+            }
+            return { ...base, installed: true, connected: true, version, detail: `signed in (${usesKey ? "API key" : "Claude account"})`, connect: undefined };
         }
         return { ...base, installed: true, connected: false, version, detail: "not signed in" };
     }

package/dist/keys.js

@@ -59,6 +59,7 @@ export const ACTIONS = {
     "session.pause": "pause the agent and hold its queued prompts",
     "session.resume": "resume a paused agent",
     "session.tree": "the conversation tree: go back to an earlier point",
+    "sidebar.focus": "sessions sidebar: j/k pick an agent, Enter or Esc back",
     "fold.toggle": "fold / unfold tool output",
     "fold.open_all": "unfold all tool output",
     "fold.close_all": "fold all tool output",
@@ -130,7 +131,8 @@ export const DEFAULT_KEYS = {
         "<leader>r": ":review<CR>",
         "<leader>T": ":templates<CR>",
         "<leader>M": ":model<CR>",
-        "<leader>e": ":effort<CR>",
+        "<leader>e": "sidebar.focus",
+        "<leader>R": ":effort<CR>",
         "<leader>E": ":engine<CR>",
         ZZ: "app.quit",
         ZQ: "app.quit_force",

package/dist/markdown.js

@@ -1,80 +1,189 @@
 /**
- * Just enough markdown for agent replies, in vim's highlight groups:
- * headings (Title), **bold**, `code` and fenced code blocks (VigentCode),
- * bullet lists, and > quotes (Comment). Code blocks are numbered so
- * VISUAL-mode `ib` and `yib` can select them.
+ * Markdown for agent replies, in vim's highlight groups: headings (Title),
+ * **bold**, *italic*, ~~strike~~, `code` and fenced code blocks (VigentCode),
+ * links, bullet / numbered / task lists (nested), > quotes (Comment),
+ * --- rules and tables. Code blocks are numbered so VISUAL-mode `ib` and
+ * `yib` can select them.
  */
-import { wrapTextWithAnsi } from "./tui.js";
+import { visibleWidth, wrapTextWithAnsi } from "./tui.js";
 import { RESET } from "./theme.js";
-function inline(P, text) {
-    let out = "";
-    const re = /(`[^`]+`)|(\*\*[^*]+\*\*)|(__[^_]+__)/g;
+const BOLD = "\x1b[1m";
+const ITALIC = "\x1b[3m";
+const UNDERLINE = "\x1b[4m";
+const STRIKE = "\x1b[9m";
+/**
+ * Inline markdown in `base`'s color: `code`, **bold**, *italic*, ~~strike~~,
+ * [links](url) and <autolinks>. After each styled piece the base color comes
+ * back, so the rest of the line keeps it.
+ */
+export function inline(P, text, base = "Normal", urls = true) {
+    const on = P.s(base);
+    let out = on;
+    const re = /(\\[\\`*_~[\]()#>+\-.!|])|(`+)([^`]|[^`].*?[^`])\2(?!`)|\*\*([^*\s](?:.*?[^*\s])?)\*\*|__([^_\s](?:.*?[^_\s])?)__|~~([^~\s](?:.*?[^~\s])?)~~|\*([^*\s](?:.*?[^*\s])?)\*|(?<![\w])_([^_\s](?:.*?[^_\s])?)_(?![\w])|\[([^\]]+)\]\(([^)\s]+)(?:\s+"[^"]*")?\)|<(https?:\/\/[^>\s]+)>/g;
     let last = 0;
     let m;
     while ((m = re.exec(text))) {
         out += text.slice(last, m.index);
-        const tok = m[0];
-        if (tok.startsWith("`"))
-            out += P.p("VigentCode", tok.slice(1, -1));
-        else
-            out += P.s("Normal") + "\x1b[1m" + tok.slice(2, -2) + RESET;
-        last = m.index + tok.length;
+        last = m.index + m[0].length;
+        if (m[1])
+            out += m[1].slice(1); // \* and friends: the character itself
+        else if (m[2])
+            out += P.p("VigentCode", m[3].replace(/^ (.*) $/, "$1")) + on;
+        else if (m[4] ?? m[5])
+            out += BOLD + inline(P, (m[4] ?? m[5]), base, urls) + RESET + on;
+        else if (m[6])
+            out += STRIKE + inline(P, m[6], base, urls) + RESET + on;
+        else if (m[7] ?? m[8])
+            out += ITALIC + inline(P, (m[7] ?? m[8]), base, urls) + RESET + on;
+        else if (m[9]) {
+            const label = m[9];
+            const url = m[10];
+            out += P.s("Special") + UNDERLINE + label + RESET + (urls && url !== label && !url.startsWith("#") ? P.p("Comment", ` (${url})`) : "") + on;
+        }
+        else if (m[11])
+            out += P.s("Special") + UNDERLINE + m[11] + RESET + on;
     }
-    return out + text.slice(last);
+    return out + text.slice(last) + RESET;
 }
 function strip(s) {
     return s.replace(/\x1b\[[0-9;]*m/g, "");
 }
+const SEPARATOR = /^\s*\|?\s*:?-+:?\s*(\|\s*:?-+:?\s*)+\|?\s*$|^\s*\|\s*:?-+:?\s*\|\s*$/;
+/** The cells of a table row: `| a | b |` → ["a", "b"] (a `\|` stays in its cell). */
+function cells(row) {
+    let s = row.trim();
+    if (s.startsWith("|"))
+        s = s.slice(1);
+    if (s.endsWith("|") && !s.endsWith("\\|"))
+        s = s.slice(0, -1);
+    return s.split(/(?<!\\)\|/).map((c) => c.trim().replace(/\\\|/g, "|"));
+}
+function isRow(line) {
+    return /\|/.test(line) && line.trim() !== "";
+}
+/**
+ * A table as box-drawn lines that fit `width`: columns as wide as their
+ * widest cell, shrunk (widest first) when the table is too wide, with cell
+ * text wrapping inside its column.
+ */
+function renderTable(P, rows, aligns, width, ascii) {
+    const g = ascii
+        ? { h: "-", v: "|", tl: "+", tm: "+", tr: "+", ml: "+", mm: "+", mr: "+", bl: "+", bm: "+", br: "+" }
+        : { h: "─", v: "│", tl: "┌", tm: "┬", tr: "┐", ml: "├", mm: "┼", mr: "┤", bl: "└", bm: "┴", br: "┘" };
+    const n = Math.max(...rows.map((r) => r.length));
+    const styled = rows.map((r, ri) => Array.from({ length: n }, (_, c) => inline(P, r[c] ?? "", ri === 0 ? "Title" : "Normal", false)));
+    const want = Array.from({ length: n }, (_, c) => Math.max(1, ...styled.map((r) => visibleWidth(strip(r[c])))));
+    // borders and padding take 3 columns per cell, plus one
+    const room = Math.max(n * 3, width - (3 * n + 1));
+    const cols = [...want];
+    while (cols.reduce((a, b) => a + b, 0) > room) {
+        const widest = cols.indexOf(Math.max(...cols));
+        if (cols[widest] <= 3)
+            break;
+        cols[widest]--;
+    }
+    const border = (l, m, r) => {
+        const s = l + cols.map((w) => g.h.repeat(w + 2)).join(m) + r;
+        return { text: P.p("NonText", s), plain: s };
+    };
+    const out = [border(g.tl, g.tm, g.tr)];
+    styled.forEach((row, ri) => {
+        const wrapped = row.map((cell, c) => wrapTextWithAnsi(cell, cols[c]));
+        const height = Math.max(...wrapped.map((w) => w.length));
+        for (let li = 0; li < height; li++) {
+            let text = P.p("NonText", g.v);
+            for (let c = 0; c < n; c++) {
+                const piece = wrapped[c][li] ?? "";
+                const pad = Math.max(0, cols[c] - visibleWidth(strip(piece)));
+                const a = aligns[c] ?? "left";
+                const left = a === "right" ? pad : a === "center" ? Math.floor(pad / 2) : 0;
+                text += ` ${" ".repeat(left)}${piece}${RESET}${" ".repeat(pad - left)} ${P.p("NonText", g.v)}`;
+            }
+            out.push({ text, plain: strip(text) });
+        }
+        if (ri === 0)
+            out.push(border(g.ml, g.mm, g.mr));
+    });
+    out.push(border(g.bl, g.bm, g.br));
+    return out;
+}
+// --- blocks ---------------------------------------------------------------
 /** Render markdown into wrapped, styled lines. `bullet` is the list marker glyph. */
-export function renderMarkdown(text, width, P, bullet = "•", startBlock = 0) {
+export function renderMarkdown(text, width, P, bullet = "•", startBlock = 0, opts = {}) {
     const lines = [];
+    const w = Math.max(10, width);
     let block = startBlock;
-    let inFence = false;
-    const push = (styled) => {
-        for (const l of wrapTextWithAnsi(styled, Math.max(10, width)))
-            lines.push({ text: l, plain: strip(l) });
+    let fence;
+    const push = (styled, prefix = "", rest = prefix) => {
+        const wrapped = wrapTextWithAnsi(styled, Math.max(4, w - visibleWidth(strip(prefix))));
+        wrapped.forEach((l, i) => {
+            const t = (i === 0 ? prefix : rest) + l;
+            lines.push({ text: t, plain: strip(t) });
+        });
     };
-    for (const raw of text.split("\n")) {
-        const fence = /^\s*(```|~~~)\s*([\w+-]*)\s*$/.exec(raw);
-        if (fence) {
-            if (!inFence) {
-                inFence = true;
-                lines.push({ text: P.p("NonText", `  ${fence[2] || "code"}`), plain: `  ${fence[2] || "code"}`, block, label: true });
-            }
-            else {
-                inFence = false;
+    const src = text.split("\n");
+    for (let i = 0; i < src.length; i++) {
+        const raw = src[i];
+        const open = /^\s*(```+|~~~+)\s*([\w+#.-]*)/.exec(raw);
+        if (fence !== undefined) {
+            if (open && open[1][0] === fence[0] && open[1].length >= fence.length && !open[2]) {
+                fence = undefined;
                 block++;
+                continue;
             }
-            continue;
-        }
-        if (inFence) {
             // code is not wrapped on words; long lines are cut by the pane
             lines.push({ text: `  ${P.p("VigentCode", raw)}`, plain: `  ${raw}`, block });
             continue;
         }
-        const heading = /^(#{1,6})\s+(.*)$/.exec(raw);
+        if (open) {
+            fence = open[1];
+            lines.push({ text: P.p("NonText", `  ${open[2] || "code"}`), plain: `  ${open[2] || "code"}`, block, label: true });
+            continue;
+        }
+        // a table: a row, then a | --- | separator
+        if (isRow(raw) && i + 1 < src.length && SEPARATOR.test(src[i + 1]) && cells(raw).length > 0) {
+            const aligns = cells(src[i + 1]).map((c) => (c.startsWith(":") && c.endsWith(":") ? "center" : c.endsWith(":") ? "right" : "left"));
+            const rows = [cells(raw)];
+            let j = i + 2;
+            while (j < src.length && isRow(src[j]) && !SEPARATOR.test(src[j]))
+                rows.push(cells(src[j++]));
+            lines.push(...renderTable(P, rows, aligns, w, !!opts.ascii));
+            i = j - 1;
+            continue;
+        }
+        const heading = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/.exec(raw);
         if (heading) {
-            push(P.p("Title", heading[2]));
+            const body = inline(P, heading[2], "Title");
+            push(heading[1].length <= 2 ? BOLD + body : body);
             continue;
         }
-        const item = /^(\s*)[-*+]\s+(.*)$/.exec(raw);
-        if (item) {
-            const indent = item[1].length > 0 ? "  " : "";
-            const body = wrapTextWithAnsi(inline(P, item[2]), Math.max(10, width - 2 - indent.length));
-            body.forEach((l, i) => {
-                const prefix = i === 0 ? `${indent}${P.p("Special", bullet)} ` : `${indent}  `;
-                lines.push({ text: prefix + l, plain: strip(prefix + l) });
-            });
+        if (/^\s{0,3}([-*_])(\s*\1){2,}\s*$/.test(raw)) {
+            const rule = (opts.ascii ? "-" : "─").repeat(Math.min(w, 60));
+            lines.push({ text: P.p("NonText", rule), plain: rule });
             continue;
         }
-        const quote = /^>\s?(.*)$/.exec(raw);
+        const quote = /^\s{0,3}((?:>\s?)+)(.*)$/.exec(raw);
         if (quote) {
-            push(P.p("Comment", `▏${quote[1]}`));
+            const depth = (quote[1].match(/>/g) ?? []).length;
+            const bar = P.p("Comment", "▏ ".repeat(depth));
+            push(inline(P, quote[2], "Comment"), bar);
+            continue;
+        }
+        const item = /^(\s*)([-*+]|\d{1,9}[.)])\s+(\[[ xX]\]\s+)?(.*)$/.exec(raw);
+        if (item) {
+            const level = Math.min(6, Math.floor(item[1].replace(/\t/g, "  ").length / 2));
+            const indent = "  ".repeat(level);
+            const ordered = /\d/.test(item[2]);
+            let marker = ordered ? item[2] : bullet;
+            if (item[3])
+                marker = /x/i.test(item[3]) ? (opts.ascii ? "[x]" : "☑") : opts.ascii ? "[ ]" : "☐";
+            const lead = `${indent}${P.p(item[3] ? (/x/i.test(item[3]) ? "String" : "Comment") : "Special", marker)} `;
+            push(inline(P, item[4]), lead, " ".repeat(visibleWidth(strip(lead))));
             continue;
         }
-        push(inline(P, raw));
+        push(raw.trim() === "" ? "" : inline(P, raw));
     }
-    if (inFence)
+    if (fence !== undefined)
         block++;
     return { lines, blocks: block - startBlock };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vigent/cli",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "A vim-style terminal app for running coding agents side by side, each in its own git worktree. Built on pi.",
   "keywords": [
     "vim",