@pugi/cli 0.1.0-beta.3 → 0.1.0-beta.30

package/dist/core/repl/slash-commands.js

@@ -38,20 +38,26 @@ import { listRoles } from '../agents/registry.js';
  * silently appear here with empty placeholders.
  */
 export const SLASH_STUB_MESSAGES = Object.freeze({
-    compact: 'Manual context compaction lands in α6.5b.',
+    // Leak L8 (2026-05-27): /compact graduated from stub. The session
+    // module now owns the summariser round-trip + boundary marker append
+    // via `dispatchCompact`. Keep the type record exhaustive so a future
+    // stub addition cannot silently overlap the wired set.
     memory: 'Session memory editor lands in α6.5b.',
     config: 'Run `pugi config list` from a fresh shell for the full surface; in-REPL editor lands in α6.5.',
     // alpha 6.13: /privacy graduated from stub; nothing reads this at
     // runtime but the type record stays exhaustive.
     privacy: '',
     budget: 'Run `pugi budget` from a fresh shell; in-REPL summary lands in α6.5.',
-    mcp: 'Run `pugi config mcp list` from a fresh shell; in-REPL palette lands in α6.5.',
+    // β4 Sl7 (2026-05-26): /mcp graduated from stub to a real handler
+    // that forwards to `runMcpCommand`. Stub message removed from the
+    // exhaustive record so the type narrows correctly.
     undo: 'Run `pugi undo` from a fresh shell; in-REPL undo lands in α6.5.',
 });
 export const SLASH_COMMAND_HELP = Object.freeze([
     // Workforce dispatch
     { name: 'brief', args: '<text>', gloss: 'Dispatch a brief to the workforce', group: 'Workforce dispatch' },
     { name: 'agents', args: '', gloss: 'List the on-watch agent roster', group: 'Workforce dispatch' },
+    { name: 'delegate', args: '<slug> <brief>', gloss: 'Dispatch a brief to one Tier 1 specialist (α7.5)', group: 'Workforce dispatch' },
     { name: 'stop', args: '<persona>', gloss: 'Stop one agent by persona slug', group: 'Workforce dispatch' },
     { name: 'jobs', args: '', gloss: 'List background jobs', group: 'Workforce dispatch' },
     { name: 'ask', args: '<question>', gloss: 'Surface a yes/no modal locally (α6.3 forcing question)', group: 'Workforce dispatch' },
@@ -59,23 +65,42 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     { name: 'clear', args: '', gloss: 'Clear conversation pane', group: 'Session' },
     { name: 'resume', args: '', gloss: 'Pick a stored session to restore', group: 'Session' },
     { name: 'context', args: '', gloss: 'Show three-tier context summary (Tier 0 skeleton + Tier 1 working set)', group: 'Session' },
-    { name: 'compact', args: '', gloss: 'Manual context compaction  (α6.5b)', group: 'Session', stub: true },
+    { name: 'compact', args: '[--force]', gloss: 'Summarise older turns into a boundary marker (leak L8). --force bypasses the noop-empty guard', group: 'Session' },
+    { name: 'rewind', args: '[N | --to <id>]', gloss: 'Roll the conversation back to a checkpoint (leak L9)', group: 'Session' },
     { name: 'memory', args: '', gloss: 'Session memory editor  (α6.5b)', group: 'Session', stub: true },
+    { name: 'init', args: '', gloss: 'Scaffold .pugi/ in the current workspace (β1 Sl11)', group: 'Session' },
     // Pugi tools
     { name: 'web', args: '<url>', gloss: 'Fetch a URL into context', group: 'Pugi tools' },
     { name: 'diff', args: '', gloss: 'Show pending diff', group: 'Pugi tools' },
-    { name: 'cost', args: '', gloss: 'Token usage + budget', group: 'Pugi tools' },
-    { name: 'status', args: '', gloss: 'Backend + tenant status', group: 'Pugi tools' },
+    { name: 'cost', args: '', gloss: 'Session token + USD totals + last 5 turn breakdown', group: 'Pugi tools' },
+    { name: 'quota', args: '', gloss: 'Plan tier + monthly usage caps (sync / review / engine)', group: 'Pugi tools' },
+    { name: 'status', args: '', gloss: 'Session snapshot — id · cwd · mode · tokens · dispatches · auth', group: 'Pugi tools' },
     { name: 'consensus', args: '[ref]', gloss: '3-model consensus review (codex · claude · deepseek)', group: 'Pugi tools' },
+    { name: 'repo-map', args: '[refresh]', gloss: 'AST-light symbol summary of the workspace (leak L28)', group: 'Pugi tools' },
     // Settings
     { name: 'config', args: '', gloss: 'Show config', group: 'Settings', stub: true },
     { name: 'privacy', args: '', gloss: 'Show privacy mode + contract', group: 'Settings' },
+    { name: 'permissions', args: '[mode] [--persist]', gloss: 'Show or flip permission mode (plan / ask / allow / bypass)  (also: /plan)', group: 'Settings' },
+    { name: 'plan', args: '[--back | --persist] [<prompt>]', gloss: 'Switch to plan mode (read-only). Same as /permissions plan, slicker UX.', group: 'Settings' },
+    { name: 'model', args: '[<slug>]', gloss: 'Show or select the active model. Bare /model lists tier-gated options', group: 'Settings' },
     { name: 'budget', args: '', gloss: 'Show usage budget', group: 'Settings', stub: true },
-    { name: 'mcp', args: '', gloss: 'List MCP servers', group: 'Settings', stub: true },
+    { name: 'mcp', args: '[sub]', gloss: 'MCP servers — list / trust / deny / install / serve / perms', group: 'Settings' },
+    { name: 'style', args: '[name] [--persist|--reset|--list]', gloss: 'Output-style preset (default / terse / explanatory / russian-formal / casual)', group: 'Settings' },
+    { name: 'theme', args: '[name] [--persist|--reset|--list]', gloss: 'TUI color palette (default / dark / light / colorblind)', group: 'Settings' },
+    { name: 'onboarding', args: '[--reset|--non-interactive]', gloss: 'First-run wizard — auth / mode / style / MCP / telemetry (leak L25)', group: 'Settings' },
+    { name: 'vim', args: '[on|off|status]', gloss: 'Toggle vim-style modal editing in the input buffer (leak L26)', group: 'Settings' },
     { name: 'undo', args: '', gloss: 'Undo last write', group: 'Settings', stub: true },
     // Meta
     { name: 'help', args: '', gloss: 'Show this help overlay', group: 'Meta' },
     { name: 'version', args: '', gloss: 'Show CLI version', group: 'Meta' },
+    { name: 'doctor', args: '', gloss: 'Environment health report (auth · API · Node · disk · MCP · …)', group: 'Meta' },
+    { name: 'prd-check', args: '<prd-path | --all> [--json]', gloss: 'Verify PRD acceptance criteria against committed code/tests/docs (Wave 6)', group: 'Meta' },
+    { name: 'chain', args: '<new|status|next|show|export|list> [...args]', gloss: 'Artifact chain — PRD → ADR → mindmap → ER → sequence → tests → code (Wave 6)', group: 'Meta' },
+    { name: 'stickers', args: '', gloss: 'show Pugi brand stickers (gimmick)', group: 'Meta' },
+    { name: 'feedback', args: '', gloss: 'file a bug / feature / general comment without leaving the REPL', group: 'Meta' },
+    { name: 'share', args: '[--gist|--pugi] [--redact] [--preview]', gloss: 'Export session transcript to gist / pugi.io (leak L20)', group: 'Meta' },
+    { name: 'release-notes', args: '[--reset]', gloss: 'Show changelog diff since last upgrade (leak L24)', group: 'Meta' },
+    { name: 'update', args: '[--check|--apply [--yes]] [--channel <name>]', gloss: 'Check for / apply CLI update on stable / beta / canary (leak L27)', group: 'Meta' },
     { name: 'quit', args: '', gloss: 'Exit the REPL', group: 'Meta' },
 ]);
 /**
@@ -135,6 +160,38 @@ export function parseSlashCommand(input) {
         case 'roster': {
             return { kind: 'roster' };
         }
+        case 'delegate': {
+            // tail must start with the persona slug followed by the brief.
+            // Slug accepts only the closed-set lowercase ASCII pattern the
+            // server-side persona registry enforces; anything else surfaces
+            // as a usage error so the operator sees the typo before the
+            // round-trip.
+            const innerSpace = tail.indexOf(' ');
+            if (innerSpace === -1 || innerSpace === 0) {
+                return {
+                    kind: 'error',
+                    message: 'Usage: /delegate <slug> <one-sentence brief>',
+                };
+            }
+            const persona = tail.slice(0, innerSpace).toLowerCase();
+            const brief = tail.slice(innerSpace + 1).trim();
+            // Pattern intentionally mirrors server-side PUGI_DELEGATE_REGEX in
+            // sessions.controller.ts (^[a-z]+$). Keeping them lockstep means
+            // the REPL surfaces typos locally instead of round-tripping a 4xx.
+            if (!/^[a-z]+$/.test(persona)) {
+                return {
+                    kind: 'error',
+                    message: `/delegate slug must be lowercase ASCII (a-z only); got '${persona}'`,
+                };
+            }
+            if (brief.length === 0) {
+                return {
+                    kind: 'error',
+                    message: 'Usage: /delegate <slug> <one-sentence brief>',
+                };
+            }
+            return { kind: 'delegate', persona, brief };
+        }
         case 'stop':
         case 'kill': {
             if (tail.length === 0) {
@@ -181,9 +238,19 @@ export function parseSlashCommand(input) {
         case 'diff': {
             return { kind: 'diff' };
         }
-        case 'cost': {
+        case 'cost':
+        case 'usage': {
+            // L19 (2026-05-27): `/usage` is an alias of `/cost` per the cost-
+            // command spec. The previous mapping routed `/usage` to the
+            // network-backed `/quota` surface, but operators trained on Claude
+            // Code expect `/usage` to surface the per-model token breakdown
+            // (same shape as `/cost`). `/quota` remains the canonical name
+            // for the tier + monthly-cap fetch.
             return { kind: 'cost' };
         }
+        case 'quota': {
+            return { kind: 'quota' };
+        }
         case 'status': {
             return { kind: 'status' };
         }
@@ -215,11 +282,280 @@ export function parseSlashCommand(input) {
             // device flow + audit identity are wired correctly).
             return { kind: 'privacy' };
         }
-        case 'compact':
+        case 'permissions':
+        case 'perms': {
+            // Leak L6: `/permissions [mode] [--persist] [--confirm]`.
+            //
+            // Argument grammar (single line, no quoting):
+            //   /permissions                   -> show current mode + table
+            //   /permissions plan|ask|allow    -> flip mode
+            //   /permissions bypass --confirm  -> flip to bypass (refused
+            //                                     without --confirm — safety)
+            //   /permissions <mode> --persist  -> also write to ~/.pugi/config.json
+            //
+            // Anything else returns an `error` result so the runtime can
+            // render the usage hint inline.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            if (tokens.length === 0) {
+                return { kind: 'permissions', persist: false, confirmBypass: false };
+            }
+            const head0 = tokens[0]?.toLowerCase();
+            if (head0 !== 'plan' && head0 !== 'ask' && head0 !== 'allow' && head0 !== 'bypass') {
+                return {
+                    kind: 'error',
+                    message: `Usage: /permissions [plan|ask|allow|bypass] [--persist] [--confirm]; unknown mode '${tokens[0] ?? ''}'`,
+                };
+            }
+            const flags = tokens.slice(1);
+            let persist = false;
+            let confirmBypass = false;
+            for (const flag of flags) {
+                if (flag === '--persist') {
+                    persist = true;
+                }
+                else if (flag === '--confirm') {
+                    confirmBypass = true;
+                }
+                else {
+                    return {
+                        kind: 'error',
+                        message: `/permissions: unknown flag '${flag}' (allowed: --persist, --confirm)`,
+                    };
+                }
+            }
+            return { kind: 'permissions', mode: head0, persist, confirmBypass };
+        }
+        case 'init': {
+            // β1 Sl11: surface the init flow inside the REPL. Tail args
+            // are ignored — the init handler is parameterless today; `pugi
+            // init --no-defaults` is the CLI surface for skipping bundled
+            // skills.
+            return { kind: 'init' };
+        }
+        case 'plan': {
+            // Leak L7: `/plan [--back | --persist] [<prompt>]`.
+            //
+            // Argument grammar (single line, no quoting):
+            //   /plan                           -> enter plan mode + banner
+            //   /plan --back                    -> restore previous mode
+            //   /plan --persist                 -> enter + write global config
+            //   /plan <prompt...>               -> enter + run one-shot engine
+            //   /plan --auto-back <prompt...>   -> enter + run + restore mode
+            //
+            // The parser pulls the flags off the head of the tail; whatever
+            // remains is the prompt. `--back` + a non-empty prompt and
+            // `--back` + `--auto-back` are both refused as `error` because
+            // they conflict at the verb level.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            let back = false;
+            let persist = false;
+            let autoBack = false;
+            const promptTokens = [];
+            for (const token of tokens) {
+                if (token === '--back') {
+                    back = true;
+                }
+                else if (token === '--persist') {
+                    persist = true;
+                }
+                else if (token === '--auto-back') {
+                    autoBack = true;
+                }
+                else {
+                    promptTokens.push(token);
+                }
+            }
+            const prompt = promptTokens.join(' ');
+            if (back && prompt.length > 0) {
+                return {
+                    kind: 'error',
+                    message: '/plan --back does not accept a prompt; revert first, then dispatch.',
+                };
+            }
+            if (back && autoBack) {
+                return {
+                    kind: 'error',
+                    message: '/plan --back and --auto-back cannot be combined.',
+                };
+            }
+            return { kind: 'plan', back, persist, autoBack, prompt };
+        }
+        case 'model': {
+            // Wave 6 BT 8 (Claude Code parity): `/model [<slug>]`. Bare form
+            // prints the tier-gated model menu + current selection; with a
+            // slug it flips workspace selection. Slug grammar (loose): alnum
+            // + dash + dot + slash. Anything outside that range becomes an
+            // error verdict so the operator sees a clear message instead of a
+            // silent no-op. Whitespace inside the tail = multiple tokens = we
+            // take the first; the help gloss documents single-slug usage.
+            const trimmedTail = tail.trim();
+            if (trimmedTail.length === 0) {
+                return { kind: 'model', slug: undefined };
+            }
+            const firstToken = trimmedTail.split(/\s+/)[0] ?? '';
+            if (!/^[A-Za-z0-9][A-Za-z0-9._\-\/]{0,63}$/.test(firstToken)) {
+                return {
+                    kind: 'error',
+                    message: `/model: invalid slug '${firstToken}'. Use letters / digits / '-' / '.' / '/' only.`,
+                };
+            }
+            return { kind: 'model', slug: firstToken };
+        }
+        case 'mcp': {
+            // β4 Sl7: tokenize the tail. Empty tail -> `list` (matches CLI).
+            // Quoting / shell-escapes are NOT supported — the slash surface is
+            // intentionally simple; complex installs (env vars, multi-word
+            // args) go through `pugi mcp install` from a fresh shell.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'mcp', args: tokens };
+        }
+        case 'style':
+        case 'output-style': {
+            // Leak L18 (2026-05-27): forward the tokenized tail unchanged so
+            // the slash + top-level CLI surfaces share one parser inside
+            // `runStyleCommand`. Quoting / multi-word args are not used (the
+            // preset slugs are single tokens by contract).
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'style', args: tokens };
+        }
+        case 'theme':
+        case 'palette':
+        case 'colors': {
+            // Leak L30 (2026-05-27): forward the tokenized tail unchanged so
+            // the slash + top-level `pugi theme` surfaces share one parser
+            // inside `runThemeCommand`. Aliases `/palette` and `/colors`
+            // exist because the leak-landscape audit found operators reach
+            // for either word interchangeably — same surface, same handler.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'theme', args: tokens };
+        }
+        case 'onboarding':
+        case 'onboard':
+        case 'setup': {
+            // Leak L25 (2026-05-27): forward the tokenized tail unchanged.
+            // The slash always routes through the non-interactive snapshot
+            // path (the REPL already owns the Ink tree); the runner picks
+            // it up from `ctx.interactive = false` in the session
+            // dispatcher.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'onboarding', args: tokens };
+        }
+        case 'vim': {
+            // Leak L26 (2026-05-27): forward the tokenized tail unchanged so
+            // the slash + top-level CLI surfaces share one parser inside
+            // `runVimCommand`. Subcommands are single tokens (on / off /
+            // status); a bare `/vim` toggles.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'vim', args: tokens };
+        }
+        case 'doctor':
+        case 'health': {
+            // L17 (2026-05-27): run the probe sweep inline. Tail is ignored —
+            // the doctor command has no operator-facing arguments (every
+            // probe runs unconditionally; per-probe disable lives on the CLI
+            // shell surface, not the slash one).
+            return { kind: 'doctor' };
+        }
+        case 'prd-check':
+        case 'prdcheck': {
+            // Wave 6 (2026-05-27): tokenise the tail and forward verbatim
+            // so the slash + shell surfaces share one `parsePrdCheckArgs`.
+            // Supports `<prd-path>`, `--all`, and `--json`.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'prd-check', args: tokens };
+        }
+        case 'chain': {
+            // Wave 6 (2026-05-27): forward the tokenized argv to
+            // `runChainCommand` via the session module. Subcommands are
+            // single tokens (new / status / next / show / export / list);
+            // the `new` subcommand accepts the intent as the joined tail so
+            // operators can write `/chain new add auth flow` без quoting.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'chain', args: tokens };
+        }
+        case 'compact': {
+            // Leak L8 (2026-05-27): graduated from stub. The session module
+            // owns the summariser round-trip. Wave 6 BT 8: `--force` overrides
+            // the noop-empty guard. Unknown flags fall through silently per
+            // the existing tail-tolerance behaviour (operators wanting a
+            // per-session compact run `pugi compact --session <id>` from a
+            // fresh shell).
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            const force = tokens.some((t) => t === '--force' || t === '-f');
+            return { kind: 'compact', force };
+        }
+        case 'rewind': {
+            // Leak L9 (2026-05-27): `/rewind [N | --to <id>]`. Tokenize the
+            // tail unchanged so `runRewindCommand` (in `runtime/commands/
+            // rewind.ts`) handles every mode (picker / turns / to-event)
+            // through one parser. The slash + top-level CLI surfaces stay
+            // single-sourced — same separation as `/compact`.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'rewind', args: tokens };
+        }
+        case 'stickers': {
+            // Leak L33 (2026-05-27): brand-personality gimmick. Tail args
+            // are ignored — the surface is intentionally parameterless. The
+            // session module delegates to the shared `runStickersCommand`
+            // so the slash + top-level paths stay single-sourced.
+            return { kind: 'stickers' };
+        }
+        case 'feedback': {
+            // Leak L21 (2026-05-27): in-CLI feedback collector. The wizard
+            // collects category/rating/comment/context/confirm interactively
+            // so the slash surface is parameterless. Tail args are reserved
+            // for a future `--message=...` quick-path; today they are
+            // accepted but ignored so the operator-level UX matches
+            // Claude Code's `/feedback`.
+            return { kind: 'feedback' };
+        }
+        case 'share': {
+            // Leak L20 (2026-05-27): forward the tokenized arg list verbatim
+            // so the session module (which owns the network + readline
+            // affordances) can hand them to runShareCommand. Defaults: no
+            // tokens means "auto-pick target + prompt for confirmation".
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'share', args: tokens };
+        }
+        case 'repo-map':
+        case 'repomap': {
+            // Leak L28 (2026-05-27): build + show the AST-light symbol
+            // summary. Accepts `refresh` as a positional или `--refresh`
+            // flag so muscle memory from both shells lands the same way.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            const refresh = tokens.includes('--refresh') || tokens.includes('refresh') || tokens.includes('-r');
+            return { kind: 'repo-map', refresh };
+        }
+        case 'release-notes':
+        case 'releasenotes':
+        case 'changelog': {
+            // Leak L24 (2026-05-27): changelog diff between last-seen +
+            // installed CLI version. Tail args are tokenized so `--reset`
+            // can flip the marker-clear bit; no other flags are honoured —
+            // the surface mirrors the CLI top-level's intentional minimalism.
+            // `changelog` alias matches operator muscle memory from npm /
+            // cargo / brew, all of which ship `changelog` subcommands.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            const reset = tokens.includes('--reset') || tokens.includes('-r');
+            return { kind: 'release-notes', reset };
+        }
+        case 'update': {
+            // Leak L27 (2026-05-27): forward the tokenized argv to the
+            // session module which delegates to `runUpdateCommand`. The
+            // dispatcher owns argv validation (unknown channel / flag) so
+            // the slash parser stays as thin as the rest of the surface.
+            // The slash form does NOT support `--apply` because spawning
+            // `npm install -g` from inside a running REPL session would
+            // corrupt the operator's running binary — the dispatcher treats
+            // `--apply` from a slash as a non-interactive offer (probe +
+            // install command, no shell-out). Top-level `pugi update --apply`
+            // remains the recommended path for the actual install.
+            const tokens = tail.length === 0 ? [] : tail.split(/\s+/).filter((s) => s.length > 0);
+            return { kind: 'update', args: tokens };
+        }
         case 'memory':
         case 'config':
         case 'budget':
-        case 'mcp':
         case 'undo': {
             const stubName = name;
             return {

package/dist/core/repl/store/session-store.js

@@ -361,7 +361,7 @@ export class SqliteSessionStore {
         // which maps to SQLITE_OPEN_READONLY. The option form is the
         // documented API; the file-URI form (file:...?mode=ro) also works.
         const db = new DatabaseSync(dbPath, { readOnly: true });
-        return new SqliteSessionStoreReadOnlyView(db);
+        return new SqliteSessionStoreReadOnlyView(db, projectStoreDir);
     }
     /* ------------------------------------------------------------ */
     /* Internals                                                    */
@@ -584,8 +584,37 @@ export class SqliteSessionStore {
  */
 export class SqliteSessionStoreReadOnlyView {
     db;
-    constructor(db) {
+    projectStoreDir;
+    constructor(db, 
+    /**
+     * Project store directory — required for the JSONL event read path.
+     * L9 (2026-05-27): `/rewind` + `/resume` need to walk events from
+     * inside the read-only view so the rewind picker + resume preview
+     * never take the writer lockfile.
+     */
+    projectStoreDir) {
         this.db = db;
+        this.projectStoreDir = projectStoreDir;
+    }
+    /**
+     * Read every event for a session via the durable JSONL log. The
+     * SQLite cache is NOT used here — JSONL is the source of truth and
+     * the cache only holds counters. The walk stitches across rotation
+     * files (`events.<n>.jsonl`) in the same order `JsonlEventLog.read`
+     * uses inside the writer path so consumers see one consistent stream
+     * whether they came in via the writer store OR the read-only view.
+     */
+    async events(sessionId, opts) {
+        const sessionDir = resolve(this.projectStoreDir, 'sessions', sessionId);
+        if (!existsSync(sessionDir))
+            return [];
+        const log = new JsonlEventLog({ sessionDir });
+        try {
+            return log.read(opts);
+        }
+        finally {
+            log.close();
+        }
     }
     async list(opts) {
         const limit = clampLimit(opts?.limit ?? DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT);

package/dist/core/repl/workspace-context.js

@@ -27,6 +27,16 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { basename, resolve as resolvePath } from 'node:path';
 import { slugForCwd } from './history.js';
+import { isBareMode } from '../bare-mode/index.js';
+/**
+ * Workspace summary shown when the operator launched with `--bare` (or
+ * `PUGI_BARE=1`). Leak L22: bare mode disables project auto-discovery
+ * across the CLI, so we never read `.pugi/PUGI.md` and never advertise
+ * a real workspace label to admin-api. Explicit string so the splash +
+ * status bar agree, and so operators triaging "why is Mira ignoring
+ * my repo" see a clear cause.
+ */
+export const BARE_MODE_WORKSPACE_LABEL = '(bare mode - auto-discovery disabled)';
 /** Cap on the PUGI.md head we forward. Mirrors the admin-api clamp. */
 const PUGI_MD_HEAD_LIMIT = 200;
 /**
@@ -48,6 +58,18 @@ export const UNBOUND_WORKSPACE_LABEL = '(not bound - run /init OR cd into projec
 export function resolveWorkspaceContext(cwd) {
     const normalised = resolvePath(cwd);
     const slug = slugForCwd(normalised);
+    // Leak L22 (2026-05-27): `--bare` short-circuits BEFORE any PUGI.md
+    // / project-marker reads so the resolver never advertises a real
+    // workspace summary to admin-api. The cwd + slug still travel for
+    // telemetry, but the model + Mira treat the session as if launched
+    // from a fresh, unbound directory.
+    if (isBareMode()) {
+        return {
+            workspaceCwd: normalised,
+            workspaceSlug: slug,
+            workspaceSummary: BARE_MODE_WORKSPACE_LABEL,
+        };
+    }
     // α6.14.2 wave 5: when the cwd has no project markers, prefer the
     // explicit "not bound" summary so admin-api's prompt builder knows
     // not to fabricate a workspace context for Mira/Pugi. The cwd +

package/dist/core/repo-map/build.js

@@ -0,0 +1,125 @@
+/**
+ * Repo-map build orchestrator — Leak L28 (2026-05-27).
+ *
+ * Single entry point that the CLI command + the engine boot path both
+ * call. Wires the scanner → extractor → cache → formatter pipeline
+ * together and surfaces a structured result the caller can render or
+ * inject without knowing the inner module shapes.
+ *
+ * The orchestrator is split out от cache.ts and the command handler
+ * so:
+ *
+ *   1. The CLI command + the engine system-prompt injector share one
+ *      code path. Drift between the two would silently change what
+ *      the model sees vs. what the operator sees.
+ *
+ *   2. The spec can exercise the full pipeline against a temp dir
+ *      without mounting Ink or the engine.
+ *
+ * Pure-ish: reads from disk (the source files + the cache), but never
+ * mutates anything outside `.pugi/repo-map.json` and never logs. The
+ * caller decides whether к persist the cache (`writeCache: true`) or
+ * к compute the map в-memory (`writeCache: false` — useful for
+ * non-interactive `--json` invocations on read-only fs).
+ */
+import { readFileSync } from 'node:fs';
+import { loadPugiIgnore } from '../context/pugiignore.js';
+import { defaultCachePath, diffCacheAgainstScan, mergeCache, readRepoMapCache, writeRepoMapCache, } from './cache.js';
+import { extractFromFile } from './extractor.js';
+import { scanRepoForMap } from './scanner.js';
+import { formatRepoMap } from './formatter.js';
+/**
+ * Run the full pipeline. Returns a structured verdict; never throws.
+ * The 'too-large' branch fires when the workspace exceeds the file
+ * cap — callers surface a hint к the operator ("repo too large for
+ * inline map — try .pugiignore") and skip injection.
+ */
+export function buildRepoMap(options) {
+    const root = options.root;
+    const refresh = options.refresh === true;
+    const writeCache = options.writeCache !== false;
+    const cachePath = options.cachePath ?? defaultCachePath(root);
+    const readFile = options.readFile ?? ((path) => readFileSync(path, 'utf8'));
+    const ignore = loadPugiIgnore(root);
+    const scan = scanRepoForMap({ root, ignore });
+    if (!scan.ok) {
+        return {
+            ok: false,
+            root,
+            reason: scan.skipped.reason,
+            walked: scan.skipped.walked,
+        };
+    }
+    const prior = refresh ? null : readCacheOrNull(cachePath);
+    const diff = diffCacheAgainstScan(prior, scan.files);
+    const freshExtracts = new Map();
+    for (const file of diff.toRebuild) {
+        let source;
+        try {
+            source = readFile(file.absPath);
+        }
+        catch {
+            // File vanished или became unreadable mid-build — skip. The
+            // cache layer will just not have an entry for it; next refresh
+            // picks it up if it reappears.
+            continue;
+        }
+        freshExtracts.set(file.relPath, extractFromFile(file, source));
+    }
+    const cache = mergeCache({
+        root,
+        prior,
+        scanned: scan.files,
+        freshExtracts,
+    });
+    let cacheWritten = false;
+    if (writeCache) {
+        const writeResult = writeRepoMapCache(cachePath, cache);
+        cacheWritten = writeResult.ok;
+    }
+    // Surface the extracts в the same order the scanner produced (sorted
+    // by POSIX path) so callers iterating the result render deterministic
+    // output. The formatter does its own priority sort, so a different
+    // order here would only affect callers that iterate manually.
+    const extracts = [];
+    for (const file of scan.files) {
+        const entry = cache.entries[file.relPath];
+        if (entry)
+            extracts.push(entry.extract);
+    }
+    return {
+        ok: true,
+        root,
+        cache,
+        extracts,
+        scanStats: scan.stats,
+        diffStats: {
+            rebuilt: diff.toRebuild.length,
+            reused: diff.reuse.length,
+            dropped: diff.toDrop.length,
+        },
+        cachePath,
+        cacheWritten,
+    };
+}
+/**
+ * Convenience wrapper: build + format в one call. The engine boot
+ * path uses this so it does not have к know the formatter shape.
+ */
+export function buildAndFormatRepoMap(options) {
+    const build = buildRepoMap(options);
+    if (!build.ok)
+        return { build };
+    const format = formatRepoMap(build.extracts, {
+        maxBytes: options.formatBytesCap,
+        omitHeader: options.omitHeader,
+    });
+    return { build, format };
+}
+function readCacheOrNull(path) {
+    const verdict = readRepoMapCache(path);
+    if (verdict.ok)
+        return verdict.cache;
+    return null;
+}
+//# sourceMappingURL=build.js.map