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

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,161 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'theme': {
+                // Leak L30 (2026-05-27): /theme [name] [--persist|--reset|--list]
+                // forwards to the shared `runThemeCommand` runner. Same async
+                // buffer-then-flush pattern as `/style` so a future async
+                // write path inside the runner cannot drop a tail emission
+                // and so multi-line payloads (banner + preview table) land
+                // one row per visual line in the conversation pane.
+                try {
+                    const { runThemeCommand } = await import('../../runtime/commands/theme.js');
+                    const lines = [];
+                    await runThemeCommand(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('/theme: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/theme failed: ${message}`);
+                }
+                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 'vim': {
+                // Leak L26 (2026-05-27): /vim forwards to the shared
+                // `runVimCommand` runner so the slash + top-level surfaces
+                // stay single-sourced. Dynamic import mirrors /style so the
+                // dispatcher does not drag the vim module graph into every
+                // keystroke.
+                //
+                // The runner mutates `~/.pugi/config.json::vimMode`; the
+                // active REPL session does NOT live-pick-up the flip (the
+                // VimInput wrapper is mounted once at REPL boot). Operators
+                // get a hint that the next session will reflect the change.
+                // A follow-up sprint can plumb a state-store subscriber so
+                // the flip takes effect mid-session.
+                try {
+                    const { runVimCommand } = await import('../../runtime/commands/vim.js');
+                    const lines = [];
+                    await runVimCommand(verdict.args, {
+                        env: process.env,
+                        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('/vim: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/vim 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 +1014,231 @@ 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 'release-notes': {
+                // Leak L24 (2026-05-27): changelog diff between the operator's
+                // last-seen + installed CLI versions. Delegate к the shared
+                // `runReleaseNotesCommand` runner so the slash + top-level
+                // paths stay single-sourced. The renderer collects each line
+                // into the system pane via `appendSystemLine` — no fresh Ink
+                // mount, no boxed render. `--reset` is honoured via the
+                // `verdict.reset` field parsed in slash-commands.ts.
+                try {
+                    const { runReleaseNotesCommand, defaultReleaseNotesHome } = await import('../../runtime/commands/release-notes.js');
+                    const lines = [];
+                    runReleaseNotesCommand({
+                        home: defaultReleaseNotesHome(),
+                        json: false,
+                        reset: verdict.reset,
+                        writeOutput: (_payload, text) => {
+                            for (const line of text.split('\n')) {
+                                lines.push(line.replace(/\s+$/u, ''));
+                            }
+                        },
+                    });
+                    if (lines.length === 0) {
+                        this.appendSystemLine('/release-notes: no output.');
+                    }
+                    else {
+                        for (const line of lines)
+                            this.appendSystemLine(line);
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/release-notes 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 +1268,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 +2808,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 +2894,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 +2955,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 +3146,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,