peaks-loop 4.0.49 → 4.0.51

package/dist/services/audit/prose-ratio-calculator.js

@@ -1,21 +1,25 @@
 /**
- * Prose-only ratio calculator — Slice C Group G3 (v2.14.0).
+ * Prose-only ratio calculator — Slice C Group G3 (v2.14.0),
+ * corrected in S3 of the 2026-09-15 diagnosis-remediation job.
  *
- * Computes the prose-only ratio for a set of red-line entries. Per
- * spec §10.2 + the v2.12.1 reform (`.peaks/memory/2026-06-27-
- * prose-only-catalog-followup.md`), an entry counts as prose-only
- * only when BOTH:
- *   1. `backing === 'prose-only'`
- *   2. `informational !== true`
+ * An entry counts as prose-only when `backing === 'prose-only'`.
+ * Full stop. There is no second condition.
  *
- * The 80 discovered advisory SKILL.md phrases (auto-marked
- * `informational=true` by `classifier.ts:141`) are excluded from
- * the ratio so the gate (≤ 5% per slice C AC A3.1) reflects the
- * actionable backlog.
+ * The pre-S3 version also required `informational !== true`, on the
+ * reasoning that auto-discovered advisory SKILL.md phrases are "not
+ * actionable red lines". Whatever the merits of that reading, the effect
+ * was to move 44 of 152 rows — 29% of the catalog — out of the
+ * denominator, so the gate reported `proseOnly: 0` while the same JSON
+ * carried 44 rows with `"backing": "prose-only"`. A metric whose
+ * denominator can be redefined by the code it measures is not a metric.
  *
- * Karpathy §2 simplicity: one exported function plus a thin
- * calculator interface; no I/O. The pure form makes the ≥8
- * test cases in prose-ratio-calculator.test.ts trivial.
+ * `informational` survives as a triage label — `discoveredProseOnly`
+ * below counts those rows — but it no longer moves any number that the
+ * ratio is computed from. Expect the ratio to look much worse than it
+ * did; that is this correction working.
+ *
+ * Karpathy §2 simplicity: one exported function plus a thin calculator
+ * interface; no I/O.
  */
 /** Default target: 5% (per A3.1). */
 export const DEFAULT_PROSE_RATIO_TARGET = 0.05;
@@ -24,18 +28,20 @@ export function computeProseRatio(entries, options = {}) {
     let cliBacked = 0;
     let partial = 0;
     let proseOnly = 0;
+    let discoveredProseOnly = 0;
     let informational = 0;
     for (const entry of entries) {
-        if (entry.informational === true) {
+        if (entry.informational === true)
             informational += 1;
-            continue;
-        }
         if (entry.backing === 'cli-backed')
             cliBacked += 1;
         else if (entry.backing === 'partial')
             partial += 1;
-        else if (entry.backing === 'prose-only')
+        else if (entry.backing === 'prose-only') {
             proseOnly += 1;
+            if (entry.informational === true)
+                discoveredProseOnly += 1;
+        }
     }
     const totalRedLines = entries.length;
     const ratio = totalRedLines === 0 ? 0 : proseOnly / totalRedLines;
@@ -44,6 +50,7 @@ export function computeProseRatio(entries, options = {}) {
         cliBacked,
         partial,
         proseOnly,
+        discoveredProseOnly,
         informational,
         ratio,
         target,

package/dist/services/audit/red-line-catalog-p2-a.js

@@ -216,7 +216,7 @@ const PRD_ARTIFACT_HANDOFF = {
 };
 const RD_HANDOFF_CONTRACT = {
     id: 'rl-rd-handoff-contract-001',
-    rule: 'peaks-rd SKILL.md must declare the QA-handoff BLOCKING contract (tech-doc + perf-baseline)',
+    rule: 'peaks-rd must not hand off to QA without a non-empty RD artifact under rd/requests/',
     markers: ['BLOCKING'],
     phrases: ['do not hand off to qa without', 'tech-doc', 'perf-baseline'],
     enforcerRef: 'src/services/audit/enforcers/lint-rd-handoff-coverage.ts',

package/dist/services/audit/red-lines-service.js

@@ -16,6 +16,8 @@ import { existsSync, readdirSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { classifyFiles } from './classifier.js';
 import { classifyBackingBatch } from './backing-detector.js';
+import { computeLiveEnforcers } from './enforcer-liveness.js';
+import { RED_LINE_CATALOG } from './red-line-catalog.js';
 import { scanSkillsTree } from './scanners/skills-tree-scanner.js';
 import { scanRulesTree } from './scanners/rules-tree-scanner.js';
 import { scanOpenSpecTree } from './scanners/openspec-scanner.js';
@@ -28,6 +30,7 @@ import { readSkillFiles, lintSectionShape, lintSectionOrder, lintFrontmatterShap
 import { lintRefPathResolves, lintNoBrokenMkdir, lintNoPwdSymlinkJumps, lintNoRelativeArchivePaths, } from './enforcers/lint-reference-integrity.js';
 import { lintCliBackMandatorText, lintCliBackNoOrphanBlocking, lintCliBackNoOrphanMustNot, } from './enforcers/lint-cli-back.js';
 import { lintNoFluff, lintNoClosingPrompt, lintStatusHeader, } from './enforcers/lint-output-style.js';
+import { lintRdHandoffContract, lintRdCoverageDiscipline, } from './enforcers/lint-rd-handoff-coverage.js';
 import { lintOpenSpecAcceptanceBullets, lintOpenSpecSpecReference, 
 // (Removed in v2.11.0 Group A: `lintTechDocPresenceShape`)
 lintPeaksDoctorAcknowledged, } from './enforcers/lint-workflow-shape.js';
@@ -59,15 +62,16 @@ function tally(entries) {
     let partial = 0;
     let proseOnly = 0;
     for (const entry of entries) {
-        // v2.12.1 catalog governance: informational entries (auto-discovered
-        // prose phrases without a catalog template) are counted in the
-        // total but excluded from `proseOnly` so the ratio (per spec §10.2
-        // ≤ 5%) reflects the actionable backlog only.
+        // S3 of the 2026-09-15 diagnosis-remediation job: `informational` is a
+        // triage label, not a ratio input. The pre-S3 version skipped
+        // informational rows here too, which is how the audit came to report
+        // `proseOnly: 0` while carrying 44 `"backing": "prose-only"` rows in
+        // the same envelope. Every prose-only row is now counted.
         if (entry.backing === 'cli-backed')
             cliBacked++;
         else if (entry.backing === 'partial')
             partial++;
-        else if (!entry.informational)
+        else if (entry.backing === 'prose-only')
             proseOnly++;
     }
     return {
@@ -87,7 +91,12 @@ export function runRedLinesAudit(input) {
     const openspec = scanOpenSpecTree({ projectRoot: input.projectRoot });
     const fileInputs = buildFileInputs(skills, rules, openspec);
     const classified = classifyFiles(fileInputs);
-    const backed = classifyBackingBatch(classified.entries, input.projectRoot);
+    // A9: `cli-backed` requires a call site, not just a file on disk. The
+    // live set is computed once for the whole catalog; `null` means the
+    // project has no `src/` tree and liveness is undecidable, in which case
+    // the detector falls back to the pre-A9 "file exists" rule.
+    const liveness = computeLiveEnforcers(input.projectRoot, RED_LINE_CATALOG.map((entry) => entry.enforcerRef).filter((ref) => ref !== null));
+    const backed = classifyBackingBatch(classified.entries, input.projectRoot, liveness.live);
     // Sub-agent-sid enforcer (Task 2): dogfoods Slice 0.5 sid-naming-guard.
     const subAgentSids = findInvalidSubAgentSids(input.projectRoot);
     const runtimeSids = findInvalidRuntimeSids(input.projectRoot);
@@ -97,7 +106,22 @@ export function runRedLinesAudit(input) {
         ...openspec.warnings,
         ...classified.warnings.map((message) => ({ file: '(classifier)', message })),
         ...backed.warnings.map((message) => ({ file: '(backing-detector)', message })),
+        ...liveness.warnings.map((message) => ({ file: '(enforcer-liveness)', message })),
     ];
+    // A9: name every enforcer that was downgraded, so the drop in
+    // `cliBacked` is attributable rather than mysterious.
+    if (liveness.unknown) {
+        warnings.push({
+            file: '(enforcer-liveness)',
+            message: 'no src/ tree under the project root; enforcer liveness is undecidable, so `cli-backed` falls back to the pre-A9 "the enforcer file exists" rule',
+        });
+    }
+    for (const ref of backed.deadEnforcers) {
+        warnings.push({
+            file: ref,
+            message: 'enforcer file exists but nothing outside src/services/audit/enforcers/ imports it; red lines backed by it are counted as prose-only',
+        });
+    }
     if (subAgentSids.scanned && subAgentSids.invalid.length > 0) {
         for (const sid of subAgentSids.invalid) {
             warnings.push({
@@ -261,15 +285,31 @@ export function runRedLinesAudit(input) {
         const skillsRoot = join(input.projectRoot, 'skills');
         if (existsSync(skillsRoot)) {
             const skillNames = [];
+            const skippedRoots = [];
             for (const entry of readdirSync(skillsRoot, { withFileTypes: true })) {
                 if (!entry.isDirectory())
                     continue;
                 if (entry.name.startsWith('.'))
                     continue;
-                if (!existsSync(join(skillsRoot, entry.name, 'SKILL.md')))
+                if (!existsSync(join(skillsRoot, entry.name, 'SKILL.md'))) {
+                    skippedRoots.push(entry.name);
                     continue;
+                }
                 skillNames.push(entry.name);
             }
+            // A11 scope limit, declared rather than left implicit: only skills
+            // with a top-level `SKILL.md` are linted. Nested roots such as
+            // `skills/bee/` hold real skills (`peaks-perf-audit`, `peaks-rd`, …)
+            // that the classifier DOES see (their markers appear as
+            // `rl-discovered-skills-bee-*` rows) but that every Theme A–G
+            // lint-style enforcer skips. A clean Theme A result therefore means
+            // "clean among the linted skills", not "clean everywhere".
+            for (const root of skippedRoots) {
+                warnings.push({
+                    file: `skills/${root}`,
+                    message: 'no top-level SKILL.md — this directory and every skill nested under it are skipped by all lint-style enforcers (including rl-section-hard-contracts-001); their red-line rows are unverified',
+                });
+            }
             const skillFiles = readSkillFiles(skillsRoot, skillNames);
             for (const skill of skillFiles) {
                 const refsDir = join(skillsRoot, skill.name, 'references');
@@ -291,6 +331,10 @@ export function runRedLinesAudit(input) {
                     ...lintNoFluff(skill),
                     ...lintNoClosingPrompt(skill),
                     ...lintPeaksDoctorAcknowledged(skill),
+                    // A10: the RD handoff gate reads the artifact, not the SKILL.md
+                    // sentence that promises one. See lint-rd-handoff-coverage.ts.
+                    ...lintRdHandoffContract(skill, input.projectRoot),
+                    ...lintRdCoverageDiscipline(skill),
                 ];
                 for (const hit of lintHits) {
                     enforcerFindings.push({

package/dist/services/capability-audit-service/independent-checker.d.ts

@@ -0,0 +1,15 @@
+import { type CapabilityBaselineRow } from '../capability-baseline/types.js';
+import type { GuardContract, GuardRunResult } from '../capability-guard-runner/types.js';
+import type { IndependentCheckResult } from './types.js';
+export interface IndependentCheckInput {
+    readonly projectRoot: string;
+    readonly baselineRows: ReadonlyArray<CapabilityBaselineRow>;
+    readonly contracts: ReadonlyArray<GuardContract>;
+    readonly guardResults: ReadonlyArray<GuardRunResult>;
+}
+/**
+ * Run the credential-free independent evaluation. The verdict is `drifted`
+ * whenever a concrete deviation is observed — this function has no path that
+ * returns `consistent` without having checked.
+ */
+export declare function runIndependentCheck(input: IndependentCheckInput): IndependentCheckResult;

package/dist/services/capability-audit-service/independent-checker.js

@@ -0,0 +1,140 @@
+// src/services/capability-audit-service/independent-checker.ts
+//
+// The live, credential-free audit scorer.
+//
+// WHY A DETERMINISTIC CHECKER AND NOT AN LLM CALL
+// ----------------------------------------------
+// `publish.yml` is a secretless OIDC trusted-publishing workflow: `id-token:
+// write`, no npm token, and no LLM credential of any kind in the environment.
+// An LLM scorer therefore cannot run in the gate that decides whether a
+// release happens. Adding a long-lived API secret to a secretless pipeline to
+// serve that gate would be a threat-model regression, and an LLM verdict is
+// non-deterministic — the same commit could flip between runs. So the live
+// scorer must be credential-free.
+//
+// WHY IT IS STILL "INDEPENDENT"
+// -----------------------------
+// Independence is a property of the information channel, not of the substrate
+// (RL-5 constrains what the scorer READS: `scorer.reads: evaluation_package_only`
+// — it never requires a model). The scorer this replaces was handed
+// `{baselineJourneyId, guard}` and asked to re-state it; an LLM given that same
+// payload would be exactly as much a rubber stamp. The disease was the payload.
+//
+// This checker answers a question no guard contract can answer, from inputs no
+// guard reads:
+//   - a guard sees only ITSELF, so it cannot report that the observation set was
+//     silently narrowed, or that a frozen row is armed by no contract at all;
+//   - this checker sees the whole frozen claim set AND the whole registry.
+// It reads only the evaluation package — no author reasoning, no session id, no
+// self-praise framing — so RL-5's exclusions hold by construction.
+//
+// WHAT IT DOES NOT COVER (stated, not hidden)
+// -------------------------------------------
+// It does not read `forbiddenChanges` prose, and it cannot judge behaviour
+// beyond what the 15 guard contracts already exercise. Its claim is narrower
+// than "the 15 journeys are intact"; `coverage` in the result discloses exactly
+// how narrow, so `consistent` is never read as more than it is.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { P0_JOURNEY_IDS } from '../capability-baseline/types.js';
+function finding(code, journeyId, detail) {
+    return { code, journeyId, detail };
+}
+/**
+ * The observed journey set must be exactly the frozen P0 set. `runAllGuards`
+ * aggregates whatever contracts it was handed, so a registry that lost a
+ * journey reports a clean `pass: 14 / fail: 0` — a narrower check that looks
+ * exactly like a green one. Nothing in the guard results can say so; only the
+ * frozen set can.
+ */
+function checkObservationSet(frozen, observed) {
+    const out = [];
+    const counts = new Map();
+    for (const j of observed)
+        counts.set(j, (counts.get(j) ?? 0) + 1);
+    for (const j of frozen) {
+        const n = counts.get(j) ?? 0;
+        if (n === 0)
+            out.push(finding('OBSERVATION_INCOMPLETE', j, `${j} is in the frozen baseline but no guard result was observed for it`));
+        else if (n > 1)
+            out.push(finding('OBSERVATION_INCOMPLETE', j, `${j} produced ${String(n)} guard results; the frozen baseline declares it once`));
+    }
+    for (const j of counts.keys()) {
+        if (!frozen.includes(j))
+            out.push(finding('OBSERVATION_INCOMPLETE', j, `${j} was observed but is not a frozen P0 journey`));
+    }
+    return out;
+}
+/** The frozen claim set itself must be the P0 set, with no duplicate rows. */
+function checkFrozenRows(rows) {
+    const out = [];
+    const seen = new Map();
+    for (const r of rows)
+        seen.set(r.journeyId, (seen.get(r.journeyId) ?? 0) + 1);
+    for (const j of P0_JOURNEY_IDS) {
+        const n = seen.get(j) ?? 0;
+        if (n === 0)
+            out.push(finding('BASELINE_ROW_SET_INVALID', j, `frozen baseline has no row for ${j}`));
+        else if (n > 1)
+            out.push(finding('BASELINE_ROW_SET_INVALID', j, `frozen baseline declares ${j} ${String(n)} times`));
+    }
+    for (const j of seen.keys()) {
+        if (!P0_JOURNEY_IDS.includes(j))
+            out.push(finding('BASELINE_ROW_SET_INVALID', j, `frozen baseline declares ${j}, which is not a P0 journey`));
+    }
+    return out;
+}
+/**
+ * Every `sourceFiles` entry of every frozen row must still exist. The guard
+ * contracts check this too, but only through their own contract — so a
+ * contract rewritten to drop that probe takes the check with it. Reading the
+ * frozen text directly means the binding survives such a rewrite.
+ */
+function checkSourceBindings(projectRoot, rows) {
+    const out = [];
+    for (const row of rows) {
+        for (const f of row.sourceFiles) {
+            if (!existsSync(join(projectRoot, f))) {
+                out.push(finding('SOURCE_FILE_MISSING', row.journeyId, `frozen sourceFiles entry "${f}" is not on disk`));
+            }
+        }
+    }
+    return out;
+}
+function countArmed(rows, contracts) {
+    let armed = 0;
+    for (const row of rows) {
+        for (const inv of row.invariants) {
+            if (contracts.some((c) => c.source.baselineRow === row.journeyId && c.source.invariant === inv))
+                armed += 1;
+        }
+    }
+    return armed;
+}
+/**
+ * Run the credential-free independent evaluation. The verdict is `drifted`
+ * whenever a concrete deviation is observed — this function has no path that
+ * returns `consistent` without having checked.
+ */
+export function runIndependentCheck(input) {
+    const observed = input.guardResults.map((r) => r.journeyId);
+    const findings = [
+        ...checkFrozenRows(input.baselineRows),
+        ...checkObservationSet(input.baselineRows.map((r) => r.journeyId), observed),
+        ...checkSourceBindings(input.projectRoot, input.baselineRows)
+    ];
+    const coverage = {
+        observations: observed.length,
+        observationsExpected: P0_JOURNEY_IDS.length,
+        invariantsFrozen: input.baselineRows.reduce((n, r) => n + r.invariants.length, 0),
+        invariantsArmed: countArmed(input.baselineRows, input.contracts),
+        // Disclosed, not checked: free-text prohibitions cannot be judged
+        // deterministically without turning a keyword scan into a fake verdict.
+        forbiddenChangesUnverified: input.baselineRows.reduce((n, r) => n + r.forbiddenChanges.length, 0)
+    };
+    return {
+        verdict: findings.length === 0 ? 'consistent' : 'drifted',
+        findings,
+        coverage
+    };
+}

package/dist/services/capability-audit-service/index.d.ts

@@ -1,3 +1,5 @@
 export { crossCheck } from './cross-check.js';
+export { runIndependentCheck } from './independent-checker.js';
+export type { IndependentCheckInput } from './independent-checker.js';
 export { isStale } from './staleness.js';
-export type { AuditVerdict, AuditEvidenceKind, AuditDimension, CrossCheck, CapabilityAuditResult } from './types.js';
+export type { AuditVerdict, AuditEvidenceKind, AuditDimension, AuditFinding, AuditFindingCode, AuditCoverage, IndependentCheckResult, CrossCheck, CapabilityAuditResult } from './types.js';

package/dist/services/capability-audit-service/index.js

@@ -1,2 +1,3 @@
 export { crossCheck } from './cross-check.js';
+export { runIndependentCheck } from './independent-checker.js';
 export { isStale } from './staleness.js';

package/dist/services/capability-audit-service/runner.d.ts

@@ -1,21 +1,25 @@
 import type { CapabilityAuditResult } from './types.js';
-import type { JourneyId } from '../capability-baseline/types.js';
-import type { GuardRunResult } from '../capability-guard-runner/types.js';
+import type { CapabilityBaselineRow, JourneyId } from '../capability-baseline/types.js';
+import type { GuardContract, GuardRunResult } from '../capability-guard-runner/types.js';
+/**
+ * `stub` means the "independent" verdict came from a hard-coded response, not
+ * from a separate context. A stub is not an evaluation, so an audit that used
+ * one is marked `degraded` and can never report `consistent`.
+ *
+ * `live` runs the deterministic independent checker: a real separate-context
+ * evaluation that needs no credentials, which is why it is the only kind that
+ * can run inside the secretless OIDC publish gate.
+ */
+export type AuditScorerMode = 'stub' | 'live';
 export interface RunAuditInput {
     readonly projectRoot: string;
     readonly sessionId: string;
     readonly journeyId: JourneyId;
-    readonly llmRunner: {
-        call(system: string, user: string, opts: {
-            maxTokens: number;
-        }): Promise<{
-            output: string;
-            tokens: {
-                input: number;
-                output: number;
-            };
-        }>;
-    };
+    readonly scorerMode: AuditScorerMode;
+    /** The frozen claim set under audit. */
+    readonly baselineRows: ReadonlyArray<CapabilityBaselineRow>;
+    /** The arming witness: which frozen invariants some contract enforces. */
+    readonly contracts: ReadonlyArray<GuardContract>;
     readonly guardSummary: {
         readonly pass: number;
         readonly fail: number;

package/dist/services/capability-audit-service/runner.js

@@ -1,29 +1,87 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { crossCheck } from './cross-check.js';
-const SYSTEM = 'You are an INDEPENDENT audit scorer. Compare the supplied capability baseline to the supplied current behavior summary. Output a single JSON object: {"verdict":"consistent" | "drifted" | "inconclusive"}. No prose.';
+import { runIndependentCheck } from './independent-checker.js';
+function scoreFor(status) {
+    return status === 'pass' ? 1 : status === 'fail' ? 0 : 0.5;
+}
 export async function runAudit(input) {
-    const userPayload = JSON.stringify({ baselineJourneyId: input.journeyId, guard: input.guardSummary });
-    const r = await input.llmRunner.call(SYSTEM, userPayload, { maxTokens: 200 });
-    const { verdict: independentVerdict } = JSON.parse(r.output);
+    const degraded = input.scorerMode === 'stub';
+    // A stub run performs no evaluation, so the checker is not run either — its
+    // result would be misread as an evaluation that happened.
+    const check = degraded
+        ? null
+        : runIndependentCheck({
+            projectRoot: input.projectRoot,
+            baselineRows: input.baselineRows,
+            contracts: input.contracts,
+            guardResults: input.guardSummary.results
+        });
     const xc = crossCheck({
         guardPass: input.guardSummary.pass,
         guardFail: input.guardSummary.fail,
-        independentPass: independentVerdict === 'consistent' ? 1 : 0,
-        independentFail: independentVerdict === 'drifted' ? 1 : 0,
+        // A degraded run has no independent verdict to compare; 0/0 keeps the
+        // cross-check shape without inventing one.
+        independentPass: check?.verdict === 'consistent' ? 1 : 0,
+        independentFail: check?.verdict === 'drifted' ? 1 : 0,
         karpathy: 'skipped'
     });
-    let verdict = independentVerdict;
-    if (xc.guardVsAudit === 'diverge')
+    // S1's rule is unchanged and load-bearing: a run that performed no separate
+    // evaluation can never be `consistent`. S11 adds the live branch. Every
+    // concrete deviation — a failed guard contract, or a finding from the
+    // independent checker — reports `drifted` instead of hiding behind
+    // `inconclusive`. So `inconclusive` is now reachable only when no evaluation
+    // ran at all, which is what it should mean.
+    let verdict = 'consistent';
+    if (degraded)
         verdict = 'inconclusive';
-    const dimensions = [{
+    else if (input.guardSummary.fail > 0)
+        verdict = 'drifted';
+    else if ((check?.findings.length ?? 0) > 0)
+        verdict = 'drifted';
+    // One dimension per journey actually run, scored from the guard result —
+    // previously this was a single row whose score was derived from the stub.
+    const dimensions = input.guardSummary.results.map((g) => {
+        // When the contract fails, include the diff detail in the evidence summary
+        // so the gate step log (and any artifact) carries a real diagnostic
+        // instead of just "workflow-trace → fail". The summary is bounded so a
+        // runaway diff can't bloat every dimension; the contract itself is the
+        // authoritative source.
+        const detail = g.status === 'fail' && g.diff
+            ? ` | ${g.diff.reason}: ${g.diff.after}`.slice(0, 4000)
+            : '';
+        return {
+            journeyId: g.journeyId,
+            consistencyScore: scoreFor(g.status),
+            evidence: [{
+                    kind: 'guard-run',
+                    ref: `capability-guard-runner:${g.journeyId}`,
+                    summary: `${g.contract} → ${g.status}${detail}`
+                }]
+        };
+    });
+    if (dimensions.length === 0) {
+        dimensions.push({
             journeyId: input.journeyId,
             consistencyScore: verdict === 'consistent' ? 1 : verdict === 'drifted' ? 0 : 0.5,
-            evidence: [
-                { kind: 'guard-run', ref: `capability-guard-runner:${input.guardSummary.total}`, summary: `${input.guardSummary.pass} pass / ${input.guardSummary.fail} fail` },
-                { kind: 'independent-eval', ref: 'audit-llm-context', summary: `independent verdict: ${independentVerdict}` }
-            ]
-        }];
+            evidence: [{ kind: 'guard-run', ref: 'capability-guard-runner:0', summary: 'no contract results were supplied' }]
+        });
+    }
+    const independentRef = degraded ? 'audit-independent-checker:stub' : 'audit-independent-checker:deterministic';
+    const first = dimensions[0];
+    dimensions[0] = {
+        ...first,
+        evidence: [
+            ...first.evidence,
+            {
+                kind: 'independent-eval',
+                ref: independentRef,
+                summary: check === null
+                    ? 'degraded: stub scorer (no independent context ran); the verdict was not derived from an evaluation'
+                    : `independent verdict: ${check.verdict}; observations ${String(check.coverage.observations)}/${String(check.coverage.observationsExpected)}; invariants armed ${String(check.coverage.invariantsArmed)}/${String(check.coverage.invariantsFrozen)}; findings: ${check.findings.length === 0 ? 'none' : check.findings.map((f) => `${f.code}(${f.journeyId})`).join(',')}`
+            }
+        ]
+    };
     const auditId = `audit-${Date.now()}-${Math.random().toString(16).slice(2, 8)}`;
     const out = {
         auditId,
@@ -31,7 +89,10 @@ export async function runAudit(input) {
         verdict,
         dimensions,
         crossCheck: xc,
-        requiresUserDecision: verdict === 'inconclusive'
+        requiresUserDecision: verdict === 'inconclusive',
+        degraded,
+        findings: check === null ? null : check.findings,
+        coverage: check === null ? null : check.coverage
     };
     const dir = join(input.projectRoot, '.peaks', '_runtime', input.sessionId, 'capability-audit');
     mkdirSync(dir, { recursive: true });

package/dist/services/capability-audit-service/types.d.ts

@@ -14,6 +14,41 @@ export interface CrossCheck {
     readonly guardVsAudit: 'agree' | 'diverge' | 'partial';
     readonly karpathyVsAudit: 'agree' | 'diverge' | 'partial';
 }
+/**
+ * Why an independent verdict came out `drifted`. Each code names a concrete,
+ * inspectable deviation rather than a summary judgement.
+ */
+export type AuditFindingCode = 
+/** The observed journey set is not the frozen P0 set. */
+'OBSERVATION_INCOMPLETE'
+/** The frozen baseline's own row set is not the P0 set. */
+ | 'BASELINE_ROW_SET_INVALID'
+/** A frozen `sourceFiles` entry no longer exists on disk. */
+ | 'SOURCE_FILE_MISSING';
+export interface AuditFinding {
+    readonly code: AuditFindingCode;
+    readonly journeyId: JourneyId;
+    readonly detail: string;
+}
+/**
+ * How wide the audit's claim actually is. Reported alongside the verdict so
+ * `consistent` is never read as broader than it is: the check verifies the
+ * frozen row set, the observation set and the file bindings — it does not
+ * evaluate `forbiddenChanges` prose, and it judges no behaviour beyond what
+ * the guard contracts already exercise.
+ */
+export interface AuditCoverage {
+    readonly observations: number;
+    readonly observationsExpected: number;
+    readonly invariantsFrozen: number;
+    readonly invariantsArmed: number;
+    readonly forbiddenChangesUnverified: number;
+}
+export interface IndependentCheckResult {
+    readonly verdict: 'consistent' | 'drifted';
+    readonly findings: ReadonlyArray<AuditFinding>;
+    readonly coverage: AuditCoverage;
+}
 export interface CapabilityAuditResult {
     readonly auditId: string;
     readonly auditedAt: string;
@@ -21,4 +56,17 @@ export interface CapabilityAuditResult {
     readonly dimensions: ReadonlyArray<AuditDimension>;
     readonly crossCheck: CrossCheck;
     readonly requiresUserDecision: boolean;
+    /**
+     * True when no separate-context evaluation ran at all — i.e. the scorer was
+     * the stub, not the deterministic independent checker. A degraded audit can
+     * never be `consistent`.
+     */
+    readonly degraded: boolean;
+    /**
+     * The independent checker's findings, in the order it produced them. Empty
+     * on a `consistent` live run; `null` on a degraded run, where no check ran.
+     */
+    readonly findings: ReadonlyArray<AuditFinding> | null;
+    /** How wide this audit's claim is; `null` on a degraded run. */
+    readonly coverage: AuditCoverage | null;
 }