@pugi/cli 0.1.0-alpha.10

package/dist/tui/repl.js

@@ -0,0 +1,214 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * REPL root component - Sprint α5.7 (ADR-0056 PR-PUGI-CLI-REPL-DEFAULT).
+ *
+ * Three-zone layout:
+ *
+ *   header   - `Pugi.io · workspace: <name> · v<X> on watch`
+ *   main     - conversation pane (top half) + agent tree (bottom half)
+ *   footer   - input box + status bar + key hints
+ *
+ * The component subscribes to a ReplSession instance for state. It does
+ * NOT own the SSE client or the transport - the session module does.
+ * This keeps the component a pure render over a typed state plus three
+ * callbacks (submit, exit, overlay request).
+ *
+ * Overlays (`/help`, `/agents`) are rendered as full-pane modals that
+ * eclipse the main area so they read top-to-bottom even on small
+ * terminals. Pressing any key dismisses an overlay.
+ */
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { Box, Text, useApp, useInput } from 'ink';
+import { PUGI_TAGLINE, THE_TEN } from '@pugi/personas';
+import { AgentTree } from './agent-tree.js';
+import { ConversationPane } from './conversation-pane.js';
+import { InputBox } from './input-box.js';
+import { ReplSplash } from './repl-splash.js';
+import { StatusBar } from './status-bar.js';
+import { UpdateBanner } from './update-banner.js';
+import { collectWorkspaceContext } from './workspace-context.js';
+import { slugForCwd } from '../core/repl/history.js';
+import { SLASH_COMMAND_HELP, SLASH_COMMAND_GROUPS } from '../core/repl/slash-commands.js';
+const TICK_INTERVAL_MS = 200;
+const PULSE_INTERVAL_MS = 700;
+export function Repl(props) {
+    const [state, setState] = useState(props.session.getState());
+    const [overlay, setOverlay] = useState('none');
+    const [pulsePhase, setPulsePhase] = useState(0);
+    const [tickNow, setTickNow] = useState((props.now ?? Date.now)());
+    // α6.14 wave 3: boot splash visible until first input, first
+    // `agent.spawned` event, or 10s idle. The host gates the initial
+    // visibility on `--no-splash` / PUGI_SKIP_SPLASH via `skipSplash`.
+    const [splashVisible, setSplashVisible] = useState(props.skipSplash !== true);
+    const dismissSplash = useCallback(() => setSplashVisible(false), []);
+    // α6.14 wave 3: workspace context snapshot for the status bar. We
+    // read once at mount and freeze; a brand-new PUGI.md or skill is
+    // surfaced on the next REPL boot rather than via a watcher.
+    const workspaceContext = useMemo(() => props.workspaceContext ?? collectWorkspaceContext(process.cwd()), [props.workspaceContext]);
+    // Subscribe to session state updates. The session module fires the
+    // callback synchronously inside `patch` so we mirror without a
+    // batching layer.
+    useEffect(() => {
+        const unsubscribe = props.session.subscribe(setState);
+        return unsubscribe;
+    }, [props.session]);
+    // 200ms tick for the status-bar wall-clock + token counter rerender.
+    // Cheaper than re-mounting the session subscription and lets the
+    // status bar lag the dispatcher events by at most one frame.
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setTickNow((props.now ?? Date.now)());
+        }, TICK_INTERVAL_MS);
+        return () => clearInterval(interval);
+    }, [props.now]);
+    // Pulse the on-watch dot every 700ms. Three glyphs cycle, so the
+    // operator sees a gentle three-step animation rather than a binary
+    // blink. Subtle by design - brand voice forbids flashing.
+    useEffect(() => {
+        const interval = setInterval(() => {
+            setPulsePhase((prev) => (prev + 1) % 3);
+        }, PULSE_INTERVAL_MS);
+        return () => clearInterval(interval);
+    }, []);
+    useEffect(() => {
+        props.onOverlayChange?.(overlay);
+    }, [overlay, props]);
+    // α6.14 wave 3: dismiss the boot splash once the first agent spawns
+    // (the operator has clearly engaged the system) or the transcript
+    // gains a row. Mirrors the natural attention shift Claude Code /
+    // Codex / Gemini CLI all do on their boot screens.
+    useEffect(() => {
+        if (!splashVisible)
+            return;
+        if (state.agents.length > 0 || state.transcript.length > 0) {
+            setSplashVisible(false);
+        }
+    }, [splashVisible, state.agents.length, state.transcript.length]);
+    const personaNames = useMemo(() => buildPersonaNameMap(), []);
+    const { exit } = useApp();
+    const handleSubmit = useCallback((line) => {
+        // Dismiss the boot splash on first operator input. Idempotent —
+        // `setSplashVisible(false)` is a no-op once the state already
+        // settled to false (timer fired or `agent.spawned` arrived).
+        setSplashVisible(false);
+        // Run async without awaiting - the session module owns the
+        // network call, errors land in the transcript automatically.
+        void props.session.handleInput(line).then((verdict) => {
+            applyVerdictSideEffects(verdict, {
+                showHelp: () => setOverlay('help'),
+                showRoster: () => setOverlay('roster'),
+                farewell: () => {
+                    setOverlay('farewell');
+                    setTimeout(() => {
+                        props.session.close();
+                        exit();
+                    }, 800);
+                },
+            });
+        });
+    }, [props.session, exit]);
+    const handleExit = useCallback(() => {
+        setOverlay('farewell');
+        setTimeout(() => {
+            props.session.close();
+            exit();
+        }, 400);
+    }, [props.session, exit]);
+    // Any keystroke dismisses an overlay; mounting useInput at the root
+    // gives us the dismiss without colliding with the input box (which
+    // unmounts while an overlay is active).
+    useInput((_input, _key) => {
+        if (overlay !== 'none' && overlay !== 'farewell') {
+            setOverlay('none');
+        }
+    }, { isActive: overlay === 'help' || overlay === 'roster' });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [props.updateBanner ? _jsx(UpdateBanner, { result: props.updateBanner }) : null, splashVisible ? (_jsx(ReplSplash, { cliVersion: state.cliVersion, workspaceLabel: state.workspaceLabel, plan: props.splashPlan, model: props.splashModel, tenant: props.splashTenant, onDismiss: dismissSplash })) : null, _jsx(Header, { state: state }), _jsx(Box, { flexDirection: "column", marginTop: 1, children: overlay === 'help' ? (_jsx(HelpOverlay, {})) : overlay === 'roster' ? (_jsx(RosterOverlay, {})) : overlay === 'farewell' ? (_jsx(FarewellOverlay, {})) : (_jsx(MainArea, { state: state, personaNames: personaNames, nowEpochMs: tickNow })) }), _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [overlay === 'farewell' ? null : (_jsx(InputBox, { onSubmit: handleSubmit, onExit: handleExit, now: props.now, 
+                        // Slug from process.cwd() (full path) so two workspaces with
+                        // the same basename do not share history. state.workspaceLabel
+                        // is the basename only. Codex review P2.
+                        workspaceSlug: slugForCwd(process.cwd()) })), _jsx(StatusBar, { connection: state.connection, activeAgentCount: countActive(state), tokensDownstreamTotal: state.tokensDownstreamTotal, briefStartedAtEpochMs: state.briefStartedAtEpochMs, nowEpochMs: tickNow, pulsePhase: pulsePhase, pugiMdCount: workspaceContext.pugiMdCount, mcpServerCount: workspaceContext.mcpServerCount, skillCount: workspaceContext.skillCount, quotaPct: props.quotaPct })] })] }));
+}
+function Header({ state }) {
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: "cyan", children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: "cyan", children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));
+}
+function MainArea({ state, personaNames, nowEpochMs, }) {
+    // Show the last 12 transcript rows in the conversation slot so the
+    // bottom of the frame stays anchored to the input box. The agent
+    // tree drops below the transcript; new agents push the operator
+    // line up the screen, mirroring Claude Code / Codex CLI.
+    const conversationSlice = state.transcript.slice(-12);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ConversationPane, { rows: conversationSlice, personaNames: personaNames }), _jsx(Box, { marginTop: 1, children: _jsx(AgentTree, { agents: state.agents, nowEpochMs: nowEpochMs }) })] }));
+}
+function HelpOverlay() {
+    // Group commands by their `group` field so the operator scans the
+    // palette by intent (dispatch → session → tools → settings → meta).
+    // The α6.14 wave-2 expansion grew the surface from 6 to 20 commands;
+    // a flat list would force the operator to read 20 rows top-to-bottom
+    // every time. Grouping cuts perceived complexity dramatically.
+    const grouped = new Map();
+    for (const row of SLASH_COMMAND_HELP) {
+        const list = grouped.get(row.group);
+        if (list) {
+            grouped.set(row.group, [...list, row]);
+        }
+        else {
+            grouped.set(row.group, [row]);
+        }
+    }
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Pugi REPL help" }), SLASH_COMMAND_GROUPS.map((group) => {
+                const rows = grouped.get(group);
+                if (!rows || rows.length === 0)
+                    return null;
+                return (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { dimColor: true, children: `  -- ${group} --` }), rows.map((row) => (_jsxs(Box, { children: [_jsx(Text, { bold: true, color: "cyan", children: `  /${row.name} ${row.args}`.padEnd(22, ' ') }), _jsx(Text, { dimColor: true, children: row.gloss })] }, row.name)))] }, group));
+            }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: `${PUGI_TAGLINE}` }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Press any key to dismiss.' }) })] }));
+}
+function RosterOverlay() {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "On-watch roster" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: THE_TEN.map((persona) => (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: `  ${persona.name.padEnd(10, ' ')}` }), _jsx(Text, { dimColor: true, children: `${persona.role.padEnd(20, ' ')}` }), _jsx(Text, { children: persona.oneLiner })] }, persona.slug))) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: 'Press any key to dismiss.' }) })] }));
+}
+function FarewellOverlay() {
+    return (_jsx(Box, { flexDirection: "column", alignItems: "center", paddingY: 2, children: _jsx(Text, { bold: true, color: "cyan", children: PUGI_TAGLINE }) }));
+}
+function applyVerdictSideEffects(verdict, handlers) {
+    switch (verdict.kind) {
+        case 'help':
+            handlers.showHelp();
+            return;
+        case 'roster':
+            handlers.showRoster();
+            return;
+        case 'quit':
+            handlers.farewell();
+            return;
+        case 'dispatch':
+        case 'stop':
+        case 'web':
+        case 'error':
+        case 'noop':
+        case 'clear':
+        case 'version':
+        case 'jobs':
+        case 'diff':
+        case 'cost':
+        case 'status':
+        case 'stub':
+            // All non-overlay verdicts: the session module already appended
+            // any operator-visible system lines. No further UI side effect.
+            return;
+    }
+}
+function countActive(state) {
+    let count = 0;
+    for (const agent of state.agents) {
+        if (agent.status === 'queued' || agent.status === 'thinking')
+            count += 1;
+    }
+    return count;
+}
+function buildPersonaNameMap() {
+    const map = new Map();
+    for (const persona of THE_TEN) {
+        map.set(persona.slug, persona.name);
+    }
+    return map;
+}
+//# sourceMappingURL=repl.js.map

package/dist/tui/slash-palette.js

@@ -0,0 +1,106 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { SLASH_COMMAND_HELP } from '../core/repl/slash-commands.js';
+export const PALETTE_ROW_LIMIT = 8;
+/**
+ * Compute the FULL filtered candidate list for a given input buffer.
+ * Centralises the "starts-with-slash → filter SLASH_COMMAND_HELP"
+ * logic so the input box and the unit test agree on the shape.
+ *
+ * Wave 4 fix 2026-05-25: returns the FULL filtered set, not just the
+ * first PALETTE_ROW_LIMIT rows. The palette renderer now windows the
+ * visible slice internally based on `focusedIndex`, so the operator
+ * can scroll past row 7 via ↑/↓ on a long list (e.g. 20 commands when
+ * the buffer is `/`). `totalBeforeLimit` is preserved on the return
+ * shape for backward compatibility but always equals `rows.length`.
+ *
+ * Behaviour:
+ *   - Empty / non-slash buffer → empty result; palette stays hidden.
+ *   - `/` alone → all registry rows (the operator wants to browse).
+ *   - `/he` → rows whose name starts with `he` (case-insensitive).
+ */
+export function filterPalette(buffer) {
+    if (!buffer.startsWith('/')) {
+        return { rows: [], totalBeforeLimit: 0 };
+    }
+    // Treat anything past the first whitespace as args - palette only
+    // filters on the command name itself.
+    const headEnd = buffer.indexOf(' ');
+    const head = headEnd === -1 ? buffer.slice(1) : buffer.slice(1, headEnd);
+    const prefix = head.toLowerCase();
+    // Lowercase row.name too so a registry entry like `Help` still matches
+    // an operator typing `/he`. Today every entry is lowercase, but the
+    // type contract on SlashCommandHelp.name does not enforce that, and
+    // a future addition would silently disappear from the palette
+    // without this guard. Codex P2.
+    const all = prefix.length === 0
+        ? SLASH_COMMAND_HELP
+        : SLASH_COMMAND_HELP.filter((row) => row.name.toLowerCase().startsWith(prefix));
+    // Defensive copy via spread so callers cannot mutate the registry
+    // through the returned readonly array (TS-only enforcement, but
+    // future refactors might assume the contract).
+    const rows = [...all];
+    return {
+        rows,
+        totalBeforeLimit: rows.length,
+    };
+}
+export function computePaletteWindow(rows, focusedIndex) {
+    const total = rows.length;
+    if (total <= PALETTE_ROW_LIMIT) {
+        return { visible: rows, startIndex: 0, total };
+    }
+    // Sliding window: anchor the start so the focused row stays inside the
+    // PALETTE_ROW_LIMIT span. Clamp at both ends so we never render fewer
+    // than PALETTE_ROW_LIMIT rows when the list is long enough to fill them.
+    let start = focusedIndex - Math.floor(PALETTE_ROW_LIMIT / 2);
+    if (start < 0)
+        start = 0;
+    const maxStart = total - PALETTE_ROW_LIMIT;
+    if (start > maxStart)
+        start = maxStart;
+    return {
+        visible: rows.slice(start, start + PALETTE_ROW_LIMIT),
+        startIndex: start,
+        total,
+    };
+}
+/**
+ * Compute the auto-complete result for the Tab key. Picks the focused
+ * row when there is one, falls back to the longest common prefix
+ * otherwise (bash-like behaviour). Returns the new buffer the input
+ * box should adopt, or `null` when there is nothing to complete.
+ */
+export function completePalette(buffer, rows, focusedIndex) {
+    if (rows.length === 0)
+        return null;
+    const target = rows[focusedIndex] ?? rows[0];
+    if (!target)
+        return null;
+    // Preserve any args the operator has already started typing after a
+    // space; only swap the head.
+    const headEnd = buffer.indexOf(' ');
+    const tail = headEnd === -1 ? '' : buffer.slice(headEnd);
+    return `/${target.name}${tail}`;
+}
+export function SlashPalette(props) {
+    if (props.rows.length === 0)
+        return null;
+    // Wave 4 fix 2026-05-25: compute the visible window so the operator
+    // can scroll past row 7 on long lists. Focus indexes the full rows
+    // array; the window slides to keep the focused row visible.
+    const window = computePaletteWindow(props.rows, props.focusedIndex);
+    const overflow = window.total > PALETTE_ROW_LIMIT;
+    // Indicator value: focused row is 1-based for human display
+    // ("→ 9/20" reads better than "→ 8/20" when the operator is on
+    // the ninth entry).
+    const focusedDisplayIndex = Math.min(window.total, Math.max(1, props.focusedIndex + 1));
+    return (_jsxs(Box, { flexDirection: "column", marginTop: 0, paddingLeft: 2, children: [window.visible.map((row, visibleIdx) => {
+                const absoluteIdx = window.startIndex + visibleIdx;
+                const focused = absoluteIdx === props.focusedIndex;
+                const glyph = focused ? '▸' : '·';
+                const cmd = `/${row.name}${row.args ? ` ${row.args}` : ''}`.padEnd(22, ' ');
+                return (_jsxs(Box, { children: [_jsx(Text, { color: focused ? 'cyan' : 'gray', children: `${glyph} ` }), _jsx(Text, { bold: focused, color: focused ? 'cyan' : undefined, dimColor: !focused, children: cmd }), _jsx(Text, { dimColor: true, children: row.gloss })] }, row.name));
+            }), overflow ? (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  → ${focusedDisplayIndex}/${window.total}` }) })) : null, _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '  ↑/↓ select  ·  Tab complete  ·  Enter run  ·  Esc close' }) })] }));
+}
+//# sourceMappingURL=slash-palette.js.map

package/dist/tui/splash-data.js

@@ -0,0 +1,61 @@
+import { homedir } from 'node:os';
+import { DEFAULT_API_URL, maskApiKey, normalizeApiUrl, readCredentialsFile, resolveActiveCredential, } from '../core/credentials.js';
+/**
+ * Decode the JWT payload for display only — no signature check. The
+ * splash never sends the token over the wire so a stale or malformed
+ * JWT is still safe to show. Mirrors `decodeJwtPrincipal` in
+ * runtime/cli.ts, intentionally duplicated rather than imported to
+ * keep the TUI layer independent of the giant CLI module.
+ */
+function decodeJwtPayload(token) {
+    try {
+        const parts = token.split('.');
+        if (parts.length < 2)
+            return null;
+        const payload = parts[1];
+        if (!payload)
+            return null;
+        const padded = payload
+            .replace(/-/g, '+')
+            .replace(/_/g, '/')
+            .padEnd(payload.length + ((4 - (payload.length % 4)) % 4), '=');
+        const json = Buffer.from(padded, 'base64').toString('utf8');
+        const obj = JSON.parse(json);
+        if (!obj || typeof obj !== 'object')
+            return null;
+        return {
+            sub: typeof obj.sub === 'string' ? obj.sub : undefined,
+            email: typeof obj.email === 'string' ? obj.email : undefined,
+            customerId: typeof obj.customerId === 'string' ? obj.customerId : undefined,
+            plan: typeof obj.plan === 'string' ? obj.plan : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function collectSplashData(input) {
+    const env = input.env ?? process.env;
+    const home = input.home ?? homedir();
+    const credential = resolveActiveCredential(env, home);
+    if (!credential) {
+        const file = readCredentialsFile(home);
+        const apiUrl = normalizeApiUrl(env.PUGI_API_URL ?? file.activeApiUrl ?? DEFAULT_API_URL);
+        return {
+            cliVersion: input.cliVersion,
+            apiUrl,
+            isAuthenticated: false,
+        };
+    }
+    const principal = decodeJwtPayload(credential.apiKey);
+    return {
+        cliVersion: input.cliVersion,
+        apiUrl: credential.apiUrl,
+        isAuthenticated: true,
+        apiKeyMasked: maskApiKey(credential.apiKey),
+        ...(principal?.email ? { email: principal.email } : {}),
+        ...(principal?.customerId ? { tenant: principal.customerId } : {}),
+        ...(principal?.plan ? { plan: principal.plan } : {}),
+    };
+}
+//# sourceMappingURL=splash-data.js.map

package/dist/tui/splash.js

@@ -0,0 +1,31 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/**
+ * Bare `pugi` (no args) splash. Rendered only on a real TTY by the
+ * CLI dispatcher; non-TTY callers see the existing usage dump.
+ *
+ * Layout intentionally restrained: bold "pugi.io" wordmark, dim
+ * version/endpoint metadata, neutral body. No background colors, no
+ * emoji decoration, ASCII separators only.
+ */
+export function Splash({ data }) {
+    const accountLine = data.isAuthenticated
+        ? `${data.email ?? data.apiKeyMasked ?? 'authenticated'}${data.tenant ? ` (tenant: ${data.tenant})` : ''}`
+        : 'not signed in';
+    const primaryHint = data.isAuthenticated
+        ? {
+            cmd: 'pugi code "fix the bug"',
+            gloss: 'Run a one-shot coding task',
+        }
+        : {
+            cmd: 'pugi login',
+            gloss: 'Connect this terminal to your Pugi account',
+        };
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsx(Box, { children: _jsx(Text, { bold: true, color: "cyan", children: "pugi.io" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `v${data.cliVersion}  ·  ${data.apiUrl}` }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Account: " }), _jsx(Text, { children: accountLine })] }), data.isAuthenticated && data.plan ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "Plan: " }), _jsx(Text, { children: data.plan })] })) : null] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Quick start:" }), _jsx(HintRow, { command: primaryHint.cmd, gloss: primaryHint.gloss }), data.isAuthenticated ? (_jsx(HintRow, { command: 'pugi login', gloss: 'Re-authenticate or switch accounts' })) : (_jsx(HintRow, { command: 'pugi code "fix the bug"', gloss: 'Run a one-shot coding task' })), _jsx(HintRow, { command: 'pugi review --triple', gloss: 'Run the Anvil triple-review gate' }), _jsx(HintRow, { command: 'pugi help', gloss: 'Full command reference' })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Docs: https://pugi.dev   \u00B7   Status: https://pugi.io/status" }) })] }));
+}
+function HintRow({ command, gloss }) {
+    // Pad command names so the gloss column lines up across rows.
+    const padded = command.padEnd(28, ' ');
+    return (_jsxs(Text, { children: [_jsx(Text, { children: `  ${padded}` }), _jsx(Text, { dimColor: true, children: gloss })] }));
+}
+//# sourceMappingURL=splash.js.map

package/dist/tui/status-bar.js

@@ -0,0 +1,71 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+/**
+ * Cyan dot glyphs across the pulse cycle. Three steps keep the motion
+ * subtle - a true gradient would force an Ink rerender on every
+ * 16ms frame and waste cycles on a status bar.
+ */
+const PULSE_DOTS = ['●', '◉', '○'];
+export function StatusBar(props) {
+    const now = props.nowEpochMs ?? Date.now();
+    const elapsedLabel = formatElapsed(props.briefStartedAtEpochMs, now);
+    const tokenLabel = formatTokens(props.tokensDownstreamTotal);
+    const phase = clampPhase(props.pulsePhase);
+    const glyph = PULSE_DOTS[Math.min(phase, PULSE_DOTS.length - 1)] ?? PULSE_DOTS[0];
+    const status = connectionLabel(props.connection);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { color: status.color, children: `${glyph ?? '●'} ${status.label}` }), _jsx(Text, { dimColor: true, children: `  ·  ${props.activeAgentCount} agents  ·  ` }), _jsx(Text, { children: `↓ ${tokenLabel} tokens` }), _jsx(Text, { dimColor: true, children: `  ·  ${elapsedLabel}` })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `${formatCount(props.pugiMdCount)} PUGI.md  ·  ${formatCount(props.mcpServerCount)} MCP  ·  ${formatCount(props.skillCount)} skills  ·  ${formatQuota(props.quotaPct)} quota` }) })] }));
+}
+/**
+ * Render a count badge — number if defined, `—` placeholder otherwise.
+ * The placeholder mirrors the splash header convention so the operator
+ * recognises "not yet known" vs "zero" at a glance.
+ */
+function formatCount(value) {
+    return typeof value === 'number' ? value.toString() : '—';
+}
+function formatQuota(pct) {
+    if (typeof pct !== 'number' || Number.isNaN(pct))
+        return '—';
+    return `${Math.round(pct)}%`;
+}
+function connectionLabel(connection) {
+    switch (connection) {
+        case 'connecting':
+            return { label: 'connecting', color: 'cyan' };
+        case 'on_watch':
+            return { label: 'on watch', color: 'cyan' };
+        case 'reconnecting':
+            return { label: 'reconnecting', color: 'yellow' };
+        case 'offline':
+            return { label: 'offline', color: 'gray' };
+    }
+}
+function formatElapsed(startedAt, now) {
+    if (typeof startedAt !== 'number')
+        return 'idle';
+    const ms = Math.max(0, now - startedAt);
+    if (ms < 60_000) {
+        return `${Math.floor(ms / 1000)}s`;
+    }
+    const minutes = Math.floor(ms / 60_000);
+    const seconds = Math.floor((ms % 60_000) / 1000);
+    return `${minutes}m ${seconds.toString().padStart(2, '0')}s`;
+}
+/**
+ * Format the downstream token counter as 1.2k / 12.4k / 1.0m. Anvil
+ * F1 emits totals in the tens-of-thousands range during a single
+ * brief, so anything more than three significant figures is noise.
+ */
+function formatTokens(total) {
+    if (total < 1_000)
+        return total.toString();
+    if (total < 1_000_000)
+        return `${(total / 1_000).toFixed(1)}k`;
+    return `${(total / 1_000_000).toFixed(1)}m`;
+}
+function clampPhase(phase) {
+    if (typeof phase !== 'number' || Number.isNaN(phase))
+        return 0;
+    return Math.max(0, Math.min(PULSE_DOTS.length - 1, Math.floor(phase)));
+}
+//# sourceMappingURL=status-bar.js.map

package/dist/tui/update-banner.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { upgradeCommand } from '../runtime/update-check.js';
+export function UpdateBanner({ result }) {
+    const command = upgradeCommand(result.method);
+    return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '─ ' }), _jsx(Text, { bold: true, color: "cyan", children: 'Pugi ' }), _jsx(Text, { children: result.installed }), _jsx(Text, { dimColor: true, children: ' (installed) → ' }), _jsx(Text, { bold: true, children: result.latest }), _jsx(Text, { dimColor: true, children: ' (latest)' })] }), _jsxs(Box, { children: [_jsx(Text, { dimColor: true, children: '  Update: ' }), _jsx(Text, { color: "cyan", children: command })] }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '  Skip with PUGI_SKIP_UPDATE_BANNER=1' }) })] }));
+}
+//# sourceMappingURL=update-banner.js.map

package/dist/tui/workspace-context.js

@@ -0,0 +1,105 @@
+/**
+ * Workspace-context badges for the REPL bottom status bar (α6.14
+ * wave 3). Mirrors the Gemini CLI pattern where the operator sees
+ * `N GEMINI.md · N MCP · N skills · N% quota` at a glance.
+ *
+ * Pure-IO helpers: each function reads disk once, swallows every error
+ * (a missing directory is the common case for a fresh workspace), and
+ * returns a count. The REPL host calls these at mount, caches the
+ * result in component state, and passes them to `<StatusBar />`. We
+ * intentionally do NOT refresh on every keystroke — a brand-new
+ * PUGI.md does not appear mid-session often enough to warrant a
+ * watcher.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, resolve } from 'node:path';
+/**
+ * Count PUGI.md files in the workspace root. We do NOT walk
+ * subdirectories — a deep grep would burn IO on every REPL boot and
+ * the convention is one root file. Mirrors how Gemini CLI counts
+ * `GEMINI.md` at the project root only.
+ */
+export function countPugiMdFiles(cwd) {
+    try {
+        const entries = readdirSync(cwd, { withFileTypes: true });
+        let count = 0;
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            // Case-insensitive so PUGI.md, Pugi.md, pugi.md all count.
+            if (entry.name.toLowerCase() === 'pugi.md')
+                count += 1;
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Count MCP servers wired into `.pugi/mcp.json` at the workspace root.
+ * Reads the file, parses JSON, returns the `servers` array length when
+ * present. Returns 0 on any failure (file missing, malformed JSON,
+ * wrong shape) — the status bar treats 0 and "error" the same.
+ */
+export function countMcpServers(cwd) {
+    const path = join(cwd, '.pugi', 'mcp.json');
+    if (!existsSync(path))
+        return 0;
+    try {
+        const raw = readFileSync(path, 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object') {
+            const servers = parsed.servers;
+            if (Array.isArray(servers))
+                return servers.length;
+            // Also support the `{ "<name>": { ... } }` map shape used by
+            // the Anthropic / Claude Code mcp config convention.
+            const entries = Object.keys(parsed);
+            return entries.length;
+        }
+        return 0;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Count installed skills across the project-local + user-global
+ * directories: `.pugi/skills/` (per-workspace) + `~/.pugi/skills/`
+ * (per-machine). Each immediate subdirectory counts as one skill;
+ * matches the `skill-creator` convention.
+ */
+export function countSkills(cwd, home = homedir()) {
+    const projectDir = resolve(cwd, '.pugi', 'skills');
+    const userDir = resolve(home, '.pugi', 'skills');
+    return countSubdirs(projectDir) + countSubdirs(userDir);
+}
+function countSubdirs(dir) {
+    try {
+        if (!existsSync(dir))
+            return 0;
+        const stat = statSync(dir);
+        if (!stat.isDirectory())
+            return 0;
+        const entries = readdirSync(dir, { withFileTypes: true });
+        let count = 0;
+        for (const entry of entries) {
+            if (entry.isDirectory())
+                count += 1;
+        }
+        return count;
+    }
+    catch {
+        return 0;
+    }
+}
+export function collectWorkspaceContext(cwd, home = homedir()) {
+    return {
+        pugiMdCount: countPugiMdFiles(cwd),
+        mcpServerCount: countMcpServers(cwd),
+        skillCount: countSkills(cwd, home),
+    };
+}
+//# sourceMappingURL=workspace-context.js.map