@pugi/cli 0.1.0-alpha.10

package/dist/tui/login-picker.js

@@ -0,0 +1,69 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+const ITEMS = [
+    {
+        provider: 'device',
+        title: 'Browser OAuth',
+        hint: 'Opens app.pugi.io in your browser to approve this device',
+    },
+    {
+        provider: 'token',
+        title: 'API key',
+        hint: 'Paste a personal access token (pugi.io/settings/api-keys)',
+    },
+    {
+        provider: 'env',
+        title: 'Environment variable',
+        hint: 'Use PUGI_API_KEY from the current shell',
+    },
+];
+/**
+ * Arrow-key login picker. Driven entirely by Ink's `useInput`. The
+ * component does NOT perform the OAuth flow itself, it only resolves
+ * the selected provider back to the caller (CLI dispatcher), which
+ * then unmounts Ink and hands control to the existing handlers in
+ * runtime/cli.ts.
+ */
+export function LoginPicker(props) {
+    const [index, setIndex] = useState(Math.min(Math.max(props.initialIndex ?? 0, 0), ITEMS.length - 1));
+    useInput((input, key) => {
+        if (key.upArrow || input === 'k') {
+            setIndex((current) => (current === 0 ? ITEMS.length - 1 : current - 1));
+            return;
+        }
+        if (key.downArrow || input === 'j') {
+            setIndex((current) => (current === ITEMS.length - 1 ? 0 : current + 1));
+            return;
+        }
+        if (key.return) {
+            const selected = ITEMS[index];
+            if (selected)
+                props.onSelect(selected.provider);
+            return;
+        }
+        if (key.escape || input === 'q') {
+            props.onCancel();
+            return;
+        }
+        // Number shortcuts mirror the legacy text picker for muscle memory.
+        if (input === '1')
+            props.onSelect('device');
+        if (input === '2')
+            props.onSelect('token');
+        if (input === '3')
+            props.onSelect('env');
+    });
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 2, paddingY: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Sign in to Pugi" }), _jsx(Text, { dimColor: true, children: `      (endpoint: ${props.apiUrl})` })] }), _jsx(Box, { marginTop: 1, flexDirection: "column", children: ITEMS.map((item, itemIndex) => {
+                    const isSelected = itemIndex === index;
+                    return (_jsx(PickerRow, { isSelected: isSelected, title: item.title, hint: item.hint }, item.provider));
+                }) }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '↑/↓ select   Enter confirm   Esc cancel' }) })] }));
+}
+function PickerRow({ isSelected, title, hint, }) {
+    // Arrow glyph + padded title so highlighted and dim rows share
+    // column alignment.
+    const indicator = isSelected ? '▸ ' : '  ';
+    const padded = title.padEnd(22, ' ');
+    return (_jsxs(Text, { children: [_jsxs(Text, { color: isSelected ? 'cyan' : undefined, bold: isSelected, children: [indicator, padded] }), _jsx(Text, { dimColor: true, children: hint })] }));
+}
+//# sourceMappingURL=login-picker.js.map

package/dist/tui/render.js

@@ -0,0 +1,125 @@
+import React from 'react';
+import { render } from 'ink';
+import { DeviceFlow } from './device-flow.js';
+import { LoginPicker } from './login-picker.js';
+import { Splash } from './splash.js';
+import { collectSplashData } from './splash-data.js';
+/**
+ * Mount `<Splash />` on a TTY, await unmount, return. The CLI
+ * dispatcher only reaches this entry point when `isInteractive()`
+ * already cleared.
+ */
+export async function renderSplash(cliVersion) {
+    const data = collectSplashData({ cliVersion });
+    const instance = render(React.createElement(Splash, { data }));
+    // The splash is static: nothing reads input, nothing animates. Defer
+    // the unmount one macrotask so Ink's log-update flush, Yoga layout
+    // settle, and the initial process.stdout.write all complete before
+    // we tear the runtime down. Without setImmediate, some terminals
+    // batch writes and lose the splash frame entirely on fast exit.
+    await new Promise((resolve) => setImmediate(resolve));
+    instance.unmount();
+    await instance.waitUntilExit();
+}
+/**
+ * Sentinel thrown when the user dismisses the login picker via Esc
+ * or `q`. The CLI dispatcher catches it, prints a one-line abort
+ * message, and exits 130 (the standard exit code for SIGINT-style
+ * user cancellations — matches gh CLI, codex, claude-code).
+ */
+export class LoginCancelledError extends Error {
+    constructor() {
+        super('Login cancelled');
+        this.name = 'LoginCancelledError';
+    }
+}
+/**
+ * Mount `<LoginPicker />`, resolve to the chosen provider. Rejects
+ * with `LoginCancelledError` when the user cancels.
+ *
+ * After selection we call `unmount()` and resolve on the next
+ * macrotask. We deliberately do NOT chain `waitUntilExit()` — under
+ * some shimmed-stdin scenarios (CI test harnesses) Ink's
+ * `waitUntilExit` never settles because its raw-mode-release path
+ * waits on a stdin event that never fires. The next handler in the
+ * CLI dispatcher restores stdin state on its own (the device flow
+ * forks a browser, the token path attaches a fresh data listener).
+ */
+export function renderLoginPicker(apiUrl) {
+    return new Promise((resolveProvider, rejectProvider) => {
+        let settled = false;
+        const finish = (cb) => {
+            if (settled)
+                return;
+            settled = true;
+            instance.unmount();
+            setImmediate(cb);
+        };
+        const instance = render(React.createElement(LoginPicker, {
+            apiUrl,
+            onSelect: (provider) => {
+                finish(() => resolveProvider(provider));
+            },
+            onCancel: () => {
+                finish(() => rejectProvider(new LoginCancelledError()));
+            },
+        }));
+    });
+}
+/**
+ * Mount `<DeviceFlow />` on a TTY and return a handle the host uses to
+ * drive the frame. Mirrors `renderLoginPicker`'s lifecycle: we
+ * deliberately do NOT call `waitUntilExit()` after unmount (some
+ * shimmed-stdin test harnesses never settle that promise — the next
+ * code path in cli.ts restores stdin state on its own).
+ */
+export function renderDeviceFlow(options) {
+    let settled = false;
+    let resolveDone = () => undefined;
+    let rejectDone = () => undefined;
+    const donePromise = new Promise((resolveFn, rejectFn) => {
+        resolveDone = resolveFn;
+        rejectDone = rejectFn;
+    });
+    // Per the spec, the polling status drives the visible spinner; the
+    // host pushes status updates via `setStatus`. We use a tiny stateful
+    // wrapper component so React owns the re-render lifecycle (calling
+    // `instance.rerender` with a new element triggers a clean diff).
+    let currentStatus = { kind: 'polling' };
+    const finish = (cb) => {
+        if (settled)
+            return;
+        settled = true;
+        instance.unmount();
+        setImmediate(cb);
+    };
+    const renderElement = () => React.createElement(DeviceFlow, {
+        verificationUrl: options.verificationUrl,
+        userCode: options.userCode,
+        browserOpened: options.browserOpened,
+        status: currentStatus,
+        onCopy: options.onCopy,
+        onCancel: () => {
+            finish(() => rejectDone(new LoginCancelledError()));
+        },
+        onContinue: () => {
+            finish(() => resolveDone());
+        },
+    });
+    const instance = render(renderElement());
+    return {
+        setStatus(next) {
+            if (settled)
+                return;
+            currentStatus = next;
+            instance.rerender(renderElement());
+        },
+        unmount() {
+            finish(() => resolveDone());
+        },
+        done() {
+            return donePromise;
+        },
+    };
+}
+//# sourceMappingURL=render.js.map

package/dist/tui/repl-render.js

@@ -0,0 +1,240 @@
+/**
+ * Production REPL mount + transport - Sprint α5.7.
+ *
+ * Owns the Ink mount lifecycle for `<Repl />` and wires the real
+ * fetch + SSE transport. The CLI dispatcher in `runtime/cli.ts` calls
+ * `renderRepl` on the bare-`pugi` path when stdin / stdout are TTYs.
+ *
+ * The transport speaks to admin-api:
+ *   POST /api/pugi/sessions             → { sessionId }
+ *   POST /api/pugi/sessions/:id/brief   → { dispatchId }
+ *   POST /api/pugi/sessions/:id/stop    → { stopped }
+ *   GET  /api/pugi/sessions/:id/stream  → text/event-stream
+ *
+ * SSE is parsed client-side from a streaming fetch response - Node 22
+ * native fetch returns a WHATWG `ReadableStream` which we feed through
+ * a tiny `event:`/`data:`/`id:` parser. This keeps the dependency
+ * graph at zero new packages.
+ */
+import React from 'react';
+import { render } from 'ink';
+import { Repl } from './repl.js';
+import { ReplSession, } from '../core/repl/session.js';
+import { resolveWorkspaceContext } from '../core/repl/workspace-context.js';
+/**
+ * Mount the REPL and resolve when the user exits via Ctrl+C × 2 or
+ * `/quit`. The session is closed (server-side stays alive; resume via
+ * `pugi resume <sessionId>` once that command exists).
+ */
+export async function renderRepl(options) {
+    const transport = createProductionTransport();
+    // Auto-bind the workspace context from process.cwd() so Mira knows
+    // which repo the operator launched the CLI in. The resolver is
+    // best-effort — any FS error falls back to a basename-only summary,
+    // never blocks REPL launch. Wave 4 fix 2026-05-25.
+    const workspace = options.workspace ?? resolveWorkspaceContext(process.cwd());
+    const session = new ReplSession({
+        apiUrl: options.apiUrl,
+        apiKey: options.apiKey,
+        workspaceLabel: options.workspaceLabel,
+        cliVersion: options.cliVersion,
+        transport,
+        workspace,
+    });
+    // Kick off the connect; the Repl renders the connecting state until
+    // the session pushes `connection: 'on_watch'` from the SSE onOpen.
+    void session.start();
+    const instance = render(React.createElement(Repl, {
+        session,
+        updateBanner: options.updateBanner ?? null,
+        skipSplash: options.skipSplash === true,
+    }));
+    try {
+        await instance.waitUntilExit();
+    }
+    finally {
+        session.close();
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Production transport                                               */
+/* ------------------------------------------------------------------ */
+function createProductionTransport() {
+    return {
+        async createSession({ apiUrl, apiKey, workspace }) {
+            // Forward the workspace bundle in the POST body so admin-api can
+            // surface `<workspace-context>` in Mira's prompt. Older admin-api
+            // builds ignore unknown fields, so this stays forward-compatible.
+            // Wave 4 fix 2026-05-25.
+            const body = {};
+            if (workspace?.workspaceCwd)
+                body.workspaceCwd = workspace.workspaceCwd;
+            if (workspace?.workspaceSlug)
+                body.workspaceSlug = workspace.workspaceSlug;
+            if (workspace?.workspaceSummary)
+                body.workspaceSummary = workspace.workspaceSummary;
+            const response = await fetch(joinUrl(apiUrl, '/api/pugi/sessions'), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify(body),
+            });
+            const json = await readJson(response);
+            const sessionId = json.sessionId;
+            if (typeof sessionId !== 'string' || sessionId.length === 0) {
+                throw new Error('admin-api did not return a sessionId');
+            }
+            return { sessionId };
+        },
+        async postBrief({ apiUrl, apiKey, sessionId, brief }) {
+            const response = await fetch(joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/brief`), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify({ brief }),
+            });
+            const json = await readJson(response);
+            const dispatchId = json.dispatchId;
+            if (typeof dispatchId !== 'string' || dispatchId.length === 0) {
+                throw new Error('admin-api did not return a dispatchId');
+            }
+            return { dispatchId };
+        },
+        async postStop({ apiUrl, apiKey, sessionId, persona }) {
+            const response = await fetch(joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/stop`), {
+                method: 'POST',
+                headers: jsonHeaders(apiKey),
+                body: JSON.stringify({ persona }),
+            });
+            const json = await readJson(response);
+            const stopped = Boolean(json.stopped);
+            return { stopped };
+        },
+        subscribe({ apiUrl, apiKey, sessionId, lastEventId, onEvent, onError, onOpen }) {
+            const controller = new AbortController();
+            const url = joinUrl(apiUrl, `/api/pugi/sessions/${encodeURIComponent(sessionId)}/stream`);
+            const headers = {
+                Accept: 'text/event-stream',
+                Authorization: `Bearer ${apiKey}`,
+            };
+            if (lastEventId) {
+                headers['Last-Event-ID'] = lastEventId;
+            }
+            void (async () => {
+                try {
+                    const response = await fetch(url, {
+                        method: 'GET',
+                        headers,
+                        signal: controller.signal,
+                    });
+                    if (!response.ok) {
+                        throw new Error(`HTTP ${response.status} on SSE stream`);
+                    }
+                    if (!response.body) {
+                        throw new Error('SSE response has no body');
+                    }
+                    onOpen();
+                    await consumeSseStream(response.body, onEvent);
+                    // Server closed the stream cleanly. Treat as an error so
+                    // the session reconnects (the spec says "transient
+                    // disconnect" - a clean close from the server side is also
+                    // transient because the operator may have toggled wifi).
+                    onError(new Error('SSE stream ended'));
+                }
+                catch (error) {
+                    if (controller.signal.aborted)
+                        return;
+                    onError(error instanceof Error ? error : new Error(String(error)));
+                }
+            })();
+            return {
+                close: () => controller.abort(),
+            };
+        },
+    };
+}
+/* ------------------------------------------------------------------ */
+/* SSE parser                                                         */
+/* ------------------------------------------------------------------ */
+/**
+ * Minimal SSE parser. Reads a UTF-8 stream of `id:` / `event:` / `data:`
+ * lines separated by blank lines. We only need the `data` payload (a
+ * JSON object) and the `id` field (so we can replay on reconnect via
+ * Last-Event-ID).
+ */
+async function consumeSseStream(body, onEvent) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder('utf-8');
+    let buffer = '';
+    let currentId = '';
+    let currentData = '';
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        let newlineIndex;
+        while ((newlineIndex = buffer.indexOf('\n')) !== -1) {
+            const rawLine = buffer.slice(0, newlineIndex).replace(/\r$/, '');
+            buffer = buffer.slice(newlineIndex + 1);
+            if (rawLine.length === 0) {
+                // Dispatch - only if we have a data payload.
+                if (currentData.length > 0) {
+                    try {
+                        const parsed = JSON.parse(currentData);
+                        onEvent(parsed, currentId);
+                    }
+                    catch {
+                        // Drop malformed frames silently - protocol-level
+                        // robustness is the controller's job, not the client's.
+                    }
+                }
+                currentData = '';
+                currentId = '';
+                continue;
+            }
+            if (rawLine.startsWith(':'))
+                continue; // Comment / keepalive.
+            const colonIndex = rawLine.indexOf(':');
+            const field = colonIndex === -1 ? rawLine : rawLine.slice(0, colonIndex);
+            const value = colonIndex === -1 ? '' : rawLine.slice(colonIndex + 1).replace(/^ /, '');
+            switch (field) {
+                case 'id':
+                    currentId = value;
+                    break;
+                case 'data':
+                    currentData = currentData.length === 0 ? value : `${currentData}\n${value}`;
+                    break;
+                case 'event':
+                case 'retry':
+                default:
+                    // We do not surface the `event:` name to the consumer - the
+                    // payload itself carries `type`. Future events that need
+                    // dispatcher-side routing without parsing JSON can wire
+                    // through this branch.
+                    break;
+            }
+        }
+    }
+}
+/* ------------------------------------------------------------------ */
+/* Small helpers                                                      */
+/* ------------------------------------------------------------------ */
+function jsonHeaders(apiKey) {
+    return {
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        Authorization: `Bearer ${apiKey}`,
+    };
+}
+async function readJson(response) {
+    if (!response.ok) {
+        const detail = await response.text().catch(() => '');
+        throw new Error(`HTTP ${response.status}${detail ? `: ${detail.slice(0, 200)}` : ''}`);
+    }
+    return response.json();
+}
+function joinUrl(base, path) {
+    const trimmedBase = base.endsWith('/') ? base.slice(0, -1) : base;
+    const trimmedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${trimmedBase}${trimmedPath}`;
+}
+//# sourceMappingURL=repl-render.js.map

package/dist/tui/repl-splash-art.js

@@ -0,0 +1,64 @@
+/**
+ * ASCII pug mascot for the REPL boot splash (α6.14 wave 3).
+ *
+ * Hand-crafted at 9 rows × 20 columns to read as a pug at a single
+ * glance — references the cyber-zoo hero glyph in
+ * `apps/clawhost-web/public/brand/hero-pug.png`: blocky pug face with
+ * angular ear flaps on either side of the head, forehead crease,
+ * angular cyan eyes (`◉`), smushed snout, undershot jaw, and a small
+ * cyan circuit chip (`▐■▌`) on the lower-right cheek.
+ *
+ * Separation of art + cyan mask lets the unit test assert structure
+ * (row count, line widths, mask shape, at-least-one cyan pixel per
+ * eye row) without coupling to the Ink renderer. The renderer in
+ * `repl-splash.tsx` splits each row into runs and colors the masked
+ * columns cyan (#3DA9FC, brandbook §05).
+ *
+ * Convention:
+ *   - PUG_MASCOT[i]            = one row of the silhouette
+ *   - PUG_MASCOT_CYAN_MASK[i]  = parallel boolean array, true => that
+ *                                column renders cyan instead of gray
+ *
+ * Both arrays MUST stay the same length and each mask row MUST be the
+ * same length as the corresponding art row. A unit test enforces this.
+ */
+/* eslint-disable no-irregular-whitespace */
+export const PUG_MASCOT = [
+    '   ▄▀▀▀▄▄▄▀▀▀▄    ',
+    '  █▄▄       ▄▄█   ',
+    '  █  ▀▄▄▄▄▄▀  █   ',
+    '  █  ◉     ◉  █   ',
+    '   ▀▄  ▀█▀  ▄▀    ',
+    '     █▀▀▀▀▀█      ',
+    '     █▒▒▒▒▒█ ▐■▌  ',
+    '      ▀▄▄▄▀       ',
+    '        ▀         ',
+];
+/**
+ * Cyan accents are derived from the source characters so the art file
+ * stays the single source of truth. Two glyph classes get colored:
+ *   - `◉`     -> the two cyan eyes on row 3
+ *   - `▐■▌`   -> the cyan chip cluster on row 6 (right cheek)
+ *
+ * Everything else renders gray. The derivation runs at module load,
+ * which keeps the mask trivially auditable from the source array.
+ */
+export const PUG_MASCOT_CYAN_MASK = PUG_MASCOT.map((row) => {
+    const mask = new Array(row.length).fill(false);
+    for (let column = 0; column < row.length; column += 1) {
+        const ch = row.charAt(column);
+        if (ch === '◉' || ch === '▐' || ch === '■' || ch === '▌') {
+            mask[column] = true;
+        }
+    }
+    return mask;
+});
+/**
+ * Pre-computed silhouette dimensions for layout math in the splash
+ * component. The unit test asserts these stay inside the documented
+ * envelope (≤22 chars wide, 9 ≤ rows ≤ 14) so a future edit can not
+ * silently bloat the terminal real estate.
+ */
+export const PUG_MASCOT_MAX_WIDTH = PUG_MASCOT.reduce((max, row) => Math.max(max, row.length), 0);
+export const PUG_MASCOT_HEIGHT = PUG_MASCOT.length;
+//# sourceMappingURL=repl-splash-art.js.map

package/dist/tui/repl-splash.js

@@ -0,0 +1,111 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * REPL boot splash (α6.14 wave 3).
+ *
+ * Rendered on REPL first paint — before the conversation pane, before
+ * any operator input lands. Mirrors the Claude Code / Codex / Gemini
+ * CLI boot-screen aesthetic while staying Pugi-brand-pure:
+ *
+ *   [PUG ASCII]   Pugi.io  v0.1.0-alphaN
+ *                 Plan:      <plan>
+ *                 Model:     <model>
+ *                 Tenant:    <customerId>
+ *                 Workspace: <basename>
+ *
+ *   ─────────────────────────────────────
+ *   Tips for getting started:
+ *     1. Type a brief, the workforce dispatches
+ *     2. /help for slash commands, /web <url> to pull a page
+ *     3. /skills install <name> for Anthropic / OpenClaw skills
+ *
+ * The splash auto-dismisses on:
+ *   - first operator keystroke (the REPL `<Repl />` host owns this and
+ *     calls the `onInteract` callback we expose),
+ *   - 10s idle timeout (built-in, configurable via `skipSplash`),
+ *   - `--no-splash` CLI flag or PUGI_SKIP_SPLASH=1 env (host gates the
+ *     mount entirely; we still respect the `skipSplash` prop as a belt
+ *     so a stray render in a test environment produces nothing).
+ *
+ * Brand voice gate: every visible string here is reviewed against the
+ * forbidden list (`journey / explore / delight / magical / friendly /
+ * AI-powered / pug-tastic`). Power words used: `brief / dispatch /
+ * ship / workforce / sentinel / skills`. No em-dashes; box-drawing
+ * `─` is OK (matches existing REPL header conventions).
+ */
+import { useEffect } from 'react';
+import { Box, Text } from 'ink';
+import { PUG_MASCOT, PUG_MASCOT_CYAN_MASK, PUG_MASCOT_MAX_WIDTH, } from './repl-splash-art.js';
+const DEFAULT_AUTO_DISMISS_MS = 10_000;
+const PLACEHOLDER = '—';
+export function ReplSplash(props) {
+    // Hooks MUST run unconditionally so the React reconciler can keep
+    // its hook order. We branch on `skipSplash` AFTER the effect
+    // declaration; the effect itself bails early when the splash is
+    // suppressed so no stray timer fires in the skip path.
+    useEffect(() => {
+        if (props.skipSplash)
+            return undefined;
+        const ms = props.autoDismissMs ?? DEFAULT_AUTO_DISMISS_MS;
+        const handle = setTimeout(() => {
+            props.onDismiss?.();
+        }, ms);
+        return () => clearTimeout(handle);
+        // Dependency on the onDismiss callback would re-arm the timer on
+        // every parent rerender; the host wraps it in useCallback so
+        // identity is stable for the splash's lifetime.
+    }, [props.autoDismissMs, props.onDismiss, props.skipSplash]);
+    // Belt for stray test renders: when the host already knows the
+    // operator opted out, we still want a render call to produce nothing
+    // visible. The host is the source of truth for mount-or-not; this is
+    // the no-op fallback.
+    if (props.skipSplash) {
+        return null;
+    }
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { flexDirection: "row", children: [_jsx(MascotColumn, {}), _jsxs(Box, { flexDirection: "column", marginLeft: 2, marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: "cyan", children: ".io" }), _jsx(Text, { dimColor: true, children: `  v${props.cliVersion}` })] }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(HeaderRow, { label: "Plan", value: props.plan ?? PLACEHOLDER }), _jsx(HeaderRow, { label: "Model", value: props.model ?? PLACEHOLDER }), _jsx(HeaderRow, { label: "Tenant", value: props.tenant ?? PLACEHOLDER }), _jsx(HeaderRow, { label: "Workspace", value: props.workspaceLabel })] })] })] }), _jsx(Box, { marginTop: 1, children: _jsx(Text, { dimColor: true, children: '─'.repeat(40) }) }), _jsxs(Box, { marginTop: 1, flexDirection: "column", children: [_jsx(Text, { dimColor: true, children: "Tips for getting started:" }), _jsx(TipRow, { index: 1, text: "Type a brief, the workforce dispatches" }), _jsx(TipRow, { index: 2, text: "/help for slash commands, /web <url> to pull a page" }), _jsx(TipRow, { index: 3, text: "/skills install <name> for Anthropic / OpenClaw skills" })] })] }));
+}
+/**
+ * Renders the multi-line ASCII pug. Each row is split into colored
+ * runs based on `PUG_MASCOT_CYAN_MASK` so the eyes + chip come out
+ * cyan and the body stays gray. Pure render of the static art array;
+ * no IO, no state.
+ */
+function MascotColumn() {
+    return (_jsx(Box, { flexDirection: "column", minWidth: PUG_MASCOT_MAX_WIDTH, children: PUG_MASCOT.map((row, rowIndex) => (_jsx(MascotRow, { row: row, mask: PUG_MASCOT_CYAN_MASK[rowIndex] ?? [] }, rowIndex))) }));
+}
+function MascotRow({ row, mask, }) {
+    // Split the row into contiguous runs of same-color cells so we emit
+    // one <Text> per run instead of one per character. Keeps the Ink
+    // render tree shallow and the snapshot diff readable.
+    const runs = [];
+    let buffer = '';
+    let bufferCyan = false;
+    for (let column = 0; column < row.length; column += 1) {
+        const ch = row.charAt(column);
+        const cyan = mask[column] === true;
+        if (buffer.length === 0) {
+            buffer = ch;
+            bufferCyan = cyan;
+            continue;
+        }
+        if (cyan === bufferCyan) {
+            buffer += ch;
+        }
+        else {
+            runs.push({ text: buffer, cyan: bufferCyan });
+            buffer = ch;
+            bufferCyan = cyan;
+        }
+    }
+    if (buffer.length > 0) {
+        runs.push({ text: buffer, cyan: bufferCyan });
+    }
+    return (_jsx(Text, { children: runs.map((run, runIndex) => run.cyan ? (_jsx(Text, { color: "cyan", children: run.text }, runIndex)) : (_jsx(Text, { color: "gray", children: run.text }, runIndex))) }));
+}
+function HeaderRow({ label, value }) {
+    const padded = `${label}:`.padEnd(11, ' ');
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: padded }), _jsx(Text, { children: value })] }));
+}
+function TipRow({ index, text }) {
+    return (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: `  ${index}. ` }), _jsx(Text, { children: text })] }));
+}
+//# sourceMappingURL=repl-splash.js.map