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

package/dist/runtime/commands/update.js

@@ -0,0 +1,289 @@
+/**
+ * Leak L27 (2026-05-27) — `pugi update` dispatcher.
+ *
+ * Top-level command + in-REPL `/update` slash share this handler.
+ * Both surfaces delegate IO + persistence here so the channel
+ * resolution, the registry probe, and the install shell-out stay
+ * single-sourced.
+ *
+ * Command grammar:
+ *
+ *   pugi update                     -> probe + interactive prompt
+ *   pugi update --check             -> probe + JSON envelope (scripted)
+ *   pugi update --channel <name>    -> switch channel + probe
+ *   pugi update --apply             -> probe + shell `npm i -g …`
+ *                                      (confirms unless --yes)
+ *   pugi update --apply --yes       -> probe + shell, no confirmation
+ *
+ * Exit codes:
+ *
+ *   0 — happy path (no update OR update completed) OR `--check` JSON
+ *   1 — install / probe failure with structured error envelope
+ *   2 — argument error (bad channel, conflicting flags)
+ *
+ * R2 atomic swap deferred (sprint plan L27 mention): the leak research
+ * also describes Claude Code's R2-backed binary swap. Pugi ships
+ * exclusively via npm today; building a parallel R2 distribution
+ * channel + checksum verification + rollback is materially more work
+ * than the L27 acceptance criteria allow. Document the deferral in
+ * the PR body and revisit when npm's once-per-day rate-limit or
+ * outage cadence justifies the parallel pipeline.
+ */
+import { spawn } from 'node:child_process';
+import { homedir } from 'node:os';
+import { DEFAULT_UPDATE_CHANNEL, UPDATE_CHANNELS, describeChannel, npmTagForChannel, parseUpdateChannel, } from '../../core/auto-update/channels.js';
+import { checkForChannelUpdate, } from '../../core/auto-update/checker.js';
+import { resolveEffectiveChannel, setUpdateChannel, writeLastCheckedAt, } from '../../core/auto-update/state.js';
+import { PUGI_CLI_VERSION } from '../version.js';
+/**
+ * Default subprocess runner. Spawns `npm install -g @pugi/cli@<tag>`
+ * inheriting stdio so the operator sees the live npm output.
+ */
+export function defaultSpawnInstaller(channel) {
+    const tag = npmTagForChannel(channel);
+    const args = ['install', '-g', `@pugi/cli@${tag}`];
+    return new Promise((resolvePromise) => {
+        const child = spawn('npm', args, { stdio: 'inherit' });
+        child.on('exit', (code) => {
+            resolvePromise(typeof code === 'number' ? code : 1);
+        });
+        child.on('error', () => {
+            // ENOENT / EACCES — npm not on PATH or permission denied. We
+            // surface a non-zero code so the dispatcher's JSON envelope
+            // tells the operator the apply failed; the inherited stdio
+            // already printed the underlying error to the terminal.
+            resolvePromise(127);
+        });
+    });
+}
+/**
+ * Parse a CLI / slash argv into our `UpdateCommandFlags`. Returns
+ * `null` AND writes the usage error via `writeError` for conflicting
+ * combinations. Both `pugi update` and the in-REPL `/update <args>`
+ * surface call through this so the validation lives in one place.
+ */
+export function parseUpdateArgs(argv, options = {}) {
+    let check = false;
+    let apply = false;
+    let yes = false;
+    let json = options.jsonDefault ?? false;
+    let channel = null;
+    let channelInvalid;
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i] ?? '';
+        if (token === '--check') {
+            check = true;
+        }
+        else if (token === '--apply') {
+            apply = true;
+        }
+        else if (token === '--yes' || token === '-y') {
+            yes = true;
+        }
+        else if (token === '--json') {
+            json = true;
+        }
+        else if (token === '--channel') {
+            const value = argv[i + 1];
+            i += 1;
+            const parsed = parseUpdateChannel(value);
+            if (!parsed) {
+                channelInvalid = value ?? '';
+                continue;
+            }
+            channel = parsed;
+        }
+        else if (token.startsWith('--channel=')) {
+            const value = token.slice('--channel='.length);
+            const parsed = parseUpdateChannel(value);
+            if (!parsed) {
+                channelInvalid = value;
+                continue;
+            }
+            channel = parsed;
+        }
+        else {
+            return {
+                error: `pugi update: unknown argument '${token}'. See \`pugi update --help\`.`,
+            };
+        }
+    }
+    if (channelInvalid !== undefined) {
+        return {
+            error: `pugi update: unknown channel '${channelInvalid}'. Allowed: ${UPDATE_CHANNELS.join(' / ')}.`,
+        };
+    }
+    return {
+        check,
+        apply,
+        yes,
+        json,
+        channel,
+    };
+}
+/**
+ * Run the full command. Returns the structured envelope so the in-
+ * REPL slash can decide whether to render the human-readable text OR
+ * pretty-print the JSON.
+ */
+export async function runUpdateCommand(ctx) {
+    const flags = ctx.flags;
+    const home = ctx.home;
+    // 1. Resolve channel. `--channel <name>` wins; otherwise read the
+    //    persisted preference; otherwise hard default `beta`.
+    const cliFlagChannel = flags.channel;
+    const effectiveChannel = resolveEffectiveChannel({
+        cliFlag: cliFlagChannel,
+        homeDir: home,
+    });
+    // 2. Persist the channel switch BEFORE the probe so a probe failure
+    //    still leaves the operator on the channel they asked for.
+    let switched = false;
+    if (cliFlagChannel) {
+        setUpdateChannel(cliFlagChannel, home);
+        switched = true;
+    }
+    // 3. Probe the registry.
+    const outcome = await checkForChannelUpdate({
+        channel: effectiveChannel,
+        currentVersion: PUGI_CLI_VERSION,
+        ...(ctx.fetchImpl ? { fetchImpl: ctx.fetchImpl } : {}),
+        ...(ctx.registryUrl ? { registryUrl: ctx.registryUrl } : {}),
+    });
+    // 4. Record the timestamp on a successful probe (regardless of
+    //    whether an update is available). Failed probes do NOT update
+    //    the timestamp so the cold-start banner retries on the next
+    //    invocation.
+    if (!outcome.error) {
+        const now = ctx.now ? new Date(ctx.now()) : new Date();
+        try {
+            writeLastCheckedAt(now, home);
+        }
+        catch {
+            // Best-effort — a read-only home should not crash the dispatcher.
+        }
+    }
+    // 5. Build the envelope shape ALL action paths share.
+    const baseEnvelope = {
+        command: 'update',
+        ok: outcome.error === null,
+        available: outcome.available,
+        channel: outcome.channel,
+        npmTag: outcome.npmTag,
+        current: outcome.current,
+        latest: outcome.latest,
+        gap: outcome.gap,
+        installCommand: outcome.installCommand,
+        action: outcome.error ? 'error' : 'probe',
+        error: outcome.error,
+        meta: { cliVersion: PUGI_CLI_VERSION },
+    };
+    // 6. --check: emit the envelope, never prompt, never apply.
+    if (flags.check) {
+        const text = renderHumanText(baseEnvelope, { switched });
+        ctx.writeOutput(baseEnvelope, text);
+        return baseEnvelope;
+    }
+    // 7. No update available — bail with a friendly message.
+    if (!outcome.available || !outcome.latest) {
+        const envelope = {
+            ...baseEnvelope,
+            action: outcome.error ? 'error' : (switched ? 'switch' : 'no_update'),
+        };
+        const text = renderHumanText(envelope, { switched });
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    // 8. Update IS available. Branch on --apply.
+    if (!flags.apply) {
+        // Default: print the offer, suggest the install command, leave
+        // the install to the operator. Mirrors the leak research note:
+        // operators install side-effects must remain explicit on the CLI
+        // happy path — `pugi update` showing the gap is informational,
+        // `pugi update --apply` is the destructive verb.
+        const envelope = {
+            ...baseEnvelope,
+            action: switched ? 'switch' : 'probe',
+        };
+        const text = renderHumanText(envelope, { switched });
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    // 9. --apply path. Confirm unless --yes, then spawn npm.
+    const installer = ctx.spawnInstaller ?? defaultSpawnInstaller;
+    let confirmed = flags.yes;
+    if (!confirmed) {
+        confirmed = await ctx.promptConfirm(`Run \`${outcome.installCommand}\` to update ${outcome.current} -> ${outcome.latest}? [y/N]`);
+    }
+    if (!confirmed) {
+        const envelope = {
+            ...baseEnvelope,
+            action: 'probe',
+            ok: false,
+            error: 'apply_cancelled_by_operator',
+        };
+        const text = `Cancelled. Run \`${outcome.installCommand}\` manually when you are ready.`;
+        ctx.writeOutput(envelope, text);
+        return envelope;
+    }
+    const exitCode = await installer(outcome.channel);
+    const applyEnvelope = {
+        ...baseEnvelope,
+        action: 'apply',
+        installExitCode: exitCode,
+        ok: exitCode === 0,
+        error: exitCode === 0 ? null : `npm_install_exit_${exitCode}`,
+    };
+    const applyText = exitCode === 0
+        ? `Updated to @pugi/cli@${outcome.latest}. Restart your shell so the new binary takes effect.`
+        : `Update failed (npm exit ${exitCode}). Try \`${outcome.installCommand}\` manually.`;
+    ctx.writeOutput(applyEnvelope, applyText);
+    return applyEnvelope;
+}
+/**
+ * Build the operator-readable hint that lives next to the JSON
+ * envelope. The text + the JSON are both passed to `writeOutput`; the
+ * caller (`writeOutput` in cli.ts) picks based on `--json`. Exported
+ * so the spec can assert the literal strings the operator sees.
+ */
+export function renderHumanText(envelope, options = {}) {
+    const { current, latest, channel, installCommand, available, error } = envelope;
+    const lines = [];
+    lines.push(`Channel: ${channel} — ${describeChannel(channel)}`);
+    if (options.switched) {
+        lines.push(`Persisted channel selection -> ${channel}.`);
+    }
+    if (error) {
+        lines.push(`Update check failed: ${error}`);
+        lines.push(`Manual: \`${installCommand}\` (no probe necessary).`);
+        return lines.join('\n');
+    }
+    if (available && latest) {
+        lines.push(`Update available: ${current} -> ${latest}.`);
+        lines.push(`Run \`${installCommand}\` to upgrade.`);
+        lines.push(`Or \`pugi update --apply\` to upgrade with confirmation.`);
+        return lines.join('\n');
+    }
+    lines.push(`Up to date (${current} is the latest on ${channel}).`);
+    return lines.join('\n');
+}
+/**
+ * Render a one-line cold-start hint that callers (REPL boot, doctor
+ * banner) splice above their own UI. Returns `null` when there is
+ * nothing to nudge the operator about. Pure — no IO.
+ */
+export function renderUpdateHint(outcome) {
+    if (!outcome.available || !outcome.latest)
+        return null;
+    return `Update available: ${outcome.current} -> ${outcome.latest}. Run \`pugi update\`.`;
+}
+/**
+ * Convenience entry point — resolve the effective channel from
+ * `~/.pugi/config.json` + DEFAULT_UPDATE_CHANNEL without forcing the
+ * caller to import multiple modules. Used by the cold-start banner +
+ * the doctor probe.
+ */
+export function effectiveChannel(home = homedir()) {
+    return resolveEffectiveChannel({ homeDir: home }) ?? DEFAULT_UPDATE_CHANNEL;
+}
+//# sourceMappingURL=update.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.24');
 /**
  * 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);

package/dist/tui/repl.js

@@ -29,6 +29,7 @@ import { StatusBar } from './status-bar.js';
 import { ToolStreamPane } from './tool-stream-pane.js';
 import { UpdateBanner } from './update-banner.js';
 import { collectWorkspaceContext } from './workspace-context.js';
+import { useTheme } from '../core/theme/context.js';
 import { slugForCwd } from '../core/repl/history.js';
 import { SLASH_COMMAND_HELP, SLASH_COMMAND_GROUPS } from '../core/repl/slash-commands.js';
 const TICK_INTERVAL_MS = 200;
@@ -202,7 +203,14 @@ export function Repl(props) {
                         sessionTokensIn: state.sessionTokensIn, sessionTokensOut: state.sessionTokensOut, sessionCostUsd: state.sessionCostUsd, sessionStartedAtEpochMs: state.sessionStartedAtEpochMs, lastTurnDelta: state.lastTurnDelta })] })] }));
 }
 function Header({ state }) {
-    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: "#3da9fc", children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: "#3da9fc", children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));
+    // Leak L30 (2026-05-27): the header `.io` brand accent + connection
+    // pill route through `useTheme()` so the operator's `/theme` flip
+    // (default / dark / light / colorblind) re-tints the chrome on
+    // re-mount. The `useTheme` hook returns the `default` preset's
+    // colors when no provider is mounted, preserving the previous
+    // `#3da9fc` constants for tests that import `<Repl />` standalone.
+    const theme = useTheme();
+    return (_jsxs(Box, { children: [_jsx(Text, { bold: true, children: "Pugi" }), _jsx(Text, { bold: true, color: theme.accent, children: ".io" }), _jsx(Text, { dimColor: true, children: `  ·  workspace: ${state.workspaceLabel}  ·  v${state.cliVersion}  ·  ` }), _jsx(Text, { color: theme.accent, children: state.connection === 'on_watch' ? 'on watch' : state.connection.replace('_', ' ') })] }));
 }
 function MainArea({ state, personaNames, nowEpochMs, hideToolStream, toolStreamCollapsed, }) {
     // α6.12: three vertical panes stacked above the input box.

package/dist/tui/style-table.js

@@ -1,6 +1,7 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
 import { OUTPUT_STYLES, OUTPUT_STYLE_SLUGS, } from '../core/output-style/presets.js';
+import { useTheme } from '../core/theme/context.js';
 /**
  * Banner above the table. Plain text (not bold) so the prefix `*`
  * remains the dominant active-row cue.
@@ -9,14 +10,19 @@ function buildBanner(active, source) {
     return `Active style: ${active} (${source})`;
 }
 export function StyleTable({ active, source }) {
+    // Leak L30 (2026-05-27): the active-row marker color flows through
+    // the theme so `colorblind` operators see cyan instead of green
+    // (which their palette re-maps to `success`). Falls back to the
+    // default theme's `success` token when no provider is mounted.
+    const theme = useTheme();
     const slugWidth = Math.max('NAME'.length, ...OUTPUT_STYLE_SLUGS.map((slug) => slug.length));
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi output styles" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  ${'NAME'.padEnd(slugWidth)}  GLOSS` }) }), OUTPUT_STYLE_SLUGS.map((slug) => (_jsx(StyleRow, { slug: slug, active: active, slugWidth: slugWidth }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: buildBanner(active, source) }) })] }));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi output styles" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  ${'NAME'.padEnd(slugWidth)}  GLOSS` }) }), OUTPUT_STYLE_SLUGS.map((slug) => (_jsx(StyleRow, { slug: slug, active: active, slugWidth: slugWidth, activeColor: theme.success }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: buildBanner(active, source) }) })] }));
 }
-function StyleRow({ slug, active, slugWidth }) {
+function StyleRow({ slug, active, slugWidth, activeColor }) {
     const isActive = slug === active;
     const marker = isActive ? '*' : ' ';
     const slugPart = slug.padEnd(slugWidth, ' ');
     const gloss = OUTPUT_STYLES[slug].gloss;
-    return (_jsxs(Box, { children: [_jsx(Text, { color: isActive ? 'green' : undefined, bold: isActive, children: `${marker} ${slugPart}` }), _jsx(Text, { children: `  ${gloss}` })] }));
+    return (_jsxs(Box, { children: [_jsx(Text, { color: isActive ? activeColor : undefined, bold: isActive, children: `${marker} ${slugPart}` }), _jsx(Text, { children: `  ${gloss}` })] }));
 }
 //# sourceMappingURL=style-table.js.map

package/dist/tui/theme-table.js

@@ -0,0 +1,29 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { compileSampleRow, THEMES, THEME_SLUGS, } from '../core/theme/presets.js';
+/**
+ * Banner above the table. Plain text (not bold) so the prefix `*`
+ * remains the dominant active-row cue. Mirrors `<StyleTable>` so the
+ * Settings-group surfaces read identically.
+ */
+function buildBanner(active, source) {
+    return `Active theme: ${active} (${source})`;
+}
+export function ThemeTable({ active, source }) {
+    const slugWidth = Math.max('NAME'.length, ...THEME_SLUGS.map((slug) => slug.length));
+    // The gloss column gets sized to the widest gloss + 2 padding so
+    // the sample column lines up. Computed once per render so the
+    // layout stays stable when the catalogue grows.
+    const glossWidth = Math.max('GLOSS'.length, ...THEME_SLUGS.map((slug) => THEMES[slug].gloss.length));
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Box, { marginBottom: 1, children: _jsx(Text, { bold: true, children: "Pugi themes" }) }), _jsx(Box, { children: _jsx(Text, { dimColor: true, children: `  ${'NAME'.padEnd(slugWidth)}  ${'GLOSS'.padEnd(glossWidth)}  SAMPLE` }) }), THEME_SLUGS.map((slug) => (_jsx(ThemeRow, { slug: slug, active: active, slugWidth: slugWidth, glossWidth: glossWidth }, slug))), _jsx(Box, { marginTop: 1, children: _jsx(Text, { children: buildBanner(active, source) }) })] }));
+}
+function ThemeRow({ slug, active, slugWidth, glossWidth }) {
+    const isActive = slug === active;
+    const marker = isActive ? '*' : ' ';
+    const slugPart = slug.padEnd(slugWidth, ' ');
+    const preset = THEMES[slug];
+    const gloss = preset.gloss.padEnd(glossWidth, ' ');
+    const sample = compileSampleRow(slug);
+    return (_jsxs(Box, { children: [_jsx(Text, { color: isActive ? preset.colors.accent : undefined, bold: isActive, children: `${marker} ${slugPart}` }), _jsx(Text, { children: `  ${gloss}  ` }), _jsx(Text, { color: preset.colors.foreground, children: sample.foreground }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.accent, children: sample.accent }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.success, children: sample.success }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.warning, children: sample.warning }), _jsx(Text, { children: ' ' }), _jsx(Text, { color: preset.colors.error, children: sample.error })] }));
+}
+//# sourceMappingURL=theme-table.js.map