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

package/dist/tui/markdown-render.js

@@ -0,0 +1,266 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+const HEADING_COLORS = ['cyan', 'magenta', 'yellow'];
+/**
+ * Very small keyword table for cosmetic code accent. The fence label is
+ * matched case-insensitively against a handful of languages we expect
+ * the personas to emit (ts/tsx/js/jsx/py/sh). Unknown languages render
+ * the body in white - no syntax error, no warning. Tests assert that
+ * an empty fence label still produces a bordered Box (no crash).
+ */
+const KEYWORDS_BY_LANG = {
+    ts: ['const', 'let', 'var', 'function', 'class', 'interface', 'type', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this', 'static', 'public', 'private', 'protected', 'readonly', 'extends', 'implements'],
+    tsx: ['const', 'let', 'var', 'function', 'class', 'interface', 'type', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this', 'static', 'public', 'private', 'protected', 'readonly', 'extends', 'implements'],
+    js: ['const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this'],
+    jsx: ['const', 'let', 'var', 'function', 'class', 'import', 'export', 'from', 'return', 'if', 'else', 'for', 'while', 'await', 'async', 'new', 'this'],
+    py: ['def', 'class', 'import', 'from', 'return', 'if', 'else', 'elif', 'for', 'while', 'with', 'as', 'try', 'except', 'finally', 'raise', 'lambda', 'pass', 'yield', 'None', 'True', 'False'],
+    sh: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'export'],
+    bash: ['if', 'then', 'else', 'fi', 'for', 'do', 'done', 'while', 'case', 'esac', 'function', 'return', 'export'],
+};
+/**
+ * Top-level entry point. Splits the source into lines, runs the
+ * block-level state machine, and emits an Ink tree. The component is
+ * memo-friendly (pure function of `source`) but we don't wrap in
+ * React.memo here - the conversation pane already memoises row keys.
+ */
+export function MarkdownRender(props) {
+    const blocks = parseBlocks(props.source);
+    const children = blocks.map((block, index) => renderBlock(block, index));
+    if (props.inline) {
+        return _jsx(_Fragment, { children: children });
+    }
+    return _jsx(Box, { flexDirection: "column", children: children });
+}
+/**
+ * Walk the source line by line and emit one Block per visual unit. The
+ * state machine has two modes: default (heading / list / paragraph) and
+ * in-code (every line is appended verbatim to the current code block).
+ *
+ * Inside a code fence we DO NOT process inline syntax - the body is
+ * preserved literally so the operator sees code that actually runs.
+ */
+function parseBlocks(source) {
+    const lines = source.split(/\r?\n/);
+    const blocks = [];
+    let inCode = false;
+    let codeLang = '';
+    let codeBody = [];
+    for (const raw of lines) {
+        const line = raw;
+        if (inCode) {
+            if (/^```/.test(line)) {
+                blocks.push({ kind: 'code', lang: codeLang, body: codeBody.join('\n') });
+                inCode = false;
+                codeBody = [];
+                codeLang = '';
+                continue;
+            }
+            codeBody.push(line);
+            continue;
+        }
+        const fenceMatch = /^```([A-Za-z0-9_+-]*)\s*$/.exec(line);
+        if (fenceMatch) {
+            inCode = true;
+            codeLang = (fenceMatch[1] ?? '').toLowerCase();
+            continue;
+        }
+        if (line.trim().length === 0) {
+            blocks.push({ kind: 'blank' });
+            continue;
+        }
+        const headingMatch = /^(#{1,3})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (headingMatch) {
+            const level = headingMatch[1].length;
+            const text = headingMatch[2];
+            blocks.push({ kind: 'heading', level, text });
+            continue;
+        }
+        const bulletMatch = /^\s*[-*]\s+(.+)$/.exec(line);
+        if (bulletMatch) {
+            blocks.push({ kind: 'bullet', text: bulletMatch[1] });
+            continue;
+        }
+        const orderedMatch = /^\s*(\d+)\.\s+(.+)$/.exec(line);
+        if (orderedMatch) {
+            blocks.push({ kind: 'ordered', index: orderedMatch[1], text: orderedMatch[2] });
+            continue;
+        }
+        blocks.push({ kind: 'paragraph', text: line });
+    }
+    // Unterminated fence: surface what we have as code so the operator
+    // still sees the body. Mirrors GitHub's render behavior.
+    if (inCode) {
+        blocks.push({ kind: 'code', lang: codeLang, body: codeBody.join('\n') });
+    }
+    return blocks;
+}
+/* ------------------------------------------------------------------ */
+/* Block renderers                                                    */
+/* ------------------------------------------------------------------ */
+function renderBlock(block, key) {
+    switch (block.kind) {
+        case 'heading': {
+            const color = HEADING_COLORS[block.level - 1] ?? 'cyan';
+            const prefix = '#'.repeat(block.level);
+            return (_jsx(Text, { bold: true, color: color, children: `${prefix} ${block.text}` }, key));
+        }
+        case 'paragraph':
+            return (_jsx(Text, { children: renderInline(block.text) }, key));
+        case 'bullet':
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: '• ' }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+        case 'ordered':
+            return (_jsxs(Box, { children: [_jsx(Text, { color: "cyan", children: `${block.index}. ` }), _jsx(Text, { children: renderInline(block.text) })] }, key));
+        case 'code':
+            return renderCodeBlock(block.lang, block.body, key);
+        case 'blank':
+            // One-line spacer between blocks. We render an empty Text so the
+            // height accounting in Ink matches what the operator sees.
+            return _jsx(Text, { children: " " }, key);
+    }
+}
+function renderCodeBlock(lang, body, key) {
+    const lines = body.split('\n');
+    const keywords = KEYWORDS_BY_LANG[lang] ?? [];
+    return (_jsx(Box, { borderStyle: "round", borderColor: "gray", flexDirection: "column", paddingX: 1, children: lines.map((line, index) => (_jsx(Text, { children: renderCodeLine(line, keywords) }, index))) }, key));
+}
+/**
+ * Per-line code accent. We do NOT build a real lexer - we split on
+ * whitespace + punctuation boundaries and color matched keywords cyan,
+ * single/double quoted strings green, and `//` / `#` comment tails gray.
+ * The output is a list of Ink Text spans. Anything unmatched stays
+ * plain white.
+ */
+function renderCodeLine(line, keywords) {
+    // Comment tail wins first - we strip it and color the rest.
+    const commentIndex = findCommentStart(line);
+    const code = commentIndex >= 0 ? line.slice(0, commentIndex) : line;
+    const comment = commentIndex >= 0 ? line.slice(commentIndex) : '';
+    const spans = [];
+    // Tokenise the code portion: alternate runs of word chars vs the rest.
+    // Strings are matched as a whole quoted span. The regex is anchored
+    // sticky to avoid catastrophic backtracking on long lines.
+    const tokenRe = /("[^"]*"|'[^']*'|`[^`]*`|\w+|\s+|[^\s\w]+)/g;
+    let match;
+    let key = 0;
+    while ((match = tokenRe.exec(code)) !== null) {
+        const tok = match[0];
+        if (/^["'`].*["'`]$/.test(tok)) {
+            spans.push(_jsx(Text, { color: "green", children: tok }, key));
+        }
+        else if (keywords.includes(tok)) {
+            spans.push(_jsx(Text, { color: "cyan", bold: true, children: tok }, key));
+        }
+        else {
+            spans.push(_jsx(Text, { children: tok }, key));
+        }
+        key += 1;
+    }
+    if (comment.length > 0) {
+        spans.push(_jsx(Text, { color: "gray", children: comment }, "comment"));
+    }
+    return _jsx(_Fragment, { children: spans });
+}
+function findCommentStart(line) {
+    // Single-line // or # outside of string literals. The probe is
+    // adequate for the persona-emitted snippets - a string literal that
+    // contains `//` would mis-color, but the output stays readable.
+    let inString = null;
+    for (let i = 0; i < line.length; i += 1) {
+        const ch = line[i];
+        if (inString) {
+            if (ch === inString && line[i - 1] !== '\\')
+                inString = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'" || ch === '`') {
+            inString = ch;
+            continue;
+        }
+        if (ch === '/' && line[i + 1] === '/')
+            return i;
+        if (ch === '#')
+            return i;
+    }
+    return -1;
+}
+/* ------------------------------------------------------------------ */
+/* Inline tokeniser                                                   */
+/* ------------------------------------------------------------------ */
+/**
+ * Parse one paragraph line into a list of inline spans, then render
+ * them as Ink Text nodes. We walk the source left-to-right and greedily
+ * consume the longest delimiter we find. Unmatched delimiters fall
+ * through as literal text - personas type `**` mid-sentence sometimes.
+ */
+function renderInline(source) {
+    const spans = tokeniseInline(source);
+    return (_jsx(_Fragment, { children: spans.map((span, index) => renderSpan(span, index)) }));
+}
+function tokeniseInline(source) {
+    const spans = [];
+    let buffer = '';
+    let i = 0;
+    while (i < source.length) {
+        const rest = source.slice(i);
+        // Inline code wins over bold/italic so that `**` inside backticks
+        // renders literally.
+        const codeMatch = /^`([^`]+)`/.exec(rest);
+        if (codeMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'code', text: codeMatch[1] });
+            i += codeMatch[0].length;
+            continue;
+        }
+        // Link before bold/italic so `[text **bold**](url)` renders linkish.
+        const linkMatch = /^\[([^\]]+)\]\(([^)\s]+)\)/.exec(rest);
+        if (linkMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'link', text: linkMatch[1], url: linkMatch[2] });
+            i += linkMatch[0].length;
+            continue;
+        }
+        // Bold (**) before italic (*) so the greedy match wins.
+        const boldMatch = /^\*\*([^*]+)\*\*/.exec(rest);
+        if (boldMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'bold', text: boldMatch[1] });
+            i += boldMatch[0].length;
+            continue;
+        }
+        const italicMatch = /^\*([^*]+)\*/.exec(rest);
+        if (italicMatch) {
+            flush(buffer, spans);
+            buffer = '';
+            spans.push({ kind: 'italic', text: italicMatch[1] });
+            i += italicMatch[0].length;
+            continue;
+        }
+        buffer += source[i];
+        i += 1;
+    }
+    flush(buffer, spans);
+    return spans;
+}
+function flush(buffer, spans) {
+    if (buffer.length === 0)
+        return;
+    spans.push({ kind: 'text', text: buffer });
+}
+function renderSpan(span, key) {
+    switch (span.kind) {
+        case 'text':
+            return _jsx(Text, { children: span.text }, key);
+        case 'bold':
+            return _jsx(Text, { bold: true, children: span.text }, key);
+        case 'italic':
+            return _jsx(Text, { italic: true, children: span.text }, key);
+        case 'code':
+            return _jsx(Text, { color: "green", children: span.text }, key);
+        case 'link':
+            return (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", underline: true, children: span.text }), _jsx(Text, { dimColor: true, children: ` (${span.url})` })] }, key));
+    }
+}
+//# sourceMappingURL=markdown-render.js.map

package/dist/tui/repl-render.js

@@ -19,8 +19,12 @@
 import React from 'react';
 import { render } from 'ink';
 import { Repl } from './repl.js';
+import { printPugMascotPreInk } from './repl-splash-mascot.js';
 import { ReplSession, } from '../core/repl/session.js';
 import { resolveWorkspaceContext } from '../core/repl/workspace-context.js';
+import { SqliteSessionStore } from '../core/repl/store/index.js';
+import { slugForCwd } from '../core/repl/history.js';
+import { WorkingSet, buildRepoSkeleton, loadPugiIgnore, PugiWatcher, } from '../core/context/index.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
@@ -33,6 +37,26 @@ export async function renderRepl(options) {
     // 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());
+    // α6.4: open the local SessionStore for `/resume` persistence. The
+    // store lives under `~/.pugi/projects/<slug>/`; failure is fail-safe
+    // — we log a one-line warning to stderr and continue with the REPL
+    // in memory-only mode. Lock-busy errors get the friendliest message
+    // so an operator running two REPLs in the same project understands
+    // the constraint.
+    const projectSlug = slugForCwd(process.cwd());
+    const { store, openedSessionId } = await openLocalStore({
+        projectSlug,
+        workspaceRoot: process.cwd(),
+        resumeLocalSessionId: options.resumeLocalSessionId,
+    });
+    // α6.5 three-tier context bootstrap. The skeleton + working set
+    // + watcher are local-first and best-effort: every step is wrapped
+    // in try/catch so an unreadable workspace never blocks REPL launch.
+    // Opt-out via PUGI_DISABLE_CONTEXT=1 for hermetic test runs.
+    const { skeleton, workingSet, watcher } = await bootstrapContext({
+        cwd: process.cwd(),
+        env: process.env,
+    });
     const session = new ReplSession({
         apiUrl: options.apiUrl,
         apiKey: options.apiKey,
@@ -40,21 +64,182 @@ export async function renderRepl(options) {
         cliVersion: options.cliVersion,
         transport,
         workspace,
+        store,
+        localSessionId: openedSessionId,
+        repoSkeleton: skeleton,
+        workingSet,
+        watcher,
     });
+    // Restore the transcript from the JSONL log if we resumed an
+    // existing session. The restore is idempotent and bypasses persist
+    // (no double-write of replayed rows).
+    if (store && openedSessionId && options.resumeLocalSessionId) {
+        try {
+            const events = await store.loadEvents(openedSessionId, { limit: 500 });
+            session.restoreTranscript(events);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[pugi] Could not restore session ${openedSessionId.slice(0, 13)}: ${msg}\n`);
+        }
+    }
     // Kick off the connect; the Repl renders the connecting state until
     // the session pushes `connection: 'on_watch'` from the SSE onOpen.
     void session.start();
+    // α6.14.2 wave 5: paint the chafa-baked brand-pug ANSI render to
+    // stdout BEFORE Ink mounts. Ink's layout engine would mis-measure
+    // the truecolor escape sequences, so the pug must land verbatim.
+    // The flag is passed into <Repl /> so the splash component knows to
+    // skip its own hand-crafted PUG_MASCOT column — otherwise the
+    // operator sees both the chafa pug AND the ASCII fallback stacked.
+    // When skipSplash is true (operator opted out via --no-splash), we
+    // suppress the pre-print too so the boot stays silent.
+    const mascotPrePrinted = options.skipSplash === true ? false : printPugMascotPreInk(process.stdout);
+    // α6.14.4 CEO dogfood 2026-05-25 (parity with Claude Code): enter
+    // the terminal's alternate screen buffer so the REPL renders on a
+    // fresh "screen" the operator cannot scroll above. On exit, leave
+    // restores the previous terminal contents — the conversation does
+    // not pollute the operator's shell history. Skipped under --no-tty
+    // and when stdout is not a TTY (pipe/CI), where the escapes would
+    // appear as literal characters.
+    const supportsAltScreen = process.stdout.isTTY === true;
+    if (supportsAltScreen) {
+        process.stdout.write('\x1b[?1049h');
+        process.stdout.write('\x1b[H');
+    }
     const instance = render(React.createElement(Repl, {
         session,
         updateBanner: options.updateBanner ?? null,
         skipSplash: options.skipSplash === true,
+        hideToolStream: options.hideToolStream === true,
+        mascotPrePrinted,
     }));
+    const restoreAltScreen = () => {
+        if (supportsAltScreen) {
+            try {
+                process.stdout.write('\x1b[?1049l');
+            }
+            catch {
+                /* shutdown race — terminal already detached */
+            }
+        }
+    };
+    // Make sure we leave the alt screen on abrupt exits too. Without
+    // this the operator's shell stays "frozen" on the Pugi splash.
+    process.once('exit', restoreAltScreen);
+    process.once('SIGINT', restoreAltScreen);
+    process.once('SIGTERM', restoreAltScreen);
     try {
         await instance.waitUntilExit();
     }
     finally {
+        restoreAltScreen();
         session.close();
+        if (store) {
+            try {
+                await store.close();
+            }
+            catch {
+                /* idempotent — already closed */
+            }
+        }
+        if (watcher) {
+            try {
+                await watcher.close();
+            }
+            catch {
+                /* idempotent — chokidar may already be torn down */
+            }
+        }
+    }
+}
+/**
+ * Open the local SessionStore for the REPL bootstrap. Returns
+ * `{ store: null, openedSessionId: undefined }` on any error so the
+ * caller falls through to memory-only mode rather than failing the
+ * launch. The one error we surface verbatim is the lock-busy case —
+ * that one is operator-actionable.
+ */
+async function openLocalStore(input) {
+    // Honour an explicit opt-out for offline-strict environments / CI.
+    // PUGI_DISABLE_SESSION_STORE=1 wipes the integration to zero. Useful
+    // for hermetic test runs and for operators who do not want any
+    // persistence under $HOME.
+    if (process.env.PUGI_DISABLE_SESSION_STORE === '1') {
+        return { store: null, openedSessionId: undefined };
+    }
+    try {
+        const store = new SqliteSessionStore({ projectSlug: input.projectSlug });
+        const row = await store.open({
+            id: input.resumeLocalSessionId,
+            workspaceRoot: input.workspaceRoot,
+            projectSlug: input.projectSlug,
+        });
+        return { store, openedSessionId: row.id };
+    }
+    catch (error) {
+        const code = error?.code;
+        const msg = error instanceof Error ? error.message : String(error);
+        if (code === 'EBUSY_SESSION_LOCK') {
+            process.stderr.write(`[pugi] ${msg} Continuing without local session persistence.\n`);
+        }
+        else {
+            process.stderr.write(`[pugi] Local session store unavailable (${msg}). Continuing in memory-only mode.\n`);
+        }
+        return { store: null, openedSessionId: undefined };
+    }
+}
+/**
+ * Bootstrap the α6.5 three-tier context primitives:
+ *
+ *   - Tier 0: `RepoSkeleton` (~5KB ASCII tree + meta) for prompt injection.
+ *   - Tier 1: `WorkingSet` LRU bounded at 50 entries.
+ *   - Filewatch: chokidar started against cwd, ignore-filtered.
+ *
+ * The bootstrap is fail-safe: every primitive is wrapped so the REPL
+ * still launches when (e.g.) chokidar refuses to start on a
+ * permission-blocked dir. The PUGI_DISABLE_CONTEXT=1 env var skips
+ * the bootstrap entirely for hermetic test runs and for operators
+ * who want a zero-touch REPL.
+ */
+async function bootstrapContext(input) {
+    if (input.env.PUGI_DISABLE_CONTEXT === '1') {
+        return { skeleton: null, workingSet: null, watcher: null };
+    }
+    let ignore;
+    try {
+        ignore = loadPugiIgnore(input.cwd);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[pugi] Three-tier context bootstrap skipped (ignore matcher failed: ${msg}).\n`);
+        return { skeleton: null, workingSet: null, watcher: null };
+    }
+    let skeleton = null;
+    try {
+        skeleton = buildRepoSkeleton(input.cwd, { ignore });
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`[pugi] Repo skeleton bootstrap failed (${msg}). Continuing without Tier 0.\n`);
+    }
+    const workingSet = new WorkingSet();
+    let watcher = null;
+    // chokidar opt-out: PUGI_DISABLE_FILEWATCH=1 keeps Tier 0/1 wired
+    // but skips the live-update channel. Useful on CI runners and on
+    // network mounts where fsevents misbehaves.
+    if (input.env.PUGI_DISABLE_FILEWATCH !== '1') {
+        try {
+            const w = new PugiWatcher({ cwd: input.cwd, ignore });
+            await w.start();
+            watcher = w;
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            process.stderr.write(`[pugi] Filewatch bootstrap failed (${msg}). Continuing without live updates.\n`);
+        }
     }
+    return { skeleton, workingSet, watcher };
 }
 /* ------------------------------------------------------------------ */
 /* Production transport                                               */

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

@@ -0,0 +1,130 @@
+/**
+ * Chafa-validated brand-pug ANSI loader (α6.14.4 wave 6, mascot regen).
+ *
+ * CEO dogfood 2026-05-25 (first pass, α6.14.2 wave 5): the hand-crafted
+ * 9-row ASCII pug in `repl-splash-art.ts` reads as "точно не похожа" —
+ * too abstract to carry the brand at boot. This module loads a pre-baked
+ * truecolor ANSI render of the canonical hero-pug PNG (cyber-zoo pug
+ * face with cyan eyes + circuit + chip) so the splash matches the brand
+ * glyph the operator already sees on pugi.io.
+ *
+ * CEO dogfood 2026-05-25 (α6.14.4): the first chafa bake at 32x16 still
+ * read as "monitor on stand", not pug — too few rows to resolve the
+ * snout / eyes / wrinkles. The vertical resolution was the bottleneck:
+ * 16 char rows ≈ 16 pixel rows with the block symbol set. The fresh
+ * bake uses `vhalf` (vertical half blocks ▀ / ▄ with independent fg+bg
+ * colours per cell) which doubles the vertical resolution per character
+ * cell, at an 80x40 frame which is 2.5× the prior dimensions. End
+ * result: ~80×80 effective pixel resolution — enough to read the
+ * snout, eye sockets, ear lines, and the circuit board accent the
+ * brand glyph carries. File grew from 8.8KB to ~40KB; ship budget
+ * gates at 100KB so we stay well under cap.
+ *
+ * Generation (operator-side, one-shot):
+ *   chafa --size 80x40 --symbols=vhalf --colors=full \
+ *     apps/clawhost-web/public/brand/hero-pug.png \
+ *     > apps/pugi-cli/assets/pugi-mascot.ansi
+ *
+ * The output is committed verbatim to the repo and shipped inside the
+ * `@pugi/cli` npm tarball under `assets/pugi-mascot.ansi` (the
+ * `package.json` `files` allowlist explicitly opts in). Runtime does
+ * NOT need `chafa` installed — we just read the file bytes and write
+ * them to stdout. If the file is missing (degraded install, tarball
+ * corruption, dev cwd drift), the splash falls back to the hand-crafted
+ * `PUG_MASCOT` art so the boot never crashes.
+ *
+ * The pre-Ink write convention mirrors the Claude Code Chrome plugin
+ * splash pattern: raw bytes go to `process.stdout` BEFORE the Ink
+ * render mount, so the terminal interprets the truecolor escapes
+ * directly instead of Ink trying to layout-engine over them.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve as resolvePath } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolve the on-disk path to `pugi-mascot.ansi` relative to the
+ * compiled module. The CLI ships to `node_modules/@pugi/cli/dist/tui/`
+ * so the asset lives at `node_modules/@pugi/cli/assets/pugi-mascot.ansi`
+ * — two directory hops up from this file. In a local `pnpm dev`
+ * checkout the structure is the same (`src/tui/` ⇒ `../../assets/`)
+ * because tsx re-resolves the same relative tree.
+ */
+export function pugMascotAssetPath() {
+    const here = dirname(fileURLToPath(import.meta.url));
+    return resolvePath(here, '..', '..', 'assets', 'pugi-mascot.ansi');
+}
+/**
+ * Read the chafa-baked ANSI render of the brand pug. Returns the raw
+ * bytes verbatim (UTF-8 string) — the terminal interprets the truecolor
+ * escapes directly. Returns null when the file is missing, unreadable,
+ * or trivially empty so the caller can fall back to `PUG_MASCOT`.
+ *
+ * `chafa --colors=full` wraps the render with cursor-hide (`\e[?25l`)
+ * on the head and cursor-show (`\e[?25h`) on the tail. We strip those
+ * so the splash does not accidentally hide the cursor across the rest
+ * of the REPL boot (Ink itself manages the cursor once it mounts).
+ *
+ * The asset is supply-chain controlled (committed in-repo, shipped in
+ * the npm tarball) so an arbitrary attacker cannot inject escapes
+ * today. The defence-in-depth strip below still drops categories of
+ * escapes that the splash has no legitimate need to emit — OSC window
+ * title sets, mouse-tracking enables, screen clears, cursor-position
+ * reports — so a future swap of the asset (or a corrupt tarball) cannot
+ * disrupt the terminal beyond the splash region. Truecolor (`CSI 38;2;
+ * R;G;B m`), reset (`CSI 0 m`), and explicit forms of cursor / line
+ * motion the render needs are left in.
+ */
+export function loadPugMascotAnsi() {
+    const path = pugMascotAssetPath();
+    try {
+        if (!existsSync(path))
+            return null;
+        const raw = readFileSync(path, 'utf8');
+        if (!raw || raw.length === 0)
+            return null;
+        // 1. Drop OSC sequences. Two terminator forms:
+        //      ESC ] ... BEL          (0x1b 0x5d ... 0x07)
+        //      ESC ] ... ESC \        (0x1b 0x5d ... 0x1b 0x5c, the ST form)
+        //    A truecolor splash never needs OSC (those are for window title,
+        //    icon, clipboard, hyperlinks, color-palette change). Drop them
+        //    so a corrupted asset cannot rename the operator's terminal tab
+        //    or smuggle a hyperlink into the splash region.
+        // 2. Drop CSI ? <mode> [hl] for mouse-tracking and screen-buffer
+        //    switch modes (1000, 1001, 1002, 1003, 1004, 1005, 1006, 1015,
+        //    1049, 47, 1047, 1048). These would either start swallowing
+        //    mouse input or flip the terminal into the alternate screen.
+        // 3. Drop CSI 6 n (cursor-position report). Would inject a fake
+        //    CPR into the operator's stdin stream.
+        // 4. Drop CSI [23]J / CSI [23]K (full screen / line clear). A
+        //    chafa render uses cursor-positioning per row, not bulk
+        //    erases; bulk clears would wipe whatever the operator already
+        //    had on screen above the splash.
+        // The cursor-hide/show wrappers (CSI ? 25 [lh]) are handled by
+        // the same CSI-?-mode pattern as the mouse / alt-screen modes.
+        const stripped = raw
+            .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '')
+            .replace(/\x1b\[\?(?:25|47|1000|1001|1002|1003|1004|1005|1006|1015|1047|1048|1049)[lh]/g, '')
+            .replace(/\x1b\[6n/g, '')
+            .replace(/\x1b\[[23]?[JK]/g, '');
+        if (stripped.trim().length === 0)
+            return null;
+        return stripped;
+    }
+    catch {
+        // Best-effort: any FS / decode error returns null so the splash
+        // falls back to the hand-crafted ASCII art. Never throws.
+        return null;
+    }
+}
+export function printPugMascotPreInk(sink) {
+    const ansi = loadPugMascotAnsi();
+    if (ansi === null)
+        return false;
+    // Trailing newline so the Ink header lands on a fresh row rather
+    // than smashing into the last pug row.
+    sink.write(ansi);
+    if (!ansi.endsWith('\n'))
+        sink.write('\n');
+    return true;
+}
+//# sourceMappingURL=repl-splash-mascot.js.map

package/dist/tui/repl-splash.js

@@ -61,7 +61,13 @@ export function ReplSplash(props) {
     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" })] })] }));
+    // α6.14.2 wave 5: when the host pre-printed the chafa-baked brand-pug
+    // ANSI render to stdout before Ink mounted, suppress the hand-crafted
+    // PUG_MASCOT column here so the operator does not see two stacked
+    // pugs. The header card still renders inline so wordmark + status
+    // rows stay attached to the splash flow.
+    const showHandCraftedMascot = props.mascotPrePrinted !== true;
+    return (_jsxs(Box, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [_jsxs(Box, { flexDirection: "row", children: [showHandCraftedMascot ? _jsx(MascotColumn, {}) : null, _jsxs(Box, { flexDirection: "column", marginLeft: showHandCraftedMascot ? 2 : 0, 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