peaks-loop 4.0.54 → 4.1.0

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')

package/dist/services/observability/jsonl-store.js

@@ -132,7 +132,8 @@ export function pruneMetricsFiles(projectRoot) {
             rmSync(path, { force: true });
             removed.push(path);
         }
-        catch { // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
+        catch {
+            // TODO(g2): legacy silent catch — grace: 1 minor release (v2.14.0)
             // best-effort: do not throw out of prune
         }
     }

package/dist/services/observability/observability-schema.d.ts

@@ -0,0 +1,71 @@
+/**
+ * `src/services/observability/observability-schema.ts`
+ *
+ * The wire format for slice-topology observability events: the schema version,
+ * the category and subagent-role vocabularies, the zod schema that is the
+ * source of truth for a `slices.jsonl` record, the emit-side contract types
+ * (`EmitOptions` / `EmitFailureReason` / `EmitResult`) and the
+ * `OBSERVABILITY_CONSTANTS` roll-up over them.
+ *
+ * Extracted verbatim (wave-3C of the file-size cap campaign) from
+ * `observability-service.ts`, which imports what it uses and re-exports every
+ * PUBLIC name below, so importers keep resolving all of them from
+ * `observability-service.js` unchanged. No emit or read logic lives here — the
+ * writer and the reader stay in the service module.
+ */
+import { z } from 'zod';
+export declare const OBSERVABILITY_SCHEMA_VERSION: 1;
+export declare const OBSERVABILITY_CATEGORIES: readonly ["slice-transition", "dispatch", "checkpoint", "mode-gate", "context-trigger", "post-compact", "cycle", "token-usage", "monotonic-trigger", "lease"];
+export type ObservabilityCategory = (typeof OBSERVABILITY_CATEGORIES)[number];
+export declare const OBSERVABILITY_SUBAGENT_ROLES: readonly ["rd", "qa", "code-reviewer", "karpathy-reviewer", "peaks-security-audit", "peaks-perf-audit"];
+export type ObservabilitySubagentRole = (typeof OBSERVABILITY_SUBAGENT_ROLES)[number];
+export declare const ObservabilityEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    ts: z.ZodString;
+    sessionId: z.ZodString;
+    category: z.ZodEnum<{
+        "slice-transition": "slice-transition";
+        dispatch: "dispatch";
+        checkpoint: "checkpoint";
+        "mode-gate": "mode-gate";
+        "context-trigger": "context-trigger";
+        "post-compact": "post-compact";
+        cycle: "cycle";
+        "token-usage": "token-usage";
+        "monotonic-trigger": "monotonic-trigger";
+        lease: "lease";
+    }>;
+    sliceRid: z.ZodOptional<z.ZodString>;
+    role: z.ZodOptional<z.ZodEnum<{
+        qa: "qa";
+        rd: "rd";
+        "code-reviewer": "code-reviewer";
+        "karpathy-reviewer": "karpathy-reviewer";
+        "peaks-security-audit": "peaks-security-audit";
+        "peaks-perf-audit": "peaks-perf-audit";
+    }>>;
+    detail: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>;
+export type ObservabilityEvent = z.infer<typeof ObservabilityEventSchema>;
+export type EmitOptions = {
+    /** Absolute path to the project root (where `.peaks/_runtime/` lives). */
+    projectRoot: string;
+};
+export type EmitFailureReason = 'invalid-schema' | 'write-failed' | 'invalid-session-id';
+export type EmitResult = {
+    /** True when the JSONL line was appended; false on any error path. */
+    written: boolean;
+    /**
+     * Absolute path to the metrics file the event was written to (or would
+     * be). Empty string when the session id named no session directory —
+     * there is no path to report, and `reason` says so.
+     */
+    path: string;
+    /** Set only when `written` is false. */
+    reason?: EmitFailureReason;
+};
+export declare const OBSERVABILITY_CONSTANTS: {
+    readonly SCHEMA_VERSION: 1;
+    readonly CATEGORIES: readonly ["slice-transition", "dispatch", "checkpoint", "mode-gate", "context-trigger", "post-compact", "cycle", "token-usage", "monotonic-trigger", "lease"];
+    readonly SUBAGENT_ROLES: readonly ["rd", "qa", "code-reviewer", "karpathy-reviewer", "peaks-security-audit", "peaks-perf-audit"];
+};

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

@@ -0,0 +1,64 @@
+/**
+ * `src/services/observability/observability-schema.ts`
+ *
+ * The wire format for slice-topology observability events: the schema version,
+ * the category and subagent-role vocabularies, the zod schema that is the
+ * source of truth for a `slices.jsonl` record, the emit-side contract types
+ * (`EmitOptions` / `EmitFailureReason` / `EmitResult`) and the
+ * `OBSERVABILITY_CONSTANTS` roll-up over them.
+ *
+ * Extracted verbatim (wave-3C of the file-size cap campaign) from
+ * `observability-service.ts`, which imports what it uses and re-exports every
+ * PUBLIC name below, so importers keep resolving all of them from
+ * `observability-service.js` unchanged. No emit or read logic lives here — the
+ * writer and the reader stay in the service module.
+ */
+import { z } from 'zod';
+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())
+});
+export const OBSERVABILITY_CONSTANTS = {
+    SCHEMA_VERSION: OBSERVABILITY_SCHEMA_VERSION,
+    CATEGORIES: OBSERVABILITY_CATEGORIES,
+    SUBAGENT_ROLES: OBSERVABILITY_SUBAGENT_ROLES
+};

package/dist/services/observability/observability-service.d.ts

@@ -18,57 +18,9 @@
  * log if it wants — but the calling hook site itself swallows the
  * result (fire-and-forget by convention).
  */
-import { z } from 'zod';
-export declare const OBSERVABILITY_SCHEMA_VERSION: 1;
-export declare const OBSERVABILITY_CATEGORIES: readonly ["slice-transition", "dispatch", "checkpoint", "mode-gate", "context-trigger", "post-compact", "cycle", "token-usage", "monotonic-trigger", "lease"];
-export type ObservabilityCategory = typeof OBSERVABILITY_CATEGORIES[number];
-export declare const OBSERVABILITY_SUBAGENT_ROLES: readonly ["rd", "qa", "code-reviewer", "karpathy-reviewer", "peaks-security-audit", "peaks-perf-audit"];
-export type ObservabilitySubagentRole = typeof OBSERVABILITY_SUBAGENT_ROLES[number];
-export declare const ObservabilityEventSchema: z.ZodObject<{
-    schemaVersion: z.ZodLiteral<1>;
-    ts: z.ZodString;
-    sessionId: z.ZodString;
-    category: z.ZodEnum<{
-        "slice-transition": "slice-transition";
-        dispatch: "dispatch";
-        checkpoint: "checkpoint";
-        "mode-gate": "mode-gate";
-        "context-trigger": "context-trigger";
-        "post-compact": "post-compact";
-        cycle: "cycle";
-        "token-usage": "token-usage";
-        "monotonic-trigger": "monotonic-trigger";
-        lease: "lease";
-    }>;
-    sliceRid: z.ZodOptional<z.ZodString>;
-    role: z.ZodOptional<z.ZodEnum<{
-        qa: "qa";
-        rd: "rd";
-        "code-reviewer": "code-reviewer";
-        "karpathy-reviewer": "karpathy-reviewer";
-        "peaks-security-audit": "peaks-security-audit";
-        "peaks-perf-audit": "peaks-perf-audit";
-    }>>;
-    detail: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-}, z.core.$strip>;
-export type ObservabilityEvent = z.infer<typeof ObservabilityEventSchema>;
-export type EmitOptions = {
-    /** Absolute path to the project root (where `.peaks/_runtime/` lives). */
-    projectRoot: string;
-};
-export type EmitFailureReason = 'invalid-schema' | 'write-failed' | 'invalid-session-id';
-export type EmitResult = {
-    /** True when the JSONL line was appended; false on any error path. */
-    written: boolean;
-    /**
-     * Absolute path to the metrics file the event was written to (or would
-     * be). Empty string when the session id named no session directory —
-     * there is no path to report, and `reason` says so.
-     */
-    path: string;
-    /** Set only when `written` is false. */
-    reason?: EmitFailureReason;
-};
+import { type EmitOptions, type EmitResult, type ObservabilityEvent, type ObservabilitySubagentRole } from './observability-schema.js';
+export { OBSERVABILITY_CATEGORIES, OBSERVABILITY_CONSTANTS, OBSERVABILITY_SCHEMA_VERSION, OBSERVABILITY_SUBAGENT_ROLES, ObservabilityEventSchema } from './observability-schema.js';
+export type { EmitFailureReason, EmitOptions, EmitResult, ObservabilityCategory, ObservabilityEvent, ObservabilitySubagentRole } from './observability-schema.js';
 /**
  * Append a single observability event to the session's JSONL metrics
  * file. Synchronous (small append, sub-ms in practice) and
@@ -97,11 +49,6 @@ export declare function readObservabilityEvents(projectRoot: string, sessionId:
  * parsed JSON and want to skip forward-compat records).
  */
 export declare function isCurrentSchemaVersion(record: unknown): record is ObservabilityEvent;
-export declare const OBSERVABILITY_CONSTANTS: {
-    readonly SCHEMA_VERSION: 1;
-    readonly CATEGORIES: readonly ["slice-transition", "dispatch", "checkpoint", "mode-gate", "context-trigger", "post-compact", "cycle", "token-usage", "monotonic-trigger", "lease"];
-    readonly SUBAGENT_ROLES: readonly ["rd", "qa", "code-reviewer", "karpathy-reviewer", "peaks-security-audit", "peaks-perf-audit"];
-};
 /**
  * Slice 2026-07-29-worktree-l2-extended Part 4.A: lease lifecycle
  * observability. Each `peaks worktree spawn / renew / release /