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

package/dist/tui/repl.js

@@ -20,20 +20,41 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 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 { AgentTreePane } from './agent-tree-pane.js';
+import { AskModal, PlanReviewModal } from './ask-modal.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 { ToolStreamPane } from './tool-stream-pane.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;
+// α6.12: maximum transcript rows the conversation pane renders at once.
+// Older rows scroll off the top; full history stays in session state.
+const CONVERSATION_WINDOW = 12;
 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.12: operator-driven collapse for the tool stream pane. The CLI
+    // host can hide the pane entirely via `--no-tool-stream`; this state
+    // is the runtime toggle (Ctrl+T) for operators who want the pane on
+    // screen but folded to a single row while they read a long reply.
+    const [toolStreamCollapsed, setToolStreamCollapsed] = useState(false);
+    // α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.
@@ -62,9 +83,24 @@ export function Repl(props) {
     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) => {
@@ -96,22 +132,78 @@ export function Repl(props) {
             setOverlay('none');
         }
     }, { isActive: overlay === 'help' || overlay === 'roster' });
-    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [props.updateBanner ? _jsx(UpdateBanner, { result: props.updateBanner }) : 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, 
+    // α6.12: Ctrl+T toggles the tool stream pane between expanded and
+    // collapsed states. Active only while no overlay is open, so the
+    // toggle never fights the help/roster dismiss handler. The input box
+    // owns its own raw-input mode, so this listener only fires on the
+    // global Ctrl+T binding rather than every printable keystroke.
+    useInput((input, key) => {
+        if (key.ctrl && input === 't') {
+            setToolStreamCollapsed((prev) => !prev);
+        }
+    }, { isActive: overlay === 'none' && props.hideToolStream !== true });
+    // α6.3 office-hours: a pending ask or plan-review modal pauses input
+    // until the operator resolves it. The modal owns its own useInput
+    // hook, so the InputBox unmounts while a modal is open to avoid two
+    // raw-input listeners competing for the same keystroke. Resolution
+    // forwards through ReplSession.resolveAsk / resolvePlanReview.
+    const askPending = state.pendingAsk !== null;
+    const planPending = state.pendingPlanReview !== null;
+    const modalActive = askPending || planPending;
+    const handleAskResolve = useCallback((verdict) => {
+        void props.session.resolveAsk(verdict);
+    }, [props.session]);
+    const handlePlanReviewResolve = useCallback((result) => {
+        void props.session.resolvePlanReview(result);
+    }, [props.session]);
+    // α6.9: Ctrl+C abort handler. Forwards to ReplSession.cancel() which
+    // aborts the in-flight dispatch, closes the SSE stream, and surfaces
+    // "Aborted." in the transcript.
+    //
+    // Return contract (consumed by InputBox):
+    //   - true        - dispatch was cancelled (keep the buffer + DO arm
+    //                   the press-again-to-exit timer; second Ctrl+C in
+    //                   the window exits).
+    //   - false       - idle / nothing to cancel (legacy: clear buffer +
+    //                   arm the exit timer so the operator sees the hint
+    //                   and can confirm exit on the next press).
+    //   - undefined   - bypassed entirely (e.g. a modal owns the input).
+    //                   InputBox MUST NOT arm the exit timer and MUST
+    //                   NOT clear the buffer. P2 fix: previously this
+    //                   returned `false` and the buffer-clear path wiped
+    //                   the operator's mid-typed modal text on the first
+    //                   Ctrl+C, costing a press of work.
+    const handleCancel = useCallback(() => {
+        if (modalActive)
+            return undefined;
+        return props.session.cancel();
+    }, [props.session, modalActive]);
+    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, mascotPrePrinted: props.mascotPrePrinted === true })) : 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, hideToolStream: props.hideToolStream === true, toolStreamCollapsed: toolStreamCollapsed })) }), state.pendingAsk ? (_jsx(Box, { marginTop: 1, children: _jsx(AskModal, { tag: state.pendingAsk, onResolve: handleAskResolve }) })) : null, state.pendingPlanReview ? (_jsx(Box, { marginTop: 1, children: _jsx(PlanReviewModal, { tag: state.pendingPlanReview, onResolve: handlePlanReviewResolve }) })) : null, _jsxs(Box, { flexDirection: "column", marginTop: 1, children: [overlay === 'farewell' || modalActive ? null : (_jsx(InputBox, { onSubmit: handleSubmit, onExit: handleExit, onCancel: handleCancel, 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 })] })] }));
+                        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, dispatchState: state.dispatchState, dispatchToolLabel: state.dispatchToolLabel })] })] }));
 }
 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 MainArea({ state, personaNames, nowEpochMs, hideToolStream, toolStreamCollapsed, }) {
+    // α6.12: three vertical panes stacked above the input box.
+    //
+    //   1. Conversation pane (top)  - transcript with Markdown render.
+    //   2. Tool stream pane (mid)   - live Read/Edit/Bash/Grep lines.
+    //                                  Hidden when `--no-tool-stream` is
+    //                                  set; collapsed via Ctrl+T while
+    //                                  the pane is visible.
+    //   3. Agent tree pane (bottom) - Cyber-Zoo roster with persona /
+    //                                  status / duration / token counts.
+    //
+    // The window over the transcript is small (last 12 rows) so the
+    // bottom of the frame stays anchored to the input box. New agents
+    // push the operator line up the screen, mirroring Claude Code /
+    // Codex CLI / Gemini CLI rendering.
+    const conversationSlice = state.transcript.slice(-CONVERSATION_WINDOW);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(ConversationPane, { rows: conversationSlice, personaNames: personaNames }), hideToolStream ? null : (_jsx(Box, { marginTop: 1, children: _jsx(ToolStreamPane, { calls: state.toolCalls, collapsed: toolStreamCollapsed }) })), _jsx(Box, { marginTop: 1, children: _jsx(AgentTreePane, { agents: state.agents, nowEpochMs: nowEpochMs }) })] }));
 }
 function HelpOverlay() {
     // Group commands by their `group` field so the operator scans the
@@ -161,12 +253,17 @@ function applyVerdictSideEffects(verdict, handlers) {
         case 'clear':
         case 'version':
         case 'jobs':
+        case 'ask':
+        case 'consensus':
         case 'diff':
         case 'cost':
         case 'status':
+        case 'resume':
         case 'stub':
             // All non-overlay verdicts: the session module already appended
-            // any operator-visible system lines. No further UI side effect.
+            // any operator-visible system lines (and, for `ask`, set
+            // pendingAsk so the modal renders on the next frame). No further
+            // UI side effect needed here.
             return;
     }
 }

package/dist/tui/slash-palette.js

@@ -3,16 +3,21 @@ import { Box, Text } from 'ink';
 import { SLASH_COMMAND_HELP } from '../core/repl/slash-commands.js';
 export const PALETTE_ROW_LIMIT = 8;
 /**
- * Compute the visible palette window for a given input buffer.
+ * 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).
- *   - Capped at PALETTE_ROW_LIMIT; the input box renders a hint when
- *     `totalBeforeLimit > rows.length`.
  */
 export function filterPalette(buffer) {
     if (!buffer.startsWith('/')) {
@@ -31,9 +36,33 @@ export function filterPalette(buffer) {
     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 {
-        rows: all.slice(0, PALETTE_ROW_LIMIT),
-        totalBeforeLimit: all.length,
+        visible: rows.slice(start, start + PALETTE_ROW_LIMIT),
+        startIndex: start,
+        total,
     };
 }
 /**
@@ -57,13 +86,21 @@ export function completePalette(buffer, rows, focusedIndex) {
 export function SlashPalette(props) {
     if (props.rows.length === 0)
         return null;
-    const total = props.totalBeforeLimit ?? props.rows.length;
-    const overflow = total - props.rows.length;
-    return (_jsxs(Box, { flexDirection: "column", marginTop: 0, paddingLeft: 2, children: [props.rows.map((row, idx) => {
-                const focused = idx === props.focusedIndex;
+    // 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 > 0 ? (_jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  · ${overflow} more (keep typing to narrow)` }) })) : null, _jsx(Box, { children: _jsx(Text, { dimColor: true, children: '  ↑/↓ select  ·  Tab complete  ·  Enter run  ·  Esc close' }) })] }));
+            }), 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/status-bar.js

@@ -12,13 +12,38 @@ export function StatusBar(props) {
     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, { 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}` })] }));
+    // α6.9: composite status label — connection problems trump dispatch
+    // state because the operator needs to know about a dropped admin-api
+    // first. When the connection is healthy (`on_watch` / `connecting`),
+    // the FSM dispatch state takes over to show the dispatch lifecycle
+    // (`dispatching` / `tool: read` / `aborting` / etc.).
+    const status = composeStatusLabel(props.connection, props.dispatchState, props.dispatchToolLabel);
+    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` }) })] }));
 }
-function connectionLabel(connection) {
+/**
+ * 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)}%`;
+}
+// Exported for test introspection (status-bar-fsm.spec.tsx asserts
+// connecting vs on_watch render in distinct colors; ink-testing-library
+// strips ANSI from lastFrame() so we read the resolved color directly).
+export function connectionLabel(connection) {
     switch (connection) {
         case 'connecting':
-            return { label: 'connecting', color: 'cyan' };
+            // P2 fix: was 'cyan', same as 'on_watch' - operator could not
+            // tell boot from stable. Magenta is distinct from every other
+            // state in this palette (cyan steady, yellow reconnect, gray
+            // offline) so a brief flicker through this state stands out.
+            return { label: 'connecting', color: 'magenta' };
         case 'on_watch':
             return { label: 'on watch', color: 'cyan' };
         case 'reconnecting':
@@ -27,6 +52,54 @@ function connectionLabel(connection) {
             return { label: 'offline', color: 'gray' };
     }
 }
+/**
+ * α6.9: compose the visible status label from connection + FSM state.
+ *
+ * Priority order:
+ *
+ *   1. `offline` / `reconnecting` — transport health wins; the
+ *      operator needs to know about a dropped stream before anything
+ *      about the dispatch.
+ *   2. `aborting` / `aborted` / `failed` — operator-visible terminal
+ *      states the FSM reached; the colour shifts to amber/red so the
+ *      anomaly stands out vs the calm cyan baseline.
+ *   3. `tool_running` — surfaces the tool label when available
+ *      (`tool: read`), falls back to `tool` when not.
+ *   4. `awaiting_response` — `dispatching` (matches Codex CLI's verb
+ *      for the same state).
+ *   5. `completed` — `shipped` (matches the agent tree status glyph
+ *      so the operator's eye links the two surfaces).
+ *   6. `idle` / unknown — connection label (`on watch` / `connecting`).
+ *
+ * The dispatch label `dispatchToolLabel` is already shaped as
+ * `tool: <kind>` upstream so we just concatenate; null falls through
+ * to the bare `tool` placeholder.
+ */
+function composeStatusLabel(connection, dispatchState, toolLabel) {
+    // Transport health wins.
+    if (connection === 'offline' || connection === 'reconnecting') {
+        return connectionLabel(connection);
+    }
+    // FSM dispatch state overlay (only when the FSM was wired).
+    switch (dispatchState) {
+        case 'aborting':
+            return { label: 'aborting', color: 'yellow' };
+        case 'aborted':
+            return { label: 'aborted', color: 'gray' };
+        case 'failed':
+            return { label: 'failed', color: 'red' };
+        case 'tool_running':
+            return { label: toolLabel ?? 'tool', color: 'cyan' };
+        case 'awaiting_response':
+            return { label: 'dispatching', color: 'cyan' };
+        case 'completed':
+            return { label: 'shipped', color: 'green' };
+        case 'idle':
+        case undefined:
+        default:
+            return connectionLabel(connection);
+    }
+}
 function formatElapsed(startedAt, now) {
     if (typeof startedAt !== 'number')
         return 'idle';

package/dist/tui/tool-stream-pane.js

@@ -0,0 +1,91 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const DEFAULT_COLLAPSE_THRESHOLD = 5;
+const DEFAULT_MAX_ROWS = 8;
+export function ToolStreamPane(props) {
+    const calls = props.calls;
+    const collapseThreshold = props.collapseThreshold ?? DEFAULT_COLLAPSE_THRESHOLD;
+    const maxRows = props.maxRows ?? DEFAULT_MAX_ROWS;
+    if (calls.length === 0) {
+        return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PaneHeader, { count: 0, collapsed: props.collapsed }), _jsx(Text, { dimColor: true, children: "No tool calls yet. Dispatch a brief and watch tools land here." })] }));
+    }
+    if (props.collapsed === true) {
+        return (_jsx(Box, { flexDirection: "column", children: _jsx(PaneHeader, { count: calls.length, collapsed: true }) }));
+    }
+    // Tail-window the rows so a long-running session does not overflow
+    // the bottom half of the frame. Older rows stay in the session state
+    // for /jobs and /diff inspection.
+    const visible = calls.slice(-maxRows);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(PaneHeader, { count: calls.length, collapsed: false }), visible.map((call) => (_jsx(ToolCallRow, { call: call, collapseThreshold: collapseThreshold }, call.id)))] }));
+}
+function PaneHeader({ count, collapsed }) {
+    const verb = collapsed ? 'Ctrl+T to expand' : 'Ctrl+T to collapse';
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, dimColor: true, children: '─ tools ' }), _jsx(Text, { dimColor: true, children: `(${count})  ` }), _jsx(Text, { dimColor: true, children: verb })] }));
+}
+function ToolCallRow({ call, collapseThreshold, }) {
+    const glyph = statusGlyph(call.status);
+    const color = statusColor(call.status);
+    const label = formatToolLabel(call.tool, call.args);
+    const summary = formatSummary(call);
+    const showHint = (call.resultLines ?? 0) > collapseThreshold;
+    return (_jsxs(Box, { children: [_jsx(Text, { color: color, children: glyph }), _jsx(Text, { children: ' ' }), _jsx(Text, { bold: true, children: label }), _jsx(Text, { dimColor: true, children: `  ${summary}` }), showHint ? (_jsx(Text, { dimColor: true, children: `  · ${call.resultLines} lines, Ctrl+O to expand` })) : null] }));
+}
+function statusGlyph(status) {
+    switch (status) {
+        case 'running':
+            return '→';
+        case 'ok':
+            return '✓';
+        case 'error':
+            return '✗';
+    }
+}
+function statusColor(status) {
+    switch (status) {
+        case 'running':
+            return 'cyan';
+        case 'ok':
+            return 'green';
+        case 'error':
+            return 'red';
+    }
+}
+/**
+ * Render the canonical `Tool(args)` form. Tool names are capitalised
+ * the way Claude Code shows them; args are truncated to 60 chars so
+ * the row stays single-line even on 80-col terminals.
+ */
+function formatToolLabel(tool, args) {
+    const name = toolDisplayName(tool);
+    const trimmedArgs = args.length > 60 ? `${args.slice(0, 57)}…` : args;
+    return `${name}(${trimmedArgs})`;
+}
+function toolDisplayName(tool) {
+    switch (tool) {
+        case 'read':
+            return 'Read';
+        case 'edit':
+            return 'Edit';
+        case 'bash':
+            return 'Bash';
+        case 'grep':
+            return 'Grep';
+        case 'glob':
+            return 'Glob';
+        case 'web_fetch':
+            return 'WebFetch';
+    }
+}
+function formatSummary(call) {
+    if (call.status === 'running') {
+        return call.detail ?? 'running...';
+    }
+    if (call.status === 'error') {
+        return call.detail ?? 'error';
+    }
+    // ok
+    const duration = typeof call.durationMs === 'number' ? `${call.durationMs}ms` : '';
+    const detail = call.detail ?? 'OK';
+    return duration.length > 0 ? `${detail} ${duration}` : detail;
+}
+//# sourceMappingURL=tool-stream-pane.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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-alpha.8",
-  "description": "Pugi CLI — terminal-native software execution system",
+  "version": "0.1.0-beta.1",
+  "description": "Pugi CLI - terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
     "type": "git",
@@ -28,30 +28,36 @@
   "files": [
     "bin/run.js",
     "dist/**/*.js",
+    "assets/**/*.ansi",
     "README.md",
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20"
+    "node": ">=22.5.0"
   },
+  "//publishConfig": "CEO sign-off 2026-05-23 alpha launch: @pugi/cli is the customer-facing CLI and ships PUBLIC so `npm i -g @pugi/cli` resolves anonymously. The HARD default-restricted memory rule (2026-05-25) applies to INTERNAL @pugi/* packages (db-client, telegram bot helpers, etc.) - those must ship access:restricted unless an additional CEO sign-off granted. @pugi/sdk + @pugi/personas were published public alongside the CLI under the same alpha-launch sign-off because the CLI's customer install pulls them as transitive deps; review before α7 GA.",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
     "@mozilla/readability": "^0.6.0",
+    "chokidar": "^3.6.0",
+    "ignore": "^5.3.2",
     "ink": "^5.0.1",
     "linkedom": "^0.18.12",
     "react": "^18.3.1",
+    "tar": "^6.2.1",
     "tinyglobby": "^0.2.16",
     "turndown": "^7.2.4",
     "undici": "^8.3.0",
     "zod": "^3.23.0",
-    "@pugi/personas": "0.1.0",
-    "@pugi/sdk": "0.1.0-alpha.8"
+    "@pugi/personas": "0.1.1",
+    "@pugi/sdk": "0.1.0-beta.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.3",
+    "@types/tar": "^6.1.13",
     "@types/turndown": "^5.0.6",
     "ink-testing-library": "^4.0.0",
     "tsx": "^4.19.0",