peaks-loop 4.0.54 → 4.1.0

package/dist/services/observability/observability-service.js

@@ -18,51 +18,16 @@
  * log if it wants — but the calling hook site itself swallows the
  * result (fire-and-forget by convention).
  */
-import { z } from 'zod';
 import { appendMetricLine, pruneMetricsFiles, readMetricLines, tryMetricsFilePath } from './jsonl-store.js';
-export const OBSERVABILITY_SCHEMA_VERSION = 1;
-export const OBSERVABILITY_CATEGORIES = [
-    'slice-transition',
-    'dispatch',
-    'checkpoint',
-    'mode-gate',
-    'context-trigger',
-    'post-compact',
-    'cycle',
-    'token-usage',
-    'monotonic-trigger',
-    // Slice 2026-07-29-worktree-l2-extended Part 4.A: lease lifecycle
-    // metrics. Emitted by `peaks worktree spawn / renew / release /
-    // gc` and by the auto-release hook in dispatch finalization (Part
-    // 3.A). Read by `peaks lease metrics`. The `detail.kind` field
-    // discriminates spawn / renew / release / gc / autoRelease /
-    // autoRelease-failed / autoRelease-skipped.
-    'lease'
-];
-// v2.12.0 fan-out collapse: `security-reviewer` (in-process RD slot)
-// moved out to the standalone `peaks-security-audit` skill; the matching
-// perf slot was `perf-baseline-reviewer` which is replaced by the
-// standalone `peaks-perf-audit` skill. The 1-minor-release back-compat
-// window keeps `security-reviewer` readable as a deprecated alias (see
-// the dispatcher in `src/services/rd/reviewer-dispatch-policy.ts`);
-// observability drops it because no new events carry that role tag.
-export const OBSERVABILITY_SUBAGENT_ROLES = [
-    'rd',
-    'qa',
-    'code-reviewer',
-    'karpathy-reviewer',
-    'peaks-security-audit',
-    'peaks-perf-audit'
-];
-export const ObservabilityEventSchema = z.object({
-    schemaVersion: z.literal(OBSERVABILITY_SCHEMA_VERSION),
-    ts: z.string().datetime({ offset: true }),
-    sessionId: z.string().min(1),
-    category: z.enum(OBSERVABILITY_CATEGORIES),
-    sliceRid: z.string().min(1).optional(),
-    role: z.enum(OBSERVABILITY_SUBAGENT_ROLES).optional(),
-    detail: z.record(z.string(), z.unknown())
-});
+import { OBSERVABILITY_SCHEMA_VERSION, ObservabilityEventSchema } from './observability-schema.js';
+// The schema version, the category / subagent-role vocabularies, the zod
+// schema, the emit contract types and the `OBSERVABILITY_CONSTANTS` roll-up
+// live in `observability-schema.ts` (wave-3C file-size cap split — those
+// declarations moved verbatim and nothing else changed). Every PUBLIC name is
+// re-exported below so importers keep resolving it from
+// `observability-service.js` unchanged; the names this module calls are
+// imported for use just above.
+export { OBSERVABILITY_CATEGORIES, OBSERVABILITY_CONSTANTS, OBSERVABILITY_SCHEMA_VERSION, OBSERVABILITY_SUBAGENT_ROLES, ObservabilityEventSchema } from './observability-schema.js';
 /**
  * Append a single observability event to the session's JSONL metrics
  * file. Synchronous (small append, sub-ms in practice) and
@@ -135,11 +100,6 @@ export function readObservabilityEvents(projectRoot, sessionId) {
 export function isCurrentSchemaVersion(record) {
     return ObservabilityEventSchema.safeParse(record).success;
 }
-export const OBSERVABILITY_CONSTANTS = {
-    SCHEMA_VERSION: OBSERVABILITY_SCHEMA_VERSION,
-    CATEGORIES: OBSERVABILITY_CATEGORIES,
-    SUBAGENT_ROLES: OBSERVABILITY_SUBAGENT_ROLES
-};
 export function emitLeaseEvent(opts) {
     const detail = { kind: opts.kind, leaseId: opts.leaseId };
     if (opts.rid !== undefined)

package/dist/services/openspec/coverage-evidence-reader.js

@@ -30,7 +30,7 @@ import { normalizePath } from '../../shared/path-utils.js';
 // ---------------------------------------------------------------------------
 const DEFAULT_DISCOVERY = [
     (root) => `${root}/coverage/coverage-summary.json`,
-    (root) => `${root}/openspec/coverage-summary.json`,
+    (root) => `${root}/openspec/coverage-summary.json`
 ];
 /**
  * Resolve the path to a coverage-summary.json.
@@ -52,7 +52,11 @@ export async function resolveCoverageSummaryPath(input) {
         if (await isReadable(abs)) {
             return ok(abs);
         }
-        return err({ code: 'not-readable', path: abs, message: `Cannot read coverage summary at ${abs}` });
+        return err({
+            code: 'not-readable',
+            path: abs,
+            message: `Cannot read coverage summary at ${abs}`
+        });
     }
     for (const factory of DEFAULT_DISCOVERY) {
         const candidate = factory(toPosix(input.projectRoot));
@@ -120,14 +124,14 @@ export async function readC8Summary(path) {
             statements,
             branches,
             functions,
-            lines,
+            lines
         });
     }
     const stat_ = await stat(path);
     return {
         path,
         capturedAt: stat_.mtime.toISOString(),
-        files,
+        files
     };
 }
 function asMetric(input) {
@@ -202,7 +206,10 @@ function parseCapabilityRow(line) {
     const trimmed = line.trim();
     if (!trimmed.startsWith('|'))
         return null;
-    const cells = trimmed.split('|').slice(1, -1).map((c) => c.trim());
+    const cells = trimmed
+        .split('|')
+        .slice(1, -1)
+        .map((c) => c.trim());
     if (cells.length < 2)
         return null;
     const capability = cells[0];
@@ -216,7 +223,7 @@ function parseCapabilityRow(line) {
         return null;
     const row = {
         capability,
-        source: normalizePath(source).replace(/^\.\//, '').replace(/\/$/, ''),
+        source: normalizePath(source).replace(/^\.\//, '').replace(/\/$/, '')
     };
     if (testAnchor !== undefined && testAnchor !== '') {
         row.testAnchor = testAnchor;
@@ -292,7 +299,7 @@ export async function validateCapabilityCoverage(input) {
                 failing.push({
                     path: file,
                     actual: { statements: 0, branches: 0, functions: 0, lines: 0 },
-                    reason: 'missing-from-summary',
+                    reason: 'missing-from-summary'
                 });
                 continue;
             }
@@ -306,9 +313,9 @@ export async function validateCapabilityCoverage(input) {
                         statements: entry.statements.pct,
                         branches: entry.branches.pct,
                         functions: entry.functions.pct,
-                        lines: entry.lines.pct,
+                        lines: entry.lines.pct
                     },
-                    reason: 'below-threshold',
+                    reason: 'below-threshold'
                 });
             }
         }
@@ -316,7 +323,7 @@ export async function validateCapabilityCoverage(input) {
             mismatches.push({
                 capability: row.capability,
                 source: row.source,
-                failingFiles: failing,
+                failingFiles: failing
             });
         }
     }
@@ -344,7 +351,7 @@ export async function findStaleChangeFiles(input) {
     const candidates = [
         `${changeRoot}/proposal.md`,
         `${changeRoot}/tasks.md`,
-        `${changeRoot}/design.md`,
+        `${changeRoot}/design.md`
     ];
     // spec files
     const specsRoot = `${changeRoot}/specs`;

package/dist/services/openspec/openspec-archive-service.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, rename, readdir } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
 import { isDirectory } from 'peaks-loop-shared/fs';
 import { validateChangeId } from './artifact-boundary.js';
-import { findStaleChangeFiles, parseCapabilityMapping, readC8Summary, resolveCoverageSummaryPath, validateCapabilityCoverage, } from './coverage-evidence-reader.js';
+import { findStaleChangeFiles, parseCapabilityMapping, readC8Summary, resolveCoverageSummaryPath, validateCapabilityCoverage } from './coverage-evidence-reader.js';
 export class OpenSpecArchiveError extends Error {
     code;
     detail;
@@ -44,7 +44,7 @@ export async function parseCoverageEvidence(proposalPath) {
             summaryStatus: 'unavailable',
             capabilityValidation: 'not-enforced',
             staleFiles: [],
-            mismatches: [],
+            mismatches: []
         };
     }
     const lines = raw.split(/\r?\n/);
@@ -57,7 +57,7 @@ export async function parseCoverageEvidence(proposalPath) {
             summaryStatus: 'unavailable',
             capabilityValidation: 'not-enforced',
             staleFiles: [],
-            mismatches: [],
+            mismatches: []
         };
     }
     const rows = [];
@@ -90,14 +90,17 @@ export async function parseCoverageEvidence(proposalPath) {
         summaryStatus: 'unavailable',
         capabilityValidation: 'not-enforced',
         staleFiles: [],
-        mismatches: [],
+        mismatches: []
     };
 }
 function parseTableRow(line) {
     const trimmed = line.trim();
     if (!trimmed.startsWith('|'))
         return null;
-    const cells = trimmed.split('|').slice(1, -1).map((c) => c.trim());
+    const cells = trimmed
+        .split('|')
+        .slice(1, -1)
+        .map((c) => c.trim());
     if (cells.length < 3)
         return null;
     const capability = cells[0];
@@ -116,7 +119,7 @@ function parseTableRow(line) {
     const row = {
         capability,
         requirement,
-        status: status,
+        status: status
     };
     if (testAnchor !== undefined && testAnchor !== '') {
         row.testAnchor = testAnchor;
@@ -154,14 +157,14 @@ function evaluateGate(evidence) {
         return {
             ok: false,
             reason: 'requirement-not-fully-covered',
-            failing,
+            failing
         };
     }
     if (evidence.rows.length === 0) {
         return {
             ok: false,
             reason: 'no-coverage-evidence-block',
-            failing: [],
+            failing: []
         };
     }
     return { ok: true };
@@ -209,9 +212,9 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
                         requirement: r.requirement,
                         status: r.status,
                         testAnchor: r.testAnchor,
-                        line: r.line,
+                        line: r.line
                     })),
-                    coverage,
+                    coverage
                 });
             }
         }
@@ -219,7 +222,7 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
         const mapping = await parseCapabilityMapping(proposalPath);
         coverage = {
             ...coverage,
-            capabilityRows: mapping.rows,
+            capabilityRows: mapping.rows
         };
         if (mapping.rows.length === 0) {
             // No mapping → cannot enforce per-capability. Refuse with the same
@@ -232,18 +235,22 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
         const projectRoot = resolve(openspecRoot, '..');
         const summaryPathResult = await resolveCoverageSummaryPath({
             projectRoot,
-            ...(options.coverageSummaryPath !== undefined ? { explicitPath: options.coverageSummaryPath } : {}),
+            ...(options.coverageSummaryPath !== undefined
+                ? { explicitPath: options.coverageSummaryPath }
+                : {})
         });
         if (!summaryPathResult.ok) {
             // AC1: missing or not-readable
-            const triedPaths = summaryPathResult.error.code === 'missing' ? summaryPathResult.error.triedPaths : [summaryPathResult.error.path];
+            const triedPaths = summaryPathResult.error.code === 'missing'
+                ? summaryPathResult.error.triedPaths
+                : [summaryPathResult.error.path];
             throw new OpenSpecArchiveError('OPENSPEC_COVERAGE_EVIDENCE_MISSING', `Refusing to archive "${changeId}": no coverage-summary.json found at any of: ${triedPaths.join(', ')}. ` +
                 'Run `pnpm test:coverage` (which invokes scripts/coverage-c8.mjs) to generate one, ' +
                 'or pass --coverage-summary <path> to point at an existing summary, ' +
                 'or re-run with --force to bypass.', {
                 changeId,
                 triedPaths,
-                coverage,
+                coverage
             });
         }
         // Parse summary + check freshness (AC2)
@@ -257,38 +264,38 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
         }
         coverage = {
             ...coverage,
-            summaryPath: summary.path,
+            summaryPath: summary.path
         };
         const staleFiles = await findStaleChangeFiles({
             projectRoot,
             openspecRoot,
             changeId,
-            summary,
+            summary
         });
         if (staleFiles.length > 0) {
             coverage = {
                 ...coverage,
                 summaryStatus: 'stale',
-                staleFiles,
+                staleFiles
             };
             throw new OpenSpecArchiveError('OPENSPEC_COVERAGE_EVIDENCE_STALE', `Refusing to archive "${changeId}": coverage-summary.json is older than ${staleFiles.length} change file(s). ` +
                 'Re-run `pnpm test:coverage` to refresh, or re-run with --force to bypass.', { changeId, staleFiles, summaryPath: summary.path, coverage });
         }
         coverage = {
             ...coverage,
-            summaryStatus: 'fresh',
+            summaryStatus: 'fresh'
         };
         // Per-capability coverage check (AC4)
         const validation = await validateCapabilityCoverage({
             projectRoot,
             summary,
-            rows: mapping.rows,
+            rows: mapping.rows
         });
         if (!validation.ok) {
             coverage = {
                 ...coverage,
                 capabilityValidation: 'mismatch',
-                mismatches: validation.mismatches,
+                mismatches: validation.mismatches
             };
             if (options.force === true) {
                 coverageMismatchBypassed = true;
@@ -298,14 +305,14 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
                     'Re-run `pnpm test:coverage` after closing the gap, or re-run with --force to bypass.', {
                     changeId,
                     mismatches: validation.mismatches,
-                    coverage,
+                    coverage
                 });
             }
         }
         else {
             coverage = {
                 ...coverage,
-                capabilityValidation: 'ok',
+                capabilityValidation: 'ok'
             };
         }
     }
@@ -320,7 +327,7 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
             from,
             to,
             applied: false,
-            ...(coverage !== undefined ? { coverage } : {}),
+            ...(coverage !== undefined ? { coverage } : {})
         };
     }
     if (await isDirectory(to)) {
@@ -335,6 +342,6 @@ export async function archiveOpenSpecChange(changeId, options = {}) {
         applied: true,
         ...(coverage !== undefined ? { coverage } : {}),
         ...(coverageGateBypassed === true ? { coverageGateBypassed: true } : {}),
-        ...(coverageMismatchBypassed === true ? { coverageMismatchBypassed: true } : {}),
+        ...(coverageMismatchBypassed === true ? { coverageMismatchBypassed: true } : {})
     };
 }

package/dist/services/openspec/openspec-init-service.js

@@ -50,7 +50,12 @@ function buildPlan(projectRoot, apply) {
         { path: changesRoot, kind: 'directory', bytes: 0, content: '' },
         { path: archiveRoot, kind: 'directory', bytes: 0, content: '' },
         { path: join(openspecRoot, 'README.md'), kind: 'file', bytes: 0, content: renderReadme() },
-        { path: join(openspecRoot, 'CHANGES.md'), kind: 'file', bytes: 0, content: renderChangesIndex() }
+        {
+            path: join(openspecRoot, 'CHANGES.md'),
+            kind: 'file',
+            bytes: 0,
+            content: renderChangesIndex()
+        }
     ];
     // Stamp byte counts now that content is finalised.
     for (const write of plannedWrites) {
@@ -94,7 +99,8 @@ export async function planOpenSpecInit(options) {
                 return directoryKeep.has(write.path);
             return !existing.includes(write.path);
         });
-        plan.alreadyInitialized = existing.length > 0 || (await isDirectory(join(openspecRoot, 'changes')));
+        plan.alreadyInitialized =
+            existing.length > 0 || (await isDirectory(join(openspecRoot, 'changes')));
         plan.existingFiles = existing;
     }
     return plan;

package/dist/services/openspec/openspec-propose-from-doctor-service.js

@@ -82,7 +82,7 @@ export function proposeFromDoctor(input) {
                 changeId,
                 finding: input.finding,
                 title: `Fix ${input.finding.rule}`,
-                date,
+                date
             });
             writeFileSync(proposalPath, content);
             created = true;

package/dist/services/openspec/openspec-scan-service.js

@@ -32,7 +32,10 @@ function parseBullets(content) {
         .map((line) => line.trim())
         .filter((line) => line.startsWith('- ') || line === '-')
         .map((line) => line.replace(/^-\s*/, '').trim())
-        .filter((line) => line.length > 0 && !line.startsWith('[ ]') && !line.startsWith('[x]') && !line.startsWith('[X]'));
+        .filter((line) => line.length > 0 &&
+        !line.startsWith('[ ]') &&
+        !line.startsWith('[x]') &&
+        !line.startsWith('[X]'));
 }
 function parseProposal(markdown) {
     const sections = parseMarkdownSections(markdown);

package/dist/services/openspec/openspec-validate-service.js

@@ -27,10 +27,18 @@ function buildInternalIssues(changeId, detail) {
         issues.push({ level: 'warning', rule: 'why-non-empty', message: 'Why section is empty' });
     }
     if (proposal.whatChanges.length === 0) {
-        issues.push({ level: 'error', rule: 'what-changes-non-empty', message: 'What Changes section has no bullets' });
+        issues.push({
+            level: 'error',
+            rule: 'what-changes-non-empty',
+            message: 'What Changes section has no bullets'
+        });
     }
     if (proposal.acceptanceCriteria.length === 0) {
-        issues.push({ level: 'error', rule: 'acceptance-non-empty', message: 'Acceptance Criteria section has no bullets' });
+        issues.push({
+            level: 'error',
+            rule: 'acceptance-non-empty',
+            message: 'Acceptance Criteria section has no bullets'
+        });
     }
     return issues;
 }
@@ -57,11 +65,20 @@ export async function validateOpenSpecChange(changeId, options = {}) {
     if (options.preferExternal === true) {
         const outcome = await runner('openspec', ['validate', changeId]);
         if (outcome.available) {
-            const cliOutput = [outcome.stdout, outcome.stderr].filter((part) => part.length > 0).join('\n').trim();
+            const cliOutput = [outcome.stdout, outcome.stderr]
+                .filter((part) => part.length > 0)
+                .join('\n')
+                .trim();
             const passed = outcome.exitCode === 0;
             const issues = passed
                 ? []
-                : [{ level: 'error', rule: 'openspec-cli-failed', message: `openspec validate exited with code ${outcome.exitCode ?? 'null'}` }];
+                : [
+                    {
+                        level: 'error',
+                        rule: 'openspec-cli-failed',
+                        message: `openspec validate exited with code ${outcome.exitCode ?? 'null'}`
+                    }
+                ];
             return { changeId, valid: passed, source: 'openspec-cli', issues, cliOutput };
         }
         const internal = await runInternal(changeId, openspecRoot);
@@ -69,7 +86,11 @@ export async function validateOpenSpecChange(changeId, options = {}) {
             return null;
         }
         internal.issues = [
-            { level: 'warning', rule: 'openspec-cli-unavailable', message: 'openspec CLI not found, fell back to internal lint' },
+            {
+                level: 'warning',
+                rule: 'openspec-cli-unavailable',
+                message: 'openspec CLI not found, fell back to internal lint'
+            },
             ...internal.issues
         ];
         return internal;

package/dist/services/perf/perf-baseline-service.js

@@ -117,12 +117,8 @@ function renderBaselineTemplate() {
 }
 function buildPlan(projectRoot, apply) {
     const sessionId = getSessionId(projectRoot);
-    const sessionRoot = sessionId !== null
-        ? getSessionDir(projectRoot, sessionId)
-        : null;
-    const perfBaselinePath = sessionRoot !== null
-        ? join(sessionRoot, 'rd', 'perf-baseline.md')
-        : null;
+    const sessionRoot = sessionId !== null ? getSessionDir(projectRoot, sessionId) : null;
+    const perfBaselinePath = sessionRoot !== null ? join(sessionRoot, 'rd', 'perf-baseline.md') : null;
     const plannedWrites = [];
     if (sessionRoot !== null && perfBaselinePath !== null) {
         plannedWrites.push({

package/dist/services/polyrepo/polyrepo-dispatcher.js

@@ -118,7 +118,8 @@ export function readManifest(root) {
         const raw = readFileSync(p, 'utf8');
         return JSON.parse(raw);
     }
-    catch { // TODO(g2): fail-closed JSON parse — null is the documented contract, caller checks via existsSync
+    catch {
+        // TODO(g2): fail-closed JSON parse — null is the documented contract, caller checks via existsSync
         return null;
     }
 }

package/dist/services/polyrepo/polyrepo-scanner.js

@@ -29,7 +29,10 @@ function childHasPeaks(dir) {
  *  leading dots or dashes. Used when the dir name itself is the id
  *  (the common case). */
 function sanitizeId(name) {
-    return name.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^[-.]+|[-.]+$/g, '');
+    return name
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '');
 }
 /** Walk the parent root at depth 1 and return discovered children. */
 export function scanPolyrepo(root, opts = {}) {

package/dist/services/prd/handoff-frontmatter-shape.d.ts

@@ -0,0 +1,42 @@
+import type { Handoff, HandoffSchemaVersion } from './handoff-types.js';
+/** Required schema version for new handoffs. */
+export declare const HANDOFF_SCHEMA_VERSION: HandoffSchemaVersion;
+export declare function serializeHandoff(handoff: Handoff): string;
+/**
+ * N1: accept BOTH shapes of `schemaVersion` — the string `'2'` and the bare
+ * YAML number `2` — and reject any other value.
+ *
+ * The reader used to require `typeof v.schemaVersion === 'string'`. That made
+ * `readHandoff` refuse `prd/handoff.md` written by `handoff-auto-regen.ts`,
+ * which emits the unquoted `schemaVersion: 2`, while the
+ * `AUDIT_REQUIRES_HANDOFF` prereq — a SUBSTRING check for `schemaVersion: 2` —
+ * happily passed the same bytes. So the gate that exists to guarantee a
+ * readable handoff was satisfied by a handoff the parser would not read, and
+ * `peaks prd handoff verify` exited 1 on a healthy file.
+ *
+ * Slice `2026-09-14-handoff-writer-gate-divergence` then fixed the other half:
+ * the writer no longer emits the quoted form at all (see
+ * `handoff-frontmatter.ts`). This tolerance stays because handoffs already on
+ * disk were written by the old writer and by hand; the writer fix must not
+ * retroactively make them unreadable.
+ */
+export declare function isSchemaVersion2(value: unknown): boolean;
+/**
+ * B1: `gateEvidence` is optional, but when present it MUST be a map of
+ * strings — an ARRAY here is the pre-B1 shape its own test file used to
+ * write, and it is a broken declaration, not a claim.
+ *
+ * F2 of `rid-b1-qa` removed this function's own copy of the shape rule. It
+ * used to be a second predicate (same boundary, different downstream result)
+ * that let the same bytes read one way here and another way through
+ * `readHandoffGateEvidence`; both now ask `classifyGateEvidence`. Only
+ * `absent` and `ok` are accepted: a malformed declaration must be refused by
+ * `readHandoff` (which is documented to throw on malformed input) exactly as
+ * the reader refuses it, so the two can never disagree about the same file.
+ *
+ * Unknown keys are still accepted HERE — the map is normalized to the five
+ * known keys by the caller — because refusing them would make a typo render
+ * a whole capsule unreadable, and the reader's `unknownKeys` is the surface
+ * that makes the typo diagnosable instead.
+ */
+export declare function isGateEvidence(value: unknown): boolean;

package/dist/services/prd/handoff-frontmatter-shape.js

@@ -0,0 +1,67 @@
+/**
+ * Slice `b1-filesplit-campaign` (wave 3) — verbatim extraction of the handoff
+ * frontmatter's FIELD-level primitives from `./handoff-service.ts`: the required
+ * schema version, the one canonical frontmatter rendering, and the two
+ * per-field acceptance rules (`schemaVersion`, `gateEvidence`). The composite
+ * predicate that calls them, `isHandoffFrontmatter`, stays in
+ * `handoff-service.ts` — it carries an existing `complexity` finding, and a new
+ * module must start clean, so only what it calls moved.
+ *
+ * Bodies, doc comments and thrown strings are unchanged; `handoff-service.ts`
+ * imports these and keeps exporting its own public surface, so no importer
+ * changed.
+ */
+import { serializeHandoffFrontmatter } from './handoff-frontmatter.js';
+import { classifyGateEvidence } from './handoff-gate-evidence.js';
+/** Required schema version for new handoffs. */
+export const HANDOFF_SCHEMA_VERSION = '2';
+export function serializeHandoff(handoff) {
+    // The one canonical frontmatter rendering, shared with
+    // `handoff-auto-regen.ts`. `yaml.stringify` used to render this block and
+    // emitted `schemaVersion: "2"` + a bare `handoffHash:`, which the
+    // `AUDIT_REQUIRES_HANDOFF` gate and both audit loaders all reject.
+    return `${serializeHandoffFrontmatter(handoff.frontmatter)}${handoff.body}`;
+}
+/**
+ * N1: accept BOTH shapes of `schemaVersion` — the string `'2'` and the bare
+ * YAML number `2` — and reject any other value.
+ *
+ * The reader used to require `typeof v.schemaVersion === 'string'`. That made
+ * `readHandoff` refuse `prd/handoff.md` written by `handoff-auto-regen.ts`,
+ * which emits the unquoted `schemaVersion: 2`, while the
+ * `AUDIT_REQUIRES_HANDOFF` prereq — a SUBSTRING check for `schemaVersion: 2` —
+ * happily passed the same bytes. So the gate that exists to guarantee a
+ * readable handoff was satisfied by a handoff the parser would not read, and
+ * `peaks prd handoff verify` exited 1 on a healthy file.
+ *
+ * Slice `2026-09-14-handoff-writer-gate-divergence` then fixed the other half:
+ * the writer no longer emits the quoted form at all (see
+ * `handoff-frontmatter.ts`). This tolerance stays because handoffs already on
+ * disk were written by the old writer and by hand; the writer fix must not
+ * retroactively make them unreadable.
+ */
+export function isSchemaVersion2(value) {
+    return value === HANDOFF_SCHEMA_VERSION || value === 2;
+}
+/**
+ * B1: `gateEvidence` is optional, but when present it MUST be a map of
+ * strings — an ARRAY here is the pre-B1 shape its own test file used to
+ * write, and it is a broken declaration, not a claim.
+ *
+ * F2 of `rid-b1-qa` removed this function's own copy of the shape rule. It
+ * used to be a second predicate (same boundary, different downstream result)
+ * that let the same bytes read one way here and another way through
+ * `readHandoffGateEvidence`; both now ask `classifyGateEvidence`. Only
+ * `absent` and `ok` are accepted: a malformed declaration must be refused by
+ * `readHandoff` (which is documented to throw on malformed input) exactly as
+ * the reader refuses it, so the two can never disagree about the same file.
+ *
+ * Unknown keys are still accepted HERE — the map is normalized to the five
+ * known keys by the caller — because refusing them would make a typo render
+ * a whole capsule unreadable, and the reader's `unknownKeys` is the surface
+ * that makes the typo diagnosable instead.
+ */
+export function isGateEvidence(value) {
+    const kind = classifyGateEvidence(value).kind;
+    return kind === 'absent' || kind === 'ok';
+}

package/dist/services/prd/handoff-frontmatter.js

@@ -131,7 +131,7 @@ export function serializeHandoffFrontmatter(frontmatter) {
         // indented lines only, leaving the top-level key set exactly as it was
         // for every capsule that declares no evidence.
         ...gateEvidenceBlock(frontmatter.gateEvidence),
-        '---',
+        '---'
     ];
     return `${lines.join('\n')}\n`;
 }