peaks-loop 4.0.54 → 4.1.1

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

@@ -1,12 +1,12 @@
-import { ZodError } from "zod";
-import { EvolutionEvaluationSchema, EvolutionProposalInputSchema, EVOLUTION_DEFAULT_DELTA_MIN, } from "./evolution-types.js";
-import { buildProposal, computeScoreDelta, ensureEvolutionEvaluationTable, getEvolutionEvaluation, insertEvolutionEvaluation, listEvolutionEvaluationsByTarget, newEvaluationId, updateEvolutionVerdict, } from "./evolution-store.js";
+import { ZodError } from 'zod';
+import { EvolutionEvaluationSchema, EvolutionProposalInputSchema, EVOLUTION_DEFAULT_DELTA_MIN } from './evolution-types.js';
+import { buildProposal, computeScoreDelta, ensureEvolutionEvaluationTable, getEvolutionEvaluation, insertEvolutionEvaluation, listEvolutionEvaluationsByTarget, newEvaluationId, updateEvolutionVerdict } from './evolution-store.js';
 export class EvolutionIntegrityError extends Error {
     code;
     findings;
     constructor(code, message, findings = []) {
         super(message);
-        this.name = "EvolutionIntegrityError";
+        this.name = 'EvolutionIntegrityError';
         this.code = code;
         this.findings = findings;
     }
@@ -46,26 +46,25 @@ export class EvolutionService {
         // can assert on a single error code.
         let parsedInput;
         try {
-            parsedInput =
-                EvolutionProposalInputSchema.parse(input);
+            parsedInput = EvolutionProposalInputSchema.parse(input);
         }
         catch (err) {
             if (err instanceof ZodError) {
                 const issue = err.issues[0];
-                if (issue?.path[0] === "single_object") {
-                    throw new EvolutionIntegrityError("EVOLUTION_MULTI_OBJECT", "proposal must target exactly one object (single_object=true); split multi-object changes into multiple rounds", [
+                if (issue?.path[0] === 'single_object') {
+                    throw new EvolutionIntegrityError('EVOLUTION_MULTI_OBJECT', 'proposal must target exactly one object (single_object=true); split multi-object changes into multiple rounds', [
                         {
-                            path: "single_object",
-                            message: issue.message,
-                        },
+                            path: 'single_object',
+                            message: issue.message
+                        }
                     ]);
                 }
-                if (issue?.path[0] === "single_optimization_dimension") {
-                    throw new EvolutionIntegrityError("EVOLUTION_MULTI_DIMENSION", "proposal must declare exactly one optimization dimension (single_optimization_dimension=true); split multi-dimension changes into multiple rounds", [
+                if (issue?.path[0] === 'single_optimization_dimension') {
+                    throw new EvolutionIntegrityError('EVOLUTION_MULTI_DIMENSION', 'proposal must declare exactly one optimization dimension (single_optimization_dimension=true); split multi-dimension changes into multiple rounds', [
                         {
-                            path: "single_optimization_dimension",
-                            message: issue.message,
-                        },
+                            path: 'single_optimization_dimension',
+                            message: issue.message
+                        }
                     ]);
                 }
             }
@@ -74,14 +73,14 @@ export class EvolutionService {
         // AC-8 defense in depth: in case a future schema version relaxes
         // the literal(true), still enforce at the service boundary.
         if (parsedInput.single_object !== true) {
-            throw new EvolutionIntegrityError("EVOLUTION_MULTI_OBJECT", "proposal must target exactly one object (single_object=true); split multi-object changes into multiple rounds", [{ path: "single_object", message: "must be true (AC-8)" }]);
+            throw new EvolutionIntegrityError('EVOLUTION_MULTI_OBJECT', 'proposal must target exactly one object (single_object=true); split multi-object changes into multiple rounds', [{ path: 'single_object', message: 'must be true (AC-8)' }]);
         }
         if (parsedInput.single_optimization_dimension !== true) {
-            throw new EvolutionIntegrityError("EVOLUTION_MULTI_DIMENSION", "proposal must declare exactly one optimization dimension (single_optimization_dimension=true); split multi-dimension changes into multiple rounds", [
+            throw new EvolutionIntegrityError('EVOLUTION_MULTI_DIMENSION', 'proposal must declare exactly one optimization dimension (single_optimization_dimension=true); split multi-dimension changes into multiple rounds', [
                 {
-                    path: "single_optimization_dimension",
-                    message: "must be true (AC-8)",
-                },
+                    path: 'single_optimization_dimension',
+                    message: 'must be true (AC-8)'
+                }
             ]);
         }
         const id = newEvaluationId();
@@ -91,17 +90,21 @@ export class EvolutionService {
         const stub = {
             id,
             proposal,
-            evaluator_id: "pending",
-            skeptic_id: "pending",
-            evaluator_result: { score: parsedInput.before_score, riskTags: [], refuteParagraph: "pending" },
+            evaluator_id: 'pending',
+            skeptic_id: 'pending',
+            evaluator_result: {
+                score: parsedInput.before_score,
+                riskTags: [],
+                refuteParagraph: 'pending'
+            },
             skeptic_result: {
                 driftRisks: [],
                 overfitRisks: [],
-                safetyRegressionRisks: [],
+                safetyRegressionRisks: []
             },
-            verdict: "needs-user-decision",
-            schema_version: "peaks.evolution/1",
-            created_at: proposal.created_at,
+            verdict: 'needs-user-decision',
+            schema_version: 'peaks.evolution/1',
+            created_at: proposal.created_at
         };
         insertEvolutionEvaluation(this.db, stub);
         return proposal;
@@ -130,36 +133,36 @@ export class EvolutionService {
     score(proposalId, args) {
         const existing = getEvolutionEvaluation(this.db, proposalId);
         if (!existing) {
-            throw new EvolutionIntegrityError("EVOLUTION_BELOW_RUBRIC", `evolution_evaluation row '${proposalId}' not found`, [{ path: "id", message: "row not found" }]);
+            throw new EvolutionIntegrityError('EVOLUTION_BELOW_RUBRIC', `evolution_evaluation row '${proposalId}' not found`, [{ path: 'id', message: 'row not found' }]);
         }
         // AC-10: scorer MUST NOT be the author.
         if (args.evaluator_id === existing.proposal.author_id) {
-            throw new EvolutionIntegrityError("EVOLUTION_SELF_SCORE", `evaluator_id '${args.evaluator_id}' equals author_id '${existing.proposal.author_id}'; self-scoring is forbidden (AC-10)`, [{ path: "evaluator_id", message: "must differ from author_id" }]);
+            throw new EvolutionIntegrityError('EVOLUTION_SELF_SCORE', `evaluator_id '${args.evaluator_id}' equals author_id '${existing.proposal.author_id}'; self-scoring is forbidden (AC-10)`, [{ path: 'evaluator_id', message: 'must differ from author_id' }]);
         }
         // AC-12 / AC-14: skeptic and evaluator are SEPARATE agents.
         if (args.skeptic_id === existing.proposal.author_id) {
-            throw new EvolutionIntegrityError("EVOLUTION_SELF_SCORE", `skeptic_id '${args.skeptic_id}' equals author_id '${existing.proposal.author_id}'; the skeptic must be a separate agent (AC-14)`, [{ path: "skeptic_id", message: "must differ from author_id" }]);
+            throw new EvolutionIntegrityError('EVOLUTION_SELF_SCORE', `skeptic_id '${args.skeptic_id}' equals author_id '${existing.proposal.author_id}'; the skeptic must be a separate agent (AC-14)`, [{ path: 'skeptic_id', message: 'must differ from author_id' }]);
         }
         if (args.skeptic_id === args.evaluator_id) {
-            throw new EvolutionIntegrityError("EVOLUTION_SELF_SCORE", `skeptic_id '${args.skeptic_id}' equals evaluator_id '${args.evaluator_id}'; the skeptic must be a separate agent from the evaluator (AC-12/AC-14)`, [{ path: "skeptic_id", message: "must differ from evaluator_id" }]);
+            throw new EvolutionIntegrityError('EVOLUTION_SELF_SCORE', `skeptic_id '${args.skeptic_id}' equals evaluator_id '${args.evaluator_id}'; the skeptic must be a separate agent from the evaluator (AC-12/AC-14)`, [{ path: 'skeptic_id', message: 'must differ from evaluator_id' }]);
         }
         const after_score = args.evaluator_result.score;
         const score_delta = computeScoreDelta(existing.proposal.before_score, after_score);
         const min = existing.proposal.score_delta_min;
         // Derive verdict. The skeptic's `blocker` is a hard revert.
-        let verdict = "needs-user-decision";
+        let verdict = 'needs-user-decision';
         if (args.skeptic_result.blocker !== undefined) {
-            verdict = "revert";
+            verdict = 'revert';
         }
         else if (score_delta < min) {
-            verdict = "revert";
+            verdict = 'revert';
         }
         const next = {
             id: existing.id,
             proposal: {
                 ...existing.proposal,
                 after_score,
-                score_delta,
+                score_delta
             },
             evaluator_id: args.evaluator_id,
             skeptic_id: args.skeptic_id,
@@ -170,24 +173,22 @@ export class EvolutionService {
             ...(args.user_confirmation_pointer !== undefined
                 ? { user_confirmation_pointer: args.user_confirmation_pointer }
                 : {}),
-            schema_version: "peaks.evolution/1",
-            created_at: new Date().toISOString(),
+            schema_version: 'peaks.evolution/1',
+            created_at: new Date().toISOString()
         };
         // AC-11 (delta threshold) explicit guard: if the caller
         // explicitly asks to mark `keep` but delta < min, throw.
-        if (verdict === "needs-user-decision" && score_delta < min) {
+        if (verdict === 'needs-user-decision' && score_delta < min) {
             // The auto-derivation already pinned verdict to `revert`; the
             // guard is for the explicit `markVerdict('keep')` path below.
         }
         // Re-validate before persisting.
         const validated = EvolutionEvaluationSchema.parse({
             ...next,
-            score_delta,
+            score_delta
         });
         // Delete + re-insert keeps the row simple; volume is tiny.
-        this.db
-            .prepare("DELETE FROM evolution_evaluation WHERE id = ?")
-            .run(existing.id);
+        this.db.prepare('DELETE FROM evolution_evaluation WHERE id = ?').run(existing.id);
         insertEvolutionEvaluation(this.db, validated);
         return validated;
     }
@@ -209,22 +210,21 @@ export class EvolutionService {
         const existing = getEvolutionEvaluation(this.db, proposalId);
         if (!existing)
             return undefined;
-        if (verdict === "keep") {
+        if (verdict === 'keep') {
             if (existing.proposal.score_delta < existing.proposal.score_delta_min) {
-                throw new EvolutionIntegrityError("EVOLUTION_DELTA_BELOW_THRESHOLD", `score_delta ${existing.proposal.score_delta} is below score_delta_min ${existing.proposal.score_delta_min}; cannot mark keep (AC-11)`, [
+                throw new EvolutionIntegrityError('EVOLUTION_DELTA_BELOW_THRESHOLD', `score_delta ${existing.proposal.score_delta} is below score_delta_min ${existing.proposal.score_delta_min}; cannot mark keep (AC-11)`, [
                     {
-                        path: "verdict",
-                        message: "score_delta below score_delta_min; revert instead or raise the score",
-                    },
+                        path: 'verdict',
+                        message: 'score_delta below score_delta_min; revert instead or raise the score'
+                    }
                 ]);
             }
-            if (userConfirmationPointer === undefined ||
-                userConfirmationPointer.trim().length === 0) {
-                throw new EvolutionIntegrityError("EVOLUTION_MISSING_USER_CONFIRMATION", "marking verdict='keep' requires a user_confirmation_pointer (AC-15)", [
+            if (userConfirmationPointer === undefined || userConfirmationPointer.trim().length === 0) {
+                throw new EvolutionIntegrityError('EVOLUTION_MISSING_USER_CONFIRMATION', "marking verdict='keep' requires a user_confirmation_pointer (AC-15)", [
                     {
-                        path: "user_confirmation_pointer",
-                        message: "required for verdict='keep'",
-                    },
+                        path: 'user_confirmation_pointer',
+                        message: "required for verdict='keep'"
+                    }
                 ]);
             }
         }
@@ -232,7 +232,7 @@ export class EvolutionService {
     }
     /** Revert a proposal (universal recovery). Always allowed. */
     revert(proposalId, userConfirmationPointer) {
-        return updateEvolutionVerdict(this.db, proposalId, "revert", userConfirmationPointer);
+        return updateEvolutionVerdict(this.db, proposalId, 'revert', userConfirmationPointer);
     }
     /** Read an evolution evaluation by id. */
     read(proposalId) {
@@ -250,12 +250,12 @@ export class EvolutionService {
     status(target) {
         const all = listEvolutionEvaluationsByTarget(this.db, {
             target_kind: target.target_kind,
-            target_release_id: target.target_release_id,
+            target_release_id: target.target_release_id
         });
         const byVerdict = {
             keep: 0,
             revert: 0,
-            "needs-user-decision": 0,
+            'needs-user-decision': 0
         };
         for (const row of all)
             byVerdict[row.verdict] += 1;
@@ -265,7 +265,7 @@ export class EvolutionService {
             target_release_id: target.target_release_id,
             total: all.length,
             byVerdict,
-            latest,
+            latest
         };
     }
 }

package/dist/services/evolution/evolution-store.d.ts

@@ -1,5 +1,5 @@
-import type Database from "better-sqlite3";
-import type { EvolutionEvaluation, EvolutionEvaluationInput, EvolutionProposal, EvolutionProposalInput, EvolutionTargetKind, EvolutionVerdict } from "./evolution-types.js";
+import type Database from 'better-sqlite3';
+import type { EvolutionEvaluation, EvolutionEvaluationInput, EvolutionProposal, EvolutionProposalInput, EvolutionTargetKind, EvolutionVerdict } from './evolution-types.js';
 /**
  * Re-apply the evolution_evaluation table migration against an
  * already-open database. Used by tests that build their own DB

package/dist/services/evolution/evolution-store.js

@@ -1,3 +1,6 @@
+import { z } from 'zod';
+import { parseJson } from '../../shared/json-parse.js';
+import { EVOLUTION_EVALUATION_MIGRATION, SCHEMA_VERSION } from './evolution-evaluation-schema.js';
 /**
  * Low-level SQLite access for the `evolution_evaluation` table. The
  * migration is registered with the existing `openStateDb()` pipeline
@@ -17,49 +20,30 @@
  *     rules are enforced at the SERVICE layer (not the DB); the DB
  *     stores the persisted, validated row.
  */
-const SCHEMA_VERSION = "peaks.evolution/1";
+/**
+ * `optimization_dimensions_json` as it comes back OUT of SQLite.
+ *
+ * WHY THIS EXISTS (batch B4). The column is TEXT, so the row type only says
+ * `string`; `JSON.parse` said `any`, and `rowToEvaluation` read `[0]` off it.
+ * The declared domain type (`EvolutionProposal.optimization_dimension: string`,
+ * min length 1) is what the value has to satisfy, and this code is the only
+ * place that can establish it — SQLite cannot.
+ *
+ * `.min(1)` is the domain invariant, not a convenience: line 130 below writes
+ * `JSON.stringify([input.optimization_dimension])`, and a proposal round
+ * carries exactly one dimension (`single_optimization_dimension: true`). The
+ * fixed first element is what lets `dimensions[0]` be read as `string` without
+ * a fallback: a row whose array is empty cannot have come from this writer, and
+ * reading it as `undefined` under a `string` type was the defect this replaces.
+ */
+const OptimizationDimensionsJsonSchema = z.tuple([z.string()]).rest(z.string());
 /**
  * Re-apply the evolution_evaluation table migration against an
  * already-open database. Used by tests that build their own DB
  * without the openStateDb pipeline. Idempotent.
  */
 export function ensureEvolutionEvaluationTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS evolution_evaluation (
-      id                          TEXT PRIMARY KEY,
-      target_kind                 TEXT NOT NULL CHECK (target_kind IN ('loop','bee','policy','gate','evaluator')),
-      target_release_id           TEXT NOT NULL,
-      optimization_dimensions_json TEXT NOT NULL,
-      target_count                INTEGER NOT NULL DEFAULT 1 CHECK (target_count = 1),
-      before_snapshot_json        TEXT NOT NULL DEFAULT '{}',
-      after_snapshot_json         TEXT NOT NULL DEFAULT '{}',
-      diff_json                   TEXT NOT NULL DEFAULT '{}',
-      before_score                REAL NOT NULL,
-      after_score                 REAL NOT NULL,
-      score_delta_min             REAL NOT NULL DEFAULT 1.0 CHECK (score_delta_min >= 0),
-      score_delta                 REAL NOT NULL,
-      author_id                   TEXT NOT NULL,
-      evaluator_id                TEXT NOT NULL,
-      skeptic_id                  TEXT NOT NULL,
-      verdict                     TEXT NOT NULL CHECK (verdict IN ('keep','revert','needs-user-decision')),
-      user_confirmation_pointer   TEXT,
-      brief_pointer               TEXT,
-      rubric_json                 TEXT NOT NULL DEFAULT '{}',
-      red_lines_json              TEXT NOT NULL DEFAULT '[]',
-      source_traces_json          TEXT NOT NULL DEFAULT '[]',
-      schema_version              TEXT NOT NULL CHECK (schema_version = 'peaks.evolution/1'),
-      created_at                  TEXT NOT NULL,
-      CHECK (length(id) > 0)
-    );
-    CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_target
-      ON evolution_evaluation(target_kind, target_release_id);
-    CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_verdict
-      ON evolution_evaluation(verdict);
-    CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_author
-      ON evolution_evaluation(author_id);
-    CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_evaluator
-      ON evolution_evaluation(evaluator_id);
-  `);
+    db.exec(EVOLUTION_EVALUATION_MIGRATION);
 }
 /**
  * Compute the score_delta from before/after scores. Exported for
@@ -99,18 +83,22 @@ export function buildProposal(id, input, createdAt) {
         red_lines: input.red_lines ?? [],
         source_traces: input.source_traces ?? [],
         schema_version: SCHEMA_VERSION,
-        created_at: createdAt ?? new Date().toISOString(),
+        created_at: createdAt ?? new Date().toISOString()
     };
 }
 function rowToEvaluation(row) {
+    // Parsed ONCE and used twice below: `optimization_dimension` is the scalar
+    // projection of `dimensions`, so re-parsing the same column would be two
+    // chances to disagree about the same bytes.
+    const dimensions = parseJson(row.optimization_dimensions_json, OptimizationDimensionsJsonSchema);
     return {
         id: row.id,
         proposal: {
             id: row.id,
             target_kind: row.target_kind,
             target_release_id: row.target_release_id,
-            optimization_dimension: JSON.parse(row.optimization_dimensions_json)[0],
-            dimensions: JSON.parse(row.optimization_dimensions_json),
+            optimization_dimension: dimensions[0],
+            dimensions,
             target_count: row.target_count,
             single_object: true,
             single_optimization_dimension: true,
@@ -126,7 +114,7 @@ function rowToEvaluation(row) {
             red_lines: JSON.parse(row.red_lines_json),
             source_traces: JSON.parse(row.source_traces_json),
             schema_version: row.schema_version,
-            created_at: row.created_at,
+            created_at: row.created_at
         },
         evaluator_id: row.evaluator_id,
         skeptic_id: row.skeptic_id,
@@ -136,19 +124,19 @@ function rowToEvaluation(row) {
             // the verdict derivation via the service layer.
             score: row.after_score,
             riskTags: [],
-            refuteParagraph: "",
+            refuteParagraph: ''
         },
         skeptic_result: {
             driftRisks: [],
             overfitRisks: [],
-            safetyRegressionRisks: [],
+            safetyRegressionRisks: []
         },
         verdict: row.verdict,
         user_confirmation_pointer: row.user_confirmation_pointer ?? undefined,
         brief_pointer: row.brief_pointer ?? undefined,
         schema_version: row.schema_version,
         created_at: row.created_at,
-        score_delta: row.score_delta,
+        score_delta: row.score_delta
     };
 }
 /**
@@ -174,9 +162,7 @@ export function insertEvolutionEvaluation(db, evalRow) {
  * absent.
  */
 export function getEvolutionEvaluation(db, id) {
-    const row = db
-        .prepare("SELECT * FROM evolution_evaluation WHERE id = ?")
-        .get(id);
+    const row = db.prepare('SELECT * FROM evolution_evaluation WHERE id = ?').get(id);
     if (!row)
         return undefined;
     return rowToEvaluation(row);
@@ -187,12 +173,12 @@ export function getEvolutionEvaluation(db, id) {
  */
 export function listEvolutionEvaluationsByTarget(db, opts) {
     const params = [opts.target_kind, opts.target_release_id];
-    let sql = "SELECT * FROM evolution_evaluation WHERE target_kind = ? AND target_release_id = ?";
+    let sql = 'SELECT * FROM evolution_evaluation WHERE target_kind = ? AND target_release_id = ?';
     if (opts.verdict) {
-        sql += " AND verdict = ?";
+        sql += ' AND verdict = ?';
         params.push(opts.verdict);
     }
-    sql += " ORDER BY created_at DESC, id ASC";
+    sql += ' ORDER BY created_at DESC, id ASC';
     const rows = db.prepare(sql).all(...params);
     return rows.map(rowToEvaluation);
 }
@@ -227,6 +213,6 @@ export function newEvaluationId() {
     // grep-friendly.
     const hex = Math.floor(Math.random() * 0x1_000_000_000_000)
         .toString(16)
-        .padStart(12, "0");
+        .padStart(12, '0');
     return `eval-${hex}`;
 }

package/dist/services/evolution/evolution-types.d.ts

@@ -1,4 +1,5 @@
-import { z } from "zod";
+import { z } from 'zod';
+export { IndependentEvaluatorResultSchema, RegressionSkepticResultSchema, type IndependentEvaluatorResult, type RegressionSkepticResult } from './evolution-constraints.js';
 /**
  * EvolutionEvaluation — spec §4.4 / §6.
  *
@@ -111,27 +112,6 @@ export declare const EvolutionProposalSchema: z.ZodObject<{
     score_delta: z.ZodNumber;
 }, z.core.$strip>;
 export type EvolutionProposal = z.infer<typeof EvolutionProposalSchema>;
-/**
- * The independent evaluator's verdict. AC-12 / AC-13: the evaluator
- * is a SEPARATE sub-agent that only sees the evaluation package.
- */
-export declare const IndependentEvaluatorResultSchema: z.ZodObject<{
-    score: z.ZodNumber;
-    riskTags: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    refuteParagraph: z.ZodString;
-}, z.core.$strip>;
-export type IndependentEvaluatorResult = z.infer<typeof IndependentEvaluatorResultSchema>;
-/**
- * The regression skeptic's verdict. AC-14: a separate sub-agent
- * that attempts to refute the proposal.
- */
-export declare const RegressionSkepticResultSchema: z.ZodObject<{
-    driftRisks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    overfitRisks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    safetyRegressionRisks: z.ZodDefault<z.ZodArray<z.ZodString>>;
-    blocker: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type RegressionSkepticResult = z.infer<typeof RegressionSkepticResultSchema>;
 /**
  * The full evolution evaluation row as persisted. Differs from the
  * proposal in that it carries the evaluator + skeptic verdicts, the