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

package/dist/runtime/commands/hooks.js

@@ -0,0 +1,184 @@
+/**
+ * `pugi hooks` — operator surface for user-config hooks (Leak L12 MVP).
+ *
+ * Two subcommands ship in the MVP:
+ *
+ *   pugi hooks list         List configured hooks per event.
+ *   pugi hooks doctor       Validate the config and surface any
+ *                           parse / schema errors.
+ *
+ * Both accept `--json` for scripted callers. Argument grammar is
+ * intentionally narrow — no `add` / `remove` / `test` subcommands in
+ * the MVP. Operators hand-edit `~/.pugi/hooks-mvp.json` for now.
+ *
+ * Exit codes:
+ *   0  -> happy path (no hooks OR config valid).
+ *   1  -> config present but invalid (only `doctor` returns this).
+ *   2  -> unknown subcommand / argument error.
+ *
+ * Brand voice: ASCII only.
+ */
+import { ALL_HOOK_EVENTS_V2, defaultHooksMvpPath, loadHooksConfig, } from '../../core/hooks/index.js';
+function parseFlags(args) {
+    const rest = [];
+    const flags = { json: false };
+    for (const arg of args) {
+        if (arg === '--json') {
+            flags.json = true;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, flags };
+}
+/**
+ * Top-level dispatcher for `pugi hooks <subcommand>`. Returns the
+ * intended process exit code. `cli.ts` is expected to set
+ * `process.exitCode = <return value>` so error states propagate to
+ * scripted callers without throwing.
+ */
+export async function runHooksCommand(args, ctx) {
+    const { rest, flags } = parseFlags(args);
+    const sub = rest[0];
+    if (!sub || sub === 'help' || sub === '--help') {
+        emitUsage(ctx, flags);
+        return sub ? 0 : 2;
+    }
+    if (sub === 'list') {
+        return runList(ctx, flags);
+    }
+    if (sub === 'doctor') {
+        return runDoctor(ctx, flags);
+    }
+    ctx.writeOutput({ ok: false, error: `unknown subcommand: ${sub}` }, `pugi hooks: unknown subcommand '${sub}'. Try 'pugi hooks --help'.`);
+    return 2;
+}
+function emitUsage(ctx, flags) {
+    const text = [
+        'pugi hooks — user-config lifecycle hooks (MVP).',
+        '',
+        'Subcommands:',
+        '  pugi hooks list        Show hooks configured per event.',
+        '  pugi hooks doctor      Validate ~/.pugi/hooks-mvp.json.',
+        '',
+        'Flags:',
+        '  --json                 Emit a JSON envelope instead of human text.',
+        '',
+        'Config file:',
+        '  ~/.pugi/hooks-mvp.json',
+        '',
+        'Status:',
+        '  MVP — 2 events out of 8. Remaining events (PostToolUse,',
+        "  UserPromptSubmit, Stop, SubagentStop, PreCompact, Notification)",
+        '  deferred to fast-follow PR.',
+    ].join('\n');
+    ctx.writeOutput({
+        ok: true,
+        command: 'hooks',
+        usage: text,
+    }, text);
+    if (flags.json) {
+        // The structured payload is already emitted by writeOutput when
+        // --json is on; nothing extra to do.
+    }
+}
+function runList(ctx, flags) {
+    let config;
+    try {
+        config = loadHooksConfig(ctx.configPath);
+    }
+    catch (error) {
+        const msg = error.message;
+        ctx.writeOutput({ ok: false, error: msg }, `pugi hooks list: ${msg}\nFix the config or remove the file. Run 'pugi hooks doctor' for details.`);
+        return 1;
+    }
+    const perEvent = {
+        SessionStart: [],
+        PreToolUse: [],
+        PostToolUse: [],
+        UserPromptSubmit: [],
+        Stop: [],
+        SubagentStop: [],
+        PreCompact: [],
+        Notification: [],
+    };
+    for (const event of ALL_HOOK_EVENTS_V2) {
+        perEvent[event] = config.list(event).map((entry) => ({
+            matcher: entry.matcher,
+            command: entry.command,
+            timeoutMs: entry.timeoutMs,
+            blocking: entry.blocking,
+        }));
+    }
+    const total = Object.values(perEvent).reduce((acc, list) => acc + list.length, 0);
+    const payload = {
+        ok: true,
+        configPath: config.configPath(),
+        total,
+        perEvent,
+    };
+    if (flags.json) {
+        ctx.writeOutput(payload, JSON.stringify(payload, null, 2));
+        return 0;
+    }
+    const lines = [];
+    lines.push(`pugi hooks (${total} configured)`);
+    lines.push(`  config: ${config.configPath()}`);
+    if (total === 0) {
+        lines.push('  no hooks configured — create the file above to add one.');
+    }
+    else {
+        for (const event of ALL_HOOK_EVENTS_V2) {
+            const list = perEvent[event];
+            if (list.length === 0)
+                continue;
+            lines.push(`  ${event}:`);
+            for (const entry of list) {
+                const tags = [];
+                if (entry.matcher)
+                    tags.push(`matcher=${entry.matcher}`);
+                if (entry.timeoutMs)
+                    tags.push(`timeoutMs=${entry.timeoutMs}`);
+                if (entry.blocking)
+                    tags.push('blocking');
+                const suffix = tags.length ? `  [${tags.join(', ')}]` : '';
+                lines.push(`    - ${entry.command}${suffix}`);
+            }
+        }
+    }
+    const text = lines.join('\n');
+    ctx.writeOutput(payload, text);
+    return 0;
+}
+function runDoctor(ctx, flags) {
+    const path = ctx.configPath ?? defaultHooksMvpPath();
+    try {
+        const config = loadHooksConfig(ctx.configPath);
+        const total = config.flatten().length;
+        const payload = {
+            ok: true,
+            configPath: config.configPath(),
+            total,
+            issues: [],
+        };
+        const text = total
+            ? `pugi hooks doctor: ${path} OK (${total} hooks).`
+            : `pugi hooks doctor: ${path} not present (no hooks configured).`;
+        ctx.writeOutput(payload, text);
+        return 0;
+    }
+    catch (error) {
+        const msg = error.message;
+        const payload = {
+            ok: false,
+            configPath: path,
+            error: msg,
+        };
+        const text = `pugi hooks doctor: ${msg}`;
+        ctx.writeOutput(payload, text);
+        return 1;
+    }
+    // flags.json is consumed by writeOutput in the host shell.
+    void flags;
+}
+//# sourceMappingURL=hooks.js.map

package/dist/runtime/commands/lsp.js

@@ -24,8 +24,8 @@
  *
  * Brand voice: ASCII only, no emoji, no banned words.
  */
-import { extname } from 'node:path';
 import { inspectLspServers, startLspClient } from '../../core/lsp/client.js';
+import { languageForFile as inferLanguage } from '../../core/lsp/language-detect.js';
 import { loadSettings } from '../../core/settings.js';
 export async function runLspCommand(args, opts) {
     const [op, file, ...rest] = args;
@@ -96,6 +96,25 @@ export async function runLspCommand(args, opts) {
         };
     }
     const settings = loadSettings(opts.cwd);
+    // Leak L15 (2026-05-27): `pugi lsp check <file>` — manual probe of
+    // the post-edit diagnostics pipeline. Identical output to what the
+    // model sees appended to its tool envelope after a successful
+    // edit/write. Lets operators dry-run the auto-diagnostic surface
+    // without dispatching an actual edit.
+    if (op === 'check') {
+        const { runPostEditDiagnostics } = await import('../../core/lsp/post-edit-diagnostics.js');
+        const result = await runPostEditDiagnostics(file, {
+            cwd: opts.cwd,
+            ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
+        });
+        if (opts.json) {
+            return { ok: true, text: JSON.stringify(result, null, 2), exitCode: 0 };
+        }
+        if (result.skip) {
+            return { ok: true, text: `${file}: skipped (${result.reason})`, exitCode: 0 };
+        }
+        return { ok: true, text: result.tail, exitCode: 0 };
+    }
     const clientResult = await startLspClient(lang, {
         cwd: opts.cwd,
         ...(settings.lsp ? { lspSettings: settings.lsp } : {}),
@@ -204,6 +223,7 @@ function usage() {
             '  pugi lsp definition <file> <line> <col>\n' +
             '  pugi lsp references <file> <line> <col>\n' +
             '  pugi lsp diagnostics <file>\n' +
+            '  pugi lsp check <file>          (Leak L15: probe post-edit tail)\n' +
             '  pugi lsp find_definition <file> <symbol>\n' +
             '  pugi lsp servers',
         exitCode: 2,
@@ -341,26 +361,8 @@ function pullLangFlag(args) {
 function isLspLanguage(value) {
     return value === 'ts' || value === 'js' || value === 'py' || value === 'go' || value === 'rust';
 }
-export function inferLanguage(file) {
-    const ext = extname(file).toLowerCase();
-    switch (ext) {
-        case '.ts':
-        case '.tsx':
-            return 'ts';
-        case '.js':
-        case '.jsx':
-        case '.mjs':
-        case '.cjs':
-            return 'js';
-        case '.py':
-        case '.pyi':
-            return 'py';
-        case '.go':
-            return 'go';
-        case '.rs':
-            return 'rust';
-        default:
-            return undefined;
-    }
-}
+// Leak L15 (2026-05-27): single source of truth for ext → language
+// lives in `core/lsp/language-detect.ts`. The CLI surface re-exports
+// the lookup so existing call sites keep their import path.
+export { inferLanguage };
 //# sourceMappingURL=lsp.js.map

package/dist/runtime/commands/repo-map.js

@@ -0,0 +1,95 @@
+/**
+ * `pugi repo-map` — Leak L28 (2026-05-27).
+ *
+ * Builds a compact AST-light summary of the workspace's source surface
+ * (top-level function / class / interface / type / enum declarations
+ * plus the leading JSDoc / markdown summary line) and renders it as
+ * a markdown listing. The same builder backs the engine boot-time
+ * system-prompt injection — running `pugi repo-map` shows the operator
+ * EXACTLY what the engine would inject.
+ *
+ * The command surface mirrors the L28 spec:
+ *
+ *   `pugi repo-map`             build + show (cache hit when fresh)
+ *   `pugi repo-map --refresh`   bust cache + rebuild from scratch
+ *   `pugi repo-map --format=json` machine-readable envelope
+ *
+ * Exit code is always 0 — the command is informational, not a gate.
+ * The `--json` envelope carries an `ok: false` branch when the repo is
+ * too large to map (the L28 5000-file ceiling), so scripted callers
+ * can detect the skip without parsing prose.
+ *
+ * The handler is awaited even though the underlying pipeline is sync,
+ * matching the pattern of every other `run*Command` (stickers, status,
+ * doctor) so future async paths (remote cache pull) drop в without
+ * changing the call sites.
+ */
+import { buildAndFormatRepoMap } from '../../core/repo-map/build.js';
+/**
+ * Run the command. Always resolves к the structured envelope so the
+ * caller can chain into a status table. Exit code is set к 0 in every
+ * branch — the command is informational.
+ */
+export async function runRepoMapCommand(ctx) {
+    const result = buildAndFormatRepoMap({
+        root: ctx.cwd,
+        refresh: ctx.refresh === true,
+        writeCache: ctx.writeCache !== false,
+        formatBytesCap: ctx.formatBytesCap,
+        omitHeader: false,
+    });
+    if (!result.build.ok) {
+        const payload = {
+            ok: false,
+            command: 'repo-map',
+            root: result.build.root,
+            reason: result.build.reason,
+            walked: result.build.walked,
+        };
+        const text = result.build.reason === 'too-large'
+            ? `repo-map skipped: workspace exceeds the ${result.build.walked}-file ceiling. Tighten .pugiignore and re-run.`
+            : `repo-map skipped: no workspace at ${result.build.root}.`;
+        ctx.writeOutput(payload, text);
+        // Informational — never a gate.
+        process.exitCode = 0;
+        return payload;
+    }
+    const build = result.build;
+    if (!build.ok) {
+        // TS narrowing — handled above.
+        throw new Error('unreachable');
+    }
+    const format = result.format;
+    const payload = {
+        ok: true,
+        command: 'repo-map',
+        root: build.root,
+        stats: {
+            filesScanned: build.scanStats.walked,
+            filesIncluded: format.filesIncluded,
+            filesRebuilt: build.diffStats.rebuilt,
+            filesReused: build.diffStats.reused,
+            filesDropped: build.diffStats.dropped,
+            skippedLarge: build.scanStats.skippedLarge,
+            skippedIgnored: build.scanStats.skippedIgnored,
+            bytes: format.bytes,
+            truncated: format.truncated,
+        },
+        cachePath: build.cachePath,
+        cacheWritten: build.cacheWritten,
+        text: format.text,
+    };
+    // The text surface IS the formatted markdown. We append a one-line
+    // stats footer so the operator sees the cache-hit ratio at a glance
+    // (engine context cache is opaque otherwise) — kept off the JSON
+    // payload so machine consumers do not have to skip a trailer.
+    const footer = formatFooter(payload.stats);
+    ctx.writeOutput(payload, `${format.text}\n${footer}`);
+    process.exitCode = 0;
+    return payload;
+}
+function formatFooter(stats) {
+    const truncatedHint = stats.truncated ? ' (truncated к budget)' : '';
+    return `${stats.filesIncluded} files · ${stats.filesRebuilt} rebuilt · ${stats.filesReused} cache hit · ${stats.bytes} bytes${truncatedHint}`;
+}
+//# sourceMappingURL=repo-map.js.map

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/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.23');
+export const PUGI_CLI_VERSION = sanitizeSemver('0.1.0-beta.25');
 /**
  * Outbound: the CLI's installed semver. Read at request time by
  * `version-interceptor.ts` and injected on every `fetch` call.