@pugi/cli 0.1.0-beta.7 → 0.1.0-beta.87

package/dist/skills/bundled/remember.js

@@ -0,0 +1,383 @@
+/**
+ * `pugi remember` — proposal-first memory curator.
+ *
+ * Bundled skill, batch 1 (backlog). Today `pugi memory write` (and
+ * the auto-extractor that fires from MEMORY: markers in chat) writes
+ * silently — operators occasionally find unwanted facts persisted with
+ * no chance to veto. This skill flips the surface: it inspects recent
+ * memory candidates, classifies each as project / personal / temp, and
+ * presents EVERY proposed write to the operator BEFORE persisting.
+ * Nothing is queued or sent to the admin-api until the operator
+ * approves it.
+ *
+ * # Three classification buckets
+ *
+ *  - project  — codebase / ADR / architecture / convention.
+ *                Targets `kind` = `architecture` | `pattern` | `bug`.
+ *  - personal — operator-specific preference, workflow, identity.
+ *                Targets `kind` = `preference` | `workflow` | `fact`.
+ *  - temp     — short-lived note, scheduled for `forgetAfter`.
+ *                Pugi heuristic: anything that looks transient
+ *                (timestamps, log paste, single-session note).
+ *
+ * # Surface
+ *
+ * Two flows:
+ *
+ *  1. **Auto-classify** an inline list of candidate strings (CLI args
+ *     or `--input <path>`). For each one Pugi emits a structured
+ *     proposal. Operator answers `y`/`n`/`s` (yes / no / skip) per
+ *     proposal. `y` enqueues via the existing `enqueueMemoryOp` API.
+ *
+ *  2. **Review queue** (`pugi remember review`) — walks any pending
+ *     memory queue lines and lets the operator drop entries before
+ *     `pugi memory sync` ships them.
+ *
+ * # Opt-in
+ *
+ * `pugi memory write …` keeps its current behaviour (immediate enqueue,
+ * no prompt). The proposal-first mode requires either:
+ *
+ *  - explicit `pugi remember <text>...` invocation, OR
+ *  - `pugi memory write --curate` flag (added in this batch; the
+ *    curator runs in proposal-first mode).
+ *
+ * # Provenance
+ *
+ * Inspired by the the upstream tool bundled-skills pattern (intel from
+ * leak-research memos, clean-room TS). No upstream code reused.
+ */
+import { readFileSync } from 'node:fs';
+import { PERSONA_MEMORY_KINDS, enqueueMemoryOp, } from '../../core/memory-sync/queue.js';
+const DEFAULT_PERSONA = 'mira';
+function parseFlags(args) {
+    const flags = {
+        json: false,
+        personaSlug: DEFAULT_PERSONA,
+        inputPath: null,
+    };
+    const positionals = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--json') {
+            flags.json = true;
+            continue;
+        }
+        if (arg === '--persona') {
+            const next = args[i + 1];
+            if (next === undefined)
+                return { flags, positionals, error: '--persona requires a value' };
+            flags.personaSlug = next;
+            i += 1;
+            continue;
+        }
+        if (arg === '--input') {
+            const next = args[i + 1];
+            if (next === undefined)
+                return { flags, positionals, error: '--input requires a path' };
+            flags.inputPath = next;
+            i += 1;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            return { flags, positionals, error: 'help' };
+        }
+        if (arg.startsWith('--')) {
+            return { flags, positionals, error: `unknown flag: ${arg}` };
+        }
+        positionals.push(arg);
+    }
+    return { flags, positionals, error: null };
+}
+/**
+ * Single-line classifier. The signal is intentionally crude (regex +
+ * keyword bags) so the behaviour is deterministic and explainable —
+ * the operator approves each proposal anyway. Edge cases land in
+ * `personal` by default because a stray project fact persisting under
+ * the operator's profile is less corrosive than a stray personal note
+ * leaking into a project's memory.
+ *
+ * Public for direct test coverage.
+ */
+export function classifyMemoryCandidate(raw, now) {
+    const trimmed = raw.trim();
+    if (trimmed === '')
+        return null;
+    if (trimmed.length > 4000)
+        return null;
+    const lower = trimmed.toLowerCase();
+    const projectSignals = [
+        /\badr-?\d+\b/,
+        /\bmigration\b/,
+        /\bschema\b/,
+        /\bendpoint\b/,
+        /\barchitecture\b/,
+        /\bconvention\b/,
+        /\bbug\b/,
+        /\bbroken\b/,
+        /\bpattern\b/,
+        /\bworkspace\b/,
+        /\bpackage\b/,
+        /\bmodule\b/,
+    ];
+    const personalSignals = [
+        /\bi (prefer|like|hate|always|never)\b/,
+        /\bmy (workflow|setup|laptop|terminal|editor)\b/,
+        /\bin russian\b/,
+        /\bin ukrainian\b/,
+        /\bdo not ask\b/,
+        /\bdon't ask\b/,
+    ];
+    const tempSignals = [
+        /\btoday\b/,
+        /\btomorrow\b/,
+        /\bnow\b/,
+        /\btemporary\b/,
+        /\bfor now\b/,
+        /\bremind me\b/,
+        /\bthis session\b/,
+    ];
+    const matchedProject = projectSignals.some((rx) => rx.test(lower));
+    const matchedPersonal = personalSignals.some((rx) => rx.test(lower));
+    const matchedTemp = tempSignals.some((rx) => rx.test(lower));
+    let bucket;
+    let rationale;
+    let kind;
+    let forgetAfter;
+    if (matchedTemp) {
+        bucket = 'temp';
+        rationale = 'looks transient (timing keyword)';
+        kind = 'fact';
+        forgetAfter = new Date(now.getTime() + 24 * 60 * 60 * 1000).toISOString();
+    }
+    else if (matchedProject && !matchedPersonal) {
+        bucket = 'project';
+        rationale = 'codebase / architecture keyword present';
+        if (/\bbug\b|\bbroken\b/.test(lower)) {
+            kind = 'bug';
+        }
+        else if (/\bpattern\b/.test(lower)) {
+            kind = 'pattern';
+        }
+        else {
+            kind = 'architecture';
+        }
+        forgetAfter = null;
+    }
+    else if (matchedPersonal && !matchedProject) {
+        bucket = 'personal';
+        rationale = 'operator preference / workflow keyword present';
+        if (/\bworkflow\b|\bsetup\b/.test(lower)) {
+            kind = 'workflow';
+        }
+        else if (/prefer|like|hate|always|never/.test(lower)) {
+            kind = 'preference';
+        }
+        else {
+            kind = 'fact';
+        }
+        forgetAfter = null;
+    }
+    else if (matchedProject && matchedPersonal) {
+        bucket = 'personal';
+        rationale = 'mixed signals; defaulting to personal (safer)';
+        kind = 'preference';
+        forgetAfter = null;
+    }
+    else {
+        bucket = 'personal';
+        rationale = 'no strong signal; defaulting to personal';
+        kind = 'fact';
+        forgetAfter = null;
+    }
+    return {
+        bucket,
+        personaSlug: DEFAULT_PERSONA,
+        kind,
+        content: trimmed,
+        forgetAfter,
+        rationale,
+    };
+}
+/**
+ * Default decide hook — reject everything. Encodes the safety invariant
+ * that NOTHING is written when the runtime forgets to pass a real
+ * approval gate. Tests assert this behaviour explicitly.
+ */
+async function defaultDecide() {
+    return 'reject';
+}
+/**
+ * Default persistence sink — append to the on-disk pending-write queue
+ * via the existing `enqueueMemoryOp` API. `pugi memory sync` is what
+ * actually ships these to the admin-api; the curator only enqueues.
+ */
+async function defaultPersist(proposal) {
+    enqueueMemoryOp({
+        op: 'write',
+        personaSlug: proposal.personaSlug,
+        kind: proposal.kind,
+        content: proposal.content,
+        forgetAfter: proposal.forgetAfter,
+    });
+}
+function loadCandidates(positionals, inputPath) {
+    const inline = positionals.length > 0 ? [positionals.join(' ')] : [];
+    if (inputPath === null)
+        return inline;
+    try {
+        const raw = readFileSync(inputPath, 'utf8');
+        const lines = raw
+            .split('\n')
+            .map((l) => l.trim())
+            .filter((l) => l !== '' && !l.startsWith('#'));
+        return [...inline, ...lines];
+    }
+    catch {
+        return inline;
+    }
+}
+function renderHumanReport(result) {
+    const lines = [];
+    lines.push(`pugi remember — proposal-first memory curator`);
+    lines.push(`proposals: ${result.proposals.length} accepted: ${result.accepted} rejected: ${result.rejected} skipped: ${result.skipped}`);
+    if (result.decisions.length === 0) {
+        lines.push('');
+        lines.push('No proposals to review.');
+        return lines.join('\n');
+    }
+    for (const entry of result.decisions) {
+        const tag = entry.decision === 'accept' ? '[ACCEPTED]' : entry.decision === 'reject' ? '[REJECTED]' : '[SKIPPED]';
+        lines.push('');
+        lines.push(`${tag} (${entry.proposal.bucket} / ${entry.proposal.kind})`);
+        lines.push(` ${entry.proposal.content}`);
+        lines.push(` rationale: ${entry.proposal.rationale}`);
+        if (entry.proposal.forgetAfter !== null) {
+            lines.push(` forget-after: ${entry.proposal.forgetAfter}`);
+        }
+    }
+    return lines.join('\n');
+}
+export async function runRememberCommand(args, ctx) {
+    const { flags, positionals, error } = parseFlags(args);
+    if (error === 'help') {
+        ctx.writeOutput({ ok: true, command: 'remember', usage: REMEMBER_USAGE }, REMEMBER_USAGE);
+        return {
+            proposals: [],
+            decisions: [],
+            accepted: 0,
+            rejected: 0,
+            skipped: 0,
+            exitCode: 0,
+        };
+    }
+    if (error !== null) {
+        ctx.writeOutput({ ok: false, command: 'remember', error }, `pugi remember: ${error}`);
+        return {
+            proposals: [],
+            decisions: [],
+            accepted: 0,
+            rejected: 0,
+            skipped: 0,
+            exitCode: 2,
+        };
+    }
+    const candidates = loadCandidates(positionals, flags.inputPath);
+    const proposals = [];
+    for (const cand of candidates) {
+        const proposal = classifyMemoryCandidate(cand, ctx.now());
+        if (proposal === null)
+            continue;
+        // Carry the operator-overridden persona slug through. The classifier
+        // hard-codes the default so callers can swap it here without
+        // touching the heuristic.
+        proposals.push({ ...proposal, personaSlug: flags.personaSlug });
+    }
+    // Guard rail: the schema enum is the source of truth for kinds. If
+    // anyone widens the classifier without widening PERSONA_MEMORY_KINDS,
+    // we surface that drift instead of writing an unknown kind to disk.
+    for (const proposal of proposals) {
+        if (!PERSONA_MEMORY_KINDS.includes(proposal.kind)) {
+            ctx.writeOutput({
+                ok: false,
+                command: 'remember',
+                error: `internal: classifier produced unknown kind '${proposal.kind}'`,
+            }, `pugi remember: internal classifier drift on '${proposal.kind}'.`);
+            return {
+                proposals,
+                decisions: [],
+                accepted: 0,
+                rejected: 0,
+                skipped: 0,
+                exitCode: 2,
+            };
+        }
+    }
+    const decide = ctx.decide ?? defaultDecide;
+    const persist = ctx.persist ?? defaultPersist;
+    const decisions = [];
+    let accepted = 0;
+    let rejected = 0;
+    let skipped = 0;
+    for (const proposal of proposals) {
+        const decision = await decide(proposal);
+        decisions.push({ proposal, decision });
+        if (decision === 'accept') {
+            try {
+                await persist(proposal);
+                accepted += 1;
+            }
+            catch (err) {
+                // Backlog: the memory-queue secret scanner can refuse a
+                // persist call even after operator approval (defense-in-depth).
+                // Surface the rejection as a `reject` outcome so the operator
+                // sees what was blocked without crashing the curator loop.
+                const message = err instanceof Error ? err.message : String(err);
+                ctx.writeOutput({
+                    ok: false,
+                    command: 'remember',
+                    error: 'persist_blocked',
+                    proposal,
+                    message,
+                }, `pugi remember: persist blocked — ${message}`);
+                decisions[decisions.length - 1] = { proposal, decision: 'reject' };
+                rejected += 1;
+            }
+        }
+        else if (decision === 'reject') {
+            rejected += 1;
+        }
+        else {
+            skipped += 1;
+        }
+    }
+    const result = {
+        proposals,
+        decisions,
+        accepted,
+        rejected,
+        skipped,
+        exitCode: 0,
+    };
+    ctx.writeOutput({ ok: true, command: 'remember', result }, renderHumanReport(result));
+    return result;
+}
+const REMEMBER_USAGE = [
+    'pugi remember — proposal-first memory curator.',
+    '',
+    'Usage:',
+    ' pugi remember [--json] [--persona <slug>] [--input <path>] <text>...',
+    '',
+    'Flags:',
+    ' --json                Emit a JSON envelope instead of human text.',
+    ' --persona <slug>      Persona slug to attribute the memory to (default: mira).',
+    ' --input <path>        Read newline-separated candidates from a file.',
+    '',
+    'Every proposal is shown to the operator BEFORE persisting; nothing is',
+    'written without explicit approval. Unlike `pugi memory write` (silent),',
+    'this surface is curate-first and exists to keep automatic memory drift',
+    'in check.',
+].join('\n');
+//# sourceMappingURL=remember.js.map

package/dist/skills/bundled/simplify.js

@@ -0,0 +1,289 @@
+/**
+ * `pugi simplify` — local 3-agent parallel code review + auto-fix loop.
+ *
+ * Bundled skill, batch 1 (backlog). Distinct from `/triple-review`,
+ * which is the pre-push consensus gate; `simplify` is the inner-loop
+ * companion that examines the current `git diff` from three orthogonal
+ * dimensions (reuse, quality, efficiency), aggregates findings, and
+ * hands the merged review to `pugi fix` so the operator does not need
+ * to scroll through three separate reports + paste suggestions back
+ * into the engine by hand.
+ *
+ * # Three review dimensions
+ *
+ *  1. reuse     — does the diff duplicate logic that already exists in
+ *                  the codebase? Prefer extraction + import over copy.
+ *  2. quality   — does the diff respect Pugi conventions: strict TS,
+ *                  no `any`, naming, error handling, test coverage?
+ *  3. efficiency — does the diff introduce avoidable allocations, sync
+ *                  I/O in hot paths, or N+1 patterns?
+ *
+ * # Flow
+ *
+ *  1. Capture `git diff` against the configured base ref (default
+ *     `origin/main`).
+ *  2. Fan out to three parallel review prompts. Each prompt is sent
+ *     through the provided `reviewerInvoker` injection point — the
+ *     real CLI wires this to `pugi fix --review-only --persona <slug>`,
+ *     tests inject a stub.
+ *  3. Collect findings. Each finding carries a dimension tag + severity
+ *     ([P1] / [P2] / [P3]) + free-form text.
+ *  4. Optionally hand the aggregated findings to `pugi fix` to apply
+ *     fixes automatically. `--review-only` skips the fix step and just
+ *     prints the merged report.
+ *
+ * # Non-goals
+ *
+ *  - **Not** a pre-push gate. Use `/triple-review` for that — it spans
+ *    three model families across paid OAuth subscriptions and is the
+ *    production-grade gate.
+ *  - **Not** a new dispatcher. The fix step delegates to the existing
+ *    `pugi fix` engine task; this skill only shapes inputs + outputs.
+ *
+ * # Provenance
+ *
+ * Inspired by the the upstream tool bundled-skills pattern (intel from
+ * leak-research memos, clean-room TS). No upstream code reused.
+ */
+import { execFileSync } from 'node:child_process';
+const DEFAULT_BASE_REF = 'origin/main';
+function parseFlags(args) {
+    const flags = {
+        json: false,
+        reviewOnly: false,
+        baseRef: DEFAULT_BASE_REF,
+        sequential: false,
+    };
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === undefined)
+            continue;
+        if (arg === '--json') {
+            flags.json = true;
+            continue;
+        }
+        if (arg === '--review-only') {
+            flags.reviewOnly = true;
+            continue;
+        }
+        if (arg === '--sequential') {
+            flags.sequential = true;
+            continue;
+        }
+        if (arg === '--base') {
+            const next = args[i + 1];
+            if (next === undefined)
+                return { flags, error: '--base requires a ref' };
+            flags.baseRef = next;
+            i += 1;
+            continue;
+        }
+        if (arg === '--help' || arg === '-h') {
+            return { flags, error: 'help' };
+        }
+        return { flags, error: `unknown argument: ${arg}` };
+    }
+    return { flags, error: null };
+}
+/**
+ * Default `git diff` capture. Lives separate from the runner so tests
+ * can stub by injecting `captureDiff`.
+ */
+export function defaultCaptureDiff(baseRef, cwd) {
+    try {
+        return execFileSync('git', ['diff', `${baseRef}...HEAD`, '--unified=3'], {
+            cwd,
+            encoding: 'utf8',
+            maxBuffer: 32 * 1024 * 1024,
+            timeout: 10_000,
+        });
+    }
+    catch {
+        return '';
+    }
+}
+const DIMENSION_PROMPTS = {
+    reuse: [
+        'You are reviewing a git diff for code reuse opportunities.',
+        'For every block that duplicates existing utilities in the workspace,',
+        'or that re-implements a helper that should be extracted, emit a',
+        'finding line. Format each finding as:',
+        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
+        'Severity rubric:',
+        ' P1 — clear duplicate of an in-repo helper.',
+        ' P2 — copy-paste of a similar block that should be extracted.',
+        ' P3 — opportunity worth noting but not blocking.',
+    ].join('\n'),
+    quality: [
+        'You are reviewing a git diff for code quality vs. Pugi conventions:',
+        'strict TypeScript (no `any`, no `// @ts-ignore`), explicit error handling,',
+        'naming consistency, test coverage for new code paths.',
+        'For every violation, emit:',
+        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
+        'Severity rubric:',
+        ' P1 — strict-mode violation or missing critical error path.',
+        ' P2 — convention drift (naming, return shape, missing test).',
+        ' P3 — style nit worth surfacing.',
+    ].join('\n'),
+    efficiency: [
+        'You are reviewing a git diff for runtime efficiency.',
+        'Flag avoidable allocations, sync I/O in hot paths, N+1 query patterns,',
+        'unbounded recursion, or accidental quadratic loops.',
+        'For every issue, emit:',
+        ' [P1|P2|P3] <relative/path>: <one-sentence summary>',
+        'Severity rubric:',
+        ' P1 — algorithmic regression or sync I/O in a hot loop.',
+        ' P2 — avoidable allocation or per-row query.',
+        ' P3 — minor optimisation worth tracking.',
+    ].join('\n'),
+};
+const FINDING_LINE = /^\[(P1|P2|P3)\]\s+([^:]+):\s+(.+)$/;
+/**
+ * Parse a free-form reviewer response into structured findings. Lines
+ * that don't match the expected `[P1] file: summary` shape are ignored
+ * so a reviewer can emit free-form commentary alongside its findings
+ * without polluting the aggregator. Exposed for test coverage of the
+ * grammar.
+ */
+export function parseReviewerFindings(dimension, raw) {
+    const findings = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('[P'))
+            continue;
+        const match = FINDING_LINE.exec(trimmed);
+        if (match === null)
+            continue;
+        const [, severity, file, summary] = match;
+        if (severity === undefined || file === undefined || summary === undefined)
+            continue;
+        findings.push({
+            dimension,
+            severity: severity,
+            file: file.trim() === '-' ? null : file.trim(),
+            summary: summary.trim(),
+        });
+    }
+    return findings;
+}
+/**
+ * Run the three dimensions in parallel (or sequentially when
+ * `--sequential` is set) and aggregate. The aggregator is the only
+ * piece of "real" work in this skill; everything else is plumbing.
+ */
+export async function aggregateReviewerResults(diff, baseRef, invoker, options = { sequential: false }) {
+    const dimensions = ['reuse', 'quality', 'efficiency'];
+    const runOne = async (dimension) => {
+        const prompt = DIMENSION_PROMPTS[dimension];
+        const raw = await invoker({ dimension, prompt, diff, baseRef });
+        const findings = parseReviewerFindings(dimension, raw);
+        return { dimension, findings, raw };
+    };
+    const results = [];
+    if (options.sequential) {
+        for (const dim of dimensions) {
+            results.push(await runOne(dim));
+        }
+    }
+    else {
+        const settled = await Promise.all(dimensions.map(runOne));
+        results.push(...settled);
+    }
+    const flat = [];
+    const summary = { P1: 0, P2: 0, P3: 0 };
+    for (const r of results) {
+        for (const f of r.findings) {
+            flat.push(f);
+            summary[f.severity] += 1;
+        }
+    }
+    return {
+        diffBytes: Buffer.byteLength(diff, 'utf8'),
+        baseRef,
+        dimensions: results,
+        findings: flat,
+        summaryBySeverity: summary,
+    };
+}
+function renderHumanReport(report, applied) {
+    const lines = [];
+    lines.push(`pugi simplify — 3-agent review @ base=${report.baseRef}`);
+    lines.push(`diff: ${report.diffBytes} bytes`);
+    lines.push(`findings: P1=${report.summaryBySeverity.P1} P2=${report.summaryBySeverity.P2} P3=${report.summaryBySeverity.P3}`);
+    lines.push('');
+    for (const reviewer of report.dimensions) {
+        lines.push(`-- ${reviewer.dimension} (${reviewer.findings.length} findings) --`);
+        if (reviewer.findings.length === 0) {
+            lines.push(' (clean)');
+        }
+        else {
+            for (const finding of reviewer.findings) {
+                lines.push(` [${finding.severity}] ${finding.file ?? '-'}: ${finding.summary}`);
+            }
+        }
+    }
+    if (applied !== null) {
+        lines.push('');
+        lines.push(`pugi fix: applied=${applied.applied} skipped=${applied.skipped}`);
+    }
+    return lines.join('\n');
+}
+export async function runSimplifyCommand(args, ctx) {
+    const { flags, error } = parseFlags(args);
+    if (error === 'help') {
+        ctx.writeOutput({ ok: true, command: 'simplify', usage: SIMPLIFY_USAGE }, SIMPLIFY_USAGE);
+        return {
+            report: emptyReport(flags.baseRef),
+            applied: null,
+            exitCode: 0,
+        };
+    }
+    if (error !== null) {
+        ctx.writeOutput({ ok: false, command: 'simplify', error }, `pugi simplify: ${error}`);
+        return { report: emptyReport(flags.baseRef), applied: null, exitCode: 2 };
+    }
+    const capture = ctx.captureDiff ?? defaultCaptureDiff;
+    const diff = capture(flags.baseRef, ctx.cwd);
+    if (diff.trim() === '') {
+        const empty = emptyReport(flags.baseRef);
+        ctx.writeOutput({
+            ok: true,
+            command: 'simplify',
+            report: empty,
+            note: `No diff against ${flags.baseRef}.`,
+        }, `pugi simplify: no diff against ${flags.baseRef}. Nothing to review.`);
+        return { report: empty, applied: null, exitCode: 0 };
+    }
+    const report = await aggregateReviewerResults(diff, flags.baseRef, ctx.reviewerInvoker, { sequential: flags.sequential });
+    let applied = null;
+    if (!flags.reviewOnly && ctx.fixer !== undefined && report.findings.length > 0) {
+        applied = await ctx.fixer(report.findings);
+    }
+    ctx.writeOutput({ ok: true, command: 'simplify', report, applied }, renderHumanReport(report, applied));
+    const exitCode = report.findings.length === 0 ? 0 : 1;
+    return { report, applied, exitCode };
+}
+function emptyReport(baseRef) {
+    return {
+        diffBytes: 0,
+        baseRef,
+        dimensions: [],
+        findings: [],
+        summaryBySeverity: { P1: 0, P2: 0, P3: 0 },
+    };
+}
+const SIMPLIFY_USAGE = [
+    'pugi simplify — local 3-agent diff review (reuse / quality / efficiency).',
+    '',
+    'Usage:',
+    ' pugi simplify [--json] [--review-only] [--sequential] [--base <ref>]',
+    '',
+    'Flags:',
+    ' --json            Emit a JSON envelope instead of human text.',
+    ' --review-only     Skip the auto-fix step; print the merged report only.',
+    ' --sequential      Run the three reviewers in series (low-quota mode).',
+    ' --base <ref>      Diff base ref (default: origin/main).',
+    '',
+    'Not a pre-push gate — for that, use /triple-review.',
+].join('\n');
+//# sourceMappingURL=simplify.js.map