peaks-loop 3.1.2 → 4.0.0-beta.10

package/dist/src/services/observability/aggregation.d.ts

@@ -1,64 +0,0 @@
-/**
- * Read-only aggregations over observability events.
- *
- * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
- * — the CLI layer reads events via `readObservabilityEvents` (or
- * `listSessionDirsWithMetrics` for cross-session rollups) and passes
- * them in. Tests pass synthetic events directly.
- *
- * Aggregations:
- *   - `aggregateStatus(events)`        → AC-1
- *   - `aggregateSlices(events)`        → AC-2
- *   - `aggregateFanout(events)`        → AC-3
- *   - `aggregateRepairCycles(events)`  → AC-4
- *
- * The dispatch / mode-gate / context / post-compact categories land
- * in Slice C (more hooks); for Slice B only `slice-transition` events
- * are emitted from the `peaks request transition` hook. Slice B
- * builds the read-side surface so Slice C is purely additive.
- */
-import { type ObservabilityEvent, type ObservabilitySubagentRole } from './observability-service.js';
-export type StatusAggregate = {
-    totalEvents: number;
-    totalSlices: number;
-    successCount: number;
-    failCount: number;
-    repairCyclePeak: number;
-    fanoutCostTotal: number;
-};
-export type SliceRollup = {
-    sliceRid: string;
-    transitions: number;
-    firstTs: string | null;
-    lastTs: string | null;
-    durationMs: number | null;
-    finalState: string | null;
-    fanoutCount: number;
-    repairCycleCount: number;
-    success: boolean;
-};
-export type FanoutBreakdown = {
-    total: number;
-    perRole: Record<ObservabilitySubagentRole, number>;
-};
-export type RepairCycleReport = {
-    totalCycles: number;
-    cap: number;
-    capHit: boolean;
-    capHitCount: number;
-    perSlice: Array<{
-        sliceRid: string;
-        cycleCount: number;
-    }>;
-};
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
-export declare const REPAIR_CYCLE_CAP = 3;
-export declare function aggregateStatus(events: readonly ObservabilityEvent[]): StatusAggregate;
-export declare function aggregateSlices(events: readonly ObservabilityEvent[]): SliceRollup[];
-export declare function aggregateFanout(events: readonly ObservabilityEvent[]): FanoutBreakdown;
-export declare function aggregateRepairCycles(events: readonly ObservabilityEvent[]): RepairCycleReport;
-export type Period = 'day' | 'week' | 'month';
-export declare function periodStartIso(period: Period, now?: () => Date): string;
-export declare function filterByPeriod(events: readonly ObservabilityEvent[], period: Period, now?: () => Date): ObservabilityEvent[];
-export declare function readAllSessionEvents(projectRoot: string): ObservabilityEvent[];
-export declare function readSessionEvents(projectRoot: string, sessionId: string): ObservabilityEvent[];

package/dist/src/services/observability/aggregation.js

@@ -1,217 +0,0 @@
-/**
- * Read-only aggregations over observability events.
- *
- * Slice B of v2.11.1. Pure functions over `readonly ObservabilityEvent[]`
- * — the CLI layer reads events via `readObservabilityEvents` (or
- * `listSessionDirsWithMetrics` for cross-session rollups) and passes
- * them in. Tests pass synthetic events directly.
- *
- * Aggregations:
- *   - `aggregateStatus(events)`        → AC-1
- *   - `aggregateSlices(events)`        → AC-2
- *   - `aggregateFanout(events)`        → AC-3
- *   - `aggregateRepairCycles(events)`  → AC-4
- *
- * The dispatch / mode-gate / context / post-compact categories land
- * in Slice C (more hooks); for Slice B only `slice-transition` events
- * are emitted from the `peaks request transition` hook. Slice B
- * builds the read-side surface so Slice C is purely additive.
- */
-import { readObservabilityEvents } from './observability-service.js';
-import { listSessionDirsWithMetrics } from './jsonl-store.js';
-// Slice lifecycle terminal states. Anything not listed is in-flight
-// (draft / spec-locked / implemented / qa-handoff / running).
-const TERMINAL_HAPPY_STATES = new Set([
-    'handed-off',
-    'verdict-issued',
-    'impact-recorded',
-    'boundary-recorded'
-]);
-const TERMINAL_FAIL_STATES = new Set(['blocked']);
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
-export const REPAIR_CYCLE_CAP = 3;
-// v2.12.0 fan-out collapse: see OBSERVABILITY_SUBAGENT_ROLES for the
-// rationale on why `security-reviewer` was dropped and `peaks-security-audit`
-// + `peaks-perf-audit` were added.
-const ZERO_FANOUT = {
-    'rd': 0,
-    'qa': 0,
-    'code-reviewer': 0,
-    'karpathy-reviewer': 0,
-    'peaks-security-audit': 0,
-    'peaks-perf-audit': 0
-};
-// ----- internal helpers -----
-function isSliceTransition(event) {
-    return event.category === 'slice-transition' && typeof event.sliceRid === 'string';
-}
-function artifactRole(event) {
-    const detail = event.detail;
-    return typeof detail.artifactRole === 'string' ? detail.artifactRole : '';
-}
-function transitionTo(event) {
-    const detail = event.detail;
-    return typeof detail.to === 'string' ? detail.to : null;
-}
-function durationMsBetween(firstTs, lastTs) {
-    const a = new Date(firstTs).getTime();
-    const b = new Date(lastTs).getTime();
-    if (!Number.isFinite(a) || !Number.isFinite(b)) {
-        return 0;
-    }
-    return Math.max(0, b - a);
-}
-// ----- per-slice rollup (shared by status + slices queries) -----
-function rollupSlices(events) {
-    const bySlice = new Map();
-    for (const event of events) {
-        if (!isSliceTransition(event))
-            continue;
-        const rid = event.sliceRid;
-        let rollup = bySlice.get(rid);
-        if (rollup === undefined) {
-            rollup = {
-                sliceRid: rid,
-                transitions: 0,
-                firstTs: null,
-                lastTs: null,
-                durationMs: null,
-                finalState: null,
-                fanoutCount: 0,
-                repairCycleCount: 0,
-                success: false
-            };
-            bySlice.set(rid, rollup);
-        }
-        rollup.transitions += 1;
-        if (rollup.firstTs === null || event.ts < rollup.firstTs)
-            rollup.firstTs = event.ts;
-        if (rollup.lastTs === null || event.ts > rollup.lastTs)
-            rollup.lastTs = event.ts;
-        const to = transitionTo(event);
-        if (to !== null)
-            rollup.finalState = to;
-    }
-    for (const rollup of bySlice.values()) {
-        if (rollup.finalState !== null && TERMINAL_HAPPY_STATES.has(rollup.finalState)) {
-            rollup.success = true;
-        }
-        if (rollup.firstTs !== null && rollup.lastTs !== null) {
-            rollup.durationMs = durationMsBetween(rollup.firstTs, rollup.lastTs);
-        }
-    }
-    return bySlice;
-}
-function computeRepairCyclesBySlice(events) {
-    // Repair cycle = each rd → qa transition within one slice (proxy for the
-    // RD→QA→RD loop). For each slice we count qa transitions that follow an
-    // rd transition. Multiple qa transitions on the same slice are capped by
-    // REPAIR_CYCLE_CAP at the report level — the per-slice count here is the
-    // raw observation count.
-    const cyclesBySlice = new Map();
-    for (const event of events) {
-        if (!isSliceTransition(event))
-            continue;
-        const rid = event.sliceRid;
-        const role = artifactRole(event);
-        if (role === 'qa') {
-            cyclesBySlice.set(rid, (cyclesBySlice.get(rid) ?? 0) + 1);
-        }
-    }
-    return cyclesBySlice;
-}
-// ----- public aggregations -----
-export function aggregateStatus(events) {
-    const bySlice = rollupSlices(events);
-    const cyclesBySlice = computeRepairCyclesBySlice(events);
-    let repairCyclePeak = 0;
-    for (const rollup of bySlice.values()) {
-        const cycles = cyclesBySlice.get(rollup.sliceRid) ?? 0;
-        rollup.repairCycleCount = cycles;
-        if (cycles > repairCyclePeak)
-            repairCyclePeak = cycles;
-    }
-    const successCount = Array.from(bySlice.values()).filter((r) => r.success).length;
-    const failCount = Array.from(bySlice.values()).filter((r) => r.finalState !== null && TERMINAL_FAIL_STATES.has(r.finalState)).length;
-    const fanoutCostTotal = events.filter((e) => e.category === 'dispatch').length;
-    return {
-        totalEvents: events.length,
-        totalSlices: bySlice.size,
-        successCount,
-        failCount,
-        repairCyclePeak,
-        fanoutCostTotal
-    };
-}
-export function aggregateSlices(events) {
-    const bySlice = rollupSlices(events);
-    const cyclesBySlice = computeRepairCyclesBySlice(events);
-    for (const rollup of bySlice.values()) {
-        rollup.repairCycleCount = cyclesBySlice.get(rollup.sliceRid) ?? 0;
-    }
-    return Array.from(bySlice.values()).sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
-}
-export function aggregateFanout(events) {
-    const perRole = { ...ZERO_FANOUT };
-    let total = 0;
-    for (const event of events) {
-        if (event.category !== 'dispatch')
-            continue;
-        if (event.role !== undefined && event.role in perRole) {
-            perRole[event.role] += 1;
-            total += 1;
-        }
-    }
-    return { total, perRole };
-}
-export function aggregateRepairCycles(events) {
-    const cyclesBySlice = computeRepairCyclesBySlice(events);
-    const perSlice = Array.from(cyclesBySlice.entries())
-        .map(([sliceRid, cycleCount]) => ({ sliceRid, cycleCount }))
-        .sort((a, b) => a.sliceRid.localeCompare(b.sliceRid));
-    const totalCycles = perSlice.reduce((sum, row) => sum + row.cycleCount, 0);
-    const capHitCount = perSlice.filter((row) => row.cycleCount >= REPAIR_CYCLE_CAP).length;
-    return {
-        totalCycles,
-        cap: REPAIR_CYCLE_CAP,
-        capHit: capHitCount > 0,
-        capHitCount,
-        perSlice
-    };
-}
-export function periodStartIso(period, now = () => new Date()) {
-    const d = now();
-    if (period === 'day') {
-        d.setUTCHours(0, 0, 0, 0);
-        return d.toISOString();
-    }
-    if (period === 'week') {
-        d.setUTCHours(0, 0, 0, 0);
-        const day = d.getUTCDay();
-        const diff = (day + 6) % 7; // Monday = 0
-        d.setUTCDate(d.getUTCDate() - diff);
-        return d.toISOString();
-    }
-    d.setUTCDate(1);
-    d.setUTCHours(0, 0, 0, 0);
-    return d.toISOString();
-}
-export function filterByPeriod(events, period, now) {
-    const start = periodStartIso(period, now);
-    return events.filter((e) => e.ts >= start);
-}
-// ----- event-source helpers (CLI calls these; tests use pure functions) -----
-export function readAllSessionEvents(projectRoot) {
-    const sessions = listSessionDirsWithMetrics(projectRoot);
-    const all = [];
-    for (const { sessionId } of sessions) {
-        for (const event of readObservabilityEvents(projectRoot, sessionId)) {
-            all.push(event);
-        }
-    }
-    all.sort((a, b) => a.ts.localeCompare(b.ts));
-    return all;
-}
-export function readSessionEvents(projectRoot, sessionId) {
-    return readObservabilityEvents(projectRoot, sessionId);
-}

package/dist/src/services/perf/perf-baseline-service.d.ts

@@ -1,70 +0,0 @@
-/**
- * Performance baseline scaffolding for the RD stage.
- *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
- * that performance tests (lighthouse / k6 / project-local benches / etc.)
- * have historically only been run at QA Gate A4 — too late in the loop,
- * because a slow regression discovered at QA triggers a return-to-rd
- * cycle, the RD ships another "fix", QA re-runs, and the same cycle
- * repeats up to 3 times before the slice ships.
- *
- * `peaks perf baseline` is the user-visible artifact of a deliberate
- * compromise: keep the heavy performance measurement as something the
- * RD runs themselves (lighthouse is project-shape dependent and we
- * don't want to bake a lighthouse dependency into the CLI), but capture
- * the result in a stable, scaffolded file under
- * `.peaks/_runtime/<sid>/rd/perf-baseline.md` so QA Gate A4 has a known-good
- * reference to diff against. The CLI itself only writes the scaffold
- * and records the path; the actual measurement is a project-local
- * concern that lives in the README, not in peaks-loop.
- *
- * The four-grounds check (per the skill-primary-CLI-auxiliary dev
- * preference):
- *   1. hook/script/CI invokability  — yes, a hook can call this CLI
- *                                     to scaffold the file on session
- *                                     init, similar to session bootstrap.
- *   2. JSON envelope that gates a downstream decision — yes,
- *                                     peaks-rd reads the result and
- *                                     attaches it to the handoff.
- *   3. Destructive --apply side effect — yes, default dry-run.
- *   4. Machine-enforced gate that prose cannot enforce — no, the
- *                                     measurement still lives in
- *                                     the LLM / project tools. We do
- *                                     NOT add a lint gate here.
- *
- * Net: CLI is justified. The destructive --apply default is dry-run,
- * matching the rest of peaks-loop's scaffolding pattern.
- */
-export type PerfBaselineInitOptions = {
-    projectRoot: string;
-    apply?: boolean;
-    reason?: string;
-};
-export type PerfBaselinePlan = {
-    apply: boolean;
-    projectRoot: string;
-    sessionId: string | null;
-    perfBaselinePath: string | null;
-    plannedWrites: Array<{
-        path: string;
-        kind: 'directory' | 'file';
-        bytes: number;
-        content: string;
-    }>;
-    alreadyInitialized: boolean;
-    existingFiles: string[];
-};
-export type PerfBaselineResult = PerfBaselinePlan & {
-    writtenFiles: string[];
-    createdDirectories: string[];
-    reason?: string;
-};
-export declare function executePerfBaselineInit(options: PerfBaselineInitOptions): Promise<PerfBaselineResult>;
-/**
- * Re-exported so the CLI command can fall back to a project-root
- * resolution when the caller did not pass --project. The CLI does
- * the same findProjectRoot walk that `workspace init` does; this
- * helper exists for the command layer to import without reaching
- * into config-safety directly.
- */
-export declare function resolveProjectRootFromCwd(cwd: string): string;

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

@@ -1,214 +0,0 @@
-/**
- * Performance baseline scaffolding for the RD stage.
- *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
- * that performance tests (lighthouse / k6 / project-local benches / etc.)
- * have historically only been run at QA Gate A4 — too late in the loop,
- * because a slow regression discovered at QA triggers a return-to-rd
- * cycle, the RD ships another "fix", QA re-runs, and the same cycle
- * repeats up to 3 times before the slice ships.
- *
- * `peaks perf baseline` is the user-visible artifact of a deliberate
- * compromise: keep the heavy performance measurement as something the
- * RD runs themselves (lighthouse is project-shape dependent and we
- * don't want to bake a lighthouse dependency into the CLI), but capture
- * the result in a stable, scaffolded file under
- * `.peaks/_runtime/<sid>/rd/perf-baseline.md` so QA Gate A4 has a known-good
- * reference to diff against. The CLI itself only writes the scaffold
- * and records the path; the actual measurement is a project-local
- * concern that lives in the README, not in peaks-loop.
- *
- * The four-grounds check (per the skill-primary-CLI-auxiliary dev
- * preference):
- *   1. hook/script/CI invokability  — yes, a hook can call this CLI
- *                                     to scaffold the file on session
- *                                     init, similar to session bootstrap.
- *   2. JSON envelope that gates a downstream decision — yes,
- *                                     peaks-rd reads the result and
- *                                     attaches it to the handoff.
- *   3. Destructive --apply side effect — yes, default dry-run.
- *   4. Machine-enforced gate that prose cannot enforce — no, the
- *                                     measurement still lives in
- *                                     the LLM / project tools. We do
- *                                     NOT add a lint gate here.
- *
- * Net: CLI is justified. The destructive --apply default is dry-run,
- * matching the rest of peaks-loop's scaffolding pattern.
- */
-import { mkdir, writeFile } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { getSessionId } from '../session/session-manager.js';
-import { getSessionDir } from '../session/getSessionDir.js';
-import { findProjectRoot } from '../config/config-safety.js';
-const README_BODY = `# Performance baseline
-
-> Scaffolding for the RD-side performance baseline. Created by
-> \`peaks perf baseline\`. The actual measurement is the RD's
-> responsibility — see the "How to fill this in" section below.
-
-## Why this exists
-
-The QA stage's Gate A4 (performance check) compares the slice's
-performance against the most recent baseline. Without an RD-side
-baseline, the first time Gate A4 runs it has nothing to compare
-against and any regression it finds is a blind-side surprise.
-Capturing the baseline at the RD stage — right after the
-implementation lands and before QA picks it up — closes that
-gap and prevents the "QA returns 3 times for the same perf
-regression" loop.
-
-## What to capture
-
-For each performance-sensitive code path in the slice, record:
-
-- **Path / route** — which entry point (page, hook, API) the
-  measurement targets.
-- **Workload** — what you did with it (cold load, hot loop, the
-  exact N of records the slice introduces).
-- **Tool** — lighthouse / k6 / autocannon / project-local bench
-  script. Match the tool to the workload; do not introduce a new
-  one if the project already has a benchmark script.
-- **Metrics** — at minimum LCP / FCP / TBT / CLS for frontend,
-  p50/p95/p99 latency + rps for backend, rss / heap growth
-  for long-running services.
-- **Baseline value** — the number you measured, with units.
-- **Threshold** — what the slice's PRD / acceptance criteria
-  consider acceptable. If the PRD does not specify, leave this
-  field as \`TBD (ask PM)\` and surface it in the RD handoff.
-
-## How to fill this in
-
-1. Run the project's chosen performance tool against the
-   implementation you just landed. If the project does not have
-   a tool yet, the lightest first step is the chrome devtools
-   performance tab on the touched route.
-2. For each metric, copy the row from "What to capture" into
-   the "Results" table below and fill in the number.
-3. The threshold is the bar QA Gate A4 will compare against.
-   Be conservative — if the threshold is tighter than what the
-   tool reports, Gate A4 will fail.
-
-## Results
-
-| Path / route | Workload | Tool | Metric | Baseline | Threshold |
-|---|---|---|---|---|---|
-|  |  |  |  |  |  |
-
-## Notes
-
-- If the slice is documentation-only or has no user-visible
-  performance surface, write \`N/A — no perf surface\` here and
-  surface that fact in the RD handoff.
-- If the measurement exceeded the threshold on the first run,
-  do NOT loosen the threshold to make it pass. The right move
-  is to optimise the implementation and re-measure, or to
-  surface the trade-off to the PRD owner for a threshold bump.
-
-## Handoff
-
-- to peaks-qa: the \`Results\` table is the input to Gate A4.
-  Without it QA cannot establish a comparison baseline.
-- to peaks-sc: any threshold bumps captured here belong in the
-  release notes if the threshold moved.
-`;
-function renderBaselineTemplate() {
-    return README_BODY;
-}
-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 plannedWrites = [];
-    if (sessionRoot !== null && perfBaselinePath !== null) {
-        plannedWrites.push({
-            path: join(sessionRoot, 'rd'),
-            kind: 'directory',
-            bytes: 0,
-            content: ''
-        });
-        plannedWrites.push({
-            path: perfBaselinePath,
-            kind: 'file',
-            bytes: 0,
-            content: renderBaselineTemplate()
-        });
-        for (const write of plannedWrites) {
-            if (write.kind === 'file') {
-                write.bytes = Buffer.byteLength(write.content, 'utf8');
-            }
-        }
-    }
-    return {
-        apply,
-        projectRoot,
-        sessionId,
-        perfBaselinePath,
-        plannedWrites,
-        alreadyInitialized: false,
-        existingFiles: []
-    };
-}
-/**
- * Idempotency: skip writes for the perf-baseline file when it
- * already exists. Re-running `peaks perf baseline` on the same
- * session is a normal RD retry pattern (re-measurement, threshold
- * adjustment, etc.); we must not blow away hand-edited content.
- */
-async function planPerfBaselineInit(options) {
-    const plan = buildPlan(options.projectRoot, options.apply ?? false);
-    if (plan.perfBaselinePath !== null && existsSync(plan.perfBaselinePath)) {
-        plan.alreadyInitialized = true;
-        plan.existingFiles = [plan.perfBaselinePath];
-        plan.plannedWrites = [];
-    }
-    return plan;
-}
-export async function executePerfBaselineInit(options) {
-    const plan = await planPerfBaselineInit(options);
-    const writtenFiles = [];
-    const createdDirectories = [];
-    if (plan.sessionId === null) {
-        return {
-            ...plan,
-            ...(options.reason !== undefined ? { reason: options.reason } : {}),
-            writtenFiles,
-            createdDirectories
-        };
-    }
-    if (plan.apply && !plan.alreadyInitialized) {
-        for (const write of plan.plannedWrites) {
-            if (write.kind === 'directory') {
-                if (!existsSync(write.path)) {
-                    await mkdir(write.path, { recursive: true });
-                    createdDirectories.push(write.path);
-                }
-                continue;
-            }
-            if (write.content.length === 0)
-                continue;
-            await writeFile(write.path, write.content, 'utf8');
-            writtenFiles.push(write.path);
-        }
-    }
-    return {
-        ...plan,
-        ...(options.reason !== undefined ? { reason: options.reason } : {}),
-        writtenFiles,
-        createdDirectories
-    };
-}
-/**
- * Re-exported so the CLI command can fall back to a project-root
- * resolution when the caller did not pass --project. The CLI does
- * the same findProjectRoot walk that `workspace init` does; this
- * helper exists for the command layer to import without reaching
- * into config-safety directly.
- */
-export function resolveProjectRootFromCwd(cwd) {
-    return findProjectRoot(cwd) ?? cwd;
-}

package/dist/src/services/prd/handoff-types.d.ts

@@ -1,64 +0,0 @@
-/**
- * peaks-prd handoff — frontmatter schema (v2.11.0, schemaVersion: 2).
- *
- * The handoff is the **immutable** single source of truth that all
- * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
- * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
- * peaks-rd tech-doc handoff (v2.10.0 and earlier).
- *
- * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex
- * sha256 of the body content (UTF-8, no BOM, no frontmatter prefix).
- * The hash is computed by `services/prd/handoff-service.ts` at write
- * time and re-verified by every consumer before reading the body
- * (D1 in `v2-11-rm-rd-techdoc-immutable-handoff`).
- *
- * Path convention: the file lands at
- * `.peaks/_runtime/<sessionId>/prd/handoff.md` (gitignored session
- * artifact; the binding to `<sessionId>` lives in
- * `.peaks/_runtime/current-change`). NEVER write under
- * `.peaks/_runtime/<change-id>/...` directly (slice 2.8.3 hard ban).
- */
-/** Schema version 2 — bumped from v1 (which had no sha256 + no AC/goal
- *  IDs in frontmatter). Every consumer MUST refuse a handoff whose
- *  frontmatter is missing or carries `schemaVersion !== '2'`. */
-export type HandoffSchemaVersion = '2';
-/**
- * Handoff frontmatter — the structured header block between the
- * leading and trailing `---` fences. `readonly` enforces D1's
- * immutability: once written, peaks-rd / peaks-qa / sub-agents MUST
- * NOT mutate the on-disk copy.
- */
-export interface HandoffFrontmatter {
-    readonly requestId: string;
-    readonly sessionId: string;
-    readonly schemaVersion: HandoffSchemaVersion;
-    /** Lowercase hex sha256 of the body content. Recomputed by
-     *  `verifyHandoff`; mismatch means tampering → refuse to read. */
-    readonly handoffHash: string;
-    /** ISO 8601 timestamp at write time. */
-    readonly writtenAt: string;
-    /** PRD goal IDs the handoff binds to (e.g. `['G1', 'G2']`). */
-    readonly goals: readonly string[];
-    /** PRD acceptance-criteria IDs (e.g. `['AC-1', 'AC-2']`). */
-    readonly acceptanceCriteria: readonly string[];
-    /** PRD preserved-behavior IDs (e.g. `['P1', 'P12']`). */
-    readonly preservedBehavior: readonly string[];
-    /** Absolute path to the handoff file on disk (for re-verify). */
-    readonly handoffPath: string;
-}
-/** Handoff — frontmatter + body. The body is the markdown source of
- *  truth that sub-agents and downstream consumers parse. */
-export interface Handoff {
-    readonly frontmatter: HandoffFrontmatter;
-    readonly body: string;
-}
-/** Result of `verifyHandoff`. `ok: true` means the frontmatter's
- *  `handoffHash` matches the recomputed sha256 of the body. */
-export interface HandoffProbe {
-    readonly ok: boolean;
-    readonly reason?: HandoffProbeReason;
-    readonly actualHash?: string;
-    readonly expectedHash?: string;
-}
-export type HandoffProbeReason = 'file-missing' | 'frontmatter-malformed' | 'hash-mismatch' | 'schema-version-mismatch';

package/dist/src/services/prd/handoff-types.js

@@ -1,22 +0,0 @@
-/**
- * peaks-prd handoff — frontmatter schema (v2.11.0, schemaVersion: 2).
- *
- * The handoff is the **immutable** single source of truth that all
- * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
- * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
- * peaks-rd tech-doc handoff (v2.10.0 and earlier).
- *
- * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex
- * sha256 of the body content (UTF-8, no BOM, no frontmatter prefix).
- * The hash is computed by `services/prd/handoff-service.ts` at write
- * time and re-verified by every consumer before reading the body
- * (D1 in `v2-11-rm-rd-techdoc-immutable-handoff`).
- *
- * Path convention: the file lands at
- * `.peaks/_runtime/<sessionId>/prd/handoff.md` (gitignored session
- * artifact; the binding to `<sessionId>` lives in
- * `.peaks/_runtime/current-change`). NEVER write under
- * `.peaks/_runtime/<change-id>/...` directly (slice 2.8.3 hard ban).
- */
-export {};