peaks-loop 4.0.49 → 4.0.50

package/dist/services/capability-guard-runner/contracts/J02.js

@@ -1,34 +1,120 @@
 import { execFileSync } from 'node:child_process';
-import { mkdtempSync } from 'node:fs';
+import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { join, resolve } from 'node:path';
+import { combineProbes, fail, missingSourceFiles, pass, probe, requireBaselineRow } from './_shared.js';
 const STATES = ['spec-locked', 'implemented', 'qa-handoff', 'handed-off'];
-export async function runJ02Contract(ctx, projectRoot = ctx.projectRoot) {
-    const bin = join(ctx.projectRoot, 'bin', 'peaks.js');
+// Per-child timeout. J02 runs six peaks CLIs in a fresh cwd; on cold CI
+// runners the first invocation pays tsx startup before the resolved file is
+// hot, and any single child that hangs would block the whole guard run until
+// the default node timeout (forever). 60s is comfortable on warm hosts and
+// tight enough that a genuine hang surfaces in the gate step within the
+// publish workflow's per-step budget.
+const CHILD_TIMEOUT_MS = 60_000;
+export async function runJ02Contract(ctx) {
+    const row = requireBaselineRow(ctx);
+    const missing = missingSourceFiles(ctx, row);
+    // Must be ABSOLUTE: the child runs with `cwd: tmp`, so a relative
+    // `bin/peaks.js` would be resolved against the temp workspace.
+    const bin = resolve(ctx.projectRoot, 'bin', 'peaks.js');
     const tmp = mkdtempSync(join(tmpdir(), 'cbl-J02-'));
-    const ws = execFileSync('node', [bin, 'workspace', 'init', '--project', tmp, '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
-    const { data: { sessionId } } = JSON.parse(ws);
-    const rid = '2026-08-03-j02-fixture';
-    const initOut = execFileSync('node', [bin, 'request', 'init', '--role', 'rd', '--id', rid, '--project', tmp, '--session-id', sessionId, '--apply', '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
-    const initEnv = JSON.parse(initOut);
-    // `request init` writes the file as `NNN-<id-slug>.md`. The transition CLI accepts
-    // the file's basename (without .md) as the requestId. Derive it from data.path.
-    const baseName = initEnv.data.path.split(/[\\/]/).pop() ?? '';
-    const requestId = baseName.replace(/\.md$/i, '');
-    let last = '';
-    for (const s of STATES) {
-        const out = execFileSync('node', [bin, 'request', 'transition', requestId, '--role', 'rd', '--state', s,
-            '--project', tmp, '--session-id', sessionId, '--confirm', '--allow-incomplete',
-            '--reason', 'J02 contract fixture', '--json'], { cwd: tmp, windowsHide: true }).toString('utf8');
-        const env = JSON.parse(out);
-        last = env.data.state;
-    }
-    const ok = last === 'handed-off';
-    return {
-        journeyId: 'J02',
-        contract: 'workflow-trace',
-        status: ok ? 'pass' : 'fail',
-        ...(ok ? {} : { diff: { before: 'handed-off', after: last, reason: 'J02#1 broken: RD state machine no longer reaches handed-off' } }),
-        artifactPath: 'tests/integration/business-capability-e2e.test.ts'
+    // Each peaks-CLI invocation in this contract is wrapped so a child that
+    // hangs (or a child that produces no stdout) cannot silently pin the gate
+    // step until CI's job-level timeout fires. `execFileSync` already throws on
+    // non-zero exit; we additionally enforce timeout and surface the actual
+    // stderr in the error so a future failure can be diagnosed without re-running
+    // with a debugger.
+    const run = (args) => {
+        try {
+            const stdout = execFileSync('node', [bin, ...args], {
+                cwd: tmp,
+                windowsHide: true,
+                timeout: CHILD_TIMEOUT_MS,
+                encoding: 'utf8',
+                // The contract spawns peaks CLIs in a temp workspace; on a CI runner
+                // there is no IDE context, so peaks would refuse every `request.*`
+                // command with CALLER_ID_INVALID. Provide a deterministic caller id
+                // tied to the contract name. The contract is the only producer of
+                // this artifact, so the synthetic id cannot collide with anything
+                // real a developer is working on.
+                env: { ...process.env, PEAKS_CALLER_ID: `guard-J02-${ctx.sessionId}` }
+            });
+            return { stdout, stderr: '' };
+        }
+        catch (e) {
+            const err = e;
+            const stderr = typeof err.stderr === 'string'
+                ? err.stderr
+                : Buffer.isBuffer(err.stderr) ? err.stderr.toString('utf8') : '';
+            const stdout = typeof err.stdout === 'string'
+                ? err.stdout
+                : Buffer.isBuffer(err.stdout) ? err.stdout.toString('utf8') : '';
+            // Preserve the original error type/message but attach stderr so the
+            // outer try-catch's `e.message.slice(0, 160)` sees something useful.
+            // Truncate stdout aggressively to keep the audit envelope bounded, but
+            // pick the HEAD and TAIL of the buffer so the leading envelope header
+            // and the trailing error are both visible.
+            const stdoutHead = stdout.slice(0, 600);
+            const stdoutTail = stdout.length > 1200 ? stdout.slice(-400) : '';
+            const stdoutPart = stdoutTail
+                ? `${stdoutHead}...<truncated ${stdout.length - 1000}B>...${stdoutTail}`
+                : stdoutHead;
+            const wrapped = new Error(`${err.message} | stderr=${stderr.slice(0, 400)} | stdout=${stdoutPart}`);
+            wrapped.stdout = stdout;
+            throw wrapped;
+        }
     };
+    try {
+        const ws = run(['workspace', 'init', '--project', tmp, '--json']);
+        const { data: { sessionId } } = JSON.parse(ws.stdout);
+        const rid = '2026-08-03-j02-fixture';
+        const initOut = run(['request', 'init', '--role', 'rd', '--id', rid, '--project', tmp, '--session-id', sessionId, '--apply', '--json']);
+        const initEnv = JSON.parse(initOut.stdout);
+        // `request init` writes the file as `NNN-<id-slug>.md`. The transition CLI accepts
+        // the file's basename (without .md) as the requestId. Derive it from data.path.
+        const baseName = initEnv.data.path.split(/[\\/]/).pop() ?? '';
+        const requestId = baseName.replace(/\.md$/i, '');
+        const transition = (state, extra) => run([
+            'request', 'transition', requestId, '--role', 'rd', '--state', state,
+            '--project', tmp, '--session-id', sessionId, '--confirm',
+            '--reason', 'J02 contract fixture', ...extra, '--json'
+        ]).stdout;
+        // Hard-gate probe, run FIRST: from the freshly initialised state, jumping
+        // straight to the terminal state skips every intermediate gate and must not
+        // be accepted without the explicit incomplete-work escape hatch. Doing this
+        // before the legal walk is what makes it a skip (from `qa-handoff` the move
+        // to `handed-off` is legal and proves nothing).
+        let gateSkipRefused = false;
+        let skipError = 'not attempted';
+        try {
+            transition('handed-off', []);
+            skipError = 'transition was accepted';
+        }
+        catch (e) {
+            gateSkipRefused = true;
+            skipError = e.message.slice(0, 160);
+        }
+        let last = '';
+        try {
+            for (const s of STATES) {
+                const env = JSON.parse(transition(s, ['--allow-incomplete']));
+                last = env.data.state;
+            }
+        }
+        catch (e) {
+            last = `error: ${e.message.slice(0, 160)}`;
+        }
+        const result = combineProbes([
+            probe(missing.length === 0, `baseline sourceFiles present (${row.sourceFiles.length})`),
+            probe(gateSkipRefused, `an incomplete jump to handed-off is refused (${skipError})`),
+            probe(last === 'handed-off', `the RD state machine reaches handed-off (saw ${last})`)
+        ]);
+        const artifact = row.sourceFiles[3] ?? 'tests/integration/job-e2e.test.ts';
+        if (result.ok)
+            return pass(ctx, artifact);
+        return fail(ctx, artifact, 'every hard gate is enforced and the RD state machine still reaches handed-off', result.detail, 'J02 invariant broken: the RD state machine or its hard-gate enforcement changed');
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
 }

package/dist/services/capability-guard-runner/contracts/J03.d.ts

@@ -1,2 +1,15 @@
 import type { GuardContext, GuardRunResult } from '../types.js';
+/**
+ * Behavioural probe of the "no silent-catch / fake-green reintroduced"
+ * invariant.
+ *
+ * The previous version read `final-review-types.ts` and asserted it contained
+ * four dimension strings — a file whose own name is `final-review`, so the
+ * check restated its filename.
+ *
+ * Here the repository's own AST guard (`scripts/lint/silent-warning-detector.mjs`)
+ * is executed and its per-rule violation counts are compared against the frozen
+ * ceilings. A newly swallowed `catch` in `src/**` raises a count and reddens the
+ * journey.
+ */
 export declare function runJ03Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J03.js

@@ -1,24 +1,75 @@
-// src/services/capability-guard-runner/contracts/J03.ts
-import { readFileSync } from 'node:fs';
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-const REQUIRED_DIMENSIONS = [
-    'functional-completeness',
-    'problem-resolution',
-    'no-new-bugs',
-    'existing-functionality-intact'
-];
+import { combineProbes, fail, missingSourceFiles, pass, probe, requireBaselineRow } from './_shared.js';
+const DETECTOR = ['scripts', 'lint', 'silent-warning-detector.mjs'];
+/**
+ * Violation ceilings measured on the frozen tree when this contract was
+ * written (2026-09-15, 767 files scanned). They are a RATCHET, not a target:
+ * the invariant is "no silent-catch or fake-green pattern is REINTRODUCED", so
+ * the check is that the count does not grow. Fixing violations lowers the
+ * ceiling in the same slice that fixes them.
+ */
+const CEILING = {
+    'catch-return-null': 41,
+    'empty-catch': 59
+};
+function parseCounts(stdout) {
+    const line = /\[silent-warning-detector\] summary: (.+)$/m.exec(stdout);
+    if (line === null)
+        return null;
+    const counts = {};
+    for (const pair of line[1].split(',')) {
+        const m = /^\s*([a-z-]+)=(\d+)\s*$/.exec(pair);
+        if (m !== null)
+            counts[m[1]] = Number(m[2]);
+    }
+    return counts;
+}
+/**
+ * Behavioural probe of the "no silent-catch / fake-green reintroduced"
+ * invariant.
+ *
+ * The previous version read `final-review-types.ts` and asserted it contained
+ * four dimension strings — a file whose own name is `final-review`, so the
+ * check restated its filename.
+ *
+ * Here the repository's own AST guard (`scripts/lint/silent-warning-detector.mjs`)
+ * is executed and its per-rule violation counts are compared against the frozen
+ * ceilings. A newly swallowed `catch` in `src/**` raises a count and reddens the
+ * journey.
+ */
 export async function runJ03Contract(ctx) {
-    // Static check: the 4-dim final-review type module MUST still export those 4 dimension strings.
-    // This is a contract against accidental removal, not a runtime test of an LLM.
-    const typesPath = join(ctx.projectRoot, 'src', 'services', 'final-review', 'final-review-types.ts');
-    const src = readFileSync(typesPath, 'utf8');
-    const missing = REQUIRED_DIMENSIONS.filter((d) => !src.includes(`'${d}'`));
-    const ok = missing.length === 0;
-    return {
-        journeyId: 'J03',
-        contract: 'workflow-trace',
-        status: ok ? 'pass' : 'fail',
-        ...(ok ? {} : { diff: { before: REQUIRED_DIMENSIONS.join(','), after: missing.join(','), reason: `J03#1 broken: missing dimensions ${missing.join(',')}` } }),
-        artifactPath: 'src/services/final-review/final-review-types.ts'
-    };
+    const row = requireBaselineRow(ctx);
+    const missing = missingSourceFiles(ctx, row);
+    const detectorPath = join(ctx.projectRoot, ...DETECTOR);
+    const detectorPresent = existsSync(detectorPath);
+    const run = detectorPresent
+        ? spawnSync('node', [detectorPath], { cwd: ctx.projectRoot, encoding: 'utf8', windowsHide: true })
+        : null;
+    const stdout = run?.stdout ?? '';
+    const counts = parseCounts(stdout);
+    const scanned = /scanned (\d+) files/.exec(stdout);
+    const grew = [];
+    const missingRules = [];
+    if (counts !== null) {
+        for (const rule of Object.keys(CEILING)) {
+            if (counts[rule] === undefined)
+                missingRules.push(rule);
+            else if (counts[rule] > CEILING[rule])
+                grew.push(`${rule}: ${String(counts[rule])} > ${String(CEILING[rule])}`);
+        }
+    }
+    const result = combineProbes([
+        probe(missing.length === 0, `baseline sourceFiles present (${row.sourceFiles.length})`),
+        probe(detectorPresent, `the repository AST guard is present (${detectorPath})`),
+        probe(scanned !== null && Number(scanned[1]) > 0, `the AST guard scanned files (${scanned?.[1] ?? 'none'})`),
+        probe(counts !== null, `the AST guard reported per-rule counts (${counts === null ? 'unparseable' : JSON.stringify(counts)})`),
+        probe(missingRules.length === 0, `every ratcheted rule was reported (missing: ${missingRules.join(',') || 'none'})`),
+        probe(grew.length === 0, `no silent-catch rule count grew past its ceiling (${grew.join('; ') || 'none'})`)
+    ]);
+    const artifact = row.sourceFiles[1] ?? 'src/services/final-review/final-review-service.ts';
+    if (result.ok)
+        return pass(ctx, artifact);
+    return fail(ctx, artifact, `silent-catch violation counts stay at or below ${JSON.stringify(CEILING)}`, result.detail, 'J03 invariant broken: a silent-catch or fake-green pattern was reintroduced under src/**');
 }

package/dist/services/capability-guard-runner/contracts/J04.d.ts

@@ -1,2 +1,8 @@
 import type { GuardContext, GuardRunResult } from '../types.js';
+/**
+ * Behavioural probe: drive `auditGoal()` with a complete and an incomplete
+ * payload and assert it accepts exactly one of them. Counting `dimension`
+ * occurrences in the source would have passed even if the six-element guard
+ * were replaced by a comment.
+ */
 export declare function runJ04Contract(ctx: GuardContext): Promise<GuardRunResult>;

package/dist/services/capability-guard-runner/contracts/J04.js

@@ -1,42 +1,75 @@
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { auditGoal, IncompleteAuditError } from '../../audit/audit-goal-service.js';
+import { combineProbes, fail, missingSourceFiles, pass, probe, requireBaselineRow } from './_shared.js';
+/** The six dimensions the frozen baseline names, in the baseline's own order. */
+const SIX_DIMENSIONS = [
+    'correctness', 'completeness', 'scope', 'risks', 'alternatives', 'constraints'
+];
+function runnerReturning(output) {
+    return { call: async () => ({ output, tokens: { input: 1, output: 1 } }) };
+}
+function envelope(dimensions, severity = 'info') {
+    return JSON.stringify({
+        summary: 's',
+        audit: dimensions.map((dimension) => ({ dimension, finding: 'f', severity })),
+        proposedGoal: 'g',
+        successCriteria: ['c'],
+        roughEffort: 'small',
+        confidence: 'high',
+        rationale: 'r'
+    });
+}
+/**
+ * Behavioural probe: drive `auditGoal()` with a complete and an incomplete
+ * payload and assert it accepts exactly one of them. Counting `dimension`
+ * occurrences in the source would have passed even if the six-element guard
+ * were replaced by a comment.
+ */
 export async function runJ04Contract(ctx) {
-    const bin = join(ctx.projectRoot, 'bin', 'peaks.js');
-    const tmp = mkdtempSync(join(tmpdir(), 'cbl-J04-'));
-    // Probe: `peaks audit goal` must be a registered subcommand (returns a help-like response or a structured envelope).
-    let helpOk = false;
+    const row = requireBaselineRow(ctx);
+    const missing = missingSourceFiles(ctx, row);
+    let completeAccepted = false;
+    let completeCount = -1;
     try {
-        const stdout = execFileSync('node', [bin, 'audit', 'goal', '--help'], {
-            cwd: ctx.projectRoot,
-            env: { ...process.env, PEAKS_CALLER_ID: `guard-J04-${ctx.sessionId}` },
-            windowsHide: true
-        }).toString('utf8');
-        helpOk = stdout.length > 0 && !stdout.includes('unknown command');
+        const out = await auditGoal({ need: 'n' }, runnerReturning(envelope(SIX_DIMENSIONS)));
+        completeAccepted = true;
+        completeCount = out.audit.length;
     }
     catch {
-        helpOk = false;
+        completeAccepted = false;
     }
-    // Probe: `peaks audit goal` without a goal must not silently succeed.
-    let rejectsEmpty = false;
+    let fiveRejected = false;
+    let rejectName = 'none';
     try {
-        execFileSync('node', [bin, 'audit', 'goal', '--project', tmp, '--json'], {
-            cwd: ctx.projectRoot,
-            env: { ...process.env, PEAKS_CALLER_ID: `guard-J04-${ctx.sessionId}` },
-            stdio: ['ignore', 'pipe', 'pipe'],
-            windowsHide: true
-        });
+        await auditGoal({ need: 'n' }, runnerReturning(envelope(SIX_DIMENSIONS.slice(0, 5))));
     }
     catch (e) {
-        rejectsEmpty = true;
+        fiveRejected = true;
+        rejectName = e.name;
+    }
+    // Any one dimension dropped must be refused — not just the last one.
+    let eachDropRejected = true;
+    const accepted = new Set();
+    for (const dropped of SIX_DIMENSIONS) {
+        const dims = SIX_DIMENSIONS.filter((d) => d !== dropped);
+        try {
+            await auditGoal({ need: 'n' }, runnerReturning(envelope(dims)));
+            eachDropRejected = false;
+            accepted.add(dropped);
+        }
+        catch {
+            /* expected */
+        }
     }
-    const ok = helpOk && rejectsEmpty;
-    return {
-        journeyId: 'J04',
-        contract: 'hook-assertion',
-        status: ok ? 'pass' : 'fail',
-        ...(ok ? {} : { diff: { before: 'audit goal is registered and rejects empty input', after: `helpOk=${helpOk} rejectsEmpty=${rejectsEmpty}`, reason: 'J04#1 broken: audit goal binding is bypassed or missing' } }),
-        artifactPath: 'src/services/audit/audit-goal-service.ts'
-    };
+    const result = combineProbes([
+        probe(missing.length === 0, `baseline sourceFiles present (${row.sourceFiles.length})`),
+        probe(completeAccepted, 'six-dimension audit is accepted'),
+        probe(completeCount === 6, `accepted audit carries exactly 6 dimensions (saw ${completeCount})`),
+        probe(fiveRejected, 'five-dimension audit is rejected'),
+        probe(rejectName === 'IncompleteAuditError', `rejection is IncompleteAuditError (saw ${rejectName}, ${IncompleteAuditError.name})`),
+        probe(eachDropRejected, `dropping any single dimension is rejected (accepted: ${[...accepted].join(',') || 'none'})`)
+    ]);
+    const artifact = row.sourceFiles[0] ?? 'src/services/audit/audit-goal-service.ts';
+    if (result.ok)
+        return pass(ctx, artifact);
+    return fail(ctx, artifact, 'auditGoal() accepts a complete six-dimension payload and rejects any five-dimension payload', result.detail, 'J04 invariant broken: the audit does not cover exactly six dimensions');
 }

package/dist/services/capability-guard-runner/contracts/J05.js

@@ -1,21 +1,123 @@
-import { readFileSync } from 'node:fs';
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-const REQUIRED_FRAGMENTS = [
-    "'functional-completeness'",
-    "'problem-resolution'",
-    "'no-new-bugs'",
-    "'existing-functionality-intact'"
+import { IncompleteFinalReviewError, MAX_EVIDENCE_BYTES_PER_FILE, outputBudgetForEvidence, prepareFinalReview, resolveOutputBudget, undeliverableDimensions } from '../../final-review/final-review-service.js';
+import { combineProbes, fail, missingSourceFiles, pass, probe, requireBaselineRow } from './_shared.js';
+/** The four dimensions the frozen baseline names. The 5th is NOT one of them. */
+const FOUR_DIMENSIONS = [
+    'functional-completeness', 'problem-resolution', 'no-new-bugs', 'existing-functionality-intact'
 ];
-export async function runJ05Contract(ctx) {
-    const servicePath = join(ctx.projectRoot, 'src', 'services', 'final-review', 'final-review-service.ts');
-    const src = readFileSync(servicePath, 'utf8');
-    const missing = REQUIRED_FRAGMENTS.filter((f) => !src.includes(f));
-    const ok = missing.length === 0;
+const FIFTH_DIMENSION = 'capability-consistency';
+/**
+ * One oversized, omitted source that backs `dimension`. `omitted` + over-cap +
+ * zero delivered bytes is the structural case: nothing can ever deliver it.
+ */
+function undeliverableSource(dimension, totalBytes) {
     return {
-        journeyId: 'J05',
-        contract: 'workflow-trace',
-        status: ok ? 'pass' : 'fail',
-        ...(ok ? {} : { diff: { before: 'all 4 dim strings present in final-review-service.ts', after: missing.join(','), reason: `J05#1 broken: missing fragments ${missing.join(',')}` } }),
-        artifactPath: 'src/services/final-review/final-review-service.ts'
+        source: {
+            key: `k-${dimension}`,
+            label: dimension,
+            segments: [`${dimension}.md`],
+            supports: [dimension],
+            delivery: { kind: 'whole' }
+        },
+        relativePath: `${dimension}.md`,
+        absolutePath: `/nonexistent/${dimension}.md`,
+        status: 'omitted',
+        totalBytes,
+        includedBytes: 0,
+        content: '',
+        reason: 'over-cap'
     };
 }
+function reviewJson(dimensions) {
+    return JSON.stringify({
+        rid: 'J05-fixture',
+        generatedAt: new Date(0).toISOString(),
+        dimensions: dimensions.map((dimension) => ({
+            dimension,
+            verdict: 'pass',
+            summary: 's',
+            evidence: [],
+            confidence: 'high'
+        })),
+        overallSummary: 's',
+        allPass: true,
+        needsAttention: []
+    });
+}
+function runnerReturning(output) {
+    return { call: async () => ({ output, tokens: { input: 1, output: 1024 } }) };
+}
+/**
+ * Drive the real 4-dimension gate: a reply covering three of four dimensions
+ * must be refused, a reply covering all four must be accepted. Reading the
+ * four strings out of `final-review-service.ts` proved only that the literals
+ * were still typed somewhere in the file.
+ */
+async function probePrepareFinalReview() {
+    const root = mkdtempSync(join(tmpdir(), 'cbl-J05-'));
+    try {
+        const sessionId = 'guard-J05';
+        mkdirSync(join(root, '.peaks', '_runtime', sessionId, 'audit-goal'), { recursive: true });
+        writeFileSync(join(root, '.peaks', '_runtime', sessionId, 'audit-goal', 'J05-fixture.json'), JSON.stringify({ successCriteria: ['c'] }));
+        const opts = { projectRoot: root, sessionId };
+        let rejected = false;
+        let rejectName = 'none';
+        try {
+            await prepareFinalReview('J05-fixture', { ...opts, llmRunner: runnerReturning(reviewJson(FOUR_DIMENSIONS.slice(0, 3))) });
+        }
+        catch (e) {
+            rejected = e.name === IncompleteFinalReviewError.name;
+            rejectName = e.name;
+        }
+        let accepted = false;
+        let acceptError = '';
+        try {
+            const out = await prepareFinalReview('J05-fixture', { ...opts, llmRunner: runnerReturning(reviewJson(FOUR_DIMENSIONS)) });
+            accepted = out.dimensions.length === 4;
+        }
+        catch (e) {
+            acceptError = `${e.name}: ${e.message.slice(0, 160)}`;
+        }
+        return {
+            rejected,
+            accepted,
+            detail: `three-dimension reply rejected=${String(rejected)} (${rejectName}); four-dimension reply accepted=${String(accepted)}${acceptError ? ` [${acceptError}]` : ''}`
+        };
+    }
+    finally {
+        rmSync(root, { recursive: true, force: true });
+    }
+}
+export async function runJ05Contract(ctx) {
+    const row = requireBaselineRow(ctx);
+    const missing = missingSourceFiles(ctx, row);
+    const prepared = await probePrepareFinalReview();
+    const oversized = FOUR_DIMENSIONS.map((d) => undeliverableSource(d, MAX_EVIDENCE_BYTES_PER_FILE + 1000));
+    const reported = undeliverableDimensions(oversized).map((r) => r.dimension);
+    const fifthOnly = undeliverableDimensions([undeliverableSource(FIFTH_DIMENSION, MAX_EVIDENCE_BYTES_PER_FILE + 1000)]);
+    const floor = outputBudgetForEvidence(0);
+    const ceiling = outputBudgetForEvidence(Number.MAX_SAFE_INTEGER);
+    let badOverrideThrows = false;
+    try {
+        resolveOutputBudget(0, { PEAKS_FINAL_REVIEW_MAX_OUTPUT_TOKENS: 'abc' });
+    }
+    catch {
+        badOverrideThrows = true;
+    }
+    const result = combineProbes([
+        probe(missing.length === 0, `baseline sourceFiles present (${row.sourceFiles.length})`),
+        probe(prepared.rejected, `a three-dimension review is refused (${prepared.detail})`),
+        probe(prepared.accepted, `a four-dimension review is accepted (${prepared.detail})`),
+        probe(reported.length === 4 && FOUR_DIMENSIONS.every((d) => reported.includes(d)), `the canonical dimension set is exactly the four baseline dimensions (reported: ${reported.join(',') || 'none'})`),
+        probe(fifthOnly.length === 0, `the fifth dimension is not part of the required set (reported: ${fifthOnly.length})`),
+        probe(MAX_EVIDENCE_BYTES_PER_FILE === 10240, `per-file evidence cap divides the total by four (${String(MAX_EVIDENCE_BYTES_PER_FILE)})`),
+        probe(floor === 15288 && ceiling === 32000, `output budget is clamped on both ends (${String(floor)} / ${String(ceiling)})`),
+        probe(badOverrideThrows, 'a non-integer budget override throws instead of falling back silently')
+    ]);
+    const artifact = row.sourceFiles[0] ?? 'src/services/final-review/final-review-service.ts';
+    if (result.ok)
+        return pass(ctx, artifact);
+    return fail(ctx, artifact, 'every final review contains exactly four dimensions, and ambiguous ones never auto-pass', result.detail, 'J05 invariant broken: the final review no longer enforces exactly four dimensions');
+}

package/dist/services/capability-guard-runner/contracts/J06.d.ts

@@ -1,2 +1,16 @@
 import type { GuardContext, GuardRunResult } from '../types.js';
+/**
+ * Behavioural probe for "the resume option always identifies the DEEPEST
+ * completed gate".
+ *
+ * The load-bearing part is that the SAME fixture is walked from shallow to
+ * deep: with only a PRD request the classifier must stop at `rd-planning`;
+ * the moment a deeper RD `qa-handoff` request appears (with its review
+ * artifacts) the point must move to `qa-validation`; adding the txt handoff
+ * must end the workflow. A classifier that returned a constant point, or that
+ * looked at file existence alone, cannot track that progression.
+ *
+ * The old check asserted that a file named `session-resume-service.ts` exists
+ * and contains the word "resume" — which the filename already guarantees.
+ */
 export declare function runJ06Contract(ctx: GuardContext): Promise<GuardRunResult>;