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

package/dist/core/prd-check/parser.js

@@ -0,0 +1,215 @@
+/**
+ * PRD parser — Pugi α7 Wave 6 (`/prd-check`, 2026-05-27).
+ *
+ * Reads a markdown PRD file and extracts the acceptance-criteria
+ * section into a list of verifiable criteria. The parser is
+ * intentionally narrow: it owns ONE function, accepts raw markdown
+ * source as a string (no fs I/O), and returns a structured list the
+ * verifier module can fan out over.
+ *
+ * Why two phases (parse → verify) instead of a single pass:
+ *
+ *   - keeps the parser deterministic + fast (pure string in, JSON
+ *     out — trivial to unit-test without touching the filesystem)
+ *
+ *   - lets the reporter render the criterion list even when every
+ *     verifier fails, so operators see WHAT failed before WHY
+ *
+ *   - mirrors the L17 doctor split: `probe-runner` runs a set of
+ *     probe descriptors → identical contract here, just for PRD
+ *     acceptance items instead of environment probes
+ *
+ * Heading recognition is tolerant by design: PRD authors use both
+ * `## Acceptance Criteria` and `## Success Criteria`, sometimes with
+ * a trailing colon, sometimes inside an h3. We accept any h2/h3
+ * matching either label (case-insensitive). The first matching
+ * section wins; subsequent matches are ignored so a PRD with both
+ * sections does not double-count items.
+ *
+ * Item recognition supports two shapes documented in the wave-6
+ * spec:
+ *
+ *   1. numbered lists      `1. <text>` / `1) <text>`
+ *   2. markdown checklists `- [ ] <text>` / `- [x] <text>`
+ *
+ * Either shape may include inline mentions the verifier extracts:
+ * file paths (`apps/foo/bar.ts`), test specs (`*.spec.ts`),
+ * route declarations (`GET /api/x`), CLI commands (`pugi prd-check`),
+ * and doc references (`docs/foo.md`). The parser captures these
+ * verbatim into `mentions` so the verifier module can fan checks
+ * without re-tokenising the prose.
+ */
+const ACCEPTANCE_HEADING_RE = /^(#{2,3})\s+(acceptance criteria|success criteria|deliverables)\b\s*:?\s*$/i;
+const ANY_HEADING_RE = /^(#{1,6})\s+\S/;
+const TITLE_HEADING_RE = /^#\s+(.+?)\s*$/;
+const NUMBERED_ITEM_RE = /^(\s*)(\d+)[\.)]\s+(.+?)\s*$/;
+const CHECKLIST_ITEM_RE = /^(\s*)-\s+\[([ xX])\]\s+(.+?)\s*$/;
+/**
+ * Public entry: parse a markdown PRD source into `ParsedPrd`. Pure
+ * function — no filesystem, no logging. The CLI handler is
+ * responsible for reading the file and forwarding the contents.
+ */
+export function parsePrd(source) {
+    const lines = source.split(/\r?\n/);
+    const title = extractTitle(lines);
+    const range = findAcceptanceRange(lines);
+    if (!range) {
+        return { title, hasAcceptanceSection: false, criteria: [] };
+    }
+    const sectionLines = lines.slice(range.start, range.end);
+    const criteria = extractCriteria(sectionLines);
+    return { title, hasAcceptanceSection: true, criteria };
+}
+/**
+ * Extract verifiable mentions from a criterion text. Exported for
+ * the verifier spec so tests can drive mention classification
+ * without running the full parser.
+ */
+export function extractMentions(text) {
+    const mentions = [];
+    const seen = new Set();
+    const push = (key, mention) => {
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        mentions.push(mention);
+    };
+    // 1) Routes — `GET /api/path`, `POST /foo`, etc. Recognised
+    //    BEFORE file paths because the trailing `/` could otherwise
+    //    be mis-classified.
+    const routeRe = /\b(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\/[A-Za-z0-9_./:\-]+)/g;
+    for (const match of text.matchAll(routeRe)) {
+        const method = match[1].toUpperCase();
+        const path = match[2];
+        push(`route:${method} ${path}`, { kind: 'route', method, path });
+    }
+    // 2) Backtick-wrapped tokens — most reliable signal. The parser
+    //    inspects each token and decides whether it is a path, a test
+    //    spec, a CLI command, or a route.
+    const backtickRe = /`([^`\n]+)`/g;
+    for (const match of text.matchAll(backtickRe)) {
+        const raw = match[1].trim();
+        classifyToken(raw, push);
+    }
+    // 3) Bare paths with at least one slash + an extension. Authors
+    //    sometimes forget the backticks; we still surface the file
+    //    so the verifier can attempt the check.
+    const barePathRe = /(?<![A-Za-z0-9])((?:[a-zA-Z0-9_.\-]+\/)+[a-zA-Z0-9_.\-]+\.[a-zA-Z0-9]{1,6})/g;
+    for (const match of text.matchAll(barePathRe)) {
+        const path = match[1];
+        classifyPath(path, push);
+    }
+    return mentions;
+}
+function classifyToken(raw, push) {
+    const trimmed = raw.replace(/[,;.]+$/u, '').trim();
+    if (trimmed.length === 0)
+        return;
+    // Route shape inside backticks (`GET /api/x`).
+    const routeMatch = trimmed.match(/^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)\s+(\/[A-Za-z0-9_./:\-]+)$/u);
+    if (routeMatch) {
+        const method = routeMatch[1].toUpperCase();
+        const path = routeMatch[2];
+        push(`route:${method} ${path}`, { kind: 'route', method, path });
+        return;
+    }
+    // Pugi command — `pugi <name>` or `/<name>`. Slash form covers
+    // REPL slash commands; pugi form covers shell commands.
+    const pugiCmdMatch = trimmed.match(/^pugi\s+([a-z][a-z0-9-]*)(?:\s+.*)?$/u);
+    if (pugiCmdMatch) {
+        const name = pugiCmdMatch[1];
+        push(`command:${name}`, { kind: 'command', name });
+        return;
+    }
+    const slashCmdMatch = trimmed.match(/^\/([a-z][a-z0-9-]*)$/u);
+    if (slashCmdMatch) {
+        const name = slashCmdMatch[1];
+        push(`command:${name}`, { kind: 'command', name });
+        return;
+    }
+    // Path shape — must contain at least one `/` AND an extension.
+    if (trimmed.includes('/') && /\.[a-zA-Z0-9]{1,6}$/.test(trimmed)) {
+        classifyPath(trimmed, push);
+    }
+}
+function classifyPath(path, push) {
+    if (/\.spec\.[a-z]+$|\.test\.[a-z]+$/u.test(path)) {
+        push(`test:${path}`, { kind: 'test', path });
+        return;
+    }
+    if (/^docs?\//u.test(path) || /\.md$/u.test(path)) {
+        push(`doc:${path}`, { kind: 'doc', path });
+        return;
+    }
+    push(`file:${path}`, { kind: 'file', path });
+}
+function extractTitle(lines) {
+    for (const line of lines) {
+        const match = line.match(TITLE_HEADING_RE);
+        if (match) {
+            return match[1].trim();
+        }
+    }
+    return null;
+}
+function findAcceptanceRange(lines) {
+    let startIdx = -1;
+    let startHeadingLevel = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        const match = line.match(ACCEPTANCE_HEADING_RE);
+        if (match) {
+            startIdx = i + 1;
+            startHeadingLevel = match[1].length;
+            break;
+        }
+    }
+    if (startIdx === -1)
+        return null;
+    let endIdx = lines.length;
+    for (let i = startIdx; i < lines.length; i += 1) {
+        const line = lines[i];
+        const headingMatch = line.match(ANY_HEADING_RE);
+        if (!headingMatch)
+            continue;
+        const level = headingMatch[1].length;
+        if (level <= startHeadingLevel) {
+            endIdx = i;
+            break;
+        }
+    }
+    return { start: startIdx, end: endIdx };
+}
+function extractCriteria(sectionLines) {
+    const out = [];
+    let index = 0;
+    for (const line of sectionLines) {
+        const checklistMatch = line.match(CHECKLIST_ITEM_RE);
+        if (checklistMatch) {
+            index += 1;
+            const marker = checklistMatch[2].toLowerCase();
+            const text = checklistMatch[3];
+            out.push({
+                index,
+                text,
+                preChecked: marker === 'x',
+                mentions: extractMentions(text),
+            });
+            continue;
+        }
+        const numberedMatch = line.match(NUMBERED_ITEM_RE);
+        if (numberedMatch) {
+            index += 1;
+            const text = numberedMatch[3];
+            out.push({
+                index,
+                text,
+                preChecked: false,
+                mentions: extractMentions(text),
+            });
+            continue;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=parser.js.map

package/dist/core/prd-check/reporter.js

@@ -0,0 +1,127 @@
+/**
+ * PRD-check reporter — Pugi α7 Wave 6 (`/prd-check`, 2026-05-27).
+ *
+ * Turns a list of `VerifiedCriterion` into either a plain-text
+ * table (matches the L17 doctor renderer layout for visual
+ * consistency) OR a structured JSON envelope for scripted callers.
+ *
+ * The reporter is intentionally render-only — it does not perform
+ * any verification work. The verifier module decides PASS / FAIL /
+ * SKIPPED; the reporter only formats those verdicts. This keeps
+ * the JSON envelope deterministic + diff-friendly between runs.
+ *
+ * Exit-code policy:
+ *
+ *   - `healthy`  -> every criterion PASS or SKIPPED. exit 0.
+ *   - `failing`  -> at least one FAIL. exit 1.
+ *   - `unparsed` -> the PRD had no acceptance section. exit 2
+ *                   (operator authored a stub but never filled it
+ *                   in — distinct signal from "criteria don't
+ *                   verify yet" so CI can route differently).
+ */
+/**
+ * Build the JSON envelope. Pure transform — no fs, no clock. The
+ * CLI handler wraps this in the writeOutput sink.
+ */
+export function buildEnvelope(input) {
+    const counts = {
+        pass: 0,
+        fail: 0,
+        skipped: 0,
+    };
+    for (const v of input.verified) {
+        counts[v.status] += 1;
+    }
+    const overall = computeOverall(input.hasAcceptanceSection, counts);
+    return {
+        command: 'prd-check',
+        prdPath: input.prdPath,
+        title: input.title,
+        overall,
+        counts,
+        criteria: input.verified.map((v) => ({
+            index: v.criterion.index,
+            text: v.criterion.text,
+            status: v.status,
+            results: v.results.map((r) => ({
+                kind: r.mention.kind,
+                target: mentionTarget(r.mention),
+                status: r.status,
+                evidence: r.evidence,
+            })),
+        })),
+    };
+}
+/** Exit code for the resolved overall verdict. */
+export function exitCodeFor(overall) {
+    switch (overall) {
+        case 'healthy':
+            return 0;
+        case 'failing':
+            return 1;
+        case 'unparsed':
+            return 2;
+    }
+}
+/**
+ * Plain-text renderer. Mirrors the L17 doctor table for visual
+ * consistency — 4 columns: # / STATUS / CRITERION / EVIDENCE. The
+ * criterion column is truncated to 60 chars so narrow terminals
+ * stay readable; the full text lives in the JSON envelope for
+ * scripted callers that want every byte.
+ */
+export function renderTable(envelope) {
+    const lines = [];
+    const titlePart = envelope.title ? ` — ${envelope.title}` : '';
+    lines.push(`Pugi PRD-check${titlePart}`);
+    lines.push('='.repeat(50));
+    lines.push(`Source: ${envelope.prdPath}`);
+    lines.push('');
+    if (envelope.overall === 'unparsed') {
+        lines.push('No acceptance-criteria section found in PRD.');
+        lines.push('');
+        lines.push('Expected one of:');
+        lines.push('  ## Acceptance Criteria');
+        lines.push('  ## Success Criteria');
+        lines.push('  ## Deliverables');
+        return lines.join('\n');
+    }
+    if (envelope.criteria.length === 0) {
+        lines.push('Acceptance section present but contains 0 items.');
+        return lines.join('\n');
+    }
+    for (const c of envelope.criteria) {
+        const status = c.status.toUpperCase().padEnd(7, ' ');
+        const truncated = c.text.length > 60 ? `${c.text.slice(0, 57)}...` : c.text;
+        lines.push(`#${String(c.index).padStart(2, ' ')}  ${status}  ${truncated}`);
+        for (const r of c.results) {
+            const subStatus = r.status.toUpperCase().padEnd(7, ' ');
+            lines.push(`        ${subStatus}  ${r.evidence}`);
+        }
+    }
+    lines.push('');
+    const { pass, fail, skipped } = envelope.counts;
+    const summary = envelope.overall === 'healthy' ? 'HEALTHY' : envelope.overall === 'failing' ? 'FAILING' : 'UNPARSED';
+    lines.push(`${fail} fail · ${pass} pass · ${skipped} skipped. Overall: ${summary}`);
+    return lines.join('\n');
+}
+function computeOverall(hasAcceptanceSection, counts) {
+    if (!hasAcceptanceSection)
+        return 'unparsed';
+    if (counts.fail > 0)
+        return 'failing';
+    return 'healthy';
+}
+function mentionTarget(mention) {
+    switch (mention.kind) {
+        case 'file':
+        case 'test':
+        case 'doc':
+            return mention.path;
+        case 'command':
+            return mention.name;
+        case 'route':
+            return `${mention.method} ${mention.path}`;
+    }
+}
+//# sourceMappingURL=reporter.js.map

package/dist/core/prd-check/verifiers.js

@@ -0,0 +1,223 @@
+/**
+ * PRD criterion verifiers — Pugi α7 Wave 6 (`/prd-check`, 2026-05-27).
+ *
+ * Given a `ParsedCriterion` from `parser.ts`, run a set of built-in
+ * checks against the repository workspace and return a
+ * `VerifiedCriterion` with a per-criterion verdict + per-mention
+ * evidence trail. The module owns the file-system + grep surface
+ * the parser deliberately avoided.
+ *
+ * Verdict semantics (mirror the doctor probe contract so the
+ * reporter can render both with the same column layout):
+ *
+ *   - PASS    : at least one mention verified AND every attempted
+ *               verifier passed
+ *   - FAIL    : at least one verifier failed (missing file, empty
+ *               doc, command not in registry, etc.)
+ *   - SKIPPED : no verifiable mentions in the criterion. The
+ *               criterion is preserved in the report so the
+ *               operator sees it, but it does not gate the verdict.
+ *
+ * Each `MentionResult` carries an evidence string the reporter
+ * shows next to the criterion. For PASS we render the resolved
+ * absolute path or matched line; for FAIL we render the missing
+ * artifact identifier so the operator can fix it directly.
+ *
+ * The verifier deps are injected (existsSync, readFileSync, …) so
+ * the spec can drive every branch without touching the real disk.
+ * The default-bound variant `runDefaultVerifiers` plugs the real
+ * Node fs helpers in for the CLI handler.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, resolve } from 'node:path';
+/**
+ * Top-level verify-one-criterion entry. Walks the mention list,
+ * dispatches each to the right verifier, then computes the
+ * roll-up. Pure with respect to `deps` — no globals touched.
+ */
+export function verifyCriterion(criterion, deps) {
+    if (criterion.mentions.length === 0) {
+        return {
+            criterion,
+            status: 'skipped',
+            results: [],
+        };
+    }
+    const results = [];
+    for (const mention of criterion.mentions) {
+        results.push(verifyMention(mention, deps));
+    }
+    const status = rollUp(results);
+    return { criterion, status, results };
+}
+/** Verify a whole PRD's worth of criteria. */
+export function verifyAll(criteria, deps) {
+    return criteria.map((c) => verifyCriterion(c, deps));
+}
+function verifyMention(mention, deps) {
+    switch (mention.kind) {
+        case 'file':
+            return verifyFile(mention, deps);
+        case 'test':
+            return verifyTest(mention, deps);
+        case 'doc':
+            return verifyDoc(mention, deps);
+        case 'command':
+            return verifyCommand(mention, deps);
+        case 'route':
+            return verifyRoute(mention, deps);
+    }
+}
+function verifyFile(mention, deps) {
+    const absolute = deps.resolveWorkspacePath(mention.path);
+    if (deps.existsSync(absolute)) {
+        return {
+            mention,
+            status: 'pass',
+            evidence: `file present (${mention.path})`,
+        };
+    }
+    return {
+        mention,
+        status: 'fail',
+        evidence: `file missing (${mention.path})`,
+    };
+}
+function verifyTest(mention, deps) {
+    const absolute = deps.resolveWorkspacePath(mention.path);
+    if (!deps.existsSync(absolute)) {
+        return {
+            mention,
+            status: 'fail',
+            evidence: `spec missing (${mention.path})`,
+        };
+    }
+    let body;
+    try {
+        body = deps.readFileSync(absolute);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            mention,
+            status: 'fail',
+            evidence: `spec unreadable: ${message}`,
+        };
+    }
+    // Count `test(`, `it(`, and `describe(...).it(` blocks. The
+    // matcher is permissive — any of the three counts because the
+    // PRD only cares whether the spec asserts anything at all.
+    const matches = body.match(/\b(it|test)\s*\(/g);
+    if (!matches || matches.length === 0) {
+        return {
+            mention,
+            status: 'fail',
+            evidence: `spec present but has 0 test()/it() blocks`,
+        };
+    }
+    return {
+        mention,
+        status: 'pass',
+        evidence: `spec present with ${matches.length} block(s)`,
+    };
+}
+function verifyDoc(mention, deps) {
+    const absolute = deps.resolveWorkspacePath(mention.path);
+    if (!deps.existsSync(absolute)) {
+        return {
+            mention,
+            status: 'fail',
+            evidence: `doc missing (${mention.path})`,
+        };
+    }
+    let body;
+    try {
+        body = deps.readFileSync(absolute);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            mention,
+            status: 'fail',
+            evidence: `doc unreadable: ${message}`,
+        };
+    }
+    const trimmed = body.trim();
+    if (trimmed.length < 100) {
+        return {
+            mention,
+            status: 'fail',
+            evidence: `doc present but too short (${trimmed.length} chars, < 100)`,
+        };
+    }
+    return {
+        mention,
+        status: 'pass',
+        evidence: `doc present (${trimmed.length} chars)`,
+    };
+}
+function verifyCommand(mention, deps) {
+    if (deps.isKnownCommand(mention.name)) {
+        return {
+            mention,
+            status: 'pass',
+            evidence: `command \`${mention.name}\` registered`,
+        };
+    }
+    return {
+        mention,
+        status: 'fail',
+        evidence: `command \`${mention.name}\` not found in CLI registry`,
+    };
+}
+function verifyRoute(mention, deps) {
+    if (deps.hasRoute(mention.method, mention.path)) {
+        return {
+            mention,
+            status: 'pass',
+            evidence: `route ${mention.method} ${mention.path} registered`,
+        };
+    }
+    return {
+        mention,
+        status: 'fail',
+        evidence: `route ${mention.method} ${mention.path} not found`,
+    };
+}
+function rollUp(results) {
+    if (results.length === 0)
+        return 'skipped';
+    const anyFail = results.some((r) => r.status === 'fail');
+    if (anyFail)
+        return 'fail';
+    const anyPass = results.some((r) => r.status === 'pass');
+    return anyPass ? 'pass' : 'skipped';
+}
+/**
+ * Default verifier deps bound to real fs + a CLI-command predicate
+ * + a grep-based route locator. The CLI handler passes the
+ * workspace root + the known-command list at call time.
+ */
+export function createDefaultDeps(options) {
+    return {
+        resolveWorkspacePath: (relative) => {
+            if (isAbsolute(relative))
+                return relative;
+            return resolve(options.workspaceRoot, relative);
+        },
+        existsSync: (path) => existsSync(path),
+        readFileSync: (path) => readFileSync(path, 'utf8'),
+        isKnownCommand: (name) => options.knownCommands.has(name),
+        hasRoute: () => {
+            // Best-effort default: the wave-6 PRD says the route verifier
+            // is "best-effort grep of controllers". Since the workspace
+            // layout varies per repo, the CLI handler injects a project
+            // -aware implementation when one is available; the default
+            // stays conservative and reports `fail` so the reporter
+            // surfaces the missing-verifier signal instead of silently
+            // passing.
+            return false;
+        },
+    };
+}
+//# sourceMappingURL=verifiers.js.map

package/dist/core/repl/session.js

@@ -36,6 +36,7 @@ import { webFetchTool } from '../../tools/web-fetch.js';
 import { loadSettings } from '../settings.js';
 import { getJobRegistry } from '../jobs/registry.js';
 import { applyCompactMask } from '../compact/buffer-rewriter.js';
+import { applyRewindMask } from '../checkpoint/rewinder.js';
 import { evaluateAutoCompact } from '../compact/auto-trigger.js';
 import { estimateTokensInMany } from '../compact/token-counter.js';
 import { extractAskTags, extractPlanReviewTags, signatureForAsk, } from './ask.js';
@@ -978,6 +979,50 @@ export class ReplSession {
                 }
                 return verdict;
             }
+            case 'prd-check': {
+                // Wave 6 (2026-05-27): forward to the same handler the shell
+                // surface uses so the verdict is identical between
+                // `/prd-check` and `pugi prd-check`. Dynamic-import the
+                // module to keep the parser + verifier graph out of the
+                // REPL hot path.
+                try {
+                    const { parsePrdCheckArgs, runPrdCheckCommand } = await import('../../runtime/commands/prd-check.js');
+                    const parsed = parsePrdCheckArgs(verdict.args, { jsonDefault: false });
+                    if (!parsed.ok) {
+                        this.appendSystemLine(`/prd-check: ${parsed.error}`);
+                        return verdict;
+                    }
+                    const lines = [];
+                    await runPrdCheckCommand({
+                        cwd: process.cwd(),
+                        ...(parsed.prdPath !== undefined ? { prdPath: parsed.prdPath } : {}),
+                        flags: parsed.flags,
+                        // The REPL slash does not have a snapshot of the CLI
+                        // command registry, so we pass an empty set; the
+                        // command:<name> verifier will report FAIL for now.
+                        // This is a deliberate trade-off — the slash surface
+                        // primarily exists for quick eyeball checks during a
+                        // session; the shell surface (which DOES inject the
+                        // full registry) is the canonical gate.
+                        knownCommands: new Set(),
+                        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('/prd-check: no output.');
+                    }
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/prd-check failed: ${message}`);
+                }
+                return verdict;
+            }
             case 'permissions': {
                 // Leak L6: handle the `/permissions [mode] [--persist]` flow.
                 // The session module forwards to the runtime helper so the
@@ -1015,6 +1060,37 @@ export class ReplSession {
                 await this.dispatchCompact('manual');
                 return verdict;
             }
+            case 'rewind': {
+                // Leak L9 (2026-05-27): /rewind appends an append-only
+                // tombstone marker that rolls the conversation back to a
+                // checkpoint. The actual replay-mask is advisory — the on-disk
+                // events stay durable so `pugi sessions undo-rewind` can
+                // reverse the operation. We forward to the same runner the
+                // top-level `pugi rewind` command uses to keep the surface
+                // single-sourced. Dynamic import avoids pulling the checkpoint
+                // graph into the dispatcher at module load.
+                if (!this.store || !this.localSessionId) {
+                    this.appendSystemLine('Local session store is disabled — /rewind is unavailable.');
+                    return verdict;
+                }
+                try {
+                    const { runRewindCommand } = await import('../../runtime/commands/rewind.js');
+                    await runRewindCommand(verdict.args, {
+                        workspaceRoot: process.cwd(),
+                        sessionId: this.localSessionId,
+                        store: this.store,
+                        writeOutput: (_payload, text) => {
+                            if (text.length > 0)
+                                this.appendSystemLine(text);
+                        },
+                    });
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    this.appendSystemLine(`/rewind failed: ${message}`);
+                }
+                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
@@ -3032,7 +3108,12 @@ export class ReplSession {
         // condensed into the boundary's `keptTailTurns + marker` slice so
         // the post-resume transcript starts at the most-recent context
         // floor rather than re-playing the full pre-compaction history.
-        const masked = applyCompactMask(events);
+        //
+        // Leak L9 (2026-05-27): then apply rewind-marker masking. Any
+        // event inside an active rewind range is stripped from the
+        // visible transcript; the on-disk events stay durable so a
+        // follow-up `pugi sessions undo-rewind` can restore them.
+        const masked = applyRewindMask(applyCompactMask(events));
         const rows = [];
         for (const event of masked) {
             const row = eventToTranscriptRow(event);