@pugi/cli 0.1.0-alpha.7 → 0.1.0-alpha.8

package/dist/core/repl/session.js

@@ -32,6 +32,9 @@ import { evaluateCap, describeVerdict } from './cap-warning.js';
 import { parseSlashCommand } from './slash-commands.js';
 import { webFetchTool } from '../../tools/web-fetch.js';
 import { loadSettings } from '../settings.js';
+import { getJobRegistry } from '../jobs/registry.js';
+import { existsSync, readdirSync, statSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
 const MAX_TRANSCRIPT_ROWS = 500;
 const MAX_RECONNECT_ATTEMPTS = 10;
 const RECONNECT_BASE_MS = 250;
@@ -45,6 +48,18 @@ export class ReplSession {
     reconnectAttempt = 0;
     reconnectTimer;
     closed = false;
+    /**
+     * Last non-trivial step.detail recorded per taskId. The server streams
+     * the persona reply incrementally via `agent.step` events whose
+     * `detail` field carries the cumulative model output. `agent.completed`
+     * arrives last and previously overwrote the visible detail to the
+     * literal string `'shipped'` while the transcript line said only
+     * `shipped.` — the actual reply text was lost. By caching the last
+     * non-trivial detail here, we can flush it into the transcript when
+     * the agent completes so the operator sees what the persona actually
+     * said. CEO wave-2 fix 2026-05-25.
+     */
+    lastStepDetail = new Map();
     constructor(options) {
         this.options = options;
         this.state = {
@@ -139,8 +154,112 @@ export class ReplSession {
                 await this.dispatchWebFetch(verdict.url);
                 return verdict;
             }
+            case 'clear': {
+                this.clearTranscript();
+                return verdict;
+            }
+            case 'version': {
+                this.appendSystemLine(`pugi ${this.options.cliVersion}`);
+                return verdict;
+            }
+            case 'jobs': {
+                await this.dispatchJobs();
+                return verdict;
+            }
+            case 'diff': {
+                this.dispatchDiff();
+                return verdict;
+            }
+            case 'cost': {
+                this.dispatchCost();
+                return verdict;
+            }
+            case 'status': {
+                this.dispatchStatus();
+                return verdict;
+            }
+            case 'stub': {
+                this.appendSystemLine(verdict.message);
+                return verdict;
+            }
         }
     }
+    /**
+     * Reset the conversation transcript. The agent registry stays intact
+     * so the operator can `/clear` to declutter the chat pane without
+     * losing visibility into running dispatches.
+     */
+    clearTranscript() {
+        this.patch({ transcript: [] });
+    }
+    /* ------------- Tier 1 / Tier 2 wired handlers -------------- */
+    async dispatchJobs() {
+        try {
+            const registry = getJobRegistry();
+            const entries = await registry.list();
+            if (entries.length === 0) {
+                this.appendSystemLine('No background jobs tracked.');
+                return;
+            }
+            this.appendSystemLine(`Background jobs (${entries.length}):`);
+            for (const entry of entries) {
+                const id = entry.id.replace(/^pj-/, '').slice(0, 8);
+                const status = entry.status;
+                const cmd = entry.command.length > 48 ? `${entry.command.slice(0, 47)}…` : entry.command;
+                this.appendSystemLine(`  ${id}  ${status.padEnd(10)}  ${cmd}`);
+            }
+        }
+        catch (error) {
+            this.appendSystemLine(`/jobs failed: ${this.errorMessage(error)}`);
+        }
+    }
+    dispatchDiff() {
+        try {
+            const artifactsRoot = resolvePath(process.cwd(), '.pugi', 'artifacts');
+            if (!existsSync(artifactsRoot)) {
+                this.appendSystemLine('No pending diffs (.pugi/artifacts/ not found).');
+                return;
+            }
+            const subdirs = readdirSync(artifactsRoot, { withFileTypes: true })
+                .filter((d) => d.isDirectory())
+                .map((d) => d.name);
+            const diffs = [];
+            for (const name of subdirs) {
+                const candidate = resolvePath(artifactsRoot, name, 'diff.patch');
+                if (existsSync(candidate)) {
+                    const size = statSync(candidate).size;
+                    diffs.push(`  ${name}/diff.patch (${size} bytes)`);
+                }
+            }
+            if (diffs.length === 0) {
+                this.appendSystemLine('No pending diffs.');
+                return;
+            }
+            this.appendSystemLine(`Pending diffs (${diffs.length}):`);
+            for (const line of diffs)
+                this.appendSystemLine(line);
+        }
+        catch (error) {
+            this.appendSystemLine(`/diff failed: ${this.errorMessage(error)}`);
+        }
+    }
+    dispatchCost() {
+        const { tokensDownstreamTotal, agents } = this.state;
+        const active = agents.filter((a) => a.status === 'queued' || a.status === 'thinking').length;
+        const lineTokens = `Tokens this session: ${tokensDownstreamTotal.toLocaleString()} (in+out).`;
+        const lineAgents = `Active dispatches: ${active} of cap.`;
+        this.appendSystemLine(lineTokens);
+        this.appendSystemLine(lineAgents);
+        this.appendSystemLine('Full per-persona budget breakdown lands in α6.5.');
+    }
+    dispatchStatus() {
+        const sessionId = this.state.sessionId ?? '(unbound)';
+        const reach = this.state.connection;
+        this.appendSystemLine(`Backend: ${this.options.apiUrl} (${reach}).`);
+        this.appendSystemLine(`Session: ${sessionId}.`);
+        this.appendSystemLine(`Workspace: ${this.state.workspaceLabel}.`);
+        this.appendSystemLine(`CLI: pugi ${this.state.cliVersion}.`);
+    }
     /**
      * Fetch one URL via the web_fetch tool and inject the resulting
      * Markdown into the transcript as an operator-attributed brief. The
@@ -307,6 +426,12 @@ export class ReplSession {
                 return;
             }
             case 'agent.step': {
+                // Cache the running detail per task so we can surface the
+                // model's actual reply when agent.completed lands (otherwise
+                // the reply disappears under the literal 'shipped' patch).
+                if (event.detail && event.detail.trim().length > 0) {
+                    this.lastStepDetail.set(event.taskId, event.detail);
+                }
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'thinking', detail: event.detail }
@@ -330,18 +455,41 @@ export class ReplSession {
             }
             case 'agent.completed': {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
+                const finalDetail = this.lastStepDetail.get(event.taskId);
+                this.lastStepDetail.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'shipped', detail: 'shipped' }
                         : a),
                 });
                 if (target) {
-                    this.appendPersonaLine(target.personaSlug, 'shipped.');
+                    // If the persona actually produced a reply via incremental
+                    // agent.step events, render that reply in the transcript so
+                    // the operator sees the full answer. The threshold (>4 chars
+                    // + not the queued placeholder) filters out the no-op
+                    // "shipped"/"queued for dispatch" placeholders the dispatcher
+                    // emits before the model speaks. Multi-line replies are
+                    // emitted line by line so the conversation pane wraps each
+                    // sentence on its own row.
+                    if (finalDetail
+                        && finalDetail !== 'queued for dispatch'
+                        && finalDetail.trim().length > 4) {
+                        for (const line of finalDetail.split('\n')) {
+                            const trimmed = line.trim();
+                            if (trimmed.length > 0) {
+                                this.appendPersonaLine(target.personaSlug, trimmed);
+                            }
+                        }
+                    }
+                    else {
+                        this.appendPersonaLine(target.personaSlug, 'shipped.');
+                    }
                 }
                 return;
             }
             case 'agent.blocked': {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
+                this.lastStepDetail.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'blocked', detail: event.detail }
@@ -354,6 +502,7 @@ export class ReplSession {
             }
             case 'agent.failed': {
                 const target = this.state.agents.find((a) => a.taskId === event.taskId);
+                this.lastStepDetail.delete(event.taskId);
                 this.patch({
                     agents: this.state.agents.map((a) => a.taskId === event.taskId
                         ? { ...a, status: 'failed', detail: event.error }

package/dist/core/repl/slash-commands.js

@@ -1,32 +1,99 @@
 /**
- * REPL slash command registry - Sprint α5.7 (ADR-0056 PR-PUGI-CLI-REPL-DEFAULT).
+ * REPL slash command registry — Sprint α5.7, expanded α6.14 wave 2.
  *
- * The REPL input box surfaces a small palette of slash commands that the
- * operator can run from inside a persistent session: dispatch a brief,
- * inspect the agent roster, stop a running persona, open the help
- * overlay, or quit. The registry is intentionally narrow at M1 -
- * complementary surfaces (`/sync`, `/handoff`, `/budget`) ship as proper
- * subcommands in α5.8+ and stay reachable from a non-REPL `pugi
- * <command>` invocation.
+ * The REPL input box surfaces a palette of slash commands the operator
+ * can run from inside a persistent session. The wave-2 expansion (CEO
+ * 2026-05-25) grows the surface from 6 to 20 commands so the `/help`
+ * overlay matches the breadth Claude Code / Codex CLI operators expect.
  *
- * The registry is pure: each entry returns a `SlashCommandResult`
- * describing what the REPL session should do next. The session module
- * owns the side effects (network calls, dispatcher invocation, exit).
- * Keeping the surface pure lets the unit test exercise every shape
- * without standing up an Ink runtime or an Anvil endpoint.
+ * The registry is pure: each `parseSlashCommand` call returns a
+ * `SlashCommandResult` describing what the REPL session should do next.
+ * The session module owns the side effects (network calls, dispatcher
+ * invocation, exit, transcript clear). Keeping the surface pure lets
+ * the unit test exercise every shape without standing up an Ink runtime
+ * or an Anvil endpoint.
+ *
+ * Tiering (per CEO wave-2 spec):
+ *
+ *   Tier 1 — wired against real state (3 + existing 6 = 9 wired):
+ *     brief, agents, stop, help, quit, web, clear, version, jobs.
+ *
+ *   Tier 2 — best-effort wiring against existing surfaces (3):
+ *     diff, cost, status.
+ *
+ *   Tier 3 — deterministic stubs ("coming in αX.Y") (8):
+ *     compact, resume, memory, config, privacy, budget, mcp, undo.
  *
  * Brand voice (brandbook §08): power words `brief / dispatch / stop /
- * agents / quit`. Tagline `Brief it. It ships.` reserved for `/quit`
- * confirmation and `/help` footer - never inline.
+ * agents / quit / shipped`. Tagline `Brief it. It ships.` reserved for
+ * `/quit` confirmation and `/help` footer — never inline.
  */
 import { listRoles } from '../agents/registry.js';
+/**
+ * Deterministic stub copy returned by the Tier 3 commands. Spec'd
+ * inline so the unit test can pin the exact text without poking at
+ * the help overlay. The version tag at the end maps to the sprint we
+ * intend to land the real wiring in.
+ */
+export const SLASH_STUB_MESSAGES = Object.freeze({
+    brief: '',
+    agents: '',
+    stop: '',
+    help: '',
+    quit: '',
+    web: '',
+    clear: '',
+    version: '',
+    jobs: '',
+    diff: '',
+    cost: '',
+    status: '',
+    compact: 'Manual context compaction lands in α6.5.',
+    resume: 'Resume last session lands in α6.4 once SQLite session.db lands.',
+    memory: 'Session memory editor lands in α6.5.',
+    config: 'Run `pugi config list` from a fresh shell for the full surface; in-REPL editor lands in α6.5.',
+    privacy: 'Run `pugi privacy show` from a fresh shell; in-REPL toggle lands in α6.5.',
+    budget: 'Run `pugi budget` from a fresh shell; in-REPL summary lands in α6.5.',
+    mcp: 'Run `pugi config mcp list` from a fresh shell; in-REPL palette lands in α6.5.',
+    undo: 'Run `pugi undo` from a fresh shell; in-REPL undo lands in α6.5.',
+});
 export const SLASH_COMMAND_HELP = Object.freeze([
-    { name: 'brief', args: '<text>', gloss: 'Dispatch a brief to the workforce' },
-    { name: 'agents', args: '', gloss: 'List the on-watch agent roster' },
-    { name: 'stop', args: '<persona>', gloss: 'Stop one agent by persona slug' },
-    { name: 'help', args: '', gloss: 'Show this help overlay' },
-    { name: 'quit', args: '', gloss: 'Exit the REPL (session resumes via pugi resume)' },
-    { name: 'web', args: '<url>', gloss: 'Fetch a URL and brief Pugi on the page' },
+    // Workforce dispatch
+    { name: 'brief', args: '<text>', gloss: 'Dispatch a brief to the workforce', group: 'Workforce dispatch' },
+    { name: 'agents', args: '', gloss: 'List the on-watch agent roster', group: 'Workforce dispatch' },
+    { name: 'stop', args: '<persona>', gloss: 'Stop one agent by persona slug', group: 'Workforce dispatch' },
+    { name: 'jobs', args: '', gloss: 'List background jobs', group: 'Workforce dispatch' },
+    // Session
+    { name: 'clear', args: '', gloss: 'Clear conversation pane', group: 'Session' },
+    { name: 'resume', args: '', gloss: 'Resume last session  (α6.4)', group: 'Session', stub: true },
+    { name: 'compact', args: '', gloss: 'Manual context compaction  (α6.5)', group: 'Session', stub: true },
+    { name: 'memory', args: '', gloss: 'Session memory editor  (α6.5)', group: 'Session', stub: true },
+    // Pugi tools
+    { name: 'web', args: '<url>', gloss: 'Fetch a URL into context', group: 'Pugi tools' },
+    { name: 'diff', args: '', gloss: 'Show pending diff', group: 'Pugi tools' },
+    { name: 'cost', args: '', gloss: 'Token usage + budget', group: 'Pugi tools' },
+    { name: 'status', args: '', gloss: 'Backend + tenant status', group: 'Pugi tools' },
+    // Settings
+    { name: 'config', args: '', gloss: 'Show config', group: 'Settings', stub: true },
+    { name: 'privacy', args: '', gloss: 'Show privacy mode', group: 'Settings', stub: true },
+    { name: 'budget', args: '', gloss: 'Show usage budget', group: 'Settings', stub: true },
+    { name: 'mcp', args: '', gloss: 'List MCP servers', group: 'Settings', stub: true },
+    { name: 'undo', args: '', gloss: 'Undo last write', group: 'Settings', stub: true },
+    // Meta
+    { name: 'help', args: '', gloss: 'Show this help overlay', group: 'Meta' },
+    { name: 'version', args: '', gloss: 'Show CLI version', group: 'Meta' },
+    { name: 'quit', args: '', gloss: 'Exit the REPL', group: 'Meta' },
+]);
+/**
+ * Ordered list of groups. Drives the `/help` overlay sectioning so the
+ * operator reads commands by intent (dispatch first, meta last).
+ */
+export const SLASH_COMMAND_GROUPS = Object.freeze([
+    'Workforce dispatch',
+    'Session',
+    'Pugi tools',
+    'Settings',
+    'Meta',
 ]);
 /**
  * Parse one line of input from the REPL. The contract:
@@ -34,13 +101,15 @@ export const SLASH_COMMAND_HELP = Object.freeze([
  *   - Empty / whitespace-only input returns `noop` with the original
  *     text so the REPL can ignore it without printing anything.
  *   - Input that does not start with `/` is treated as an implicit
- *     `/brief <text>` - the most-common operator action.
+ *     `/brief <text>` — the most-common operator action.
  *   - `/<name> [args]` resolves the name against the registry; unknown
  *     names return `error` so the REPL can render a one-line tip
  *     instead of silently dropping the input.
+ *   - Tier 3 stubs return `{ kind: 'stub', name, message }` so the REPL
+ *     can render the deterministic "coming in αX.Y" copy uniformly.
  *
  * The function never throws. Bad input maps to a structured result the
- * REPL can render - the alternative (throwing from a keystroke handler)
+ * REPL can render — the alternative (throwing from a keystroke handler)
  * would unmount Ink mid-frame.
  */
 export function parseSlashCommand(input) {
@@ -98,6 +167,40 @@ export function parseSlashCommand(input) {
             }
             return { kind: 'web', url: tail };
         }
+        case 'clear':
+        case 'cls': {
+            return { kind: 'clear' };
+        }
+        case 'version':
+        case 'v': {
+            return { kind: 'version' };
+        }
+        case 'jobs': {
+            return { kind: 'jobs' };
+        }
+        case 'diff': {
+            return { kind: 'diff' };
+        }
+        case 'cost': {
+            return { kind: 'cost' };
+        }
+        case 'status': {
+            return { kind: 'status' };
+        }
+        case 'compact':
+        case 'resume':
+        case 'memory':
+        case 'config':
+        case 'privacy':
+        case 'budget':
+        case 'mcp':
+        case 'undo': {
+            return {
+                kind: 'stub',
+                name: name,
+                message: SLASH_STUB_MESSAGES[name],
+            };
+        }
         default: {
             return {
                 kind: 'error',

package/dist/runtime/cli.js

@@ -35,7 +35,7 @@ import { runBudgetCommand } from './commands/budget.js';
  * packages/pugi-sdk/package.json); the publish workflow validates the
  * three are in lockstep.
  */
-const PUGI_CLI_VERSION = '0.1.0-alpha.7';
+const PUGI_CLI_VERSION = '0.1.0-alpha.8';
 const handlers = {
     accounts,
     build: runEngineTask('build_task'),

package/dist/tui/input-box.js

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

package/dist/tui/repl.js

@@ -26,7 +26,7 @@ import { InputBox } from './input-box.js';
 import { StatusBar } from './status-bar.js';
 import { UpdateBanner } from './update-banner.js';
 import { slugForCwd } from '../core/repl/history.js';
-import { SLASH_COMMAND_HELP } from '../core/repl/slash-commands.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) {
@@ -114,7 +114,27 @@ function MainArea({ state, personaNames, nowEpochMs, }) {
     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() {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: "Pugi REPL help" }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: SLASH_COMMAND_HELP.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))) }), _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.' }) })] }));
+    // 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.' }) })] }));
@@ -138,6 +158,15 @@ function applyVerdictSideEffects(verdict, handlers) {
         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;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pugi/cli",
-  "version": "0.1.0-alpha.7",
+  "version": "0.1.0-alpha.8",
   "description": "Pugi CLI — terminal-native software execution system",
   "homepage": "https://pugi.io",
   "repository": {
@@ -47,7 +47,7 @@
     "undici": "^8.3.0",
     "zod": "^3.23.0",
     "@pugi/personas": "0.1.0",
-    "@pugi/sdk": "0.1.0-alpha.7"
+    "@pugi/sdk": "0.1.0-alpha.8"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",