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

package/dist/tui/repl.js

@@ -20,22 +20,32 @@ 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`.
@@ -122,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, 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, 
+    // α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, pugiMdCount: workspaceContext.pugiMdCount, mcpServerCount: workspaceContext.mcpServerCount, skillCount: workspaceContext.skillCount, quotaPct: props.quotaPct })] })] }));
+                        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
@@ -187,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/status-bar.js

@@ -12,7 +12,12 @@ 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);
+    // α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` }) })] }));
 }
 /**
@@ -28,10 +33,17 @@ function formatQuota(pct) {
         return '—';
     return `${Math.round(pct)}%`;
 }
-function connectionLabel(connection) {
+// 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':
@@ -40,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-alpha.9",
-  "description": "Pugi CLI — terminal-native software execution system",
+  "version": "0.1.0-beta.2",
+  "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.9"
+    "@pugi/personas": "0.1.2",
+    "@pugi/sdk": "0.1.0-beta.2"
   },
   "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",