peaks-loop 4.0.53 → 4.1.0

package/dist/services/loop/loop-bee-relation-store.js

@@ -56,7 +56,7 @@ function rowToLoopBeeRelation(row) {
         role: row.role,
         reason: row.reason,
         schema_version: row.schema_version,
-        created_at: row.created_at,
+        created_at: row.created_at
     };
 }
 /**
@@ -84,14 +84,12 @@ export function insertLoopBeeRelation(db, row) {
         role: row.role,
         reason: row.reason,
         schema_version: row.schema_version,
-        created_at: createdAt,
+        created_at: createdAt
     };
 }
 /** Read a single LoopBeeRelation row by id; returns undefined if absent. */
 export function getLoopBeeRelation(db, id) {
-    const row = db
-        .prepare("SELECT * FROM loop_bee_relation WHERE id = ?")
-        .get(id);
+    const row = db.prepare('SELECT * FROM loop_bee_relation WHERE id = ?').get(id);
     if (!row)
         return undefined;
     return rowToLoopBeeRelation(row);
@@ -99,8 +97,8 @@ export function getLoopBeeRelation(db, id) {
 /** List LoopBeeRelation rows for a given loop_release_id (optionally filtered by role). */
 export function listLoopBeeRelationsByLoop(db, loop_release_id, role) {
     const sql = role === undefined
-        ? "SELECT * FROM loop_bee_relation WHERE loop_release_id = ? ORDER BY id ASC"
-        : "SELECT * FROM loop_bee_relation WHERE loop_release_id = ? AND role = ? ORDER BY id ASC";
+        ? 'SELECT * FROM loop_bee_relation WHERE loop_release_id = ? ORDER BY id ASC'
+        : 'SELECT * FROM loop_bee_relation WHERE loop_release_id = ? AND role = ? ORDER BY id ASC';
     const params = role === undefined ? [loop_release_id] : [loop_release_id, role];
     const rows = db.prepare(sql).all(...params);
     return rows.map(rowToLoopBeeRelation);
@@ -108,15 +106,15 @@ export function listLoopBeeRelationsByLoop(db, loop_release_id, role) {
 /** List LoopBeeRelation rows for a given bee_release_id (optionally filtered by role). */
 export function listLoopBeeRelationsByBee(db, bee_release_id, role) {
     const sql = role === undefined
-        ? "SELECT * FROM loop_bee_relation WHERE bee_release_id = ? ORDER BY id ASC"
-        : "SELECT * FROM loop_bee_relation WHERE bee_release_id = ? AND role = ? ORDER BY id ASC";
+        ? 'SELECT * FROM loop_bee_relation WHERE bee_release_id = ? ORDER BY id ASC'
+        : 'SELECT * FROM loop_bee_relation WHERE bee_release_id = ? AND role = ? ORDER BY id ASC';
     const params = role === undefined ? [bee_release_id] : [bee_release_id, role];
     const rows = db.prepare(sql).all(...params);
     return rows.map(rowToLoopBeeRelation);
 }
 /** Update the role of an existing relation. Returns the new row, or undefined if absent. */
 export function updateLoopBeeRelationRole(db, id, newRole) {
-    const stmt = db.prepare("UPDATE loop_bee_relation SET role = ? WHERE id = ?");
+    const stmt = db.prepare('UPDATE loop_bee_relation SET role = ? WHERE id = ?');
     const info = stmt.run(newRole, id);
     if (info.changes === 0)
         return undefined;
@@ -124,7 +122,7 @@ export function updateLoopBeeRelationRole(db, id, newRole) {
 }
 /** Remove a LoopBeeRelation row by id. Returns true if a row was deleted. */
 export function removeLoopBeeRelation(db, id) {
-    const stmt = db.prepare("DELETE FROM loop_bee_relation WHERE id = ?");
+    const stmt = db.prepare('DELETE FROM loop_bee_relation WHERE id = ?');
     const info = stmt.run(id);
     return info.changes > 0;
 }

package/dist/services/loop/loop-bee-relation-types.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * LoopBeeRelation — spec §4.6.
  *

package/dist/services/loop/loop-bee-relation-types.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * LoopBeeRelation — spec §4.6.
  *
@@ -27,17 +27,12 @@ import { z } from "zod";
  *   - `created_at` is server-stamped from the system clock; the input
  *     schema does not let clients supply it (would be a backdate hole).
  */
-export const LoopBeeRelationRoleSchema = z.enum([
-    "main",
-    "supporting",
-    "candidate",
-    "retired",
-]);
+export const LoopBeeRelationRoleSchema = z.enum(['main', 'supporting', 'candidate', 'retired']);
 export const LOOP_BEE_RELATION_ROLES = [
-    "main",
-    "supporting",
-    "candidate",
-    "retired",
+    'main',
+    'supporting',
+    'candidate',
+    'retired'
 ];
 /**
  * Zod schema for the create payload (LoopBeeRelationInput).
@@ -56,19 +51,15 @@ export const LoopBeeRelationInputSchema = z.object({
         .min(1)
         .max(64)
         .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
-        message: "loop_release_id must be kebab-case starting with a lowercase letter",
+        message: 'loop_release_id must be kebab-case starting with a lowercase letter'
     }),
     bee_release_id: z
         .number()
         .int()
         .gt(0)
-        .max(2 ** 31 - 1, "bee_release_id out of 32-bit range"),
+        .max(2 ** 31 - 1, 'bee_release_id out of 32-bit range'),
     role: LoopBeeRelationRoleSchema,
-    reason: z
-        .string()
-        .trim()
-        .min(1, "reason is required (LLM-authored NL explanation)")
-        .max(2000),
+    reason: z.string().trim().min(1, 'reason is required (LLM-authored NL explanation)').max(2000)
 });
 /**
  * Full Zod schema for a LoopBeeRelation row as persisted. Differs from
@@ -83,10 +74,8 @@ export const LoopBeeRelationInputSchema = z.object({
  */
 export const LoopBeeRelationSchema = LoopBeeRelationInputSchema.extend({
     id: z.number().int().gt(0),
-    schema_version: z
-        .literal("peaks.loop-bee-relation/1")
-        .default("peaks.loop-bee-relation/1"),
-    created_at: z.string().datetime(),
+    schema_version: z.literal('peaks.loop-bee-relation/1').default('peaks.loop-bee-relation/1'),
+    created_at: z.string().datetime()
 });
 /**
  * Convenience: strict-parse an unknown payload into a LoopBeeRelation
@@ -107,8 +96,8 @@ export function safeParseLoopBeeRelation(input) {
     return {
         ok: false,
         findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
+            path: i.path.join('.'),
+            message: i.message
+        }))
     };
 }

package/dist/services/loop/loop-release-service.d.ts

@@ -1,5 +1,5 @@
-import type Database from "better-sqlite3";
-import { type LoopRelease, type LoopReleaseInput, type LoopReleaseLifecycleStatus } from "./loop-release-types.js";
+import type Database from 'better-sqlite3';
+import { type LoopRelease, type LoopReleaseInput, type LoopReleaseLifecycleStatus } from './loop-release-types.js';
 /**
  * Thin service wrapper around the loop_release store. M1 keeps the
  * surface tiny on purpose: create / read / list / search. Promotion,

package/dist/services/loop/loop-release-service.js

@@ -1,5 +1,5 @@
-import { LoopReleaseSchema, } from "./loop-release-types.js";
-import { ensureLoopReleaseTable, insertLoopRelease, getLoopRelease, listLoopReleasesByStatus, searchLoopReleasesByScenario, } from "./loop-release-store.js";
+import { LoopReleaseSchema } from './loop-release-types.js';
+import { ensureLoopReleaseTable, insertLoopRelease, getLoopRelease, listLoopReleasesByStatus, searchLoopReleasesByScenario } from './loop-release-store.js';
 /**
  * Thin service wrapper around the loop_release store. M1 keeps the
  * surface tiny on purpose: create / read / list / search. Promotion,
@@ -46,7 +46,7 @@ export class LoopReleaseService {
     list(opts = {}) {
         if (opts.status)
             return listLoopReleasesByStatus(this.db, opts.status);
-        const all = ["candidate", "stable", "retired"];
+        const all = ['candidate', 'stable', 'retired'];
         const out = [];
         for (const s of all)
             out.push(...listLoopReleasesByStatus(this.db, s));

package/dist/services/loop/loop-release-store.d.ts

@@ -1,5 +1,5 @@
-import type Database from "better-sqlite3";
-import type { LoopRelease, LoopReleaseLifecycleStatus } from "./loop-release-types.js";
+import type Database from 'better-sqlite3';
+import type { LoopRelease, LoopReleaseLifecycleStatus } from './loop-release-types.js';
 /**
  * Low-level SQLite access for the `loop_release` table. The
  * migration is registered with the existing `openStateDb()` pipeline

package/dist/services/loop/loop-release-store.js

@@ -79,7 +79,7 @@ function rowToLoopRelease(row) {
         shareable: row.shareable === 1,
         share_excluded_paths: JSON.parse(row.share_excluded_paths),
         desktop_visible: row.desktop_visible === 1,
-        export_bundle_format: row.export_bundle_format,
+        export_bundle_format: row.export_bundle_format
     };
 }
 /**
@@ -105,9 +105,7 @@ export function insertLoopRelease(db, row) {
 }
 /** Read a single LoopRelease row by id; returns undefined if absent. */
 export function getLoopRelease(db, id) {
-    const row = db
-        .prepare("SELECT * FROM loop_release WHERE id = ?")
-        .get(id);
+    const row = db.prepare('SELECT * FROM loop_release WHERE id = ?').get(id);
     if (!row)
         return undefined;
     return rowToLoopRelease(row);
@@ -115,7 +113,7 @@ export function getLoopRelease(db, id) {
 /** List LoopRelease rows filtered by lifecycle_status. */
 export function listLoopReleasesByStatus(db, status) {
     const rows = db
-        .prepare("SELECT * FROM loop_release WHERE lifecycle_status = ? ORDER BY archived_at DESC, id ASC")
+        .prepare('SELECT * FROM loop_release WHERE lifecycle_status = ? ORDER BY archived_at DESC, id ASC')
         .all(status);
     return rows.map(rowToLoopRelease);
 }
@@ -128,7 +126,7 @@ export function listLoopReleasesByStatus(db, status) {
 export function searchLoopReleasesByScenario(db, query) {
     const like = `%${query}%`;
     const rows = db
-        .prepare("SELECT * FROM loop_release WHERE scenario LIKE ? COLLATE NOCASE ORDER BY archived_at DESC, id ASC")
+        .prepare('SELECT * FROM loop_release WHERE scenario LIKE ? COLLATE NOCASE ORDER BY archived_at DESC, id ASC')
         .all(like);
     return rows.map(rowToLoopRelease);
 }

package/dist/services/loop/loop-release-types.d.ts

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * LoopRelease — spec §4.1 (Loop Engineering Asset).
  *

package/dist/services/loop/loop-release-types.js

@@ -1,4 +1,4 @@
-import { z } from "zod";
+import { z } from 'zod';
 /* ---------------------------------------------------------------------- */
 /* PRD-002b slice 2 — schema-limit constants extracted from inline         */
 /* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
@@ -59,11 +59,7 @@ const LOOP_CRYSTALLIZATION_EVIDENCE_MAX = 128;
  *     `"peaks.bundle/1"` per the spec §7A.2 contract — no other
  *     value is accepted in this schema version.
  */
-export const LoopReleaseLifecycleStatusSchema = z.enum([
-    "candidate",
-    "stable",
-    "retired",
-]);
+export const LoopReleaseLifecycleStatusSchema = z.enum(['candidate', 'stable', 'retired']);
 /**
  * The M3 share / desktop extension fields, listed for code-search /
  * lint discoverability. They are now part of the schema (with safe
@@ -75,10 +71,10 @@ export const LoopReleaseLifecycleStatusSchema = z.enum([
  *   - export_bundle_format: constant "peaks.bundle/1" (CLI-written).
  */
 export const LOOP_RELEASE_M3_FIELDS = [
-    "shareable",
-    "share_excluded_paths",
-    "desktop_visible",
-    "export_bundle_format",
+    'shareable',
+    'share_excluded_paths',
+    'desktop_visible',
+    'export_bundle_format'
 ];
 /**
  * M3 share / desktop extension schema. Added to `LoopReleaseInputSchema`
@@ -92,13 +88,9 @@ export const LOOP_RELEASE_M3_FIELDS = [
  */
 export const LoopReleaseM3ExtensionSchema = z.object({
     shareable: z.boolean().default(true),
-    share_excluded_paths: z
-        .array(z.string().min(1).max(LOOP_SHARE_EXCLUDED_PATH_MAX))
-        .default([]),
+    share_excluded_paths: z.array(z.string().min(1).max(LOOP_SHARE_EXCLUDED_PATH_MAX)).default([]),
     desktop_visible: z.boolean().default(true),
-    export_bundle_format: z
-        .literal("peaks.bundle/1")
-        .default("peaks.bundle/1"),
+    export_bundle_format: z.literal('peaks.bundle/1').default('peaks.bundle/1')
 });
 /**
  * Zod schema for the create payload (LoopReleaseInput). Mirrors the
@@ -113,31 +105,31 @@ export const LoopReleaseInputSchema = z
         .min(1)
         .max(LOOP_ID_MAX)
         .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
-        message: "id must be kebab-case starting with a lowercase letter (e.g. loop-onboarding-research)",
+        message: 'id must be kebab-case starting with a lowercase letter (e.g. loop-onboarding-research)'
     }),
     name: z.string().min(1).max(LOOP_NAME_MAX),
     scenario: z.string().trim().min(1).max(LOOP_SCENARIO_MAX),
     trigger_policy: z.string().trim().min(1).max(LOOP_TRIGGER_POLICY_MAX),
     success_criteria: z
         .array(z.string().trim().min(1).max(LOOP_SUCCESS_CRITERIA_ITEM_MAX))
-        .min(1, "success_criteria must list at least one declarative criterion"),
+        .min(1, 'success_criteria must list at least one declarative criterion'),
     interaction_policy: z
         .string()
         .trim()
-        .min(1, "interaction_policy must declare human-NL-choice-only semantics")
+        .min(1, 'interaction_policy must declare human-NL-choice-only semantics')
         .max(LOOP_INTERACTION_POLICY_MAX),
     feedback_policy: z.string().trim().min(1).max(LOOP_FEEDBACK_POLICY_MAX),
     evolution_policy: z.string().trim().min(1).max(LOOP_EVOLUTION_POLICY_MAX),
     evaluator_policy: z.array(z.string().trim().min(1).max(LOOP_EVALUATOR_POLICY_ITEM_MAX)).min(1),
     linked_bees: z.array(z.string().min(1).max(LOOP_LINKED_BEE_MAX)).default([]),
     run_history: z.array(z.string().min(1).max(LOOP_HISTORY_ITEM_MAX)).default([]),
-    crystallization_evidence: z.array(z.string().min(1).max(LOOP_CRYSTALLIZATION_EVIDENCE_MAX)).default([]),
+    crystallization_evidence: z
+        .array(z.string().min(1).max(LOOP_CRYSTALLIZATION_EVIDENCE_MAX))
+        .default([]),
     lifecycle_status: LoopReleaseLifecycleStatusSchema,
-    version: z
-        .string()
-        .regex(/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/, {
-        message: "version must be a semver string (e.g. 0.1.0)",
-    }),
+    version: z.string().regex(/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/, {
+        message: 'version must be a semver string (e.g. 0.1.0)'
+    })
 })
     .extend(LoopReleaseM3ExtensionSchema.shape);
 /**
@@ -152,9 +144,7 @@ export const LoopReleaseInputSchema = z
  * service.create/read paths.
  */
 export const LoopReleaseSchema = LoopReleaseInputSchema.extend({
-    schema_version: z
-        .literal("peaks.loop/1")
-        .default("peaks.loop/1"),
+    schema_version: z.literal('peaks.loop/1').default('peaks.loop/1')
 });
 /**
  * Convenience: strict-parse an unknown payload into a LoopRelease row.
@@ -174,8 +164,8 @@ export function safeParseLoopRelease(input) {
     return {
         ok: false,
         findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
+            path: i.path.join('.'),
+            message: i.message
+        }))
     };
 }

package/dist/services/loop/monotonic-guard-types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * peaks-loop v3.0.0 — Slice C.1
+ *
+ * Type declarations for the monotonic-improvement guard, relocated verbatim
+ * from `monotonic-guard.ts` so that module stays under the repo file-size cap.
+ * No behaviour lives here: every declaration is erased at compile time and the
+ * guard module re-exports all of them from its own path.
+ */
+/** Per-evaluator score row, derived from an `EvaluatorVerdictEnvelope`. */
+export interface MonotonicScoreRow {
+    readonly evaluator: string;
+    readonly score: number;
+    readonly gateAction: 'pass' | 'warn' | 'block';
+    readonly degraded: boolean;
+    /** ISO-8601 timestamp the verdict was recorded. */
+    readonly observedAt: string;
+}
+/** Cycle index — a single attempt at the loop. */
+export interface MonotonicCycle {
+    readonly cycle: number;
+    /** Per-evaluator score rows. Same evaluator appearing twice collapses
+     *  to the last entry (BC: deterministic, no merging surprises). */
+    readonly scores: readonly MonotonicScoreRow[];
+}
+export interface MonotonicRegression {
+    readonly evaluator: string;
+    readonly previousScore: number;
+    readonly currentScore: number;
+    readonly delta: number;
+}
+/** Result of a `checkMonotonicImprovement` call. */
+export interface MonotonicReport {
+    readonly status: 'pass' | 'warn' | 'block' | 'skip';
+    readonly ok: boolean;
+    readonly reason: string;
+    readonly threshold: number;
+    readonly previousCycle: number | null;
+    readonly currentCycle: number;
+    /** Per-evaluator regressions exceeding the threshold (sorted by |delta| desc). */
+    readonly regressions: readonly MonotonicRegression[];
+    /** Convenience boolean — true iff a regression exceeds the threshold. */
+    readonly monotonicityViolation: boolean;
+    /** Diagnostic hint surfaced as `MONOTONICITY_VIOLATION` in the CLI envelope. */
+    readonly code: 'MONOTONIC_OK' | 'MONOTONIC_NO_PREVIOUS' | 'MONOTONIC_VIOLATION' | 'MONOTONIC_INCOMPARABLE_EVALUATORS';
+}
+export interface CheckMonotonicOptions {
+    /** Maximum regression permitted (in [0,1] scale). Default 0.05 (5%). */
+    readonly threshold?: number;
+    /** When provided, the guard logs the cycle id this report refers to. */
+    readonly nowIso?: string;
+}

package/dist/services/loop/monotonic-guard-types.js

@@ -0,0 +1,9 @@
+/**
+ * peaks-loop v3.0.0 — Slice C.1
+ *
+ * Type declarations for the monotonic-improvement guard, relocated verbatim
+ * from `monotonic-guard.ts` so that module stays under the repo file-size cap.
+ * No behaviour lives here: every declaration is erased at compile time and the
+ * guard module re-exports all of them from its own path.
+ */
+export {};

package/dist/services/loop/monotonic-guard.d.ts

@@ -13,54 +13,13 @@
  *
  * File budget: ≤ 800 lines (Karpathy §2).
  */
-/** Per-evaluator score row, derived from an `EvaluatorVerdictEnvelope`. */
-export interface MonotonicScoreRow {
-    readonly evaluator: string;
-    readonly score: number;
-    readonly gateAction: 'pass' | 'warn' | 'block';
-    readonly degraded: boolean;
-    /** ISO-8601 timestamp the verdict was recorded. */
-    readonly observedAt: string;
-}
-/** Cycle index — a single attempt at the loop. */
-export interface MonotonicCycle {
-    readonly cycle: number;
-    /** Per-evaluator score rows. Same evaluator appearing twice collapses
-     *  to the last entry (BC: deterministic, no merging surprises). */
-    readonly scores: readonly MonotonicScoreRow[];
-}
-export interface MonotonicRegression {
-    readonly evaluator: string;
-    readonly previousScore: number;
-    readonly currentScore: number;
-    readonly delta: number;
-}
-/** Result of a `checkMonotonicImprovement` call. */
-export interface MonotonicReport {
-    readonly status: 'pass' | 'warn' | 'block' | 'skip';
-    readonly ok: boolean;
-    readonly reason: string;
-    readonly threshold: number;
-    readonly previousCycle: number | null;
-    readonly currentCycle: number;
-    /** Per-evaluator regressions exceeding the threshold (sorted by |delta| desc). */
-    readonly regressions: readonly MonotonicRegression[];
-    /** Convenience boolean — true iff a regression exceeds the threshold. */
-    readonly monotonicityViolation: boolean;
-    /** Diagnostic hint surfaced as `MONOTONICITY_VIOLATION` in the CLI envelope. */
-    readonly code: 'MONOTONIC_OK' | 'MONOTONIC_NO_PREVIOUS' | 'MONOTONIC_VIOLATION' | 'MONOTONIC_INCOMPARABLE_EVALUATORS';
-}
+import type { CheckMonotonicOptions, MonotonicCycle, MonotonicReport, MonotonicScoreRow } from './monotonic-guard-types.js';
+export type { CheckMonotonicOptions, MonotonicCycle, MonotonicRegression, MonotonicReport, MonotonicScoreRow } from './monotonic-guard-types.js';
 /** Convert an envelope-shaped verdict row to `MonotonicScoreRow`.
  *  Pure helper, exported for the CLI layer. */
 export declare function toScoreRow(evaluator: string, gateAction: 'pass' | 'warn' | 'block', degraded: boolean, observedAtIso?: string): MonotonicScoreRow;
 /** Default threshold = 5% of [0,1] scale → 0.05. */
 export declare const DEFAULT_MONOTONIC_THRESHOLD = 0.05;
-export interface CheckMonotonicOptions {
-    /** Maximum regression permitted (in [0,1] scale). Default 0.05 (5%). */
-    readonly threshold?: number;
-    /** When provided, the guard logs the cycle id this report refers to. */
-    readonly nowIso?: string;
-}
 /** Compare `previous` against `current` and report monotonicity.
  *
  *  Rules (reflected in `tests/unit/loop/monotonic-guard.test.ts`):

package/dist/services/loop/monotonic-runner-types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Monotonic-runner type + constant surface — moved VERBATIM out of
+ * `monotonic-runner.ts` for the 300-raw-line cap (slice
+ * `b1-filesplit-campaign`, wave 3C). The only code is
+ * `classifyFsError`, a pure error-tag helper carried across verbatim; beside
+ * it sit the local IO result union, the cycle-line tag/type, the
+ * walked-evaluator set, and the public options/result interfaces.
+ * `monotonic-runner.ts` re-exports the public names, so existing import
+ * paths keep working.
+ */
+import type { MonotonicReport, MonotonicScoreRow } from './monotonic-guard.js';
+/** Local discriminated result for IO. Internal callers coalesce
+ *  `ok: false` to `null` so the public `loadPreviousCycle`
+ *  signature stays `MonotonicCycle | null` (BC — see
+ *  `monotonic-guard.test.ts:199`). */
+export type LoadResult<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly reason: 'NOT_FOUND' | 'IO_ERROR' | 'PARSE_ERROR';
+};
+export declare function classifyFsError(err: unknown): 'NOT_FOUND' | 'IO_ERROR';
+/** Tag for cycle lines in the jsonl-store. */
+export declare const MONOTONIC_CYCLE_KIND = "monotonic-cycle";
+export interface MonotonicCycleLine {
+    readonly kind: typeof MONOTONIC_CYCLE_KIND;
+    readonly rid: string;
+    readonly cycle: number;
+    readonly persistedAt: string;
+    readonly scores: readonly MonotonicScoreRow[];
+}
+/** Set of evaluator kinds the loop walker actually scores — keeps the
+ *  guard surface tight (the verdict-aggregate is the cross-source merge
+ *  and not a per-cycle input). */
+export declare const WALKED_EVALUATORS: readonly ["karpathy", "code-review", "security-review", "perf-baseline"];
+export type WalkedKind = (typeof WALKED_EVALUATORS)[number];
+export interface RunMonotonicOptions {
+    readonly projectRoot: string;
+    readonly sid: string;
+    readonly rid: string;
+    /** Threshold (0..1 scale). Default 0.05 (5%). */
+    readonly threshold?: number;
+    /** When set, write the current cycle score rows to disk (default: true). */
+    readonly persist?: boolean;
+    /** When set, override the auto-derived cycle index. */
+    readonly cycle?: number;
+    /** Override the peaks binary path (default: `node bin/peaks.js`). */
+    readonly peaksBin?: string;
+}
+export interface RunMonotonicResult {
+    readonly projectRoot: string;
+    readonly sid: string;
+    readonly rid: string;
+    readonly currentCycle: number;
+    readonly previousCycle: number | null;
+    readonly persistedAt: string | null;
+    readonly rows: readonly MonotonicScoreRow[];
+    readonly report: MonotonicReport;
+    /** Additive surface for non-fatal persistence warnings (e.g. append
+     *  failure). Optional so existing destructures keep compiling. */
+    readonly warnings?: readonly string[];
+}

package/dist/services/loop/monotonic-runner-types.js

@@ -0,0 +1,17 @@
+export function classifyFsError(err) {
+    const code = err?.code;
+    if (code === 'ENOENT')
+        return 'NOT_FOUND';
+    return 'IO_ERROR';
+}
+/** Tag for cycle lines in the jsonl-store. */
+export const MONOTONIC_CYCLE_KIND = 'monotonic-cycle';
+/** Set of evaluator kinds the loop walker actually scores — keeps the
+ *  guard surface tight (the verdict-aggregate is the cross-source merge
+ *  and not a per-cycle input). */
+export const WALKED_EVALUATORS = [
+    'karpathy',
+    'code-review',
+    'security-review',
+    'perf-baseline'
+];

package/dist/services/loop/monotonic-runner.d.ts

@@ -1,35 +1,6 @@
-import { type MonotonicCycle, type MonotonicScoreRow, type MonotonicReport } from './monotonic-guard.js';
-/** Set of evaluator kinds the loop walker actually scores — keeps the
- *  guard surface tight (the verdict-aggregate is the cross-source merge
- *  and not a per-cycle input). */
-declare const WALKED_EVALUATORS: readonly ["karpathy", "code-review", "security-review", "perf-baseline"];
-type WalkedKind = (typeof WALKED_EVALUATORS)[number];
-export interface RunMonotonicOptions {
-    readonly projectRoot: string;
-    readonly sid: string;
-    readonly rid: string;
-    /** Threshold (0..1 scale). Default 0.05 (5%). */
-    readonly threshold?: number;
-    /** When set, write the current cycle score rows to disk (default: true). */
-    readonly persist?: boolean;
-    /** When set, override the auto-derived cycle index. */
-    readonly cycle?: number;
-    /** Override the peaks binary path (default: `node bin/peaks.js`). */
-    readonly peaksBin?: string;
-}
-export interface RunMonotonicResult {
-    readonly projectRoot: string;
-    readonly sid: string;
-    readonly rid: string;
-    readonly currentCycle: number;
-    readonly previousCycle: number | null;
-    readonly persistedAt: string | null;
-    readonly rows: readonly MonotonicScoreRow[];
-    readonly report: MonotonicReport;
-    /** Additive surface for non-fatal persistence warnings (e.g. append
-     *  failure). Optional so existing destructures keep compiling. */
-    readonly warnings?: readonly string[];
-}
+import { type MonotonicCycle } from './monotonic-guard.js';
+import { type RunMonotonicOptions, type RunMonotonicResult } from './monotonic-runner-types.js';
+export type { RunMonotonicOptions, RunMonotonicResult, WalkedKind } from './monotonic-runner-types.js';
 /** Resolve the slice dir — kept for API/BC (run-driver.ts uses it to
  *  derive `cyclesDir`). The monotonic-runner writer no longer writes
  *  here; the jsonl-store is the new persistence layer. */
@@ -60,5 +31,3 @@ export declare function resolveMonotonicContext(opts: {
     sid: string;
     rid: string;
 };
-/** Suppress unused-import lint when only the typedefs are exported. */
-export type { WalkedKind };

package/dist/services/loop/monotonic-runner.js

@@ -26,23 +26,7 @@ import { dispatchEvaluator } from './evaluator-dispatcher.js';
 import { checkMonotonicImprovement, toScoreRow, DEFAULT_MONOTONIC_THRESHOLD } from './monotonic-guard.js';
 import { appendMetricLine, readMetricLines } from '../observability/jsonl-store.js';
 import { findProjectRoot } from '../config/config-safety.js';
-function classifyFsError(err) {
-    const code = err?.code;
-    if (code === 'ENOENT')
-        return 'NOT_FOUND';
-    return 'IO_ERROR';
-}
-/** Tag for cycle lines in the jsonl-store. */
-const MONOTONIC_CYCLE_KIND = 'monotonic-cycle';
-/** Set of evaluator kinds the loop walker actually scores — keeps the
- *  guard surface tight (the verdict-aggregate is the cross-source merge
- *  and not a per-cycle input). */
-const WALKED_EVALUATORS = [
-    'karpathy',
-    'code-review',
-    'security-review',
-    'perf-baseline'
-];
+import { classifyFsError, MONOTONIC_CYCLE_KIND, WALKED_EVALUATORS } from './monotonic-runner-types.js';
 /** Resolve the slice dir — kept for API/BC (run-driver.ts uses it to
  *  derive `cyclesDir`). The monotonic-runner writer no longer writes
  *  here; the jsonl-store is the new persistence layer. */
@@ -55,8 +39,8 @@ export function sliceDir(projectRoot, sid, rid) {
  *  `.peaks/_sub_agents/<sid>/shared/` dir for cross-session signal.
  *  Returns `null` on any read error. */
 export function loadPreviousCycle(projectRoot, sid, rid) {
-    return loadMostRecentCycleFromJsonl(projectRoot, sid, rid)
-        ?? loadMostRecentCycleFromSubAgents(projectRoot, sid, rid);
+    return (loadMostRecentCycleFromJsonl(projectRoot, sid, rid) ??
+        loadMostRecentCycleFromSubAgents(projectRoot, sid, rid));
 }
 /** Scan the jsonl-store from tail backwards for the most recent
  *  `monotonic-cycle` line matching `rid`. Returns `null` when no
@@ -106,7 +90,13 @@ function parseScoreRows(raw) {
         const observedAt = typeof r['observedAt'] === 'string' ? r['observedAt'] : new Date(0).toISOString();
         out.push({
             evaluator: r['evaluator'],
-            score: typeof r['score'] === 'number' ? r['score'] : (gate === 'pass' ? 1.0 : gate === 'warn' ? 0.5 : 0.0),
+            score: typeof r['score'] === 'number'
+                ? r['score']
+                : gate === 'pass'
+                    ? 1.0
+                    : gate === 'warn'
+                        ? 0.5
+                        : 0.0,
             gateAction: gate,
             degraded: r['degraded'] === true,
             observedAt