@pugi/cli 0.1.0-beta.1 → 0.1.0-beta.11

package/dist/tools/lsp-tools.js

@@ -0,0 +1,189 @@
+import { gateOnCancellation, OperatorAbortedError } from './file-tools.js';
+import { recordToolCall, recordToolResult } from '../core/session.js';
+/** Cap for any single LSP tool's payload size. Keeps model context lean. */
+const LSP_PAYLOAD_CAP_BYTES = 8 * 1024;
+export async function lspHover(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'lsp_hover', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'lsp_hover', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await client.hover(file, { line, character: col }, ctx.cancellation);
+        if (!result.ok)
+            return failure(result);
+        if (!result.value) {
+            return { ok: true, value: { content: '' } };
+        }
+        const content = truncate(result.value.content);
+        return {
+            ok: true,
+            value: {
+                content: content.text,
+                ...(result.value.range ? { range: result.value.range } : {}),
+            },
+            ...(content.truncated ? { truncated: true } : {}),
+        };
+    });
+}
+export async function lspDefinition(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'lsp_definition', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'lsp_definition', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await client.definition(file, { line, character: col }, ctx.cancellation);
+        if (!result.ok)
+            return failure(result);
+        const capped = capLocations(result.value);
+        return {
+            ok: true,
+            value: capped.value,
+            ...(capped.truncated ? { truncated: true } : {}),
+        };
+    });
+}
+export async function lspReferences(ctx, lang, file, line, col) {
+    const toolCallId = recordToolCall(ctx.session, 'lsp_references', `${lang}:${file}:${line}:${col}`);
+    return guard(ctx, 'lsp_references', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await client.references(file, { line, character: col }, ctx.cancellation);
+        if (!result.ok)
+            return failure(result);
+        const capped = capLocations(result.value);
+        return {
+            ok: true,
+            value: capped.value,
+            ...(capped.truncated ? { truncated: true } : {}),
+        };
+    });
+}
+export async function lspDiagnostics(ctx, lang, file) {
+    const toolCallId = recordToolCall(ctx.session, 'lsp_diagnostics', `${lang}:${file}`);
+    return guard(ctx, 'lsp_diagnostics', toolCallId, async () => {
+        const client = ctx.lspClients?.get(lang);
+        if (!client)
+            return unavailable(lang);
+        const result = await client.diagnostics(file, ctx.cancellation);
+        if (!result.ok)
+            return failure(result);
+        const capped = capDiagnostics(result.value);
+        return {
+            ok: true,
+            value: capped.value,
+            ...(capped.truncated ? { truncated: true } : {}),
+        };
+    });
+}
+async function guard(ctx, toolName, toolCallId, op) {
+    try {
+        gateOnCancellation(ctx, toolName);
+    }
+    catch (error) {
+        if (error instanceof OperatorAbortedError) {
+            recordToolResult(ctx.session, toolCallId, 'cancelled', error.message);
+            return { ok: false, reason: 'operator_aborted', detail: error.message };
+        }
+        throw error;
+    }
+    try {
+        const result = await op();
+        if (result.ok) {
+            recordToolResult(ctx.session, toolCallId, 'success', summarize(result.value));
+        }
+        else {
+            recordToolResult(ctx.session, toolCallId, 'error', `${result.reason ?? 'error'}: ${result.detail ?? ''}`);
+        }
+        return result;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        recordToolResult(ctx.session, toolCallId, 'error', message);
+        return { ok: false, reason: 'lsp_error', detail: message };
+    }
+}
+function unavailable(lang) {
+    return {
+        ok: false,
+        reason: 'lsp_unavailable',
+        detail: `no LSP server started for ${lang}. Install the server and re-run ` +
+            `with --lsp ${lang}, or fall back to grep.`,
+    };
+}
+function failure(result) {
+    if (result.ok) {
+        // Shouldn't be hit — caller checks first.
+        return { ok: true, value: result.value };
+    }
+    return { ok: false, reason: result.reason, detail: result.detail };
+}
+function summarize(value) {
+    if (value === null || value === undefined)
+        return 'no result';
+    if (Array.isArray(value))
+        return `${value.length} items`;
+    if (typeof value === 'object')
+        return Object.keys(value).join(',');
+    return String(value);
+}
+function truncate(text) {
+    const bytes = Buffer.byteLength(text, 'utf8');
+    if (bytes <= LSP_PAYLOAD_CAP_BYTES)
+        return { text, truncated: false };
+    // Truncate to the cap byte boundary. We don't try to honor codepoint
+    // alignment — UTF-8 surrogate splits show up as a single ? at the
+    // boundary, which is acceptable for a debug surface; the dispatcher
+    // is the trust boundary for "this is what the model will see".
+    const buf = Buffer.from(text, 'utf8').subarray(0, LSP_PAYLOAD_CAP_BYTES);
+    return { text: `${buf.toString('utf8')}\n... [truncated]`, truncated: true };
+}
+function capLocations(locations) {
+    // Cap at 200 locations OR the byte cap, whichever hits first. The
+    // 200 number is the operator-facing "this is a hot symbol" threshold —
+    // a richer surface (paginated `pugi lsp references --offset N`) is
+    // open backlog.
+    const COUNT_CAP = 200;
+    if (locations.length === 0)
+        return { value: locations, truncated: false };
+    const trimmed = locations.slice(0, COUNT_CAP);
+    const serialized = JSON.stringify(trimmed);
+    if (Buffer.byteLength(serialized, 'utf8') <= LSP_PAYLOAD_CAP_BYTES && trimmed.length === locations.length) {
+        return { value: trimmed, truncated: false };
+    }
+    // Trim by halves until we fit the byte cap. Worst case ~10 iterations
+    // for the 200 max, fine for an interactive tool.
+    let upper = trimmed.length;
+    while (upper > 1) {
+        const half = Math.floor(upper / 2);
+        const sub = trimmed.slice(0, half);
+        if (Buffer.byteLength(JSON.stringify(sub), 'utf8') <= LSP_PAYLOAD_CAP_BYTES) {
+            return { value: sub, truncated: true };
+        }
+        upper = half;
+    }
+    return { value: trimmed.slice(0, 1), truncated: true };
+}
+function capDiagnostics(items) {
+    if (items.length === 0)
+        return { value: items, truncated: false };
+    const serialized = JSON.stringify(items);
+    if (Buffer.byteLength(serialized, 'utf8') <= LSP_PAYLOAD_CAP_BYTES) {
+        return { value: items, truncated: false };
+    }
+    // Diagnostics are sorted error-first in LSP convention; trim from the
+    // tail so we keep the highest-severity items.
+    let upper = items.length;
+    while (upper > 1) {
+        const half = Math.floor(upper / 2);
+        const sub = items.slice(0, half);
+        if (Buffer.byteLength(JSON.stringify(sub), 'utf8') <= LSP_PAYLOAD_CAP_BYTES) {
+            return { value: sub, truncated: true };
+        }
+        upper = half;
+    }
+    return { value: items.slice(0, 1), truncated: true };
+}
+/** Test-only surface so specs can poke truncation directly. */
+export const __test__ = { truncate, capLocations, capDiagnostics, LSP_PAYLOAD_CAP_BYTES };
+//# sourceMappingURL=lsp-tools.js.map

package/dist/tools/registry.js

@@ -1,8 +1,19 @@
 const registry = [
+    // α7.7: unified-diff patch apply. Routes through the same security
+    // gate as Layer A/B/C, so the risk class matches `edit`/`write`
+    // (medium — writes inside the workspace, never to protected files).
+    { name: 'apply_patch', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
     { name: 'bash', permission: 'bash', risk: 'high', concurrencySafe: false, m1: true },
     { name: 'edit', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
     { name: 'glob', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'grep', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
+    // α7.7: LSP read-only surface. Server runs locally, no Anvil
+    // round-trip. Concurrency-safe because every operation reads
+    // server state without mutating workspace files.
+    { name: 'lsp_definition', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
+    { name: 'lsp_diagnostics', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
+    { name: 'lsp_hover', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
+    { name: 'lsp_references', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'question', permission: 'none', risk: 'low', concurrencySafe: false, m1: true },
     { name: 'read', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'skill', permission: 'read', risk: 'low', concurrencySafe: true, m1: true },
@@ -11,6 +22,21 @@ const registry = [
     { name: 'task_list', permission: 'none', risk: 'low', concurrencySafe: true, m1: true },
     { name: 'task_update', permission: 'none', risk: 'low', concurrencySafe: false, m1: true },
     { name: 'web_fetch', permission: 'network', risk: 'medium', concurrencySafe: true, m1: true },
+    // α7.7: scratch worktree management. `worktree_create` writes nothing
+    // dangerous (a clone under `.pugi/worktrees/`); `worktree_promote`
+    // applies a diff back to the main tree, so it shares the `edit`
+    // risk class. `worktree_drop` is the cleanup primitive.
+    //
+    // R1 fix (2026-05-26, PR #413 r1, Fix 9): raised `worktree_create`
+    // and `worktree_drop` from `low` to `medium`. `worktree_drop` runs
+    // `rmSync` on its target — even with the new path-containment gate
+    // in `core/edits/worktree.ts::dropWorktree`, a destructive primitive
+    // belongs in `medium` so the permission FSM prompts on every call.
+    // `worktree_create` is raised for disk-pressure parity (a runaway
+    // agent loop could fill the disk with abandoned scratch worktrees).
+    { name: 'worktree_create', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
+    { name: 'worktree_drop', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
+    { name: 'worktree_promote', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
     { name: 'write', permission: 'edit', risk: 'medium', concurrencySafe: false, m1: true },
 ];
 export const toolRegistry = registry.sort((a, b) => a.name.localeCompare(b.name));

package/dist/tools/skill-tool.js

@@ -0,0 +1,96 @@
+import { listSkills } from '../core/skills/loader.js';
+import { hashSkillDir, verifyTrust } from '../core/skills/trust.js';
+export const SKILL_BODY_CAP_BYTES = 32 * 1024;
+export const SKILL_LIST_CAP = 100;
+export function skillList(ctx, input) {
+    const scope = input.scope ?? 'all';
+    const all = [];
+    if (scope === 'all' || scope === 'global') {
+        all.push(...listSkills('global', ctx.workspaceRoot));
+    }
+    if (scope === 'all' || scope === 'workspace') {
+        all.push(...listSkills('workspace', ctx.workspaceRoot));
+    }
+    // Dedup by name, prefer workspace scope when both exist (workspace
+    // overrides global per skills loader convention).
+    const byName = new Map();
+    for (const skill of all) {
+        const prev = byName.get(skill.name);
+        if (!prev || skill.scope === 'workspace') {
+            byName.set(skill.name, skill);
+        }
+    }
+    return Array.from(byName.values())
+        .slice(0, SKILL_LIST_CAP)
+        .map((skill) => ({
+        name: skill.name,
+        description: skill.frontmatter.description,
+        scope: skill.scope,
+    }));
+}
+export async function skillInvoke(ctx, input) {
+    if (!input.name || typeof input.name !== 'string') {
+        throw new Error('skill: name is required');
+    }
+    // Defense-in-depth: skill loader already validates slugs but the
+    // tool surface is operator-controlled.
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(input.name)) {
+        throw new Error(`skill: invalid skill name shape: "${input.name}"`);
+    }
+    // Workspace scope wins over global (operator override). Mirrors
+    // SkillLoader convention.
+    const workspace = listSkills('workspace', ctx.workspaceRoot).find((s) => s.name === input.name);
+    const global = workspace
+        ? null
+        : listSkills('global', ctx.workspaceRoot).find((s) => s.name === input.name);
+    const skill = workspace ?? global;
+    if (!skill) {
+        throw new Error(`skill: not found: "${input.name}"`);
+    }
+    // β1a r1 (2026-05-26): re-verify the on-disk skill payload against
+    // the trust manifest sha256 on EVERY invoke, not just at install
+    // time. Before this fix a post-install swap (malicious npm dep that
+    // touches `~/.pugi/skills/<name>/SKILL.md` after the operator
+    // approved the install) would bypass the trust gate — `listSkills`
+    // reads the body fresh from disk and the loader does no integrity
+    // check. The skill body lands directly in the model's tool result,
+    // so a mutated body is a prompt-injection vector against the agent
+    // loop's tool surface.
+    //
+    // Posture:
+    //   - `trusted`   → proceed (body is hash-pinned).
+    //   - `unsigned`  → refuse: the operator never approved this skill.
+    //     This catches the case where a skill directory was dropped in
+    //     manually (no `pugi skills install`) and the loader picked it
+    //     up. Refusing is fail-closed.
+    //   - `mismatch`  → refuse + surface the recorded vs actual hashes
+    //     so the operator can decide between re-trust and revoke.
+    //
+    // Performance: `hashSkillDir` walks the skill directory on every
+    // invoke. Skills are small (median 4-8 files, <50KB total) so the
+    // cost is sub-millisecond on warm cache. The β1a r1 spec exercises
+    // a mutated-body case; the existing skill-tool.spec.ts cases for
+    // happy-path use the `recordTrust` helper to seed the registry.
+    const actualHash = hashSkillDir(skill.dir);
+    const verdict = await verifyTrust('skill', skill.scope, skill.name, actualHash);
+    if (verdict.status === 'unsigned') {
+        throw new Error(`skill: refused to invoke "${skill.name}" — no trust entry (run \`pugi skills trust ${skill.name}\` to approve)`);
+    }
+    if (verdict.status === 'mismatch') {
+        throw new Error(`skill: refused to invoke "${skill.name}" — sha256 mismatch (recorded ${verdict.recorded.slice(0, 12)}…, actual ${verdict.actual.slice(0, 12)}…). Re-trust via \`pugi skills trust ${skill.name}\`.`);
+    }
+    const body = skill.body;
+    const truncated = Buffer.byteLength(body, 'utf8') > SKILL_BODY_CAP_BYTES;
+    const cappedBody = truncated
+        ? body.slice(0, SKILL_BODY_CAP_BYTES) +
+            `\n\n(... truncated at ${SKILL_BODY_CAP_BYTES} bytes — see \`pugi skills info ${skill.name}\` for full text)`
+        : body;
+    return {
+        name: skill.name,
+        scope: skill.scope,
+        description: skill.frontmatter.description,
+        body: cappedBody,
+        truncated,
+    };
+}
+//# sourceMappingURL=skill-tool.js.map

package/dist/tools/tasks.js

@@ -0,0 +1,208 @@
+/**
+ * task_* tool family — β1 T1/T6 (TodoWrite + agent task ledger).
+ *
+ * Mirrors Claude Code's TodoWrite tool surface so a model trained on
+ * the upstream tool grammar speaks Pugi's variant verbatim. Four ops:
+ *
+ *   - `task_create` — append a new task to the session's todo ledger.
+ *     Returns the assigned id.
+ *   - `task_get`    — fetch a single task by id.
+ *   - `task_list`   — list every task in the current session, ordered
+ *                     by createdAt ascending.
+ *   - `task_update` — mutate status/title/notes of an existing task.
+ *                     Append-only journal — every mutation lands as a
+ *                     fresh JSONL line and the latest line per id wins
+ *                     on `task_list` / `task_get` reads.
+ *
+ * Persistence: append-only JSONL at
+ * `.pugi/sessions/<sessionId>/tasks.jsonl`. Append-only keeps crash
+ * recovery trivial — a partial write at the end of the file is the
+ * worst case and the parser drops the malformed tail line.
+ *
+ * Scope: this is the local-side ledger surface. Anvil-side mirror
+ * (cabinet `/projects/[id]/tasks` page) ships in β5 once the session-
+ * memory hook lands; until then the ledger is purely local.
+ */
+import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+function ledgerPath(ctx) {
+    // Defense-in-depth: the sessionId is supposed to be a UUID minted by
+    // openSession() but the tool surface is operator-facing. Validate the
+    // shape before composing a path — refuse anything that contains
+    // separators or shell wildcards.
+    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(ctx.sessionId)) {
+        throw new Error(`task_*: invalid sessionId shape: "${ctx.sessionId}"`);
+    }
+    return join(ctx.workspaceRoot, '.pugi', 'sessions', ctx.sessionId, 'tasks.jsonl');
+}
+function nowIso(ctx) {
+    return (ctx.now ? ctx.now() : new Date()).toISOString();
+}
+function ensureDir(path) {
+    // β1a r1 (2026-05-26): switched from POSIX-only
+    // `path.slice(0, path.lastIndexOf('/'))` to `path.dirname()` so
+    // Windows path separators (`\`) work. Also chmod the per-session
+    // directory to 0o700 — the tasks ledger carries operator-confidential
+    // brief text, status notes, and timing metadata that should not be
+    // world-readable through an inherited umask.
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+        try {
+            chmodSync(dir, 0o700);
+        }
+        catch {
+            // Best-effort. POSIX permission setting is a no-op on Windows
+            // NTFS, and the dir-creation race with another concurrent task
+            // tool call is the only realistic failure case. The 0o600 mode
+            // on the JSONL file itself remains the primary guard; the dir
+            // chmod is defense in depth for tools that walk `.pugi/`.
+        }
+    }
+}
+function readJournal(ctx) {
+    const path = ledgerPath(ctx);
+    if (!existsSync(path))
+        return [];
+    const raw = readFileSync(path, 'utf8');
+    const out = [];
+    for (const line of raw.split('\n')) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if ((parsed.op === 'create' || parsed.op === 'update') &&
+                typeof parsed.id === 'string' &&
+                typeof parsed.at === 'string') {
+                out.push(parsed);
+            }
+        }
+        catch {
+            // Drop malformed line (partial-write tail or external corruption).
+            // The append-only design guarantees only the LAST line can be bad
+            // — everything before it is whole.
+        }
+    }
+    return out;
+}
+function fold(journal) {
+    const out = new Map();
+    for (const entry of journal) {
+        if (entry.op === 'create') {
+            if (!entry.title)
+                continue;
+            out.set(entry.id, {
+                id: entry.id,
+                title: entry.title,
+                status: entry.status ?? 'pending',
+                ...(entry.notes !== undefined ? { notes: entry.notes } : {}),
+                createdAt: entry.at,
+                updatedAt: entry.at,
+            });
+        }
+        else {
+            const prev = out.get(entry.id);
+            if (!prev)
+                continue; // update before create — drop silently
+            out.set(entry.id, {
+                ...prev,
+                ...(entry.title !== undefined ? { title: entry.title } : {}),
+                ...(entry.status !== undefined ? { status: entry.status } : {}),
+                ...(entry.notes !== undefined ? { notes: entry.notes } : {}),
+                updatedAt: entry.at,
+            });
+        }
+    }
+    return out;
+}
+function appendEntry(ctx, entry) {
+    const path = ledgerPath(ctx);
+    ensureDir(path);
+    appendFileSync(path, `${JSON.stringify(entry)}\n`, {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+}
+export function taskCreate(ctx, input) {
+    const title = input.title?.trim();
+    if (!title) {
+        throw new Error('task_create: title is required');
+    }
+    if (title.length > 2_000) {
+        throw new Error('task_create: title exceeds 2000 char cap');
+    }
+    const status = input.status ?? 'pending';
+    if (!isValidStatus(status)) {
+        throw new Error(`task_create: invalid status "${status}"`);
+    }
+    const id = `task-${randomUUID()}`;
+    const at = nowIso(ctx);
+    const entry = {
+        op: 'create',
+        id,
+        title,
+        status,
+        at,
+        ...(input.notes !== undefined ? { notes: input.notes } : {}),
+    };
+    appendEntry(ctx, entry);
+    return {
+        id,
+        title,
+        status,
+        ...(input.notes !== undefined ? { notes: input.notes } : {}),
+        createdAt: at,
+        updatedAt: at,
+    };
+}
+export function taskGet(ctx, id) {
+    if (typeof id !== 'string' || id.length === 0) {
+        throw new Error('task_get: id is required');
+    }
+    const folded = fold(readJournal(ctx));
+    return folded.get(id) ?? null;
+}
+export function taskList(ctx) {
+    const folded = fold(readJournal(ctx));
+    return Array.from(folded.values()).sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function taskUpdate(ctx, input) {
+    if (!input.id)
+        throw new Error('task_update: id is required');
+    const folded = fold(readJournal(ctx));
+    const existing = folded.get(input.id);
+    if (!existing) {
+        throw new Error(`task_update: unknown id "${input.id}"`);
+    }
+    if (input.status !== undefined && !isValidStatus(input.status)) {
+        throw new Error(`task_update: invalid status "${input.status}"`);
+    }
+    if (input.title !== undefined && input.title.trim().length === 0) {
+        throw new Error('task_update: title cannot be empty');
+    }
+    const at = nowIso(ctx);
+    const entry = {
+        op: 'update',
+        id: input.id,
+        at,
+        ...(input.title !== undefined ? { title: input.title } : {}),
+        ...(input.status !== undefined ? { status: input.status } : {}),
+        ...(input.notes !== undefined ? { notes: input.notes } : {}),
+    };
+    appendEntry(ctx, entry);
+    return {
+        ...existing,
+        ...(input.title !== undefined ? { title: input.title } : {}),
+        ...(input.status !== undefined ? { status: input.status } : {}),
+        ...(input.notes !== undefined ? { notes: input.notes } : {}),
+        updatedAt: at,
+    };
+}
+function isValidStatus(status) {
+    return (status === 'pending' ||
+        status === 'in_progress' ||
+        status === 'completed' ||
+        status === 'cancelled');
+}
+//# sourceMappingURL=tasks.js.map

package/dist/tui/ask-modal.js

@@ -85,7 +85,7 @@ export function AskModal(props) {
             setBuffer((prev) => prev + input);
         }
     }, { isActive: props.inert !== true });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "yellow", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "yellow", children: '? ' }), _jsx(Text, { bold: true, children: 'Need your call before I continue' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: props.tag.question }) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [props.tag.options.map((opt, idx) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: opt.label })] }), opt.desc ? (_jsx(Box, { marginLeft: 5, children: _jsx(Text, { dimColor: true, children: opt.desc }) })) : null] }, opt.value))), _jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: `  ${props.tag.options.length + 1}. ` }), _jsx(Text, { dimColor: true, children: 'Other (type a custom answer)' })] })] }), mode === 'pick' ? (_jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `Press 1-${props.tag.options.length + 1} to choose. Esc cancels.` }) })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '> ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type your custom answer. Enter submits. Esc cancels.' }) })] }))] }));
 }
 export function PlanReviewModal(props) {
     const [mode, setMode] = useState('pick');
@@ -130,7 +130,7 @@ export function PlanReviewModal(props) {
             setBuffer((prev) => prev + input);
         }
     }, { isActive: props.inert !== true });
-    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '  [a] approve  ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify  ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "magenta", paddingX: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "magenta", children: '? ' }), _jsx(Text, { bold: true, children: 'Plan review - approve before I execute' })] }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: 'Steps:' }), props.tag.steps.map((step, idx) => (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", bold: true, children: `  ${idx + 1}. ` }), _jsx(Text, { children: step.text })] }, `step-${idx}`)))] }), props.tag.risk ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { bold: true, color: "red", children: 'Risk:' }), _jsx(Box, { marginLeft: 2, children: _jsx(Text, { children: props.tag.risk }) })] })) : null, mode === 'pick' ? (_jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: '  [a] approve  ' }), _jsx(Text, { color: "yellow", bold: true, children: '[m] modify  ' }), _jsx(Text, { color: "red", bold: true, children: '[c] cancel' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Press a, m, or c. Esc cancels.' }) })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: 'modify > ' }), _jsx(Text, { children: buffer }), _jsx(Text, { inverse: true, children: ' ' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: 'Type the revision. Enter submits. Esc cancels.' }) })] }))] }));
 }
 /* ------------------------------------------------------------------ */
 /* Verdict serialisation                                              */

package/dist/tui/conversation-pane.js

@@ -36,7 +36,7 @@ function PaneHeader({ count }) {
 function ConversationRow({ row, personaNames, }) {
     switch (row.source) {
         case 'operator':
-            return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: '› ' }), _jsx(Text, { children: row.text })] }));
+            return (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "#3da9fc", children: '› ' }), _jsx(Text, { children: row.text })] }));
         case 'system':
             return (_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '· ' }), _jsx(Text, { dimColor: true, children: row.text })] }));
         case 'persona': {

package/dist/tui/input-box.js

@@ -499,7 +499,7 @@ export function InputBox(props) {
         : Math.min(paletteIndex, paletteView.rows.length - 1);
     const divider = '─'.repeat(innerWidth);
     const focusedMatch = search ? search.matches[search.focusedIndex] : undefined;
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "cyan", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "cyan", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C abort / ×2 exit' }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), _jsx(Box, { paddingX: 1, flexDirection: "column", children: search ? (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '(reverse-i-search) ' }), _jsx(Text, { children: `\`${search.query}\`: ` }), _jsx(Text, { color: "yellow", children: focusedMatch ? focusedMatch.brief : '(no match)' })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `Ctrl+R next  ·  Ctrl+S prev  ·  Enter accept  ·  Esc cancel  ·  ${search.matches.length} match${search.matches.length === 1 ? '' : 'es'}` }) })] })) : (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '› ' }), _jsx(Text, { children: renderLineWithCursor(line, cursor, cursorVisible) })] })) }), _jsx(Text, { color: "#3da9fc", dimColor: true, children: divider }), line.length > innerWidth - 4 ? (_jsxs(Box, { children: [_jsx(Text, { color: "gray", children: '┊ ' }), _jsx(Text, { dimColor: true, children: 'line wraps - Enter still submits' })] })) : null, _jsx(SlashPalette, { rows: paletteView.rows, focusedIndex: clampedPaletteIndex, totalBeforeLimit: paletteView.totalBeforeLimit }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '↑/↓ history  ·  Ctrl+R search  ·  / commands  ·  Enter brief  ·  Esc cancel  ·  Ctrl+C abort / ×2 exit' }) })] }));
 }
 /**
  * Render the line with the cursor glyph inserted at `cursor`. The cursor

package/dist/tui/markdown-render.js

@@ -107,9 +107,9 @@ function renderBlock(block, key) {
         case 'paragraph':
             return (_jsx(Text, { children: renderInline(block.text) }, key));
         case 'bullet':
-            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
         case 'ordered':
-            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "#3da9fc", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
         case 'code':
             return renderCodeBlock(block.lang, block.body, key);
         case 'blank':
@@ -148,7 +148,7 @@ function renderCodeLine(line, keywords) {
             spans.push(_jsx(Text, { color: "green", children: tok }, key));
         }
         else if (keywords.includes(tok)) {
-            spans.push(_jsx(Text, { color: "cyan", bold: true, children: tok }, key));
+            spans.push(_jsx(Text, { color: "#3da9fc", bold: true, children: tok }, key));
         }
         else {
             spans.push(_jsx(Text, { children: tok }, key));
@@ -260,7 +260,7 @@ function renderSpan(span, key) {
         case 'code':
             return _jsx(Text, { color: "green", children: span.text }, key);
         case 'link':
-            return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
+            return (_jsxs(Text, { children: [_jsx(Text, { color: "#3da9fc", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
     }
 }
 //# sourceMappingURL=markdown-render.js.map