peaks-loop 4.0.54 → 4.1.1

package/dist/services/memory/project-memory-service/types.js

@@ -6,79 +6,4 @@
 // from here, and the top-level `index.ts` re-exports them for back-compat
 // with downstream callers (CLI commands, audit writers, presence service).
 // ---------------------------------------------------------------------------
-/**
- * Canonical memory-kind vocabulary — the single source of truth.
- *
- * The union type, the accepted-kind set in the frontmatter parser, the
- * hot/warm tier map below, `KIND_ORDER` in the reindex view, and the CLI
- * `--kind` help text all derive from this tuple. Adding a kind here is the
- * only edit required; TypeScript then forces `MEMORY_KIND_TIER` to cover it.
- *
- * Slice 2026-09-10-memory-vocab-and-rotate (E): the original 8 kinds are
- * unchanged. The 13 appended kinds were observed on disk with real values
- * that the index schema rejected (`peaks memory reindex` reported them as
- * `unrecognized kind value`). Accepting them moves those files into the
- * index; files with no kind field at all stay reported as unclassified.
- */
-export const PROJECT_MEMORY_KINDS = [
-    // Original 8 (pre-2026-09-10).
-    'project',
-    'rule',
-    'decision',
-    'reference',
-    'feedback',
-    'convention',
-    'module',
-    'lesson',
-    // Slice E expansion — observed on-disk values, hot tier.
-    'bug',
-    'investigation',
-    'technical-pattern',
-    'project-rule',
-    // Slice E expansion — observed on-disk values, warm tier.
-    'design',
-    'handoff',
-    'session-handoff',
-    'project-todo',
-    'publish-closure',
-    'project-closure',
-    'slice-closure',
-    'slice-pilot-findings',
-    'sediment'
-];
-/**
- * Hot/warm tier per kind. Insertion order IS the deterministic section order
- * used by the generated `MEMORY.md` (`KIND_ORDER` in `index/reindex.ts`),
- * so this object's key order is load-bearing — append new kinds at the end
- * of their tier block rather than reshuffling existing entries.
- *
- * The `Record<ProjectMemoryKind, MemoryKindTier>` annotation makes a missing
- * tier a compile error whenever `PROJECT_MEMORY_KINDS` grows.
- */
-export const MEMORY_KIND_TIER = {
-    // hot — full body kept in the index
-    feedback: 'hot',
-    decision: 'hot',
-    rule: 'hot',
-    convention: 'hot',
-    module: 'hot',
-    lesson: 'hot',
-    bug: 'hot',
-    investigation: 'hot',
-    'technical-pattern': 'hot',
-    'project-rule': 'hot',
-    // warm — same entry shape, read on demand
-    project: 'warm',
-    reference: 'warm',
-    design: 'warm',
-    handoff: 'warm',
-    'session-handoff': 'warm',
-    'project-todo': 'warm',
-    'publish-closure': 'warm',
-    'project-closure': 'warm',
-    'slice-closure': 'warm',
-    'slice-pilot-findings': 'warm',
-    sediment: 'warm'
-};
-export const HOT_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'hot');
-export const WARM_MEMORY_KINDS = PROJECT_MEMORY_KINDS.filter((kind) => MEMORY_KIND_TIER[kind] === 'warm');
+export { HOT_MEMORY_KINDS, MEMORY_KIND_TIER, PROJECT_MEMORY_KINDS, WARM_MEMORY_KINDS } from './memory-kinds.js';

package/dist/services/migrate-skill-name/migrate.js

@@ -79,7 +79,7 @@ export function migrateSkillName(opts) {
         keyValueReplacements: 0,
         stringReplacements: 0,
         skipped: [...SKIP_DIRS],
-        errors: [],
+        errors: []
     };
     for (const file of files) {
         if (shouldSkip(opts.projectRoot, file))

package/dist/services/migrate-skill-name/schema.js

@@ -21,5 +21,5 @@ export const MigrateResultSchema = z.object({
     keyValueReplacements: z.number().int().gte(0),
     stringReplacements: z.number().int().gte(0),
     skipped: z.array(z.string()),
-    errors: z.array(z.string()),
+    errors: z.array(z.string())
 });

package/dist/services/mode/mode-enforcement.js

@@ -60,7 +60,8 @@ export async function requireUserConfirmation(options) {
     // For assisted/strict, env var is ignored unless --force-confirm is also set
     if (process.env.PEAKS_AUTO_CONFIRM === '1') {
         if (options.forceConfirm) {
-            console.error(// TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
+            console.error(
+            // TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
             `[WARNING] --force-confirm used in ${mode} mode. ` +
                 'This bypasses user confirmation. Use with caution.');
             return;
@@ -69,7 +70,8 @@ export async function requireUserConfirmation(options) {
     }
     // --force-confirm without env var
     if (options.forceConfirm) {
-        console.error(// TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
+        console.error(
+        // TODO(g2): legacy console.error without envelope — grace: 1 minor release (v2.14.0)
         `[WARNING] --force-confirm used in ${mode} mode. ` +
             'This bypasses user confirmation. Use with caution.');
         return;

package/dist/services/mode/mode-status-service.d.ts

@@ -59,16 +59,34 @@ export interface ModeStatus {
  */
 export declare function resolvePresenceMode(projectRoot: string): ResolvedPresenceMode;
 /**
- * Resolve the auto-compact profile from the MODE, not from the 24h
- * state machine. `24h` mode → `partial` (earlier thresholds for
- * long-run sessions); every other mode → `standard`.
+ * Resolve the auto-compact profile: `partial` (earlier thresholds for
+ * long-run sessions) or `standard`.
  *
- * Slice 2026-09-09-mode-consolidation: this replaced the previous
- * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
- * long-run *phase*; the mode is the autonomy level the user (or the
- * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
- * session keeps the partial profile even while it is in
- * `WAITING_USER`, which is the correct long-run behaviour.
+ * Two sources answer "is this a 24h long run?", and EITHER is enough:
+ *
+ *   1. the PRESENCE MODE is `24h` — the autonomy level the user (or
+ *      the T3/T4 auto-engage) selected; or
+ *   2. the 24h STATE MACHINE is engaged (`24H_ACTIVE` /
+ *      `WAITING_USER`) — the durable, session-scoped record.
+ *
+ * Why both (slice H3, rid=h3-24h-threshold-not-wired): source 1 alone
+ * is not reliable. The mode lives on a per-caller, per-workflow
+ * presence lease, and `applyAutoEngagePresenceMode` can only stamp
+ * leases that are already in flight — entering `24H_ACTIVE` with no
+ * in-flight lease fails closed as `{ applied: false, reason:
+ * 'no-in-flight-lease' }`. A fresh lease is also written without a
+ * mode (`workflow-presence-lifecycle.initWorkflow`), so a successful
+ * stamp does not survive the next skill workflow either. The observed
+ * consequence was a `24H_ACTIVE` session resolving to `standard` and
+ * auto-compacting LATER than a plain session, the opposite of the
+ * documented contract.
+ *
+ * The union is a superset of both the pre-2026-09-09 mapping (state
+ * machine) and the 2026-09-09-mode-consolidation mapping (presence
+ * mode): keep partial while the mode says `24h` even in
+ * `WAITING_USER`, and keep it when only the state machine knows.
+ * Nothing that resolved to `partial` before resolves to `standard`
+ * now; a project with no 24h run is byte-identical to before.
  */
 export declare function resolveAutoCompactProfile(projectRoot: string): AutoCompactMode;
 /**

package/dist/services/mode/mode-status-service.js

@@ -46,19 +46,65 @@ export function resolvePresenceMode(projectRoot) {
     }
 }
 /**
- * Resolve the auto-compact profile from the MODE, not from the 24h
- * state machine. `24h` mode → `partial` (earlier thresholds for
- * long-run sessions); every other mode → `standard`.
+ * The 24h state-machine states in which the long run is ENGAGED.
  *
- * Slice 2026-09-09-mode-consolidation: this replaced the previous
- * `24h-state.state === '24H_ACTIVE'` mapping. The state machine is the
- * long-run *phase*; the mode is the autonomy level the user (or the
- * T3/T4 auto-engage) selected. Keying off the mode means a `24h`
- * session keeps the partial profile even while it is in
- * `WAITING_USER`, which is the correct long-run behaviour.
+ * `24H_ACTIVE` is the run itself; `WAITING_USER` is a pause *inside*
+ * it (the run is still on — the user just has to answer). `BRAINSTORM`
+ * / `USER_CONFIRM` precede the run, `HANDOFF` ends it, `IDLE` means it
+ * never started.
+ */
+const ENGAGED_24H_STATES = new Set(['24H_ACTIVE', 'WAITING_USER']);
+/**
+ * Fail-soft read of the bound session's 24h state machine: `true` when
+ * the long run is engaged. Every degradation (no session, missing or
+ * malformed snapshot) reads as `false` so a non-24h project is
+ * untouched by this signal.
+ */
+function is24hRunEngaged(projectRoot) {
+    try {
+        const sessionId = getCurrentSessionId(projectRoot);
+        if (sessionId === null)
+            return false;
+        return ENGAGED_24H_STATES.has(read24hState(projectRoot, sessionId).state);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Resolve the auto-compact profile: `partial` (earlier thresholds for
+ * long-run sessions) or `standard`.
+ *
+ * Two sources answer "is this a 24h long run?", and EITHER is enough:
+ *
+ *   1. the PRESENCE MODE is `24h` — the autonomy level the user (or
+ *      the T3/T4 auto-engage) selected; or
+ *   2. the 24h STATE MACHINE is engaged (`24H_ACTIVE` /
+ *      `WAITING_USER`) — the durable, session-scoped record.
+ *
+ * Why both (slice H3, rid=h3-24h-threshold-not-wired): source 1 alone
+ * is not reliable. The mode lives on a per-caller, per-workflow
+ * presence lease, and `applyAutoEngagePresenceMode` can only stamp
+ * leases that are already in flight — entering `24H_ACTIVE` with no
+ * in-flight lease fails closed as `{ applied: false, reason:
+ * 'no-in-flight-lease' }`. A fresh lease is also written without a
+ * mode (`workflow-presence-lifecycle.initWorkflow`), so a successful
+ * stamp does not survive the next skill workflow either. The observed
+ * consequence was a `24H_ACTIVE` session resolving to `standard` and
+ * auto-compacting LATER than a plain session, the opposite of the
+ * documented contract.
+ *
+ * The union is a superset of both the pre-2026-09-09 mapping (state
+ * machine) and the 2026-09-09-mode-consolidation mapping (presence
+ * mode): keep partial while the mode says `24h` even in
+ * `WAITING_USER`, and keep it when only the state machine knows.
+ * Nothing that resolved to `partial` before resolves to `standard`
+ * now; a project with no 24h run is byte-identical to before.
  */
 export function resolveAutoCompactProfile(projectRoot) {
-    return resolvePresenceMode(projectRoot).mode === '24h' ? 'partial' : 'standard';
+    if (resolvePresenceMode(projectRoot).mode === '24h')
+        return 'partial';
+    return is24hRunEngaged(projectRoot) ? 'partial' : 'standard';
 }
 /**
  * Assemble the full stacked status. `sessionId` defaults to the
@@ -95,6 +141,12 @@ export function resolveModeStatus(input) {
             jobMode = false;
         }
     }
+    // Delegate rather than re-derive `is24h ? 'partial' : 'standard'`: the
+    // profile has a second source (the 24h state machine), and a local
+    // copy of the old one-source rule would make `peaks code mode status`
+    // advertise a different profile than the one `peaks code
+    // auto-compact` actually applies.
+    const autoCompactProfile = resolveAutoCompactProfile(projectRoot);
     return {
         mode: presence.mode,
         skill: presence.skill,
@@ -102,7 +154,7 @@ export function resolveModeStatus(input) {
         is24h,
         h24State,
         jobMode,
-        autoCompactProfile: is24h ? 'partial' : 'standard',
-        autoCompactThresholds: AUTO_COMPACT_THRESHOLDS[is24h ? 'partial' : 'standard']
+        autoCompactProfile,
+        autoCompactThresholds: AUTO_COMPACT_THRESHOLDS[autoCompactProfile]
     };
 }

package/dist/services/observability/aggregation-helpers.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `src/services/observability/aggregation-helpers.ts`
+ *
+ * The event-detail readers the aggregations in `aggregation.ts` are built on
+ * (category test, `detail` field extraction, timestamp difference), the
+ * per-slice repair-cycle count, and the two event-source helpers the CLI
+ * calls. Moved verbatim (wave 3, file-size cap campaign) so the aggregation
+ * module stays under the 300 raw-line cap. The first four were module-private
+ * before the move and are NOT re-exported from `aggregation.ts`; the two
+ * event-source helpers were public and are re-exported there, so that
+ * module's public surface is unchanged.
+ */
+import { type ObservabilityEvent } from './observability-service.js';
+export declare function isSliceTransition(event: ObservabilityEvent): event is ObservabilityEvent & {
+    sliceRid: string;
+};
+export declare function artifactRole(event: ObservabilityEvent): string;
+export declare function transitionTo(event: ObservabilityEvent): string | null;
+export declare function durationMsBetween(firstTs: string, lastTs: string): number;
+export declare function computeRepairCyclesBySlice(events: readonly ObservabilityEvent[]): Map<string, number>;
+export declare function readAllSessionEvents(projectRoot: string): ObservabilityEvent[];
+export declare function readSessionEvents(projectRoot: string, sessionId: string): ObservabilityEvent[];

package/dist/services/observability/aggregation-helpers.js

@@ -0,0 +1,65 @@
+/**
+ * `src/services/observability/aggregation-helpers.ts`
+ *
+ * The event-detail readers the aggregations in `aggregation.ts` are built on
+ * (category test, `detail` field extraction, timestamp difference), the
+ * per-slice repair-cycle count, and the two event-source helpers the CLI
+ * calls. Moved verbatim (wave 3, file-size cap campaign) so the aggregation
+ * module stays under the 300 raw-line cap. The first four were module-private
+ * before the move and are NOT re-exported from `aggregation.ts`; the two
+ * event-source helpers were public and are re-exported there, so that
+ * module's public surface is unchanged.
+ */
+import { readObservabilityEvents } from './observability-service.js';
+import { listSessionDirsWithMetrics } from './jsonl-store.js';
+export function isSliceTransition(event) {
+    return event.category === 'slice-transition' && typeof event.sliceRid === 'string';
+}
+export function artifactRole(event) {
+    const detail = event.detail;
+    return typeof detail.artifactRole === 'string' ? detail.artifactRole : '';
+}
+export function transitionTo(event) {
+    const detail = event.detail;
+    return typeof detail.to === 'string' ? detail.to : null;
+}
+export 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);
+}
+export 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;
+}
+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/services/observability/aggregation-types.d.ts

@@ -0,0 +1,66 @@
+/**
+ * `src/services/observability/aggregation-types.ts`
+ *
+ * The result shapes of the read-side aggregations over observability events
+ * (`aggregation.ts`), plus the data they are built from: the slice lifecycle
+ * terminal states, the RD/QA repair-loop cap, and the zeroed fan-out row.
+ * Extracted verbatim (wave 3, file-size cap campaign) so the aggregation
+ * module stays under the 300 raw-line cap — no aggregation logic lives here.
+ * `aggregation.ts` imports and re-exports every PUBLIC name below, so
+ * importers keep resolving them from `aggregation.js` unchanged; the
+ * module-private constants are imported for use and stay unexported there.
+ */
+import 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;
+    }>;
+};
+export declare const TERMINAL_HAPPY_STATES: ReadonlySet<string>;
+export declare const TERMINAL_FAIL_STATES: ReadonlySet<string>;
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
+export declare const REPAIR_CYCLE_CAP = 3;
+export declare const ZERO_FANOUT: Record<ObservabilitySubagentRole, number>;
+export type Period = 'day' | 'week' | 'month';
+/**
+ * Cumulative 5-metric surface for the `peaks dashboard summary` CLI.
+ * All values are derived from raw observability events (per-event
+ * counting), not from state files — semantics differ from
+ * `peaks dashboard long-run`, which derives indicators from
+ * `.peaks/_runtime/<sid>/24h-state.json`.
+ */
+export type DashboardMetrics = {
+    readonly cycleCount: number;
+    readonly tokenCount: number;
+    readonly dispatchCount: number;
+    readonly compactCount: number;
+    readonly monotonicTriggerCount: number;
+};

package/dist/services/observability/aggregation-types.js

@@ -0,0 +1,34 @@
+/**
+ * `src/services/observability/aggregation-types.ts`
+ *
+ * The result shapes of the read-side aggregations over observability events
+ * (`aggregation.ts`), plus the data they are built from: the slice lifecycle
+ * terminal states, the RD/QA repair-loop cap, and the zeroed fan-out row.
+ * Extracted verbatim (wave 3, file-size cap campaign) so the aggregation
+ * module stays under the 300 raw-line cap — no aggregation logic lives here.
+ * `aggregation.ts` imports and re-exports every PUBLIC name below, so
+ * importers keep resolving them from `aggregation.js` unchanged; the
+ * module-private constants are imported for use and stay unexported there.
+ */
+// Slice lifecycle terminal states. Anything not listed is in-flight
+// (draft / spec-locked / implemented / qa-handoff / running).
+export const TERMINAL_HAPPY_STATES = new Set([
+    'handed-off',
+    'verdict-issued',
+    'impact-recorded',
+    'boundary-recorded'
+]);
+export const TERMINAL_FAIL_STATES = new Set(['blocked']);
+/** RD/QA repair-loop cap (matches the peaks-code 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.
+export const ZERO_FANOUT = {
+    rd: 0,
+    qa: 0,
+    'code-reviewer': 0,
+    'karpathy-reviewer': 0,
+    'peaks-security-audit': 0,
+    'peaks-perf-audit': 0
+};

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

@@ -17,65 +17,17 @@
  * 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-code repair-loop contract). */
-export declare const REPAIR_CYCLE_CAP = 3;
+import { type ObservabilityEvent } from './observability-service.js';
+import { type DashboardMetrics, type FanoutBreakdown, type Period, type RepairCycleReport, type SliceRollup, type StatusAggregate } from './aggregation-types.js';
+export { REPAIR_CYCLE_CAP } from './aggregation-types.js';
+export { readAllSessionEvents, readSessionEvents } from './aggregation-helpers.js';
+export type { DashboardMetrics, FanoutBreakdown, Period, RepairCycleReport, SliceRollup, StatusAggregate } from './aggregation-types.js';
 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[];
-/**
- * Cumulative 5-metric surface for the `peaks dashboard summary` CLI.
- * All values are derived from raw observability events (per-event
- * counting), not from state files — semantics differ from
- * `peaks dashboard long-run`, which derives indicators from
- * `.peaks/_runtime/<sid>/24h-state.json`.
- */
-export type DashboardMetrics = {
-    readonly cycleCount: number;
-    readonly tokenCount: number;
-    readonly dispatchCount: number;
-    readonly compactCount: number;
-    readonly monotonicTriggerCount: number;
-};
 /**
  * Aggregate the 5 dashboard metric classes for a single session, filtered
  * to events with `ts >= since`. Events with unparseable timestamps are

package/dist/services/observability/aggregation.js

@@ -18,49 +18,17 @@
  * 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-code 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);
-}
+import { REPAIR_CYCLE_CAP, TERMINAL_FAIL_STATES, TERMINAL_HAPPY_STATES, ZERO_FANOUT } from './aggregation-types.js';
+import { computeRepairCyclesBySlice, durationMsBetween, isSliceTransition, transitionTo } from './aggregation-helpers.js';
+// The result shapes and their data (terminal states, repair-loop cap, zeroed
+// fan-out row) live in `aggregation-types.ts`; the event-detail readers, the
+// per-slice cycle count and the event-source helpers live in
+// `aggregation-helpers.ts` (wave-3 file-size cap split; declarations moved
+// verbatim). Every PUBLIC name is re-exported below so importers keep
+// resolving it from `aggregation.js` unchanged; the module-private readers are
+// imported for use here and not re-exported.
+export { REPAIR_CYCLE_CAP } from './aggregation-types.js';
+export { readAllSessionEvents, readSessionEvents } from './aggregation-helpers.js';
 // ----- per-slice rollup (shared by status + slices queries) -----
 function rollupSlices(events) {
     const bySlice = new Map();
@@ -102,24 +70,6 @@ function rollupSlices(events) {
     }
     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);
@@ -179,6 +129,7 @@ export function aggregateRepairCycles(events) {
         perSlice
     };
 }
+// ----- period rollup (AC-5 — Slice D, but helpers live here) -----
 export function periodStartIso(period, now = () => new Date()) {
     const d = now();
     if (period === 'day') {
@@ -200,21 +151,7 @@ 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);
-}
+// ----- rid-030 F-direction: 5-metric dashboard summary -----
 /**
  * Aggregate the 5 dashboard metric classes for a single session, filtered
  * to events with `ts >= since`. Events with unparseable timestamps are
@@ -240,8 +177,8 @@ export function aggregateDashboardMetrics(projectRoot, sessionId, since) {
             const detail = event.detail;
             const t = typeof detail.totalTokens === 'number'
                 ? detail.totalTokens
-                : (typeof detail.inputTokens === 'number' ? detail.inputTokens : 0)
-                    + (typeof detail.outputTokens === 'number' ? detail.outputTokens : 0);
+                : (typeof detail.inputTokens === 'number' ? detail.inputTokens : 0) +
+                    (typeof detail.outputTokens === 'number' ? detail.outputTokens : 0);
             tokenCount += t;
         }
         else if (event.category === 'dispatch')
@@ -274,8 +211,8 @@ export function aggregateDashboardMetricsFromEvents(events, since = null) {
             const detail = event.detail;
             const t = typeof detail.totalTokens === 'number'
                 ? detail.totalTokens
-                : (typeof detail.inputTokens === 'number' ? detail.inputTokens : 0)
-                    + (typeof detail.outputTokens === 'number' ? detail.outputTokens : 0);
+                : (typeof detail.inputTokens === 'number' ? detail.inputTokens : 0) +
+                    (typeof detail.outputTokens === 'number' ? detail.outputTokens : 0);
             tokenCount += t;
         }
         else if (event.category === 'dispatch')