peaks-loop 4.0.48 → 4.0.50

package/dist/services/audit/enforcers/lint-catalog-governance.d.ts

@@ -3,11 +3,24 @@
  *
  * Two enforcers: catalog size must grow to ≥ 40 (the P2-a target),
  * and the prose-only ratio must stay ≤ 7% (per spec §10.2 L2
- * acceptance; tightened from the pre-v2.12.1 5% target to reflect
- * the catalog governance reform — see `.peaks/memory/2026-06-27-
- * prose-only-catalog-followup.md` for the full rationale and the
- * per-entry backlog triage). Both fire on the catalog's static
- * state — no file scan, just the catalog itself.
+ * acceptance). Both fire on the state the classifier produced — no
+ * extra file scan beyond what the audit already did.
+ *
+ * C6 of the 2026-09-15 diagnosis: this gate and
+ * `prose-ratio-calculator.computeProseRatio` (behind
+ * `peaks audit prose-ratio`) are the two "prose-only ratio" gates, and
+ * they used to disagree. The calculator excluded `informational` rows
+ * from its numerator; this one excluded `informational` rows from *its*
+ * numerator by a different route (red-lines-service passed it a
+ * `proseOnlyCount` that had already been filtered). Both now measure the
+ * same quantity, identically defined:
+ *
+ *   numerator   = rows classified `backing === 'prose-only'`, all of them
+ *   denominator = every classified row (`entries.length`)
+ *
+ * They still carry different *thresholds* — 7% here, 5% as the
+ * `peaks audit prose-ratio` default — which is a policy difference, not
+ * an accounting one. Nothing redefines what is being counted.
  */
 import type { LintHit } from './lint-style.js';
 export declare const CATALOG_SIZE_TARGET = 40;
@@ -22,11 +35,10 @@ export interface CatalogProseOnlyRatio {
 }
 export declare function lintCatalogSize(actualSize: number): readonly LintHit[];
 /**
- * Prose-only ratio: count catalog entries whose `enforcerRef` is
- * null (i.e. not backed by a CLI surface) divided by the total
- * catalog size. Per spec §10.2, the L2 acceptance is ≤ 10% at
- * P2-a; v2.12.1 catalog governance tightened the gate to ≤ 7%
- * after the discovered-prose-only reform (see
- * `.peaks/memory/2026-06-27-prose-only-catalog-followup.md`).
+ * Prose-only ratio: rows the classifier tagged `prose-only`, divided by
+ * every row the classifier produced. `catalogSize` is a slight misnomer
+ * — it is `entries.length`, the count of classified rows, not the size of
+ * the hand-maintained catalog. Same numerator and denominator as
+ * `computeProseRatio`; see the module docstring above.
  */
 export declare function lintCatalogProseOnlyRatio(catalogSize: number, proseOnlyCount: number): readonly LintHit[];

package/dist/services/audit/enforcers/lint-catalog-governance.js

@@ -1,12 +1,9 @@
 export const CATALOG_SIZE_TARGET = 40;
-// v2.12.1 catalog governance: 5% was unreachable without demoting the
-// 80 discovered prose-only entries (which are advisory SKILL.md
-// phrases, not actionable red lines). After the v2.12.1 reform the
-// ratio dropped from 60.1% (89/148) to 6.1% (9/148); the remaining
-// 9 entries are the real backlog (5 unique catalog ids: prototype-
-// fidelity-001/002, mock-placement-001, resume-detection-001,
-// pre-rd-scan-001, design-draft-confirm-001). Bumping the target to
-// 7% acknowledges the reform while keeping the gate active.
+// The v2.12.1 reform left this at 7% by demoting discovered advisory
+// rows out of the numerator. S3 of the 2026-09-15 diagnosis-remediation
+// job removed that demotion, so the observed ratio is 66% (101/153) —
+// the gate now fires, which is the intended outcome: the number was
+// always this bad, it was just being reported as 0%.
 export const PROSE_ONLY_RATIO_TARGET = 0.07;
 function syntheticHit(catalogId, rule, matched) {
     // No specific file to point at — return a synthetic hit against
@@ -31,12 +28,11 @@ export function lintCatalogSize(actualSize) {
     return [syntheticHit('rl-catalog-total-001', 'Catalog governance: catalog size must grow to ≥ 40 (L2.3 P2-a target)', `(catalog size ${actualSize} < target ${CATALOG_SIZE_TARGET})`)];
 }
 /**
- * Prose-only ratio: count catalog entries whose `enforcerRef` is
- * null (i.e. not backed by a CLI surface) divided by the total
- * catalog size. Per spec §10.2, the L2 acceptance is ≤ 10% at
- * P2-a; v2.12.1 catalog governance tightened the gate to ≤ 7%
- * after the discovered-prose-only reform (see
- * `.peaks/memory/2026-06-27-prose-only-catalog-followup.md`).
+ * Prose-only ratio: rows the classifier tagged `prose-only`, divided by
+ * every row the classifier produced. `catalogSize` is a slight misnomer
+ * — it is `entries.length`, the count of classified rows, not the size of
+ * the hand-maintained catalog. Same numerator and denominator as
+ * `computeProseRatio`; see the module docstring above.
  */
 export function lintCatalogProseOnlyRatio(catalogSize, proseOnlyCount) {
     if (catalogSize === 0)

package/dist/services/audit/enforcers/lint-rd-handoff-coverage.d.ts

@@ -1,18 +1,8 @@
+import type { LintHit, SkillFile } from './lint-style.js';
 /**
- * P2-b sweep 005 — peaks-rd handoff + coverage enforcers.
- *
- * Closes three peaks-rd discovered lines:
- *  - md-121 : "do not hand off to QA without [tech-doc.md]" (BLOCKING)
- *  - md-127 : "do not hand off to QA without a perf-baseline" (BLOCKING)
- *  - md-162 : "100% coverage target on testable files is meaningful"
- *
- * Two enforcers (handoff + coverage). The handoff enforcer
- * checks for both 'tech-doc' and 'perf-baseline' handoff
- * markers; the coverage enforcer checks for the 100%-target
- * phrasing + the no-coverage-padding rule.
- *
- * scope: peaks-rd only.
+ * peaks-rd must not hand off to QA without a reviewable RD artifact. The
+ * check reads `.peaks/_runtime/<sessionId>/rd/requests/*.md`; it does not
+ * read the SKILL.md sentence that promises one.
  */
-import type { LintHit, SkillFile } from './lint-style.js';
-export declare function lintRdHandoffContract(skill: SkillFile): ReadonlyArray<LintHit>;
+export declare function lintRdHandoffContract(skill: SkillFile, projectRoot: string): ReadonlyArray<LintHit>;
 export declare function lintRdCoverageDiscipline(skill: SkillFile): ReadonlyArray<LintHit>;

package/dist/services/audit/enforcers/lint-rd-handoff-coverage.js

@@ -1,17 +1,85 @@
-const TECH_DOC_HANDOFF = /do not hand off to qa without[^\n]*tech-doc/im;
-const PERF_BASELINE_HANDOFF = /do not hand off to qa without[^\n]*perf-baseline/im;
+/**
+ * P2-b sweep 005 — peaks-rd handoff + coverage enforcers.
+ *
+ * Closes three peaks-rd discovered lines:
+ *  - md-121 : "do not hand off to QA without [the RD artifact]" (BLOCKING)
+ *  - md-127 : "do not hand off to QA without a perf-baseline" (BLOCKING)
+ *  - md-162 : "100% coverage target on testable files is meaningful"
+ *
+ * A10 of the 2026-09-15 diagnosis — `lintRdHandoffContract` used to regex
+ * the peaks-rd SKILL.md prose for the sentence *"do not hand off to QA
+ * without this file"* and call that enforcement. It never opened a file
+ * under `.peaks/_runtime/`. The gate was verifying a sentence about the
+ * artifact instead of the artifact: the exact failure the 4.0.49 release
+ * note named, found alive inside the enforcer layer.
+ *
+ * It now reads `.peaks/_runtime/<sessionId>/rd/requests/*.md` — the
+ * artifact the sentence is about (contract:
+ * `skills/bee/peaks-rd/references/artifact-per-request.md`) — and reports
+ * when nothing is there. When no session binding can be resolved it
+ * reports nothing, matching the soft-pass convention of its sibling
+ * enforcers (`pre-rd-scan.ts`, `lint-audit-regression.ts`).
+ *
+ * `lintRdCoverageDiscipline` still reads the skill doc, because its rule
+ * *is* about what the skill doc declares. It is not a handoff gate.
+ *
+ * scope: peaks-rd only.
+ */
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
 const COVERAGE_TARGET = /100%\s*coverage target[^\n]*testable files/i;
 const NO_PADDING = /must not write coverage-padding tests/i;
-function findHandoffContract(lines) {
-    let techDoc = false;
-    let perfBaseline = false;
-    for (const line of lines) {
-        if (TECH_DOC_HANDOFF.test(line))
-            techDoc = true;
-        if (PERF_BASELINE_HANDOFF.test(line))
-            perfBaseline = true;
+/** The artifact whose absence makes an RD→QA handoff invalid. */
+const RD_ARTIFACT_RELATIVE = '.peaks/_runtime';
+/**
+ * Resolve the bound session id from `.peaks/_runtime/session.json`. Both
+ * key spellings are accepted: the file has shipped as `peakSessionId` and
+ * as `sessionId`, and reading only one silently disables the check.
+ */
+function resolveSessionBinding(projectRoot) {
+    const sessionJsonPath = join(projectRoot, '.peaks', '_runtime', 'session.json');
+    if (!existsSync(sessionJsonPath)) {
+        return { sessionId: null, reason: 'no .peaks/_runtime/session.json' };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(sessionJsonPath, 'utf8'));
+    }
+    catch (error) {
+        return { sessionId: null, reason: `session.json is not readable JSON (${String(error)})` };
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return { sessionId: null, reason: 'session.json is not an object' };
+    }
+    const record = parsed;
+    for (const key of ['sessionId', 'peakSessionId']) {
+        const value = record[key];
+        if (typeof value === 'string' && value.length > 0) {
+            return { sessionId: value, reason: `bound via session.json:${key}` };
+        }
+    }
+    return { sessionId: null, reason: 'session.json carries no session id' };
+}
+/** Count non-empty `*.md` files in `dir`. A missing dir counts as zero. */
+function countNonEmptyArtifacts(dir) {
+    let names;
+    try {
+        names = readdirSync(dir).filter((name) => name.endsWith('.md'));
+    }
+    catch {
+        return 0;
     }
-    return { techDoc, perfBaseline };
+    let count = 0;
+    for (const name of names) {
+        try {
+            if (statSync(join(dir, name)).size > 0)
+                count += 1;
+        }
+        catch {
+            continue;
+        }
+    }
+    return count;
 }
 function findCoverageContract(lines) {
     let target = false;
@@ -24,26 +92,27 @@ function findCoverageContract(lines) {
     }
     return { target, noPadding };
 }
-export function lintRdHandoffContract(skill) {
+/**
+ * peaks-rd must not hand off to QA without a reviewable RD artifact. The
+ * check reads `.peaks/_runtime/<sessionId>/rd/requests/*.md`; it does not
+ * read the SKILL.md sentence that promises one.
+ */
+export function lintRdHandoffContract(skill, projectRoot) {
     if (skill.name !== 'peaks-rd')
         return [];
-    const lines = skill.lines.length > 0
-        ? skill.lines
-        : skill.body.split(/\r?\n/);
-    const { techDoc, perfBaseline } = findHandoffContract(lines);
-    if (techDoc && perfBaseline)
+    const binding = resolveSessionBinding(projectRoot);
+    if (binding.sessionId === null)
+        return [];
+    const requestsDir = join(projectRoot, RD_ARTIFACT_RELATIVE, binding.sessionId, 'rd', 'requests');
+    const artifactCount = countNonEmptyArtifacts(requestsDir);
+    if (artifactCount > 0)
         return [];
-    const missing = [];
-    if (!techDoc)
-        missing.push('tech-doc handoff BLOCKING');
-    if (!perfBaseline)
-        missing.push('perf-baseline handoff BLOCKING');
     return [{
             catalogId: 'rl-rd-handoff-contract-001',
-            rule: 'peaks-rd SKILL.md must declare the QA-handoff BLOCKING contract (tech-doc + perf-baseline)',
-            file: skill.path,
+            rule: 'peaks-rd must not hand off to QA without a non-empty RD artifact under rd/requests/',
+            file: requestsDir,
             line: 1,
-            matchedText: `missing markers: ${missing.join(', ')}`
+            matchedText: `no non-empty .md artifact under ${requestsDir} (${binding.reason})`,
         }];
 }
 export function lintRdCoverageDiscipline(skill) {

package/dist/services/audit/enforcers/lint-style.d.ts

@@ -14,7 +14,15 @@ export interface SkillFile {
 export declare function readSkillFiles(skillsRoot: string, names: readonly string[]): readonly SkillFile[];
 /** Theme A — section structure. Returns lint hits (positive = rule
  *  satisfied, so a missing heading fires the lint hit; downstream
- *  audit service decides whether to WARN or pass). */
+ *  audit service decides whether to WARN or pass).
+ *
+ *  A11 of the 2026-09-15 diagnosis: the `Hard contracts` rule used to
+ *  match the *heading text* and stop there. `peaks-perf-audit/SKILL.md`
+ *  carries `## Hard contracts (BLOCKING)` — the word BLOCKING is in the
+ *  heading — while every bullet beneath it is unmarked prose, so the
+ *  audit counted a BLOCKING red line with no contract behind it. The
+ *  rule now also requires at least one marker line inside the section
+ *  body, which is what makes a contract visible to the classifier. */
 export declare function lintSectionShape(skill: SkillFile): readonly LintHit[];
 /**
  * ASCII wireframe section-order check (spec §5.4 line 647).

package/dist/services/audit/enforcers/lint-style.js

@@ -45,13 +45,36 @@ function matchedText(lines, line) {
         return '';
     return (lines[line - 1] ?? '').trim();
 }
+/** A red-line marker that makes a contract line machine-visible. */
+const CONTRACT_MARKER = /\b(MANDATORY|BLOCKING|MUST NOT|RED LINE)\b/;
+/**
+ * Collect the body of the section that starts at `headingLine` (1-based):
+ * every line up to the next `## ` heading.
+ */
+function sectionBody(lines, headingLine) {
+    const body = [];
+    for (let i = headingLine; i < lines.length; i += 1) {
+        if (/^##\s/.test(lines[i] ?? ''))
+            break;
+        body.push(lines[i] ?? '');
+    }
+    return body;
+}
 /** Theme A — section structure. Returns lint hits (positive = rule
  *  satisfied, so a missing heading fires the lint hit; downstream
- *  audit service decides whether to WARN or pass). */
+ *  audit service decides whether to WARN or pass).
+ *
+ *  A11 of the 2026-09-15 diagnosis: the `Hard contracts` rule used to
+ *  match the *heading text* and stop there. `peaks-perf-audit/SKILL.md`
+ *  carries `## Hard contracts (BLOCKING)` — the word BLOCKING is in the
+ *  heading — while every bullet beneath it is unmarked prose, so the
+ *  audit counted a BLOCKING red line with no contract behind it. The
+ *  rule now also requires at least one marker line inside the section
+ *  body, which is what makes a contract visible to the classifier. */
 export function lintSectionShape(skill) {
     const hits = [];
     const rules = [
-        { id: 'rl-section-hard-contracts-001', rule: 'Hard contracts for browser/IO surface', pattern: SECTION_HARD_CONTRACTS_HEADING },
+        { id: 'rl-section-hard-contracts-001', rule: 'Hard contracts for browser/IO surface', pattern: SECTION_HARD_CONTRACTS_HEADING, requiresBodyMarker: true },
         { id: 'rl-section-mandatory-artifact-001', rule: 'Mandatory per-request artifact', pattern: SECTION_MANDATORY_HEADING },
         { id: 'rl-section-default-runbook-001', rule: 'Default runbook pointer', pattern: SECTION_DEFAULT_RUNBOOK_HEADING },
         { id: 'rl-section-gate-index-001', rule: 'Gate index', pattern: SECTION_GATE_INDEX_HEADING },
@@ -67,6 +90,19 @@ export function lintSectionShape(skill) {
                 line: 1,
                 matchedText: '(missing section)'
             });
+            continue;
+        }
+        if (r.requiresBodyMarker === true) {
+            const declared = sectionBody(skill.lines, line).some((l) => CONTRACT_MARKER.test(l));
+            if (!declared) {
+                hits.push({
+                    catalogId: r.id,
+                    rule: r.rule,
+                    file: skill.path,
+                    line,
+                    matchedText: `(heading at line ${line} but no BLOCKING/MANDATORY/MUST NOT/RED LINE line inside the section)`
+                });
+            }
         }
     }
     return hits;

package/dist/services/audit/prose-ratio-calculator.d.ts

@@ -1,33 +1,44 @@
 /**
- * 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.
  */
 import type { RedLineEntry } from './types.js';
 export interface ProseRatioResult {
-    /** Total catalog size (entries.length). */
+    /** Total entries considered (entries.length) — the denominator, always. */
     readonly totalRedLines: number;
     /** Count of entries with backing === 'cli-backed'. */
     readonly cliBacked: number;
     /** Count of entries with backing === 'partial'. */
     readonly partial: number;
-    /** Count of entries with backing === 'prose-only' AND informational !== true. */
+    /** Count of entries with backing === 'prose-only'. THE numerator. */
     readonly proseOnly: number;
-    /** Count of entries with informational === true (excluded from ratio). */
+    /**
+     * Breakdown only — the subset of `proseOnly` that carries
+     * `informational: true` (auto-discovered advisory phrases with no
+     * catalog template). Included in `proseOnly`; changing it changes
+     * nothing about `proseOnly` or `ratio`.
+     */
+    readonly discoveredProseOnly: number;
+    /** Count of entries with informational === true, whatever their backing. */
     readonly informational: number;
     /** proseOnly / totalRedLines. Returns 0 when totalRedLines === 0. */
     readonly ratio: number;

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;