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

package/dist/core/repl/session.js

@@ -390,6 +390,11 @@ export class ReplSession {
             // admin-api down) is silent - the operator can still type
             // `/privacy` to see the contract.
             void this.fetchAndAnnouncePrivacyMode().catch(() => undefined);
+            // Leak L21 (2026-05-27): silently drain any feedback envelopes
+            // that landed offline during a previous session. Best-effort —
+            // a failed flush leaves the queue intact for the next start.
+            // Never blocks bootstrap.
+            void this.flushFeedbackQueueOnBootstrap().catch(() => undefined);
         }
         catch (error) {
             this.appendSystemLine(`Could not open Pugi session: ${this.errorMessage(error)}`);
@@ -433,6 +438,21 @@ export class ReplSession {
             // Silent fail - offline / DNS / unauth all collapse to no banner.
         }
     }
+    /**
+     * Leak L21 (2026-05-27): on bootstrap, drain the local feedback
+     * queue silently. Operators who ran `pugi feedback` while offline
+     * see their envelopes flushed on the next online session without
+     * any extra command. The drain is best-effort and never blocks
+     * the REPL — a failed flush leaves the queue intact for the next
+     * bootstrap attempt.
+     */
+    async flushFeedbackQueueOnBootstrap() {
+        const { flushFeedbackQueueSilently } = await import('../../runtime/commands/feedback.js');
+        await flushFeedbackQueueSilently(process.cwd(), {
+            apiUrl: this.options.apiUrl,
+            apiKey: this.options.apiKey,
+        });
+    }
     /**
      * Tear down the SSE stream and stop the reconnect timer. The session
      * id stays valid server-side; `pugi resume <id>` reopens later.
@@ -768,6 +788,89 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'style': {
+                // Leak L18 (2026-05-27): /style [name] [--persist|--reset|--list]
+                // forwards to the shared `runStyleCommand` runner so the slash
+                // + top-level surfaces share one code path. Dynamic import
+                // keeps the dispatcher free of the output-style module graph
+                // until the operator first invokes the slash. The runner's
+                // exit code is captured but NOT propagated to process.exitCode
+                // — REPL session should not die because a bad preset slug was
+                // typed in the input box.
+                try {
+                    const { runStyleCommand } = await import('../../runtime/commands/style.js');
+                    // L18 P1 fix (2026-05-27): writeOutput is invoked SYNCHRONOUSLY
+                    // by `runStyleCommand` for each emitted block. We buffer every
+                    // emission into `lines` and flush after the await resolves so
+                    // that:
+                    //   (1) any future async write path inside the runner cannot
+                    //       drop a tail emission (callback never references the
+                    //       Ink frame directly), and
+                    //   (2) multi-line payloads (e.g. the active-style banner +
+                    //       catalogue table) render one row per visual line in the
+                    //       conversation pane, matching the `/stickers` surface.
+                    const lines = [];
+                    await runStyleCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (_payload, text) => {
+                            for (const raw of text.split('\n')) {
+                                const trimmed = raw.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/style: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/style failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'onboarding': {
+                // Leak L25 (2026-05-27): /onboarding forwards to the shared
+                // `runOnboardingCommand` runner. From inside the REPL we ALWAYS
+                // route through the non-interactive snapshot path — the REPL
+                // already owns the Ink tree and mounting a second Ink wizard
+                // on top would conflict over stdin raw mode. Operators who
+                // want the interactive walk exit the REPL and run
+                // `pugi onboarding` from a fresh shell; the slash surface
+                // surfaces the recap card + hints inline so the operator
+                // sees current values without leaving the session.
+                try {
+                    const { runOnboardingCommand } = await import('../../runtime/commands/onboarding.js');
+                    const { resolveActiveCredential } = await import('../credentials.js');
+                    const credential = resolveActiveCredential();
+                    const lines = [];
+                    await runOnboardingCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        env: process.env,
+                        authPresent: credential !== null,
+                        interactive: false,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/onboarding: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/onboarding failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'doctor': {
                 // L17 (2026-05-27): run the doctor probe sweep inline. We
                 // dynamic-import the runtime/commands/doctor module so the
@@ -839,12 +942,196 @@ export class ReplSession {
                 await this.dispatchCompact('manual');
                 return verdict;
             }
+            case 'share': {
+                // Leak L20 (2026-05-27): /share forwards to the same runner the
+                // top-level `pugi share` command uses. The session module
+                // wires writeOutput to appendSystemLine so the upload result +
+                // privacy gate banner land in the REPL transcript inline.
+                // Confirmation prompt + readline still use stdio because the
+                // Ink frame is held by the input box; operators wanting fully
+                // scripted shares pass `--yes` so no prompt fires.
+                try {
+                    const { runShareCommand } = await import('../../runtime/commands/share.js');
+                    const lines = [];
+                    await runShareCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        cliVersion: this.options.cliVersion,
+                        sessionId: this.localSessionId ?? undefined,
+                        writeOutput: (_payload, text) => {
+                            const trimmed = text.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/share: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/share failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'plan': {
+                // Leak L7: handle `/plan [--back | --persist] [<prompt>]`.
+                // The session module forwards the mode-switch portion to the
+                // shared runtime helper so the workspace + global-config writes
+                // share one code path with `pugi plan`. When the operator
+                // typed a prompt alongside (`/plan write me X`), the prompt is
+                // forwarded through the dispatch FSM exactly as if they had
+                // typed it directly — the only difference is the gate now
+                // refuses write/dispatch tools because the workspace mode flipped
+                // to plan first. Same dynamic-import trick as /permissions to
+                // avoid pulling the engine adapter graph into the dispatcher.
+                try {
+                    const { runPlanCommand } = await import('../../runtime/commands/plan.js');
+                    const lines = [];
+                    await runPlanCommand({ back: verdict.back, persist: verdict.persist }, {
+                        workspaceRoot: process.cwd(),
+                        writeOutput: (line) => {
+                            const trimmed = line.replace(/\n+$/u, '');
+                            if (trimmed.length > 0)
+                                lines.push(trimmed);
+                        },
+                    });
+                    for (const line of lines)
+                        this.appendSystemLine(line);
+                    // Optional one-shot engine dispatch: when the operator typed
+                    // a prompt alongside the slash, route it through the existing
+                    // dispatch path. We rewrite the verdict into a synthetic
+                    // `dispatch` result so the engine sees the user's prompt with
+                    // the plan-mode gate already in place. `--auto-back` is NOT
+                    // honoured in the slash surface today — operators stay in
+                    // plan mode and revert manually with `/plan --back`. The CLI
+                    // top-level `pugi plan --auto-back` exists for scripted use.
+                    if (verdict.prompt.length > 0 && !verdict.back) {
+                        return { kind: 'dispatch', brief: verdict.prompt };
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/plan failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'stickers': {
+                // Leak L33 (2026-05-27): brand-personality gimmick. Delegate to
+                // the shared `runStickersCommand` so the slash + top-level
+                // paths stay single-sourced. The renderer routes the text
+                // through the system pane line-buffer (ascii-only — no fresh
+                // Ink mount) so the gimmick lands as a single contiguous
+                // block в the conversation transcript.
+                try {
+                    const { runStickersCommand } = await import('../../runtime/commands/stickers.js');
+                    // L33 P1 fix (2026-05-27): await the runner even though the
+                    // current implementation is synchronous. Two reasons:
+                    //   (1) future-proofs the call site against the runner growing
+                    //       an async path (e.g. remote stickerpack fetch) — without
+                    //       this await, a returned promise would resolve AFTER we
+                    //       flushed `lines` and the gimmick would render blank, and
+                    //   (2) keeps the slash dispatcher uniform with the other
+                    //       command runners (style, doctor, permissions, plan), all
+                    //       of which are awaited.
+                    const lines = [];
+                    await runStickersCommand({
+                        json: false,
+                        asciiOnly: true,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                const trimmed = line.replace(/\s+$/u, '');
+                                lines.push(trimmed);
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/stickers: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/stickers failed: ${message}`);
+                }
+                return verdict;
+            }
+            case 'feedback': {
+                // Leak L21 (2026-05-27): in-CLI feedback collector. The wizard
+                // mounts a fresh Ink tree (renderFeedbackPrompt) outside the
+                // live REPL input box so the operator can step through
+                // category / rating / comment / context / confirm without
+                // interleaving with persona output. The session module owns
+                // the submit + queue wiring so the slash + top-level CLI
+                // surfaces stay single-sourced through `runFeedbackCommand`.
+                try {
+                    await this.runFeedbackSlash();
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/feedback failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'stub': {
                 this.appendSystemLine(verdict.message);
                 return verdict;
             }
         }
     }
+    /**
+     * Leak L21 (2026-05-27): drive the `/feedback` wizard from inside
+     * the REPL. Mounts the Ink prompt, collects the draft, hands it to
+     * `runFeedbackCommand` (which routes to submit-now or
+     * queue-locally), then writes the operator-facing toast to the
+     * conversation system pane.
+     *
+     * The session module owns the wiring (cwd, cliVersion, apiUrl,
+     * apiKey, transcript provider) so the slash + top-level CLI paths
+     * stay single-sourced through `runFeedbackCommand`.
+     */
+    async runFeedbackSlash() {
+        const { renderFeedbackPrompt } = await import('../../tui/feedback-prompt.js');
+        const { runFeedbackCommand, renderFeedbackToast } = await import('../../runtime/commands/feedback.js');
+        const { submitFeedback, redactSessionContext } = await import('../feedback/submitter.js');
+        const verdict = await renderFeedbackPrompt();
+        if (verdict.cancelled || !verdict.draft) {
+            this.appendSystemLine('Feedback cancelled. Nothing was sent.');
+            return;
+        }
+        // Build a session-context provider that reads the LAST 5 turns
+        // from the live transcript + applies the redactor. Only invoked
+        // when the operator opted in on step 4.
+        const sessionContextProvider = () => {
+            const last5 = this.state.transcript
+                .filter((row) => row.source !== 'system')
+                .slice(-5)
+                .map((row) => ({
+                role: row.source === 'operator' ? 'user' : 'assistant',
+                text: row.text,
+            }));
+            // The workspace context exposed to the session does not carry
+            // a git branch field today, so we omit `gitBranch` here. When
+            // `ReplWorkspaceContext` gains the field we can forward it via
+            // an extra options entry without changing the redactor contract.
+            return redactSessionContext(last5);
+        };
+        const result = await runFeedbackCommand({
+            cwd: process.cwd(),
+            cliVersion: this.options.cliVersion,
+            submit: async (env) => submitFeedback(env, {
+                apiUrl: this.options.apiUrl,
+                apiKey: this.options.apiKey,
+            }),
+            draft: verdict.draft,
+            sessionContext: sessionContextProvider,
+        });
+        this.appendSystemLine(renderFeedbackToast(result));
+    }
     /**
      * Leak L8 (2026-05-27): drive the `/compact` flow from inside the
      * REPL. Reuses the standalone runner so the wire shape + reason
@@ -874,10 +1161,25 @@ export class ReplSession {
                 },
             });
             if (result.status === 'compacted') {
-                // Echo a visible separator into the transcript so the operator
-                // immediately sees where the compaction landed. The Ink banner
-                // renders the row when the session reloads / resumes.
-                this.appendSystemLine(`─── context compacted (${result.turnsBefore} turns → 1 summary, ${trigger}) ───`);
+                // L29 (2026-05-27): emit a structured `compact-boundary` row so
+                // the conversation pane routes the marker through the dedicated
+                // `<CompactBanner />` Ink component (gray, terminal-width
+                // separator) instead of leaking the raw text into a `system`
+                // row. The plain-text body is kept as a deterministic fallback
+                // for non-Ink consumers (snapshot tests, JSON-mode exports).
+                const turnsBefore = result.turnsBefore ?? 0;
+                this.appendRow({
+                    source: 'compact-boundary',
+                    text: `─── context compacted (${turnsBefore} turns → 1 summary, ${trigger}) ───`,
+                    compaction: {
+                        turnsBefore,
+                        trigger,
+                        summaryTokenCount: result.tokensSummarised,
+                        // Fresh in-REPL compaction lands at the head of the
+                        // transcript — no turns have followed it yet.
+                        turnsAgo: 0,
+                    },
+                });
             }
         }
         catch (error) {
@@ -2399,13 +2701,14 @@ export class ReplSession {
         this.appendRow({ source: 'persona', text: stripped, personaSlug });
     }
     appendRow(input) {
-        if (input.text.length === 0)
+        if (input.text.length === 0 && input.source !== 'compact-boundary')
             return;
         const row = {
             id: randomUUID(),
             source: input.source,
             text: input.text,
             personaSlug: input.personaSlug,
+            compaction: input.compaction,
             timestampEpochMs: this.now(),
         };
         const next = this.state.transcript.concat(row).slice(-MAX_TRANSCRIPT_ROWS);
@@ -2484,6 +2787,15 @@ export class ReplSession {
     persistRow(row) {
         if (!this.store)
             return;
+        // L29 (2026-05-27): `compact-boundary` transcript rows are echoes of
+        // the JSONL `compaction` event the compact runner already appended
+        // via `appendCompactBoundary`. Persisting them here would double-
+        // write the marker (and worse, with a stripped payload that lacks
+        // `summary` / `coversUntilOffset`) — `isCompactBoundary` would
+        // reject the duplicate but `applyCompactMask` would still index off
+        // the wrong offset. Skip the write.
+        if (row.source === 'compact-boundary')
+            return;
         const kind = row.source === 'operator' ? 'user'
             : row.source === 'persona' ? 'persona'
                 : 'system';
@@ -2536,6 +2848,13 @@ export class ReplSession {
             if (row)
                 rows.push(row);
         }
+        // L29 (2026-05-27): tag each compact-boundary row with the count of
+        // operator + persona turns that landed AFTER it in the replay
+        // window. The banner reads `turnsAgo` to render the "N turns ago"
+        // suffix so a long session that resumes across multiple compactions
+        // stays self-orienting. System rows + sibling boundaries are NOT
+        // counted — they are chrome, not operator-visible turns.
+        annotateBoundaryTurnsAgo(rows);
         // Cap at MAX_TRANSCRIPT_ROWS - the same cap appendRow uses so the
         // window math stays consistent post-restore.
         const capped = rows.slice(-MAX_TRANSCRIPT_ROWS);
@@ -2720,26 +3039,70 @@ function eventToTranscriptRow(event) {
         };
     }
     if (event.kind === 'compaction') {
-        // Leak L8: render the marker as a system separator line on
-        // replay. The full summary text is intentionally NOT inlined here
-        // (a 2k-token summary in the transcript would defeat the purpose
-        // of compacting); the operator sees the "context compacted"
-        // banner and can run `/context` to inspect the marker payload
-        // when they want the details.
+        // L8 + L29 (2026-05-27): render the marker as a structured
+        // `compact-boundary` row so the renderer can route it to the
+        // dedicated <CompactBanner /> Ink component. The full summary text
+        // is intentionally NOT inlined here (a 2k-token summary in the
+        // transcript would defeat the purpose of compacting); the operator
+        // sees the "context compacted" banner and can run `/context` to
+        // inspect the marker payload when they want the details. The plain
+        // text fallback stays in place for non-Ink consumers (snapshot
+        // tests, future JSON exports).
         const compactionPayload = (event.payload ?? null);
         const trigger = compactionPayload?.trigger === 'auto' ? 'auto' : 'manual';
         const turns = typeof compactionPayload?.summaryTurnsBefore === 'number'
             ? compactionPayload.summaryTurnsBefore
             : 0;
+        const tokens = typeof compactionPayload?.summaryTokenCount === 'number'
+            ? compactionPayload.summaryTokenCount
+            : undefined;
         return {
             id: randomUUID(),
-            source: 'system',
+            source: 'compact-boundary',
             text: `─── context compacted (${turns} turns → 1 summary, ${trigger}) ───`,
+            compaction: {
+                turnsBefore: turns,
+                trigger,
+                summaryTokenCount: tokens,
+            },
             timestampEpochMs: event.t,
         };
     }
     return null;
 }
+/**
+ * L29 (2026-05-27): walk a chronological transcript window and stamp
+ * every `compact-boundary` row's `compaction.turnsAgo` with the count of
+ * operator + persona rows that land AFTER it. The annotation runs in
+ * place on the array — boundaries earlier in time get larger `turnsAgo`
+ * values, the boundary at the head of the window gets zero. System rows
+ * and sibling boundaries are excluded from the count (they are chrome,
+ * not operator-visible turns).
+ *
+ * Exported so a future spec can lock the contract and so the in-REPL
+ * `/compact` path can reuse the same counter on live appends if it ever
+ * needs to. Pure function (mutates only the input slice).
+ */
+export function annotateBoundaryTurnsAgo(rows) {
+    let trailingTurns = 0;
+    for (let i = rows.length - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (row.source === 'operator' || row.source === 'persona') {
+            trailingTurns += 1;
+            continue;
+        }
+        if (row.source === 'compact-boundary') {
+            // Re-assign with the live `turnsAgo`. Carry forward the existing
+            // structured payload so we never lose the trigger / token-count
+            // data the renderer needs.
+            const compaction = row.compaction ?? { turnsBefore: 0, trigger: 'manual' };
+            rows[i] = {
+                ...row,
+                compaction: { ...compaction, turnsAgo: trailingTurns },
+            };
+        }
+    }
+}
 /**
  * Heuristic: does this text contain Markdown structures that benefit
  * from atomic grouping? Code fences, bullet lists, numbered lists,

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

@@ -78,14 +78,20 @@ export const SLASH_COMMAND_HELP = Object.freeze([
     // 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)', 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: 'budget', args: '', gloss: 'Show usage budget', 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: 'onboarding', args: '[--reset|--non-interactive]', gloss: 'First-run wizard — auth / mode / style / MCP / telemetry (leak L25)', 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: '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: 'quit', args: '', gloss: 'Exit the REPL', group: 'Meta' },
 ]);
 /**
@@ -317,6 +323,54 @@ export function parseSlashCommand(input) {
             // 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 'mcp': {
             // β4 Sl7: tokenize the tail. Empty tail -> `list` (matches CLI).
             // Quoting / shell-escapes are NOT supported — the slash surface is
@@ -325,6 +379,26 @@ export function parseSlashCommand(input) {
             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 '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 'doctor':
         case 'health': {
             // L17 (2026-05-27): run the probe sweep inline. Tail is ignored —
@@ -341,6 +415,30 @@ export function parseSlashCommand(input) {
             // fresh shell.
             return { kind: 'compact' };
         }
+        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 'memory':
         case 'config':
         case 'budget':

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 +