@gobing-ai/spur 0.4.1 → 0.4.3

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts

@@ -1,12 +1,10 @@
 /**
- * detect-pipeline-driving — @1.2 pipeline-driving testee detector (task 0277, W7).
+ * detect-pipeline-driving — live Phase 1.0 CLI gate over the @1.2 detector (task 0277 W7).
  *
- * Pure function over the raw testee string → boolean. Used by the dogfood driver
- * (Phase 1.0 refuse-ambiguous gate) and by unit tests so the matcher contract is
- * machine-checked rather than agent-interpreted.
- *
- * Also ships a **CLI gate** (import.meta.main) so Phase 1.0 is a live shell call,
- * not agent-only prose interpretation:
+ * The detector and its policy helpers are application-owned in
+ * `plugins/sp/lib/dogfood-pipeline.ts` (task 1173); this script keeps the shell entry the dogfood
+ * driver calls, with argv, usage, exit codes and refusal messages unchanged. Callers and tests may
+ * keep importing this path — every former export is re-exported.
  *
  *   bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \
  *     --testee "/sp:dev-run 0125 --auto --next" [--max-retry-present] \
@@ -16,267 +14,11 @@
  *   0 — proceed (may print implement-heavy advisory on stderr)
  *   2 — refuse: pipeline-driving without explicit --max-retry
  *   1 — usage / argument error
- *
- * Contract (0274 §3 dogfood-pipeline-detect, 0277 R1):
- *   - Word-boundary matchers with `-` treated as a word char (NOT a boundary).
- *     A token counts only when it is a distinct hyphen-word, not when it is a
- *     substring of a longer alphanumeric or hyphen run. This removes the
- *     leading-space dependency of the @1.1 prose detector.
- *   - Two token shapes, both with strict `[^\w-]` boundaries:
- *       (a) complete tokens — `--next`, `dev-run`, `dev-runall`, `dev-wrap`,
- *           `dev-wrapall`, `dev-idea` — matched as whole hyphen-words so the
- *           slash form `/sp:dev-run` matches on its `dev-run` tail whether or
- *           not it is preceded by a space, but `--next` does NOT match inside
- *           `--next-gen` (the trailing `-gen` breaks the boundary).
- *       (b) bare nouns — `run`, `runall`, `wrap`, `wrapall`, `idea` — matched
- *           only as standalone words, so `run` matches in
- *           `bun ... task run 0042` but NOT inside `runaway`/`prerun`, and
- *           `idea` does NOT match inside `idealist`/`ideal`.
- *   - Listing both shapes is what makes the detector leading-space invariant
- *     (the slash form is caught by its `dev-*` tail; the bare noun is caught
- *     when it appears as its own word) without letting `run` leak into every
- *     `-run-` identifier.
- *
- * Non-goals of detectPipelineDriving: decides ambiguity only. It does NOT decide
- * observe vs fix — any explicit `--max-retry` value proceeds regardless.
- * Implement-heavy advisory is a separate helper (detectImplementHeavy).
- */
-
-/**
- * Tokens whose presence makes a testee pipeline-driving. Ordered for stable
- * diagnostics. Two shapes per the contract above: complete `dev-*` / `--next`
- * tokens first, then bare nouns.
- */
-const PIPELINE_TOKENS = [
-    '--next',
-    'dev-runall',
-    'dev-wrapall',
-    'dev-refineall',
-    'dev-verifyall',
-    'dev-run',
-    'dev-wrap',
-    'dev-idea',
-    'refineall',
-    'verifyall',
-    'runall',
-    'wrapall',
-    'run',
-    'wrap',
-    'idea',
-] as const;
-
-/** Refuse message when pipeline-driving and `--max-retry` was not passed (exact string). */
-export const PIPELINE_DRIVING_REFUSE_MESSAGE =
-    '⚠ pipeline-driving testee detected; pass --max-retry 0 (observe-only) or --max-retry N (fix mode, tree mutation acknowledged)';
-
-/**
- * Refuse message when the testee carries a mutating `--fix` mode (`--fix all` /
- * `--fix blockers-first`) and `--max-retry` was not passed. A mutating fix mode
- * mutates the working tree independent of pipeline-driving (task 0293 R1/R2):
- * `--max-retry 0` bounds the **driver** only — the testee's own `--fix` pass
- * still mutates the tree — so the message must not imply otherwise.
- */
-export const MUTATING_FIX_REFUSE_MESSAGE =
-    '⚠ mutating --fix mode detected (--fix all | --fix blockers-first); pass --max-retry 0 (observe-only for the driver; the testee still mutates the tree) or --max-retry N (fix mode, driver + testee both mutate)';
-
-/** Advisory when pipeline-driving + implement-heavy derived steps (exact string). */
-export const IMPLEMENT_HEAVY_ADVISORY_MESSAGE =
-    '⚠ implement-heavy pipeline dogfood: prefer --max-retry 0 (observe-only) or step-split; operator --max-retry N overrides';
-
-/**
- * Tokens that mark a derived step as implement-heavy (mutates product/code or
- * drives a mutating pipeline leg). Deliberately excludes verify/review/unit-only
- * surfaces even when they carry `--next`.
- */
-const IMPLEMENT_HEAVY_TOKENS = [
-    'dev-runall',
-    'dev-wrapall',
-    'dev-run',
-    'dev-wrap',
-    'dev-idea',
-    'runall',
-    'wrapall',
-    // bare `run` / `wrap` / `idea` — only when not clearly a non-mutating surface
-    'run',
-    'wrap',
-    'idea',
-    'implement',
-] as const;
-
-/**
- * A verify/review surface stops being non-mutating the moment it carries a
- * repair mode: `--fix all` / `--fix blockers-first` applies Edit/Write repairs
- * to the working tree (0280 dogfood, finding P2). `--fix none` stays
- * observational. Boundary-guarded so `--prefix all` / `--focus all` never match.
- * Exported so the Phase 1.0 gate and tests share one matcher (task 0293 R1/R4).
- */
-export function hasMutatingFixMode(step: string): boolean {
-    return /(?<![\w-])--fix[=\s]+(all|blockers-first)(?![\w-])/i.test(step);
-}
-
-/**
- * Match a token at a word boundary. A "word boundary" here is the position
- * between a non-`[\w-]` char (or string start) and the token, and between the
- * token and a non-`[\w-]` char (or string end). Treating `-` as a word char
- * is what makes `--next` reject `--next-gen` and `dev-run` reject `dev-runner`.
- */
-function tokenMatches(testee: string, token: string): boolean {
-    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    // (?<![\w-]) — not preceded by a word char or hyphen.
-    // (?![\w-])  — not followed by a word char or hyphen.
-    const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, 'i');
-    return re.test(testee);
-}
-
-/**
- * Returns whether the testee string is pipeline-driving (contains any of the
- * pipeline-driving tokens as a distinct hyphen-word). Machine-checked
- * counterpart of the prose list in SKILL.md §Pipeline-driving detection and
- * dev-dogfood.md.
- */
-export function detectPipelineDriving(testee: string): boolean {
-    if (typeof testee !== 'string' || testee.length === 0) {
-        return false;
-    }
-    return PIPELINE_TOKENS.some((token) => tokenMatches(testee, token));
-}
-
-/**
- * True when a single step label (or the whole testee) is implement-heavy —
- * it chains into real implementation / wrap / idea work, not verify-only.
- *
- * Non-mutating surfaces (`dev-verify`, `dev-review`, `dev-unit`, plain
- * `dev-refine` without a further run) are never implement-heavy even if
- * pipeline-driving via `--next` — UNLESS they carry a mutating repair mode
- * (`--fix all` / `--fix blockers-first`), which turns the verify/review leg
- * into a tree-mutating fix pass (0280 dogfood, finding P2).
- */
-export function isImplementHeavyStep(step: string): boolean {
-    if (typeof step !== 'string' || step.length === 0) return false;
-    // Explicit non-mutating surfaces win unless a mutating token co-occurs.
-    const nonMutatingOnly =
-        tokenMatches(step, 'dev-verify') || tokenMatches(step, 'dev-review') || tokenMatches(step, 'dev-unit');
-    const hasMutating = IMPLEMENT_HEAVY_TOKENS.some((token) => tokenMatches(step, token)) || hasMutatingFixMode(step);
-    if (nonMutatingOnly && !hasMutating) return false;
-    // refine alone is planning, not implement-heavy; refine+run/--next chain is.
-    if (tokenMatches(step, 'dev-refine') && !hasMutating && !tokenMatches(step, '--next')) {
-        return false;
-    }
-    if (tokenMatches(step, 'dev-refine') && tokenMatches(step, '--next')) {
-        // refine --next chains into run → implement-heavy
-        return true;
-    }
-    return hasMutating;
-}
-
-/**
- * True when the testee is implement-heavy: it carries a pipeline-driving token,
- * a mutating `--fix` mode, OR at least one derived step (or the testee itself
- * when no steps given) is implement-heavy. Used for the W8 Phase 1 advisory
- * after step derivation.
- *
- * Task 0293 R3: a mutating `--fix` mode alone is implement-heavy even with no
- * pipeline token — the verify/review leg itself becomes a tree-mutating fix
- * pass.
- */
-export function detectImplementHeavy(testee: string, derivedSteps: string[] = []): boolean {
-    if (isImplementHeavyStep(testee)) return true;
-    if (!detectPipelineDriving(testee)) return false;
-    return derivedSteps.some((step) => isImplementHeavyStep(step));
-}
-
-export interface GateResult {
-    pipelineDriving: boolean;
-    mutatingFix: boolean;
-    maxRetryPresent: boolean;
-    implementHeavy: boolean;
-    refuse: boolean;
-    advisory: boolean;
-    message: string | null;
-    exitCode: 0 | 1 | 2;
-}
-
-/**
- * Phase 1.0 + W8 gate decision. Pure — no I/O. The CLI wrapper prints and exits.
- *
- * Refuse condition (task 0293 R1) is the union of two **independent** mutation
- * sources, each gated on `!maxRetryPresent`:
- *
- *   1. pipeline-driving testee (`--next`, `dev-run`, …) — refuses because the
- *      testee chains lifecycle legs whose cumulative blast radius the driver
- *      cannot pre-attribute.
- *   2. mutating `--fix` mode (`--fix all` / `--fix blockers-first`) — refuses
- *      because the testee itself applies Edit/Write repairs even with no
- *      pipeline token. `--max-retry 0` bounds the **driver** only; the testee
- *      still mutates (honesty note in MUTATING_FIX_REFUSE_MESSAGE).
- *
- * Pipeline-driving is reported first when both co-occur (its refuse message is
- * the superset — chain + tree mutation).
  */
-export function evaluateDogfoodGate(
-    testee: string,
-    options: { maxRetryPresent?: boolean; steps?: string[] } = {},
-): GateResult {
-    const maxRetryPresent = options.maxRetryPresent === true;
-    const steps = options.steps ?? [];
-    const pipelineDriving = detectPipelineDriving(testee);
-    const mutatingFix = hasMutatingFixMode(testee);
-    const implementHeavy = detectImplementHeavy(testee, steps);
-
-    if (pipelineDriving && !maxRetryPresent) {
-        return {
-            pipelineDriving,
-            mutatingFix,
-            maxRetryPresent,
-            implementHeavy,
-            refuse: true,
-            advisory: false,
-            message: PIPELINE_DRIVING_REFUSE_MESSAGE,
-            exitCode: 2,
-        };
-    }
-
-    if (mutatingFix && !maxRetryPresent) {
-        return {
-            pipelineDriving,
-            mutatingFix,
-            maxRetryPresent,
-            implementHeavy,
-            refuse: true,
-            advisory: false,
-            message: MUTATING_FIX_REFUSE_MESSAGE,
-            exitCode: 2,
-        };
-    }
-
-    if (implementHeavy) {
-        return {
-            pipelineDriving,
-            mutatingFix,
-            maxRetryPresent,
-            implementHeavy,
-            refuse: false,
-            advisory: true,
-            message: IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
-            exitCode: 0,
-        };
-    }
-
-    return {
-        pipelineDriving,
-        mutatingFix,
-        maxRetryPresent,
-        implementHeavy,
-        refuse: false,
-        advisory: false,
-        message: null,
-        exitCode: 0,
-    };
-}
 
-export { PIPELINE_TOKENS };
+import { evaluateDogfoodGate } from '../../lib/dogfood-pipeline';
 
-// ── CLI entry (live Phase 1.0 gate) ──────────────────────────────────────────
+export * from '../../lib/dogfood-pipeline';
 
 export interface CliArgs {
     testee: string | null;

package/plugins/sp/scripts/dogfood-testing/validate-report.mjs

@@ -4,6 +4,8 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // plugins/sp/scripts/dogfood-testing/validate-report.ts
 import { readFileSync } from "node:fs";
+
+// plugins/sp/lib/dogfood-report.ts
 var REQUIRED_SECTIONS = [1, 2, 3, 4, 5, 6];
 var CANONICAL_PROTOCOL = "sp:dogfood-testing@1.2";
 function countSectionHeadings(markdown, section) {
@@ -188,6 +190,7 @@ function validateReport(markdown) {
   validateCostEvidence(markdown, errors);
   return { ok: errors.length === 0, errors };
 }
+// plugins/sp/scripts/dogfood-testing/validate-report.ts
 function parseValidateCliArgs(argv) {
   let file = null;
   let json = false;

package/plugins/sp/scripts/dogfood-testing/validate-report.ts

@@ -1,283 +1,17 @@
 /**
- * validate-report — @1.2 dogfood report contract checker (task 0276, W6).
+ * validate-report — CLI entry for the @1.2 dogfood report contract checker (task 0276 W6, 0278 R6).
  *
- * Pure function over a report markdown string → { ok, errors[] } with stable error
- * codes, callable from tests and by agents finalizing a run. It validates the
- * *complete-report* shape: the six unique section headings, Issues subheads, the
- * mandatory summary footer with both delivery paths, frontmatter protocol string,
- * ledger↔declared-steps cardinality, and the Cost evidence contract (task 0913):
- * a complete report must carry a Cost block (Ledger estimate / Method / Meter),
- * percentages within 0..100, observable token totals consistent with the ledger
- * row sums (fresh + cached), and no fabricated share when no observable rows
- * exist. Unknown cells are never folded into zero; all-unknown evidence must
- * render `n/a`. Aborted/partial reports remain out of scope — they legitimately
- * lack the footer and Steps line.
+ * The validation logic is application-owned in `plugins/sp/lib/dogfood-report.ts` (task 1173); this
+ * script opens the file, runs the check and prints — argv, usage, exit codes and every exported
+ * symbol stay as they were, so callers and tests keep importing this path.
  *
  * CLI (task 0278 R6): `bun …/validate-report.ts --file <report.md> [--json]`
  */
 
 import { readFileSync } from 'node:fs';
+import { validateReport } from '../../lib/dogfood-report';
 
-export interface ReportValidation {
-    ok: boolean;
-    errors: string[];
-}
-
-const REQUIRED_SECTIONS = [1, 2, 3, 4, 5, 6] as const;
-const CANONICAL_PROTOCOL = 'sp:dogfood-testing@1.2';
-
-function countSectionHeadings(markdown: string, section: number): number {
-    const re = new RegExp(`^### ${section}\\.`, 'gm');
-    return (markdown.match(re) ?? []).length;
-}
-
-function countLedgerDataRows(markdown: string): number | null {
-    const heading = markdown.match(/^### 3\. Monitor Ledger\s*$/m);
-    if (!heading || heading.index === undefined) return null;
-    const after = markdown.slice(heading.index + heading[0].length);
-    const nextHeading = after.search(/^### /m);
-    const body = nextHeading === -1 ? after : after.slice(0, nextHeading);
-    const rows = body
-        .split('\n')
-        .filter((line) => line.trim().startsWith('|'))
-        .filter((line) => !/^\|[\s:|-]+\|?\s*$/.test(line.trim()))
-        // drift:external rows are documentary (task 0296) — included in the table but
-        // subtracted from the executed-step count, per the @1.2 cardinality contract;
-        // the prescribed code-span form (`drift:external`) matches too (task 0701 R5b).
-        .filter((line) => !/^\|\s*`?drift:/.test(line.trim()));
-    // Minus the header row; what remains are data rows.
-    return Math.max(rows.length - 1, 0);
-}
-
-function declaredExecutedSteps(markdown: string): number | null {
-    const match = markdown.match(/\*\*Steps:\*\*\s*\d+\s+derived,\s*(\d+)\s+executed/)?.[1];
-    return match ? Number.parseInt(match, 10) : null;
-}
-
-// ── Cost evidence contract (task 0913, R2) ──────────────────────────────────
-
-const UNKNOWN_CELLS = new Set(['~unknown', 'unknown', '—', '-', '?', 'n/a', '~n/a']);
-
-/** Display-rounding tolerance: a whole-percent share may differ from the exact
- * value by at most 1 point (e.g. 700/2100 = 33.3% may display as 33%). */
-const CACHE_SHARE_TOLERANCE = 1;
-
-function sectionBody(markdown: string, headingRe: RegExp): string | null {
-    const heading = markdown.match(headingRe);
-    if (!heading || heading.index === undefined) return null;
-    const after = markdown.slice(heading.index + heading[0].length);
-    const nextHeading = after.search(/^###? /m);
-    return nextHeading === -1 ? after : after.slice(0, nextHeading);
-}
-
-interface CostTotals {
-    total: number | 'n/a' | null;
-    cached: number | 'n/a' | null;
-    pct: number | 'n/a' | null;
-}
-
-function parseTokensLine(line: string): CostTotals | null {
-    const match = line.match(
-        /~(?<total>n\/a|\d+)\s+total\s*\|\s*~(?<cached>n\/a|\d+)\s+cached(?:\s*\(\s*~?(?<pct>n\/a|\d+(?:\.\d+)?)%\s*hit rate\))?/i,
-    );
-    if (!match) return null;
-    const num = (v: string | undefined): number | 'n/a' | null =>
-        v === undefined ? null : v === 'n/a' ? 'n/a' : Number.parseInt(v, 10);
-    return { total: num(match.groups?.total), cached: num(match.groups?.cached), pct: num(match.groups?.pct) };
-}
-
-interface LedgerCostRow {
-    step: string;
-    fresh: number | null;
-    cached: number | null;
-    cachePct: number | null;
-    unknownCell: boolean;
-}
-
-function parseTokenCell(cell: string): number | null {
-    const t = cell.trim();
-    if (UNKNOWN_CELLS.has(t)) return null;
-    const m = t.match(/~?(\d+)/)?.[1];
-    return m ? Number.parseInt(m, 10) : null;
-}
-
-function parsePctCell(cell: string): number | null {
-    const t = cell.trim();
-    if (UNKNOWN_CELLS.has(t)) return null;
-    const m = t.match(/(\d+(?:\.\d+)?)\s*%/)?.[1];
-    return m ? Number.parseFloat(m) : null;
-}
-
-function ledgerCostRows(markdown: string): LedgerCostRow[] {
-    const body = sectionBody(markdown, /^### 3\. Monitor Ledger\s*$/m);
-    if (body === null) return [];
-    return body
-        .split('\n')
-        .filter((line) => line.trim().startsWith('|'))
-        .filter((line) => !/^\|[\s:|-]+\|?\s*$/.test(line.trim()))
-        .filter((line) => !/^\|\s*`?drift:/.test(line.trim()))
-        .slice(1) // drop header row
-        .map((line) => {
-            const cells = line
-                .split('|')
-                .map((c) => c.trim())
-                .filter((c, i, a) => !(i === 0 && c === '') && !(i === a.length - 1 && c === ''));
-            // Columns: 0 Step … 5 Fresh, 6 Cached, 7 Cache %
-            const freshCell = cells[5] ?? '';
-            const cachedCell = cells[6] ?? '';
-            return {
-                step: cells[0] ?? '',
-                fresh: parseTokenCell(freshCell),
-                cached: parseTokenCell(cachedCell),
-                cachePct: parsePctCell(cells[7] ?? ''),
-                unknownCell: UNKNOWN_CELLS.has(freshCell) || UNKNOWN_CELLS.has(cachedCell),
-            };
-        });
-}
-
-function validateCostEvidence(markdown: string, errors: string[]): void {
-    const costBlock = sectionBody(markdown, /^#### Cost\s*$/m);
-    if (costBlock === null) {
-        errors.push('missing_cost_block');
-        return;
-    }
-    for (const field of ['Ledger estimate', 'Method', 'Meter']) {
-        if (!costBlock.includes(`**${field}:**`)) errors.push(`missing_cost_field:${field}`);
-    }
-
-    const ledgerLine = costBlock.split('\n').find((l) => l.includes('**Ledger estimate:**')) ?? '';
-    const costTotals = parseTokensLine(ledgerLine);
-    // A label present but unparseable is its own defect (task 0913 review P3-1): report it and
-    // keep validating — an early return here disabled every downstream cost check, including
-    // the per-row impossible-percentage scan. An absent label is already reported above as
-    // missing_cost_field; with no line to parse there is nothing further to check for it.
-    if (ledgerLine !== '' && costTotals === null) errors.push('malformed_cost_line');
-    const footerLine = markdown.split('\n').find((l) => l.trim().startsWith('Tokens:'));
-    const footerTotals = footerLine ? parseTokensLine(footerLine) : null;
-    // Same contract for the footer: a present-but-unparseable Tokens: line must not
-    // silently skip the footer totals comparison. An absent Tokens: line with the
-    // summary block present is its own defect (task 0913 verify advisory).
-    if (footerLine !== undefined && footerTotals === null) errors.push('malformed_footer');
-    if (footerLine === undefined && markdown.includes('── Dogfood Summary ──')) {
-        errors.push('missing_footer_tokens');
-    }
-
-    // Percentages must be within 0..100 wherever cost evidence renders one.
-    const pctScopes = [costBlock, footerLine ?? ''];
-    for (const row of ledgerCostRows(markdown)) {
-        if (row.cachePct !== null) pctScopes.push(`${row.cachePct}%`);
-    }
-    for (const scope of pctScopes) {
-        for (const m of scope.matchAll(/(\d+(?:\.\d+)?)\s*%/g)) {
-            const pct = Number.parseFloat(m[1] ?? '');
-            if (pct < 0 || pct > 100) errors.push(`impossible_percentage:${m[0].trim()}`);
-        }
-    }
-
-    const rows = ledgerCostRows(markdown);
-
-    // Unknown cells are never folded into a numeric share: a row whose basis is
-    // unknown must carry `—`, never a computed percent.
-    for (const row of rows) {
-        if (row.unknownCell && row.cachePct !== null) errors.push('unknown_row_with_numeric_cache');
-    }
-
-    // Per-row arithmetic: a numeric Cache % must match the row's own fresh/cached cells
-    // (±1pt display rounding), not merely the aggregate share (task 0913 verify advisory).
-    for (const row of rows) {
-        if (row.fresh === null || row.cached === null || row.cachePct === null) continue;
-        const basis = row.fresh + row.cached;
-        if (basis === 0) continue;
-        const expected = Math.round((row.cached / basis) * 100);
-        if (Math.abs(row.cachePct - expected) > CACHE_SHARE_TOLERANCE) {
-            errors.push(`cache_pct_mismatch:${row.step}_expected_${expected}`);
-        }
-    }
-
-    const observable = rows.filter((r) => r.fresh !== null && r.cached !== null);
-    const sumFresh = observable.reduce((acc, r) => acc + (r.fresh ?? 0), 0);
-    const sumCached = observable.reduce((acc, r) => acc + (r.cached ?? 0), 0);
-
-    const checkTotals = (label: string, totals: CostTotals | null): void => {
-        if (totals === null) return;
-        if (observable.length > 0) {
-            const expectedTotal = sumFresh + sumCached;
-            if (typeof totals.total === 'number' && totals.total !== expectedTotal) {
-                errors.push(`cost_total_mismatch:${label}_expected_${expectedTotal}`);
-            }
-            if (typeof totals.cached === 'number' && totals.cached !== sumCached) {
-                errors.push(`cost_total_mismatch:${label}_cached_expected_${sumCached}`);
-            }
-            const expectedPct = expectedTotal > 0 ? Math.round((sumCached / expectedTotal) * 100) : null;
-            if (expectedPct !== null) {
-                if (totals.pct === 'n/a' || totals.pct === null) {
-                    errors.push(`missing_cache_share:${label}`);
-                } else if (
-                    typeof totals.pct === 'number' &&
-                    Math.abs(totals.pct - expectedPct) > CACHE_SHARE_TOLERANCE
-                ) {
-                    errors.push(`cache_share_mismatch:${label}_expected_${expectedPct}`);
-                }
-            }
-        } else if (
-            typeof totals.total === 'number' ||
-            typeof totals.cached === 'number' ||
-            typeof totals.pct === 'number'
-        ) {
-            // No observable denominator: numeric totals/shares fabricate evidence
-            // from unknown rows (unknown folded into zero). `n/a` is the honest form.
-            errors.push(`fabricated_cache_share:${label}`);
-        }
-    };
-    checkTotals('cost', costTotals);
-    checkTotals('footer', footerTotals);
-}
-
-export function validateReport(markdown: string): ReportValidation {
-    const errors: string[] = [];
-
-    // Footer (W2/D1) — the mirrored footer block at the report end.
-    if (!markdown.includes('── Dogfood Summary ──')) errors.push('missing_footer');
-    if (!markdown.includes('[Live:')) errors.push('missing_live_path');
-    if (!markdown.includes('[Report:')) errors.push('missing_report_path');
-
-    // Six unique section headings (W2/D3).
-    for (const section of REQUIRED_SECTIONS) {
-        const count = countSectionHeadings(markdown, section);
-        if (count === 0) errors.push(`missing_section:${section}`);
-        if (count > 1) errors.push(`duplicate_section:${section}`);
-    }
-
-    // Issues subheads (W2/D3).
-    if (!markdown.includes('#### Fixed') || !markdown.includes('#### Unresolved')) {
-        errors.push('missing_issues_subheads');
-    }
-
-    // Protocol string (W1/D5) — colon form, exact version.
-    const protocolMatch = markdown.match(/^protocol:\s*(\S+)\s*$/m);
-    if (!protocolMatch || protocolMatch[1] !== CANONICAL_PROTOCOL) {
-        errors.push('protocol_string');
-    }
-
-    // Ledger cardinality (W3/D4) — data rows == declared executed steps.
-    const executed = declaredExecutedSteps(markdown);
-    if (executed === null) {
-        errors.push('missing_steps_declared');
-    } else {
-        const rows = countLedgerDataRows(markdown);
-        if (rows === null || rows !== executed) {
-            errors.push('ledger_cardinality');
-        }
-    }
-
-    // Cost evidence (task 0913, R2) — required block, arithmetic consistency,
-    // honest unknowns.
-    validateCostEvidence(markdown, errors);
-
-    return { ok: errors.length === 0, errors };
-}
-
-// ── CLI entry (Phase 4 self-validate — task 0278 R6) ─────────────────────────
+export * from '../../lib/dogfood-report';
 
 export interface ValidateCliArgs {
     file: string | null;