@pugi/cli 0.1.0-beta.22 → 0.1.0-beta.23

package/dist/runtime/commands/release-notes.js

@@ -0,0 +1,229 @@
+/**
+ * `pugi release-notes` — changelog diff between last-seen + current
+ * (Leak L24, 2026-05-27).
+ *
+ * Parity command with Claude Code's `/release-notes`, which shows
+ * what changed between the previously-installed CLI version and the
+ * currently-installed one. The Pugi variant reads the bundled
+ * `CHANGELOG.md`, slices it к the range `(last-seen, current]`, and
+ * renders the Markdown sections to the operator. After а successful
+ * render the marker is bumped к `current` so the next invocation is а
+ * no-op until the operator upgrades again.
+ *
+ * # Module contract
+ *
+ *   - This file owns the WIRING from CLI flags + ambient state к the
+ *     parser + state I/O helpers. The parser + state modules в
+ *     `core/release-notes/` have zero coupling к the CLI dispatch
+ *     surface.
+ *
+ *   - `runReleaseNotesCommand` is the single entry point. Both the
+ *     top-level `pugi release-notes` handler в `runtime/cli.ts` AND
+ *     the in-REPL `/release-notes` slash command call it. The
+ *     function returns а structured `ReleaseNotesResult` so the
+ *     slash dispatcher can route the lines к the system pane
+ *     without re-reading the changelog.
+ *
+ *   - Exit code is ALWAYS 0. The command is informational, never а
+ *     gate. Read failures, missing CHANGELOG, and write failures all
+ *     degrade к а structured envelope with а human-readable footer.
+ *
+ *   - The changelog source is captured behind а function so the spec
+ *     can stub it without touching disk. The default reads the file
+ *     bundled with the CLI install (resolved relative к the package
+ *     root); fixtures pass an in-memory string.
+ *
+ *   - `--reset` flag clears the last-seen marker AND re-renders the
+ *     full bundled changelog as if the operator had never run the
+ *     command. Distinct from а plain `--all` toggle because the
+ *     reset PERSISTS (the next invocation again shows everything
+ *     newer than the cleared marker — `none`).
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseChangelog, sliceVersionsBetween, } from '../../core/release-notes/parser.js';
+import { clearLastSeenVersion, readLastSeenVersion, writeLastSeenVersion, } from '../../core/release-notes/state.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+/**
+ * Default loader для the bundled `apps/pugi-cli/CHANGELOG.md`. The
+ * compiled bundle ships under `dist/runtime/commands/release-notes.js`;
+ * the CHANGELOG sits next к `package.json` at the package root, two
+ * directories up from `dist/runtime/commands/`. We also probe а
+ * couple of fallback locations so the dev path (running the source
+ * directly из `src/`) works без а compile step.
+ */
+export function defaultReadChangelog() {
+    const candidates = resolveChangelogCandidates();
+    for (const candidate of candidates) {
+        try {
+            if (existsSync(candidate)) {
+                return readFileSync(candidate, 'utf8');
+            }
+        }
+        catch {
+            // Permission errors, transient FS hiccups — keep probing the
+            // remaining candidates. Returning null at the end is fine; the
+            // renderer surfaces а "changelog-missing" envelope.
+        }
+    }
+    return null;
+}
+function resolveChangelogCandidates() {
+    // import.meta.url points к the compiled JS in production
+    // (`dist/runtime/commands/release-notes.js`) and к the source TS в
+    // tests / dev runs. We probe both relative ancestries so either
+    // path lands on `<package>/CHANGELOG.md`.
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        return [
+            resolve(here, '../../..', 'CHANGELOG.md'),
+            resolve(here, '../../../..', 'CHANGELOG.md'),
+            resolve(process.cwd(), 'apps/pugi-cli/CHANGELOG.md'),
+            resolve(process.cwd(), 'CHANGELOG.md'),
+        ];
+    }
+    catch {
+        // Some non-ESM contexts (very old node, eval'd code) reject
+        // `import.meta.url`. Fall back к cwd-relative probes — works for
+        // tests that run from the package root.
+        return [
+            resolve(process.cwd(), 'apps/pugi-cli/CHANGELOG.md'),
+            resolve(process.cwd(), 'CHANGELOG.md'),
+        ];
+    }
+}
+/**
+ * Default home dir resolver. Centralised so the CLI handler can call
+ * `runReleaseNotesCommand` without re-importing `os.homedir`.
+ */
+export function defaultReleaseNotesHome() {
+    return homedir();
+}
+/**
+ * Pick + render the release notes, hand the result к the output
+ * sink, persist the marker. Always exits 0.
+ */
+export function runReleaseNotesCommand(ctx) {
+    const readChangelog = ctx.readChangelog ?? defaultReadChangelog;
+    const currentVersion = ctx.currentVersion ?? PUGI_CLI_VERSION;
+    // `--reset` clears the marker before slicing. We capture the
+    // pre-clear value so the JSON envelope still shows the operator
+    // what their previous marker was, which makes scripting + bug
+    // reports easier.
+    const lastSeenBefore = readLastSeenVersion(ctx.home);
+    if (ctx.reset) {
+        clearLastSeenVersion(ctx.home);
+    }
+    const lastSeen = ctx.reset ? null : lastSeenBefore;
+    const raw = readChangelog();
+    if (raw === null) {
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'changelog-missing',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderMissingChangelog(currentVersion),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const sections = parseChangelog(raw);
+    if (sections.length === 0) {
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'changelog-empty',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderEmptyChangelog(currentVersion),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const slice = sliceVersionsBetween(sections, lastSeen, currentVersion);
+    if (slice.length === 0) {
+        // Nothing new — render the no-op message and DO NOT touch the
+        // marker (marker already equals current OR is newer; either way
+        // re-writing it is а no-op write we can avoid).
+        const result = {
+            command: 'release-notes',
+            currentVersion,
+            lastSeenVersion: lastSeenBefore ?? 'none',
+            sections: [],
+            status: 'up-to-date',
+            markerPersisted: false,
+            persistFailure: null,
+            text: renderUpToDate(currentVersion, lastSeenBefore),
+        };
+        ctx.writeOutput(result, result.text);
+        process.exitCode = 0;
+        return result;
+    }
+    const persist = writeLastSeenVersion(ctx.home, currentVersion);
+    const text = renderSections(slice, currentVersion, lastSeen, persist);
+    const result = {
+        command: 'release-notes',
+        currentVersion,
+        lastSeenVersion: lastSeenBefore ?? 'none',
+        sections: slice,
+        status: ctx.reset ? 'reset' : 'rendered',
+        markerPersisted: persist.status === 'ok',
+        persistFailure: persist.status === 'failed' ? persist.reason : null,
+        text,
+    };
+    ctx.writeOutput(result, text);
+    process.exitCode = 0;
+    return result;
+}
+function renderSections(sections, current, lastSeen, persist) {
+    const header = lastSeen
+        ? `Pugi release notes — ${lastSeen} → ${current}`
+        : `Pugi release notes — up to ${current}`;
+    const blocks = [header, '═'.repeat(Math.max(header.length, 30))];
+    for (const section of sections) {
+        const subhead = section.date
+            ? `## [${section.version}] - ${section.date}`
+            : `## [${section.version}]`;
+        blocks.push('');
+        blocks.push(subhead);
+        if (section.body.length > 0) {
+            blocks.push('');
+            blocks.push(section.body);
+        }
+    }
+    if (persist.status === 'failed') {
+        blocks.push('');
+        blocks.push(`Warning: could not persist last-seen marker (${persist.reason}). Next run will surface the same notes.`);
+    }
+    return blocks.join('\n');
+}
+function renderUpToDate(current, lastSeen) {
+    const lines = ['No new release notes.'];
+    lines.push(`Installed: ${current}`);
+    lines.push(`Last seen: ${lastSeen ?? 'none'}`);
+    return lines.join('\n');
+}
+function renderMissingChangelog(current) {
+    return [
+        'Release notes are not bundled with this install.',
+        `Installed: ${current}`,
+        'See https://pugi.io/changelog for the rendered changelog.',
+    ].join('\n');
+}
+function renderEmptyChangelog(current) {
+    return [
+        'Bundled changelog is empty — no parsed sections.',
+        `Installed: ${current}`,
+        'See https://pugi.io/changelog for the rendered changelog.',
+    ].join('\n');
+}
+//# sourceMappingURL=release-notes.js.map

package/dist/runtime/commands/theme.js

@@ -0,0 +1,196 @@
+/**
+ * Leak L30 (2026-05-27) — `pugi theme` top-level command + REPL slash
+ * companion.
+ *
+ * Operator surface:
+ *
+ *   pugi theme                       Show active theme + table.
+ *   pugi theme <name>                Switch workspace theme (current cwd).
+ *   pugi theme <name> --persist      Switch + also write user default.
+ *   pugi theme --reset               Clear workspace override → back to default.
+ *   pugi theme --reset --user        Also clear the user default.
+ *   pugi theme --list                Print the catalogue (no flip).
+ *   pugi theme --json                Structured envelope variant.
+ *
+ * The same runner powers `/theme` from inside the REPL. The REPL
+ * dispatcher (see `core/repl/session.ts`) routes through here so the
+ * two surfaces stay single-sourced — operators trained on one read
+ * the same payload + table on the other. Matches the leak L18
+ * `/style` runner exactly so the two settings surfaces are
+ * paste-comparable for the operator + grep-comparable for future
+ * maintenance.
+ *
+ * Exit codes:
+ *   0 — show / switch / reset all succeed
+ *   1 — unknown preset slug (returned BEFORE any write)
+ *   2 — conflicting flags (e.g. `--reset` with a positional slug)
+ *
+ * The exit codes are surfaced through `process.exitCode` by the
+ * dispatcher in `cli.ts` — this module returns a structured payload
+ * + writes via the injected `writeOutput`. Throwing is reserved for
+ * truly unexpected errors (fs permissions etc.); the spec hooks the
+ * happy + sad paths through `writeOutput` shape, not via try/catch
+ * on the throw.
+ */
+import { DEFAULT_THEME, isThemeSlug, renderThemeTable, THEME_SLUGS, } from '../../core/theme/presets.js';
+import { clearUserTheme, clearWorkspaceTheme, resolveTheme, setUserTheme, setWorkspaceTheme, } from '../../core/theme/state.js';
+/**
+ * Entry point. Parses `args`, applies the operation, emits the
+ * payload + text via `ctx.writeOutput`, and returns the exit code the
+ * dispatcher should hand back to the shell.
+ */
+export async function runThemeCommand(args, ctx) {
+    const flags = parseFlags(args);
+    // Reset path
+    if (flags.reset) {
+        if (flags.slug !== null) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/theme --reset cannot be combined with a preset name. Use one or the other.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        if (flags.persist) {
+            const payload = buildPayload({
+                status: 'invalid_flags',
+                ctx,
+                message: '/theme --reset cannot be combined with --persist. Use --reset --user to also clear the user default.',
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 2;
+        }
+        clearWorkspaceTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.user) {
+            clearUserTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const payload = buildPayload({
+            status: 'reset',
+            ctx,
+            message: flags.user
+                ? `Cleared workspace + user theme. Active: ${DEFAULT_THEME} (default).`
+                : `Cleared workspace theme. Active: ${describeActive(ctx)}.`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // List path
+    if (flags.list && flags.slug === null) {
+        const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        const payload = buildPayload({
+            status: 'listed',
+            ctx,
+            message: renderThemeTable(resolved.slug),
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Switch path
+    if (flags.slug !== null) {
+        if (!isThemeSlug(flags.slug)) {
+            const payload = buildPayload({
+                status: 'invalid_slug',
+                ctx,
+                attemptedSlug: flags.slug,
+                message: `Unknown theme "${flags.slug}". Try one of: ${THEME_SLUGS.join(', ')}.`,
+            });
+            ctx.writeOutput(payload, payload.message);
+            return 1;
+        }
+        const before = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        setWorkspaceTheme(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        if (flags.persist) {
+            setUserTheme(flags.slug, { workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+        }
+        const tail = flags.persist ? ' (workspace + user default)' : ' (workspace)';
+        const payload = buildPayload({
+            status: 'switched',
+            ctx,
+            previous: before.slug,
+            persistedToUser: flags.persist,
+            message: `Theme → ${flags.slug}${tail}. Was: ${before.slug} (${before.source}).`,
+        });
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    // Show path (no args)
+    const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    const banner = `Active theme: ${resolved.slug} (${resolved.source})`;
+    const table = renderThemeTable(resolved.slug);
+    const payload = buildPayload({
+        status: 'show',
+        ctx,
+        message: `${banner}\n\n${table}`,
+    });
+    ctx.writeOutput(payload, payload.message);
+    return 0;
+}
+function describeActive(ctx) {
+    const resolved = resolveTheme({ workspaceRoot: ctx.workspaceRoot, env: ctx.env });
+    return `${resolved.slug} (${resolved.source})`;
+}
+function buildPayload(args) {
+    const resolved = resolveTheme({ workspaceRoot: args.ctx.workspaceRoot, env: args.ctx.env });
+    const payload = {
+        command: 'theme',
+        status: args.status,
+        active: resolved.slug,
+        source: resolved.source,
+        presets: THEME_SLUGS,
+        message: args.message,
+    };
+    if (args.previous !== undefined)
+        payload.previous = args.previous;
+    if (args.persistedToUser !== undefined)
+        payload.persistedToUser = args.persistedToUser;
+    if (args.attemptedSlug !== undefined)
+        payload.attemptedSlug = args.attemptedSlug;
+    return payload;
+}
+function parseFlags(args) {
+    const flags = {
+        slug: null,
+        persist: false,
+        reset: false,
+        user: false,
+        list: false,
+    };
+    for (const arg of args) {
+        if (arg === '--persist')
+            flags.persist = true;
+        else if (arg === '--reset')
+            flags.reset = true;
+        else if (arg === '--user')
+            flags.user = true;
+        else if (arg === '--list')
+            flags.list = true;
+        else if (arg.startsWith('-')) {
+            // Unknown flag — keep simple parser. Treat as positional so the
+            // downstream isThemeSlug check rejects it with a clear "unknown
+            // theme" message rather than swallowing silently. Mirrors the
+            // L18 style runner's behaviour for grep-parity.
+            if (flags.slug === null)
+                flags.slug = arg;
+        }
+        else if (flags.slug === null) {
+            flags.slug = arg;
+        }
+    }
+    // Normalise the slug to lowercase so `pugi theme DARK` works the
+    // same as `pugi theme dark`. The catalogue is lowercase-only by
+    // contract; this keeps operators from tripping on shift-key habits.
+    if (flags.slug !== null)
+        flags.slug = flags.slug.toLowerCase();
+    return flags;
+}
+/**
+ * Re-export for the slash-command dispatcher in
+ * `core/repl/session.ts` so it can render a preview block if a
+ * future surface (`/theme --preview`) lands. Kept here so the
+ * runtime module is the single import point for theme-related
+ * surfaces; consumers should NOT reach into `core/theme/*` directly
+ * unless they are Ink components that need the React context.
+ */
+export { THEMES as THEME_CATALOGUE, } from '../../core/theme/presets.js';
+//# sourceMappingURL=theme.js.map

package/dist/runtime/commands/vim.js

@@ -0,0 +1,140 @@
+/**
+ * Leak L26 (2026-05-27) — `pugi vim` top-level command + REPL slash
+ * companion.
+ *
+ * Operator surface:
+ *
+ *   pugi vim                       Show current vim-mode state.
+ *   pugi vim on                    Enable + persist (~/.pugi/config.json).
+ *   pugi vim off                   Disable + persist (default).
+ *   /vim                           Toggle from inside the REPL.
+ *   /vim on                        Enable from inside the REPL.
+ *   /vim off                       Disable from inside the REPL.
+ *
+ * The same runner backs both surfaces so the slash + the shell verb
+ * stay single-sourced — operators trained on one read the same
+ * payload + banner on the other.
+ *
+ * Exit codes:
+ *   0 — show / enable / disable / toggle happy path
+ *   2 — unknown subcommand (e.g. `pugi vim chaos`)
+ *
+ * NOTE: there are NO `--persist` flag and no workspace tier. Vim mode
+ * is a single user-level preference, matching the leak research note
+ * that operators expect modal editing to be a body-memory trait, not
+ * a per-repo concern (see `core/vim/state.ts` header).
+ */
+import { resolveVimMode, setVimMode } from '../../core/vim/state.js';
+/**
+ * Banner shown on enable so the operator can see the binding cheat
+ * sheet without reaching for `/help`. Echoed by both surfaces.
+ */
+export const VIM_ENABLED_BANNER = 'Vim mode on. Esc=normal, i=insert, :w=submit, :q=cancel.';
+/**
+ * Entry point. Parses `args`, flips persistence as needed, emits the
+ * payload + text via `ctx.writeOutput`, and returns the exit code.
+ */
+export async function runVimCommand(args, ctx) {
+    // Validate args before reading state so a bad call never has a
+    // side-effect.
+    if (args.length > 1) {
+        const payload = {
+            command: 'vim',
+            status: 'invalid_args',
+            active: resolveVimMode({ env: ctx.env }),
+            message: `pugi vim takes at most one argument (on / off / toggle). Got: ${args.join(' ')}`,
+            attemptedArg: args.join(' '),
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 2;
+    }
+    const current = resolveVimMode({ env: ctx.env });
+    const verb = args[0]?.toLowerCase() ?? '';
+    // No args → toggle (slash convention from the leak research). The
+    // CLI shell surface ALSO toggles on bare invocation so the two
+    // surfaces converge; if the operator wants the read-only show they
+    // can pipe through `pugi vim --json` or query the config directly.
+    // We surface the change as a `show` status when nothing flipped so
+    // scripts can distinguish read from write.
+    if (verb === '') {
+        const next = !current;
+        setVimMode(next, { env: ctx.env });
+        const status = next ? 'enabled' : 'disabled';
+        const message = next ? VIM_ENABLED_BANNER : 'Vim mode off.';
+        const payload = {
+            command: 'vim',
+            status,
+            active: next,
+            previous: current,
+            message,
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'on' || verb === 'enable' || verb === 'true') {
+        if (current) {
+            const payload = {
+                command: 'vim',
+                status: 'unchanged',
+                active: true,
+                previous: true,
+                message: 'Vim mode already on.',
+            };
+            ctx.writeOutput(payload, payload.message);
+            return 0;
+        }
+        setVimMode(true, { env: ctx.env });
+        const payload = {
+            command: 'vim',
+            status: 'enabled',
+            active: true,
+            previous: current,
+            message: VIM_ENABLED_BANNER,
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'off' || verb === 'disable' || verb === 'false') {
+        if (!current) {
+            const payload = {
+                command: 'vim',
+                status: 'unchanged',
+                active: false,
+                previous: false,
+                message: 'Vim mode already off.',
+            };
+            ctx.writeOutput(payload, payload.message);
+            return 0;
+        }
+        setVimMode(false, { env: ctx.env });
+        const payload = {
+            command: 'vim',
+            status: 'disabled',
+            active: false,
+            previous: current,
+            message: 'Vim mode off.',
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    if (verb === 'status' || verb === 'show') {
+        const payload = {
+            command: 'vim',
+            status: 'show',
+            active: current,
+            message: current ? 'Vim mode is on.' : 'Vim mode is off.',
+        };
+        ctx.writeOutput(payload, payload.message);
+        return 0;
+    }
+    const payload = {
+        command: 'vim',
+        status: 'invalid_args',
+        active: current,
+        message: `Unknown vim subcommand "${verb}". Try one of: on, off, status.`,
+        attemptedArg: verb,
+    };
+    ctx.writeOutput(payload, payload.message);
+    return 2;
+}
+//# sourceMappingURL=vim.js.map

package/dist/runtime/version.js

@@ -44,7 +44,7 @@ export function sanitizeSemver(raw) {
  * during import). When bumping the CLI version BOTH literals must be
  * updated; the release smoke-test (`pack:smoke`) verifies they agree.
  */
-export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.22');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.23');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.

package/dist/tui/doctor-table.js

@@ -1,31 +1,46 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-/** Brand-voice palette for status cells. Mirrors the table chrome
- *  used by `<AgentProgressCard>` so the operator's eye trains on a
- *  consistent OK/WARN/ERROR/SKIPPED colour grammar. */
-const STATUS_COLOR = {
-    ok: 'green',
-    warn: 'yellow',
-    error: 'red',
-    skipped: 'gray',
-};
-const OVERALL_COLOR = {
-    healthy: 'green',
-    warning: 'yellow',
-    error: 'red',
-};
+import { useTheme } from '../core/theme/context.js';
+/**
+ * Leak L30 (2026-05-27): status colors flow through the active theme
+ * instead of being hard-coded Ink color names. The `colorblind`
+ * preset re-maps OK/WARN/ERROR to a blue-yellow-magenta axis so
+ * deuteranopia operators can still distinguish the three states; the
+ * `default` / `dark` / `light` themes route to green/yellow/red
+ * variants tuned for each background. `skipped` keeps a muted color
+ * (theme-controlled muted token) so dimmed rows still pick up the
+ * theme tint.
+ */
+function buildStatusColor(theme) {
+    return {
+        ok: theme.success,
+        warn: theme.warning,
+        error: theme.error,
+        skipped: theme.muted,
+    };
+}
+function buildOverallColor(theme) {
+    return {
+        healthy: theme.success,
+        warning: theme.warning,
+        error: theme.error,
+    };
+}
 export function DoctorTable({ envelope }) {
+    const theme = useTheme();
+    const statusColor = buildStatusColor(theme);
+    const overallColor = buildOverallColor(theme);
     const nameWidth = Math.max('NAME'.length, ...envelope.probes.map((row) => row.name.length));
     const statusWidth = Math.max('STATUS'.length, ...envelope.probes.map((row) => row.status.length));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi Doctor" }) }), envelope.probes.map((row) => (_jsx(DoctorRow, { row: row, nameWidth: nameWidth, statusWidth: statusWidth }, row.name))), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [envelope.counts.error, " error(s), ", envelope.counts.warn, " warning(s), ", envelope.counts.ok, " ok,", ' ', envelope.counts.skipped, " skipped. Overall:", ' ', _jsx(Text, { color: OVERALL_COLOR[envelope.overall], bold: true, children: envelope.overall.toUpperCase() })] }) }), _jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["CLI ", envelope.meta.cliVersion, "  Node ", envelope.meta.nodeVersion, "  cwd ", envelope.meta.cwd] }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi Doctor" }) }), envelope.probes.map((row) => (_jsx(DoctorRow, { row: row, nameWidth: nameWidth, statusWidth: statusWidth, statusColor: statusColor }, row.name))), _jsx(Box, { marginTop: 1, children: _jsxs(Text, { children: [envelope.counts.error, " error(s), ", envelope.counts.warn, " warning(s), ", envelope.counts.ok, " ok,", ' ', envelope.counts.skipped, " skipped. Overall:", ' ', _jsx(Text, { color: overallColor[envelope.overall], bold: true, children: envelope.overall.toUpperCase() })] }) }), _jsx(Box, { children: _jsxs(Text, { dimColor: true, children: ["CLI ", envelope.meta.cliVersion, "  Node ", envelope.meta.nodeVersion, "  cwd ", envelope.meta.cwd] }) })] }));
 }
-function DoctorRow({ row, nameWidth, statusWidth }) {
+function DoctorRow({ row, nameWidth, statusWidth, statusColor }) {
     const namePart = row.name.padEnd(nameWidth, ' ');
     const statusPart = row.status.toUpperCase().padEnd(statusWidth, ' ');
     const latencyPart = typeof row.latencyMs === 'number' ? ` (${row.latencyMs}ms)` : '';
     const showRemediation = typeof row.remediation === 'string' &&
         row.remediation.length > 0 &&
         (row.status === 'warn' || row.status === 'error');
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { children: [namePart, "  "] }), _jsx(Text, { color: STATUS_COLOR[row.status], bold: true, children: statusPart }), _jsxs(Text, { children: ['  ', row.detail, latencyPart] })] }), showRemediation && (_jsx(Box, { marginLeft: nameWidth + statusWidth + 4, children: _jsxs(Text, { dimColor: true, children: ["\u2192 ", row.remediation] }) }))] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { children: [_jsxs(Text, { children: [namePart, "  "] }), _jsx(Text, { color: statusColor[row.status], bold: true, children: statusPart }), _jsxs(Text, { children: ['  ', row.detail, latencyPart] })] }), showRemediation && (_jsx(Box, { marginLeft: nameWidth + statusWidth + 4, children: _jsxs(Text, { dimColor: true, children: ["\u2192 ", row.remediation] }) }))] }));
 }
 //# sourceMappingURL=doctor-table.js.map

package/dist/tui/repl-render.js

@@ -22,6 +22,8 @@ import React from 'react';
 import { render } from 'ink';
 import { Repl } from './repl.js';
 import { printPugMascotPreInk } from './repl-splash-mascot.js';
+import { ThemeProvider } from '../core/theme/context.js';
+import { resolveTheme } from '../core/theme/state.js';
 import { ReplSession, } from '../core/repl/session.js';
 import { resolveWorkspaceContext } from '../core/repl/workspace-context.js';
 import { SqliteSessionStore } from '../core/repl/store/index.js';
@@ -181,13 +183,26 @@ export async function renderRepl(options) {
     // (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);
-    const instance = render(React.createElement(Repl, {
+    // Leak L30 (2026-05-27): resolve the active theme ONCE at mount
+    // and wrap `<Repl />` in `<ThemeProvider>` so every Ink consumer
+    // (`<Header>`, `<DoctorTable>`, `<StyleTable>`, `<ThemeTable>`,
+    // …) picks up the same color tokens. The provider is stable for
+    // the lifetime of the REPL — operator `/theme <name>` writes to
+    // disk + appends a system line, and the next `pugi` launch re-
+    // mounts with the new slug. Re-mounting mid-session would race
+    // against Ink's raw-mode handler so we deliberately keep the
+    // session-lifetime contract instead of polling the config file.
+    const resolvedTheme = resolveTheme({
+        workspaceRoot: process.cwd(),
+        env: process.env,
+    });
+    const instance = render(React.createElement(ThemeProvider, { slug: resolvedTheme.slug }, React.createElement(Repl, {
         session,
         updateBanner: options.updateBanner ?? null,
         skipSplash: options.skipSplash === true,
         hideToolStream: options.hideToolStream === true,
         mascotPrePrinted,
-    }));
+    })));
     // 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', bootstrap.restore);