@pugi/cli 0.1.0-alpha.9 → 0.1.0-beta.1

package/dist/runtime/commands/skills.js

@@ -0,0 +1,401 @@
+import { createInterface } from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { assertValidSlug, globalSkillDir, installSkill, listSkills, parseSkillMarkdown, removeSkill, workspaceSkillDir, } from '../../core/skills/loader.js';
+import { cleanupTmp, fetchSource } from '../../core/skills/sources.js';
+import { hashSkillDir, recordTrust, revokeTrust, verifyTrust, } from '../../core/skills/trust.js';
+import { readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const USAGE = [
+    'Usage:',
+    '  pugi skills list [--global|--workspace]            Show installed skills.',
+    '  pugi skills install <source> [--global|--workspace] [--yes] [--as <name>]',
+    '                                                     Fetch + trust-prompt + activate a skill.',
+    '  pugi skills info <name>                            Show metadata + body preview.',
+    '  pugi skills remove <name> [--global|--workspace]   Delete an installed skill.',
+    '  pugi skills trust <name> [--global|--workspace]    Re-trust the on-disk payload.',
+    '',
+    'Source forms accepted by `install`:',
+    '  gh:owner/repo[/subdir][@ref]   GitHub tree fetch (default ref: main).',
+    '  https://github.com/...         GitHub tree/blob URL.',
+    '  anthropic:<slug>               Shortcut for gh:anthropics/skills/<slug>@main.',
+    '  npm:<package>[@version]        npm registry tarball.',
+    '  ./path | /abs/path             Local filesystem.',
+    '  <slug>                         Catalog lookup (catalog.pugi.dev).',
+].join('\n');
+export async function runSkillsCommand(args, ctx) {
+    const sub = args[0];
+    if (!sub || sub === '--help' || sub === '-h') {
+        ctx.writeOutput({ command: 'skills', usage: USAGE.split('\n') }, USAGE);
+        return;
+    }
+    switch (sub) {
+        case 'list':
+            return runSkillsList(args.slice(1), ctx);
+        case 'install':
+            return runSkillsInstall(args.slice(1), ctx);
+        case 'info':
+            return runSkillsInfo(args.slice(1), ctx);
+        case 'remove':
+            return runSkillsRemove(args.slice(1), ctx);
+        case 'trust':
+            return runSkillsTrust(args.slice(1), ctx);
+        default:
+            throw new Error(`Unknown sub-command "pugi skills ${sub}". Expected list, install, info, remove, or trust.`);
+    }
+}
+function parseFlags(args) {
+    let scope = 'both';
+    let yes = false;
+    let asName;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--global')
+            scope = 'global';
+        else if (arg === '--workspace')
+            scope = 'workspace';
+        else if (arg === '--yes' || arg === '-y')
+            yes = true;
+        else if (arg === '--as') {
+            asName = args[++i];
+        }
+        else if (arg && !arg.startsWith('--')) {
+            positional.push(arg);
+        }
+        else if (arg) {
+            throw new Error(`Unknown flag: ${arg}`);
+        }
+    }
+    return { scope, yes, asName, positional };
+}
+async function runSkillsList(args, ctx) {
+    const flags = parseFlags(args);
+    const includeGlobal = flags.scope === 'global' || flags.scope === 'both';
+    const includeWorkspace = flags.scope === 'workspace' || flags.scope === 'both';
+    const global = includeGlobal ? listSkills('global', ctx.workspaceRoot) : [];
+    const workspace = includeWorkspace ? listSkills('workspace', ctx.workspaceRoot) : [];
+    const all = [...global, ...workspace];
+    const trustStatuses = await Promise.all(all.map(async (skill) => {
+        const actual = hashSkillDir(skill.dir);
+        const verdict = await verifyTrust('skill', skill.scope, skill.name, actual);
+        return { skill, trust: verdict };
+    }));
+    if (ctx.json) {
+        ctx.writeOutput({
+            command: 'skills.list',
+            skills: trustStatuses.map(({ skill, trust }) => ({
+                name: skill.name,
+                scope: skill.scope,
+                dir: skill.dir,
+                description: skill.frontmatter.description,
+                version: skill.frontmatter.metadata.version ?? null,
+                tools: skill.frontmatter.metadata.tools ?? [],
+                trust: trust.status,
+            })),
+        }, '');
+        return;
+    }
+    if (trustStatuses.length === 0) {
+        ctx.writeOutput({ command: 'skills.list', skills: [] }, 'No skills installed. Try `pugi skills install anthropic:python-coding-standards`.');
+        return;
+    }
+    const lines = ['Installed skills:'];
+    for (const { skill, trust } of trustStatuses) {
+        const version = skill.frontmatter.metadata.version ? ` v${String(skill.frontmatter.metadata.version)}` : '';
+        const trustMark = trust.status === 'trusted' ? '[trusted]' : trust.status === 'unsigned' ? '[unsigned]' : '[mismatch]';
+        lines.push(`  ${skill.name.padEnd(28)} ${skill.scope.padEnd(10)} ${trustMark.padEnd(11)}${version}`);
+        lines.push(`    ${truncate(skill.frontmatter.description, 80)}`);
+    }
+    ctx.writeOutput({ command: 'skills.list', skills: trustStatuses }, lines.join('\n'));
+}
+async function runSkillsInstall(args, ctx) {
+    const flags = parseFlags(args);
+    const source = flags.positional[0];
+    if (!source) {
+        throw new Error('pugi skills install requires a <source> argument. See `pugi skills --help`.');
+    }
+    const scope = flags.scope === 'workspace' ? 'workspace' : 'global';
+    // 1. Fetch payload to tmp dir.
+    let fetched;
+    try {
+        fetched = await fetchSource(source);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.writeOutput({ command: 'skills.install', status: 'fetch_failed', source, error: message }, `Skill fetch failed: ${message}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (fetched.inferredKind !== 'skill') {
+        cleanupTmp(fetched.tmpDir);
+        const message = `Source ${source} looks like an agent (single .md), not a skill. Use \`pugi agents install\` instead.`;
+        ctx.writeOutput({ command: 'skills.install', status: 'wrong_kind', source }, message);
+        process.exitCode = 1;
+        return;
+    }
+    // 2. Parse SKILL.md to surface metadata in the trust prompt.
+    const skillMdPath = join(fetched.tmpDir, 'SKILL.md');
+    let parsed;
+    try {
+        parsed = parseSkillMarkdown(readFileSync(skillMdPath, 'utf8'));
+    }
+    catch (error) {
+        cleanupTmp(fetched.tmpDir);
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.writeOutput({ command: 'skills.install', status: 'parse_failed', source, error: message }, `Skill parse failed: ${message}`);
+        process.exitCode = 1;
+        return;
+    }
+    const skillName = flags.asName ?? parsed.frontmatter.name;
+    // Fail-fast before any FS or trust-prompt work: a hostile `--as` flag
+    // or a hostile frontmatter `name` must never reach path.join.
+    try {
+        assertValidSlug(skillName, 'skill');
+    }
+    catch (error) {
+        cleanupTmp(fetched.tmpDir);
+        const message = error instanceof Error ? error.message : String(error);
+        ctx.writeOutput({ command: 'skills.install', status: 'invalid_name', source, name: skillName, error: message }, message);
+        process.exitCode = 1;
+        return;
+    }
+    const sha256 = hashSkillDir(fetched.tmpDir);
+    const targetDir = scope === 'global' ? globalSkillDir(skillName) : workspaceSkillDir(ctx.workspaceRoot, skillName);
+    const summary = {
+        name: skillName,
+        description: parsed.frontmatter.description,
+        version: parsed.frontmatter.metadata.version ?? null,
+        tools: parsed.frontmatter.metadata.tools ?? [],
+        files: countFiles(fetched.tmpDir),
+        source: fetched.sourceUrl,
+        targetDir,
+        sha256,
+    };
+    if (!flags.yes) {
+        const decision = await promptTrust('skill', summary, parsed.body);
+        if (decision === 'no') {
+            cleanupTmp(fetched.tmpDir);
+            ctx.writeOutput({ command: 'skills.install', status: 'declined', source, name: skillName }, 'Install declined. Nothing changed.');
+            return;
+        }
+    }
+    // 3. Install to disk.
+    const installedDir = installSkill({
+        payloadDir: fetched.tmpDir,
+        name: skillName,
+        scope,
+        workspaceRoot: ctx.workspaceRoot,
+    });
+    // 4. Record trust.
+    await recordTrust({
+        kind: 'skill',
+        scope,
+        name: skillName,
+        sha256,
+        source: fetched.sourceUrl,
+        signedBy: signerIdentity(),
+    });
+    cleanupTmp(fetched.tmpDir);
+    ctx.writeOutput({
+        command: 'skills.install',
+        status: 'installed',
+        name: skillName,
+        scope,
+        dir: installedDir,
+        sha256,
+        source: fetched.sourceUrl,
+    }, [
+        `Installed skill "${skillName}" (${scope}).`,
+        `  Path:    ${installedDir}`,
+        `  Source:  ${fetched.sourceUrl}`,
+        `  sha256:  ${sha256}`,
+    ].join('\n'));
+}
+async function runSkillsInfo(args, ctx) {
+    const flags = parseFlags(args);
+    const name = flags.positional[0];
+    if (!name) {
+        throw new Error('pugi skills info requires a <name> argument.');
+    }
+    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
+    if (matches.length === 0) {
+        ctx.writeOutput({ command: 'skills.info', status: 'not_found', name }, `No skill "${name}" installed. Try \`pugi skills list\`.`);
+        process.exitCode = 1;
+        return;
+    }
+    const skill = matches[0];
+    if (!skill) {
+        ctx.writeOutput({ command: 'skills.info', status: 'not_found', name }, `No skill "${name}" installed.`);
+        process.exitCode = 1;
+        return;
+    }
+    const actualSha = hashSkillDir(skill.dir);
+    const trust = await verifyTrust('skill', skill.scope, skill.name, actualSha);
+    const preview = skill.body.slice(0, 800);
+    const lines = [
+        `Skill: ${skill.name}`,
+        `  Scope:        ${skill.scope}`,
+        `  Path:         ${skill.dir}`,
+        `  Description:  ${skill.frontmatter.description}`,
+        `  Version:      ${String(skill.frontmatter.metadata.version ?? '(unset)')}`,
+        `  Tools:        ${(skill.frontmatter.metadata.tools ?? []).join(', ') || '(none)'}`,
+        `  Trust:        ${trust.status}`,
+        `  sha256:       ${actualSha}`,
+        '',
+        'Body preview:',
+        preview,
+        skill.body.length > 800 ? `... (${skill.body.length - 800} more chars)` : '',
+    ]
+        .filter((line) => line !== '')
+        .join('\n');
+    ctx.writeOutput({
+        command: 'skills.info',
+        name: skill.name,
+        scope: skill.scope,
+        dir: skill.dir,
+        frontmatter: skill.frontmatter,
+        sha256: actualSha,
+        trust,
+        bodyPreview: preview,
+        bodyLength: skill.body.length,
+    }, lines);
+}
+async function runSkillsRemove(args, ctx) {
+    const flags = parseFlags(args);
+    const name = flags.positional[0];
+    if (!name) {
+        throw new Error('pugi skills remove requires a <name> argument.');
+    }
+    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
+    if (matches.length === 0) {
+        ctx.writeOutput({ command: 'skills.remove', status: 'not_found', name }, `No skill "${name}" installed.`);
+        process.exitCode = 1;
+        return;
+    }
+    for (const skill of matches) {
+        removeSkill(skill.name, skill.scope, ctx.workspaceRoot);
+        await revokeTrust('skill', skill.scope, skill.name);
+    }
+    ctx.writeOutput({
+        command: 'skills.remove',
+        status: 'removed',
+        name,
+        removed: matches.map((m) => ({ name: m.name, scope: m.scope, dir: m.dir })),
+    }, `Removed ${matches.length} skill install(s) named "${name}".`);
+}
+async function runSkillsTrust(args, ctx) {
+    const flags = parseFlags(args);
+    const name = flags.positional[0];
+    if (!name) {
+        throw new Error('pugi skills trust requires a <name> argument.');
+    }
+    const matches = findSkill(name, flags.scope, ctx.workspaceRoot);
+    if (matches.length === 0) {
+        ctx.writeOutput({ command: 'skills.trust', status: 'not_found', name }, `No skill "${name}" installed.`);
+        process.exitCode = 1;
+        return;
+    }
+    const skill = matches[0];
+    if (!skill) {
+        process.exitCode = 1;
+        return;
+    }
+    const sha256 = hashSkillDir(skill.dir);
+    await recordTrust({
+        kind: 'skill',
+        scope: skill.scope,
+        name: skill.name,
+        sha256,
+        source: skill.dir,
+        signedBy: signerIdentity(),
+    });
+    ctx.writeOutput({ command: 'skills.trust', status: 'trusted', name: skill.name, scope: skill.scope, sha256 }, `Re-trusted skill "${skill.name}" (${skill.scope}). sha256 = ${sha256}.`);
+}
+/* ----------------------------- shared helpers ----------------------------- */
+function findSkill(name, scope, workspaceRoot) {
+    const scopes = scope === 'both' ? ['global', 'workspace'] : [scope];
+    const out = [];
+    for (const s of scopes) {
+        const all = listSkills(s, workspaceRoot);
+        for (const skill of all) {
+            if (skill.name === name)
+                out.push(skill);
+        }
+    }
+    return out;
+}
+function countFiles(dir) {
+    // Conservative — recurse and count regular files only. Used for the
+    // trust prompt summary so the operator sees payload bulk.
+    let total = 0;
+    const walk = (d) => {
+        for (const entry of readdirSync(d, { withFileTypes: true })) {
+            const full = join(d, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.isFile())
+                total++;
+        }
+    };
+    walk(dir);
+    return total;
+}
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return `${text.slice(0, max - 1)}…`;
+}
+function signerIdentity() {
+    return (process.env.PUGI_TRUSTED_BY?.trim() ||
+        process.env.USER?.trim() ||
+        process.env.USERNAME?.trim() ||
+        'cli');
+}
+/**
+ * Interactive trust prompt. Reads from stdin; `info` shows the full
+ * body; `y` accepts; everything else declines.
+ *
+ * Bypassable only via the operator-passed `--yes` flag in the caller
+ * (never auto-injected from another code path).
+ */
+async function promptTrust(kind, summary, body) {
+    const banner = [
+        '',
+        `About to install ${kind} "${summary.name}"`,
+        `  Description:  ${summary.description}`,
+        `  Version:      ${summary.version ?? '(unset)'}`,
+        `  Tools:        ${summary.tools.join(', ') || '(none)'}`,
+        `  Files:        ${summary.files}`,
+        `  Source:       ${summary.source}`,
+        `  Target:       ${summary.targetDir}`,
+        `  sha256:       ${summary.sha256}`,
+        '',
+        'This payload becomes part of the system prompt and may influence agent decisions.',
+        'Trust this install? [y/N/info] ',
+    ].join('\n');
+    process.stdout.write(banner);
+    if (!input.isTTY) {
+        // Non-interactive caller without --yes: refuse rather than block.
+        process.stdout.write('\n(non-interactive stdin; declining install)\n');
+        return 'no';
+    }
+    const rl = createInterface({ input, output });
+    try {
+        while (true) {
+            const answer = (await rl.question('')).trim().toLowerCase();
+            if (answer === 'y' || answer === 'yes')
+                return 'yes';
+            if (answer === 'info') {
+                process.stdout.write('\n');
+                process.stdout.write(body);
+                process.stdout.write('\n\nTrust this install? [y/N] ');
+                continue;
+            }
+            return 'no';
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+//# sourceMappingURL=skills.js.map

package/dist/tools/file-tools.js

@@ -6,6 +6,35 @@ import { decidePermission } from '../core/permission.js';
 import { createReadRecord, hashContent } from '../core/file-cache.js';
 import { resolveWorkspacePath } from '../core/path-security.js';
 import { recordFileMutation, recordToolCall, recordToolResult } from '../core/session.js';
+/**
+ * α6.9 WriteGate marker — thrown by `gateOnCancellation` when the
+ * caller supplied a cancellation token that has already aborted. The
+ * tool dispatch loop in `tool-bridge.ts` recognises the name and folds
+ * the throw into a `status: 'aborted'` tool result rather than a hard
+ * error so the loop terminates cleanly.
+ */
+export class OperatorAbortedError extends Error {
+    constructor(toolName) {
+        super(`operator_aborted: ${toolName} refused — operator cancelled the dispatch.`);
+        this.name = 'OperatorAbortedError';
+    }
+}
+/**
+ * α6.9 WriteGate: refuse the tool dispatch when the active
+ * cancellation token has aborted. Idempotent (the token's `isAborted`
+ * is a getter, no side effects). Returns void on the happy path so the
+ * tool can proceed; throws `OperatorAbortedError` when cancelled.
+ *
+ * The audit trail still gets the call: `recordToolCall` already fired
+ * upstream of this guard so the abort + reason are persisted. The
+ * matching `recordToolResult` is fired by the caller in its catch
+ * block with `status: 'cancelled'` (see existing path for `error`).
+ */
+export function gateOnCancellation(ctx, toolName) {
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        throw new OperatorAbortedError(toolName);
+    }
+}
 /**
  * Re-check the permission decision against the *resolved* real path so
  * a workspace-local symlink (`alias -> .env`) cannot bypass the protected
@@ -42,6 +71,13 @@ function permissionGatedResolve(ctx, inputPath, action, toolName) {
 }
 export function readTool(ctx, path) {
     const toolCallId = recordToolCall(ctx.session, 'read', path);
+    // α6.9 WriteGate: fail fast on operator cancel BEFORE permission
+    // decision so a half-second post-cancel race never lands the read.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: read refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('read');
+    }
     const decision = decidePermission({ tool: 'read', kind: 'read', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for read ${path}: ${decision.reason}`;
@@ -64,6 +100,14 @@ export function readTool(ctx, path) {
 }
 export function writeTool(ctx, path, content) {
     const toolCallId = recordToolCall(ctx.session, 'write', path);
+    // α6.9 WriteGate: refuse the write when the operator has cancelled
+    // the dispatch. The audit log captures the cancellation reason so a
+    // post-mortem can distinguish operator_aborted from settings-deny.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: write refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('write');
+    }
     const decision = decidePermission({ tool: 'write', kind: 'edit', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for write ${path}: ${decision.reason}`;
@@ -95,6 +139,15 @@ export function writeTool(ctx, path, content) {
 }
 export function editTool(ctx, path, oldString, newString) {
     const toolCallId = recordToolCall(ctx.session, 'edit', path);
+    // α6.9 WriteGate: refuse the edit when the operator has cancelled
+    // the dispatch. Edits are higher-risk than reads — surface the abort
+    // BEFORE we even consult permissions so a cancel-during-tool-loop
+    // never partially mutates the workspace.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: edit refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('edit');
+    }
     const decision = decidePermission({ tool: 'edit', kind: 'edit', target: path }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for edit ${path}: ${decision.reason}`;
@@ -140,6 +193,14 @@ export function editTool(ctx, path, oldString, newString) {
 }
 export function globTool(ctx, pattern) {
     const toolCallId = recordToolCall(ctx.session, 'glob', pattern);
+    // α6.9 WriteGate: cancel-aware short-circuit. Glob is read-only but
+    // can be expensive on large trees; respecting the abort here keeps
+    // the tool loop responsive when the operator hits Ctrl+C mid-scan.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: glob refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('glob');
+    }
     // Pugi globs are workspace-scoped. Reject any pattern that could enumerate
     // outside the workspace:
     //   1. absolute paths (`/etc/**/*`) — globSync resolves these against `/`
@@ -169,11 +230,28 @@ export function globTool(ctx, pattern) {
 }
 export function grepTool(ctx, query) {
     const toolCallId = recordToolCall(ctx.session, 'grep', query);
+    // α6.9 WriteGate: refuse before scanning. Grep walks the whole
+    // workspace and can take seconds on a large repo; check abort first
+    // so a cancel mid-scan returns immediately rather than after the
+    // full walk completes.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: grep refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('grep');
+    }
     const files = globTool(ctx, '**/*').filter((path) => !path.endsWith('/'));
     const matches = [];
     for (const path of files) {
         if (matches.length >= 200)
             break;
+        // α6.9 WriteGate: poll abort inside the file loop so a cancel
+        // arriving mid-scan terminates early. The per-file branch keeps
+        // the responsiveness bounded by the slowest single-file read.
+        if (ctx.cancellation && ctx.cancellation.isAborted) {
+            const reason = `operator_aborted: grep stopped mid-scan after ${matches.length} matches`;
+            recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+            throw new OperatorAbortedError('grep');
+        }
         // Permission gate every file read individually — grep used to bypass
         // `decidePermission` and could surface lines from protected files
         // (.env, *.sql, *.pem, ~/.ssh/**) when invoked from a directory walk.
@@ -241,6 +319,18 @@ export const BASH_DEFAULT_TIMEOUT_MS = 30_000;
 export const BASH_CHILD_MAXBUFFER = 10 * 1024 * 1024;
 export function bashTool(ctx, command, options = {}) {
     const toolCallId = recordToolCall(ctx.session, 'bash', command);
+    // α6.9 WriteGate: bash is the highest-risk tool surface. Refuse
+    // before the destructive-pattern classifier even runs so a
+    // cancelled dispatch never spawns a child process. Note: this is
+    // pre-spawn cancellation only; once the /bin/sh -c process is
+    // running, the synchronous spawnSync wait blocks until it exits or
+    // the 30s timeout fires. Phase 2 will wire SIGTERM forwarding via
+    // an async wrapper.
+    if (ctx.cancellation && ctx.cancellation.isAborted) {
+        const reason = 'operator_aborted: bash refused';
+        recordToolResult(ctx.session, toolCallId, 'cancelled', reason);
+        throw new OperatorAbortedError('bash');
+    }
     const decision = decidePermission({ tool: 'bash', kind: 'bash', target: command }, ctx.settings, ctx.root);
     if (decision.decision !== 'allow') {
         const reason = `Permission ${decision.decision} for bash: ${decision.reason}`;

package/dist/tools/web-fetch.js

@@ -240,7 +240,7 @@ function ipv4IsBlocked(ip) {
  * a literal IP (with brackets stripped). We honor that fast-path and
  * skip DNS.
  */
-async function validateHostnameForFetch(hostname) {
+export async function validateHostnameForFetch(hostname) {
     // URL.hostname keeps the brackets off IPv6 literals already.
     if (!hostname)
         return 'empty hostname';

package/dist/tui/agent-tree-pane.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { AgentTree } from './agent-tree.js';
+export function AgentTreePane(props) {
+    const onWatch = props.agents.filter((a) => a.status === 'queued' || a.status === 'thinking').length;
+    const total = props.agents.length;
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ agents ' }), _jsx(Text, { dimColor: true, children: `(${total} total, ${onWatch} on watch)` })] }), _jsx(AgentTree, { agents: props.agents, nowEpochMs: props.nowEpochMs })] }));
+}
+//# sourceMappingURL=agent-tree-pane.js.map

package/dist/tui/ask-cli.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, useApp } from 'ink';
+import { AskModal, PlanReviewModal } from './ask-modal.js';
+export async function renderAskCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(AskModal, { tag: options.tag, onResolve: (verdict) => {
+                resolveOuter(verdict);
+                // Slight delay so Ink flushes the unmount before the parent
+                // CLI prints the verdict line. Otherwise the modal frame and
+                // the verdict line can interleave on slow terminals.
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const verdict = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // Ink may throw if exit() races with a re-render; the verdict is
+        // already captured so we ignore.
+    }
+    return verdict;
+}
+export async function renderPlanReviewCli(options) {
+    let resolveOuter;
+    const outerPromise = new Promise((resolve) => {
+        resolveOuter = resolve;
+    });
+    function App() {
+        const { exit } = useApp();
+        return (_jsx(PlanReviewModal, { tag: options.tag, onResolve: (result) => {
+                resolveOuter(result);
+                setTimeout(() => exit(), 16);
+            } }));
+    }
+    const instance = render(_jsx(App, {}));
+    const result = await outerPromise;
+    try {
+        await instance.waitUntilExit();
+    }
+    catch {
+        // See renderAskCli — captured verdict supersedes a late Ink throw.
+    }
+    return result;
+}
+//# sourceMappingURL=ask-cli.js.map