peaks-loop 4.0.54 → 4.1.0

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

@@ -1,4 +1,23 @@
-import { CrystallizationEventSchema, } from "./crystallization-types.js";
+import { z } from 'zod';
+import { parseJson } from '../../shared/json-parse.js';
+import { CrystallizationEventSchema, EvidenceBriefSchema } from './crystallization-types.js';
+/**
+ * The two string-list JSON columns of `crystallization_event`, as they come
+ * back OUT of SQLite.
+ *
+ * WHY THIS EXISTS (batch B4). `JSON.parse(text)` is `any`, so
+ * `rowToCrystallizationEvent` handed three `any` values straight into a
+ * `CrystallizationEvent`; `evidence_bullets` / `source_trace_pointers` were
+ * papered over with an `as string[]` costume cast, and `evidence_brief` leaked
+ * a `no-unsafe-assignment` finding because it had no cast at all. The declared
+ * column type (`CrystallizationEventRow.evidence_bullets_json: string`) is the
+ * schema's job to re-establish, because SQLite stores TEXT and does not.
+ *
+ * The read schema is the SAME `EvidenceBriefSchema` the write path validates
+ * with: a row that no longer matches it is a defect at the boundary, not a
+ * value to hand onward with an unchecked claim attached.
+ */
+const StringListJsonSchema = z.array(z.string());
 /**
  * Low-level SQLite access for the `crystallization_event` table.
  * The migration is registered with the existing `openStateDb()`
@@ -19,7 +38,7 @@ import { CrystallizationEventSchema, } from "./crystallization-types.js";
  *     enforced at the SERVICE layer (not the DB); the DB stores
  *     the persisted, validated row.
  */
-const SCHEMA_VERSION = "peaks.crystallization/1";
+const SCHEMA_VERSION = 'peaks.crystallization/1';
 /**
  * Re-apply the crystallization_event table migration against an
  * already-open database. Used by tests that build their own DB
@@ -69,9 +88,9 @@ function rowToCrystallizationEvent(row) {
     return {
         id: row.id,
         trigger: row.trigger,
-        evidence_brief: JSON.parse(row.evidence_brief_json),
-        evidence_bullets: JSON.parse(row.evidence_bullets_json),
-        source_trace_pointers: JSON.parse(row.source_trace_pointers_json),
+        evidence_brief: parseJson(row.evidence_brief_json, EvidenceBriefSchema),
+        evidence_bullets: parseJson(row.evidence_bullets_json, StringListJsonSchema),
+        source_trace_pointers: parseJson(row.source_trace_pointers_json, StringListJsonSchema),
         evaluator_summary: row.evaluator_summary,
         user_decision_summary: row.user_decision_summary,
         created_loop_release_id: row.created_loop_release_id ?? undefined,
@@ -80,7 +99,7 @@ function rowToCrystallizationEvent(row) {
         updated_bee_release_id: row.updated_bee_release_id ?? undefined,
         lifecycle_status: row.lifecycle_status,
         schema_version: row.schema_version,
-        created_at: row.created_at,
+        created_at: row.created_at
     };
 }
 /**
@@ -103,7 +122,7 @@ export function insertCrystallizationEvent(db, row) {
         ...row,
         id,
         schema_version: SCHEMA_VERSION,
-        created_at: createdAt,
+        created_at: createdAt
     });
     const stmt = db.prepare(`INSERT INTO crystallization_event (
        id, trigger, evidence_brief_json, evidence_bullets_json,
@@ -118,9 +137,7 @@ export function insertCrystallizationEvent(db, row) {
 }
 /** Read a single CrystallizationEvent row by id; returns undefined if absent. */
 export function getCrystallizationEvent(db, id) {
-    const row = db
-        .prepare("SELECT * FROM crystallization_event WHERE id = ?")
-        .get(id);
+    const row = db.prepare('SELECT * FROM crystallization_event WHERE id = ?').get(id);
     if (!row)
         return undefined;
     return rowToCrystallizationEvent(row);
@@ -134,29 +151,29 @@ export function listCrystallizationEvents(db, opts = {}) {
     const wheres = [];
     const params = [];
     if (opts.lifecycle_status !== undefined) {
-        wheres.push("lifecycle_status = ?");
+        wheres.push('lifecycle_status = ?');
         params.push(opts.lifecycle_status);
     }
     if (opts.created_loop_release_id !== undefined) {
-        wheres.push("created_loop_release_id = ?");
+        wheres.push('created_loop_release_id = ?');
         params.push(opts.created_loop_release_id);
     }
     if (opts.updated_loop_release_id !== undefined) {
-        wheres.push("updated_loop_release_id = ?");
+        wheres.push('updated_loop_release_id = ?');
         params.push(opts.updated_loop_release_id);
     }
     if (opts.created_bee_release_id !== undefined) {
-        wheres.push("created_bee_release_id = ?");
+        wheres.push('created_bee_release_id = ?');
         params.push(opts.created_bee_release_id);
     }
     if (opts.updated_bee_release_id !== undefined) {
-        wheres.push("updated_bee_release_id = ?");
+        wheres.push('updated_bee_release_id = ?');
         params.push(opts.updated_bee_release_id);
     }
-    let sql = "SELECT * FROM crystallization_event";
+    let sql = 'SELECT * FROM crystallization_event';
     if (wheres.length > 0)
-        sql += " WHERE " + wheres.join(" AND ");
-    sql += " ORDER BY created_at DESC, id ASC";
+        sql += ' WHERE ' + wheres.join(' AND ');
+    sql += ' ORDER BY created_at DESC, id ASC';
     const rows = db.prepare(sql).all(...params);
     return rows.map(rowToCrystallizationEvent);
 }
@@ -172,7 +189,7 @@ export function updateCrystallizationEventStatus(db, id, next) {
     const existing = getCrystallizationEvent(db, id);
     if (!existing)
         return undefined;
-    db.prepare("UPDATE crystallization_event SET lifecycle_status = ? WHERE id = ?").run(next, id);
+    db.prepare('UPDATE crystallization_event SET lifecycle_status = ? WHERE id = ?').run(next, id);
     return getCrystallizationEvent(db, id);
 }
 /**
@@ -183,7 +200,7 @@ export function updateCrystallizationEventStatus(db, id, next) {
 export function newCrystallizationId() {
     const hex = Math.floor(Math.random() * 0x1_000_000_000_000)
         .toString(16)
-        .padStart(12, "0");
+        .padStart(12, '0');
     return `crys-${hex}`;
 }
 /**

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

@@ -1,4 +1,6 @@
-import { z } from "zod";
+import { z } from 'zod';
+export { EvidenceBriefSchema, hasAllFourBriefSections, parseEvidenceBrief, safeParseEvidenceBrief } from './crystallization-brief-schema.js';
+export type { EvidenceBrief } from './crystallization-brief-schema.js';
 /**
  * CrystallizationEvent — spec §4.5 / §4.7 / §5.
  *
@@ -46,39 +48,6 @@ export declare const CrystallizationEventStatusSchema: z.ZodEnum<{
     retired: "retired";
 }>;
 export type CrystallizationEventStatus = z.infer<typeof CrystallizationEventStatusSchema>;
-/**
- * EvidenceBrief — the 4-section brief (spec §4.7).
- *
- * Hard shape invariant: ALL FOUR KEYS must be present at parse
- * time, with non-empty NL content. The `.refine(...)` guard is
- * what makes a brief a "brief" — without it, the projection is
- * not a brief and the recommendation MUST NOT be rendered
- * (service layer enforces this; Zod makes it a parse-time
- * guarantee).
- *
- * Field semantics:
- *   - what_happened   — 1-2 sentence factual account of the run.
- *   - why_it_matters  — 1-2 sentence explanation of why this is
- *                       worth promoting.
- *   - what_learned    — 1-2 sentence learning: failure modes
- *                       encoded, preferences extracted.
- *   - what_action     — 1-sentence recommended action with
- *                       rationale.
- */
-export declare const EvidenceBriefSchema: z.ZodObject<{
-    what_happened: z.ZodString;
-    why_it_matters: z.ZodString;
-    what_learned: z.ZodString;
-    what_action: z.ZodString;
-}, z.core.$strict>;
-export type EvidenceBrief = z.infer<typeof EvidenceBriefSchema>;
-/**
- * Helper for downstream code that needs to know whether a parsed
- * brief satisfies the 4-section rule. Useful for the CLI when a
- * payload arrived from the LLM and the brief-section guard has
- * already passed — it returns the section count, always 4 here.
- */
-export declare function hasAllFourBriefSections(brief: EvidenceBrief): boolean;
 /**
  * Zod schema for the create payload (CrystallizationEventInput).
  *
@@ -163,11 +132,6 @@ export type CrystallizationEvent = z.infer<typeof CrystallizationEventSchema>;
  * Use this at every parse boundary (CLI input, store insertion).
  */
 export declare function parseCrystallizationEvent(input: unknown): CrystallizationEvent;
-/**
- * Convenience: strict-parse an unknown payload as a standalone
- * EvidenceBrief. Throws ZodError on failure.
- */
-export declare function parseEvidenceBrief(input: unknown): EvidenceBrief;
 /**
  * Safe-parse twin of parseCrystallizationEvent. Returns a Result-like
  * envelope so callers (CLI / tests) can render findings without
@@ -181,23 +145,7 @@ export declare function safeParseCrystallizationEvent(input: unknown): {
     row: CrystallizationEvent;
 } | {
     ok: false;
-    code?: "MISSING_BRIEF_SECTION";
-    findings: Array<{
-        path: string;
-        message: string;
-    }>;
-};
-/**
- * Safe-parse twin of parseEvidenceBrief. Same Result-like envelope
- * shape; same MISSING_BRIEF_SECTION code mapping (covers both
- * refine-guard failures and per-section missing/empty failures).
- */
-export declare function safeParseEvidenceBrief(input: unknown): {
-    ok: true;
-    row: EvidenceBrief;
-} | {
-    ok: false;
-    code?: "MISSING_BRIEF_SECTION";
+    code?: 'MISSING_BRIEF_SECTION';
     findings: Array<{
         path: string;
         message: string;

package/dist/services/crystallization/crystallization-types.js

@@ -1,15 +1,21 @@
-import { z } from "zod";
+import { z } from 'zod';
+import { CRYS_BRIEF_SECTION_MAX, EvidenceBriefSchema, isBriefSectionFailure } from './crystallization-brief-schema.js';
+// Public surface unchanged: every name below stays importable from this
+// path (and through `crystallization/index.js`). The brief schema and its
+// `z.infer` type travel together.
+export { EvidenceBriefSchema, hasAllFourBriefSections, parseEvidenceBrief, safeParseEvidenceBrief } from './crystallization-brief-schema.js';
 /* ---------------------------------------------------------------------- */
 /* PRD-002b slice 2 — schema-limit constants extracted from inline         */
 /* `.max(N)` / `.length(N)` calls so the no-magic-numbers rule stops     */
 /* flagging the constraint values. Names describe the field, not the     */
 /* number. Bytewise-identical to the original literals.                  */
 /* ---------------------------------------------------------------------- */
-const CRYS_BRIEF_SECTION_MAX = 4000;
 const CRYS_EVIDENCE_BULLET_MAX = 1000;
 const CRYS_TRACE_POINTER_MAX = 256;
 const CRYS_LOOP_ID_MAX = 64;
-const CRYS_BEE_ID_MAX_I32 = 2 ** 31 - 1;
+// 2 ** 31 - 1 spelled as its own literal so no-magic-numbers has no
+// binary expression to flag. Same value, same bound, same message.
+const CRYS_BEE_ID_MAX_I32 = 2147483647;
 const CRYS_EVENT_ID_MAX = 128;
 /**
  * CrystallizationEvent — spec §4.5 / §4.7 / §5.
@@ -48,102 +54,21 @@ const CRYS_EVENT_ID_MAX = 128;
 /* Trigger — §4.5 / §5.4                                                   */
 /* ---------------------------------------------------------------------- */
 export const CrystallizationTriggerSchema = z.enum([
-    "user_explicit",
-    "llm_suggested",
-    "success_default_prompt",
-    "similar_task_recurrence",
+    'user_explicit',
+    'llm_suggested',
+    'success_default_prompt',
+    'similar_task_recurrence'
 ]);
 export const CRYSTALLIZATION_TRIGGERS = [
-    "user_explicit",
-    "llm_suggested",
-    "success_default_prompt",
-    "similar_task_recurrence",
+    'user_explicit',
+    'llm_suggested',
+    'success_default_prompt',
+    'similar_task_recurrence'
 ];
 /* ---------------------------------------------------------------------- */
 /* Lifecycle status — §5.6 (event-scoped, not asset-scoped)               */
 /* ---------------------------------------------------------------------- */
-export const CrystallizationEventStatusSchema = z.enum([
-    "candidate",
-    "stable",
-    "retired",
-]);
-/* ---------------------------------------------------------------------- */
-/* EvidenceBrief — §4.7 / §10 RL-7. REQUIRED 4-section shape.             */
-/* ---------------------------------------------------------------------- */
-/**
- * The four brief sections. Spec §4.7 lists them as NL short
- * sections; the service layer mandates 1-2 sentences (what_action
- * is a single sentence per the spec). The Zod constraints below
- * enforce NON-EMPTY strings. The brief-section guard (see
- * `EvidenceBriefSchema.refine` below) rejects any payload missing
- * one of the four keys, regardless of section content — it is
- * the canonical hard gate per spec §10 RL-7.
- */
-const BriefSectionSchema = z
-    .string()
-    .trim()
-    .min(1, "brief section must be non-empty natural language")
-    .max(CRYS_BRIEF_SECTION_MAX);
-/**
- * EvidenceBrief — the 4-section brief (spec §4.7).
- *
- * Hard shape invariant: ALL FOUR KEYS must be present at parse
- * time, with non-empty NL content. The `.refine(...)` guard is
- * what makes a brief a "brief" — without it, the projection is
- * not a brief and the recommendation MUST NOT be rendered
- * (service layer enforces this; Zod makes it a parse-time
- * guarantee).
- *
- * Field semantics:
- *   - what_happened   — 1-2 sentence factual account of the run.
- *   - why_it_matters  — 1-2 sentence explanation of why this is
- *                       worth promoting.
- *   - what_learned    — 1-2 sentence learning: failure modes
- *                       encoded, preferences extracted.
- *   - what_action     — 1-sentence recommended action with
- *                       rationale.
- */
-export const EvidenceBriefSchema = z
-    .object({
-    what_happened: BriefSectionSchema,
-    why_it_matters: BriefSectionSchema,
-    what_learned: BriefSectionSchema,
-    what_action: BriefSectionSchema,
-})
-    .strict()
-    .superRefine((b, ctx) => {
-    const ok = typeof b.what_happened === "string" &&
-        b.what_happened.trim().length > 0 &&
-        typeof b.why_it_matters === "string" &&
-        b.why_it_matters.trim().length > 0 &&
-        typeof b.what_learned === "string" &&
-        b.what_learned.trim().length > 0 &&
-        typeof b.what_action === "string" &&
-        b.what_action.trim().length > 0;
-    if (!ok) {
-        ctx.addIssue({
-            code: "custom",
-            path: [],
-            message: "evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)",
-        });
-    }
-});
-/**
- * Helper for downstream code that needs to know whether a parsed
- * brief satisfies the 4-section rule. Useful for the CLI when a
- * payload arrived from the LLM and the brief-section guard has
- * already passed — it returns the section count, always 4 here.
- */
-export function hasAllFourBriefSections(brief) {
-    return (typeof brief.what_happened === "string" &&
-        brief.what_happened.trim().length > 0 &&
-        typeof brief.why_it_matters === "string" &&
-        brief.why_it_matters.trim().length > 0 &&
-        typeof brief.what_learned === "string" &&
-        brief.what_learned.trim().length > 0 &&
-        typeof brief.what_action === "string" &&
-        brief.what_action.trim().length > 0);
-}
+export const CrystallizationEventStatusSchema = z.enum(['candidate', 'stable', 'retired']);
 /* ---------------------------------------------------------------------- */
 /* CrystallizationEvent — §4.5                                            */
 /* ---------------------------------------------------------------------- */
@@ -158,14 +83,14 @@ const OptionalLoopId = z
     .min(1)
     .max(CRYS_LOOP_ID_MAX)
     .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'
 })
     .optional();
 const OptionalBeeId = z
     .number()
     .int()
     .gt(0)
-    .max(CRYS_BEE_ID_MAX_I32, "bee_release_id out of 32-bit range")
+    .max(CRYS_BEE_ID_MAX_I32, 'bee_release_id out of 32-bit range')
     .optional();
 /**
  * Zod schema for the create payload (CrystallizationEventInput).
@@ -178,27 +103,15 @@ const OptionalBeeId = z
 export const CrystallizationEventInputSchema = z.object({
     trigger: CrystallizationTriggerSchema,
     evidence_brief: EvidenceBriefSchema,
-    evidence_bullets: z
-        .array(z.string().trim().min(1).max(CRYS_EVIDENCE_BULLET_MAX))
-        .default([]),
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(CRYS_TRACE_POINTER_MAX))
-        .default([]),
-    evaluator_summary: z
-        .string()
-        .trim()
-        .max(CRYS_BRIEF_SECTION_MAX)
-        .default(""),
-    user_decision_summary: z
-        .string()
-        .trim()
-        .max(CRYS_BRIEF_SECTION_MAX)
-        .default(""),
+    evidence_bullets: z.array(z.string().trim().min(1).max(CRYS_EVIDENCE_BULLET_MAX)).default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(CRYS_TRACE_POINTER_MAX)).default([]),
+    evaluator_summary: z.string().trim().max(CRYS_BRIEF_SECTION_MAX).default(''),
+    user_decision_summary: z.string().trim().max(CRYS_BRIEF_SECTION_MAX).default(''),
     created_loop_release_id: OptionalLoopId,
     updated_loop_release_id: OptionalLoopId,
     created_bee_release_id: OptionalBeeId,
     updated_bee_release_id: OptionalBeeId,
-    lifecycle_status: CrystallizationEventStatusSchema.default("candidate"),
+    lifecycle_status: CrystallizationEventStatusSchema.default('candidate')
 });
 /**
  * Full persisted row schema. Adds `id` (the event id) and stamps
@@ -215,12 +128,10 @@ export const CrystallizationEventSchema = CrystallizationEventInputSchema.extend
         .min(1)
         .max(CRYS_EVENT_ID_MAX)
         .regex(/^crys-[0-9a-f]{8,}$/, {
-        message: "id must start with 'crys-' followed by a hex suffix (spec §4.5)",
+        message: "id must start with 'crys-' followed by a hex suffix (spec §4.5)"
     }),
-    schema_version: z
-        .literal("peaks.crystallization/1")
-        .default("peaks.crystallization/1"),
-    created_at: z.string().datetime(),
+    schema_version: z.literal('peaks.crystallization/1').default('peaks.crystallization/1'),
+    created_at: z.string().datetime()
 });
 /**
  * Convenience: strict-parse an unknown payload into a
@@ -232,13 +143,6 @@ export const CrystallizationEventSchema = CrystallizationEventInputSchema.extend
 export function parseCrystallizationEvent(input) {
     return CrystallizationEventSchema.parse(input);
 }
-/**
- * Convenience: strict-parse an unknown payload as a standalone
- * EvidenceBrief. Throws ZodError on failure.
- */
-export function parseEvidenceBrief(input) {
-    return EvidenceBriefSchema.parse(input);
-}
 /**
  * Safe-parse twin of parseCrystallizationEvent. Returns a Result-like
  * envelope so callers (CLI / tests) can render findings without
@@ -252,66 +156,9 @@ export function safeParseCrystallizationEvent(input) {
     if (r.success)
         return { ok: true, row: r.data };
     const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
+        path: i.path.join('.'),
+        message: i.message
     }));
     const isBrief = isBriefSectionFailure(r.error.issues);
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
-}
-/**
- * Safe-parse twin of parseEvidenceBrief. Same Result-like envelope
- * shape; same MISSING_BRIEF_SECTION code mapping (covers both
- * refine-guard failures and per-section missing/empty failures).
- */
-export function safeParseEvidenceBrief(input) {
-    const r = EvidenceBriefSchema.safeParse(input);
-    if (r.success)
-        return { ok: true, row: r.data };
-    const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
-    }));
-    const isBrief = isBriefSectionFailure(r.error.issues);
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
-}
-/**
- * Decide whether a ZodIssue[] is a "brief section" failure: every
- * issue points at one of the four required keys (the section is
- * missing, or empty after trim), OR the explicit refine-guard issue
- * is present. Used by both `safeParseCrystallizationEvent` and
- * `safeParseEvidenceBrief` so callers see a single
- * `MISSING_BRIEF_SECTION` code regardless of which Zod boundary
- * caught the failure.
- */
-function isBriefSectionFailure(issues) {
-    if (issues.length === 0)
-        return false;
-    // Explicit refine guard (EvidenceBriefSchema.refine message).
-    if (issues.some((i) => i.message.includes("evidence_brief must contain all 4 sections"))) {
-        return true;
-    }
-    // Per-section Zod failures (min(1) on each section key, or
-    // too_small, or invalid_type). Each issue's path will be either
-    // the section key (`what_happened`) OR the parent `evidence_brief`
-    // — Zod reports missing-key issues against the parent object.
-    return issues.every((i) => {
-        const path = i.path.join(".");
-        if (path === "evidence_brief")
-            return true;
-        if (i.path.length >= 2 && i.path[0] === "evidence_brief") {
-            const key = i.path[i.path.length - 1];
-            return (key === "what_happened" ||
-                key === "why_it_matters" ||
-                key === "what_learned" ||
-                key === "what_action");
-        }
-        return (path === "what_happened" ||
-            path === "why_it_matters" ||
-            path === "what_learned" ||
-            path === "what_action");
-    });
+    return isBrief ? { ok: false, code: 'MISSING_BRIEF_SECTION', findings } : { ok: false, findings };
 }

package/dist/services/crystallization/evidence-brief-builder.d.ts

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { type EvidenceBrief } from "./crystallization-types.js";
+import { z } from 'zod';
+import { type EvidenceBrief } from './crystallization-types.js';
 /**
  * EvidenceBriefBuilder — spec §4.7 / §10 RL-7.
  *
@@ -129,7 +129,7 @@ export declare function safeRenderRecommendationPayload(input: unknown): {
     payload: RecommendationPayload;
 } | {
     ok: false;
-    code?: "MISSING_BRIEF_SECTION";
+    code?: 'MISSING_BRIEF_SECTION';
     findings: Array<{
         path: string;
         message: string;

package/dist/services/crystallization/evidence-brief-builder.js

@@ -1,5 +1,5 @@
-import { z } from "zod";
-import { EvidenceBriefSchema, } from "./crystallization-types.js";
+import { z } from 'zod';
+import { EvidenceBriefSchema } from './crystallization-types.js';
 /* ---------------------------------------------------------------------- */
 /* PRD-002b slice 2 — schema-limit constants extracted from inline         */
 /* `.max(N)` calls so the no-magic-numbers rule stops flagging the        */
@@ -88,9 +88,7 @@ export const BriefTraceInputSchema = z.object({
      * Source trace ids backing the brief (the column on
      * crystallization_event spec §4.5).
      */
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
-        .default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX)).default([])
 });
 /**
  * The summary emitted by the independent evaluators (spec §4.5
@@ -99,8 +97,8 @@ export const BriefTraceInputSchema = z.object({
  * flows into the recommendation envelope.
  */
 export const EvaluatorSummarySchema = z.object({
-    one_liner: z.string().trim().max(BRIEF_EVALUATOR_ONE_LINER_MAX).default(""),
-    risk_tags: z.array(z.string().trim().min(1).max(BRIEF_EVALUATOR_RISK_TAG_MAX)).default([]),
+    one_liner: z.string().trim().max(BRIEF_EVALUATOR_ONE_LINER_MAX).default(''),
+    risk_tags: z.array(z.string().trim().min(1).max(BRIEF_EVALUATOR_RISK_TAG_MAX)).default([])
 });
 /* ---------------------------------------------------------------------- */
 /* Recommendation envelope — the CLI renders this.                       */
@@ -108,23 +106,21 @@ export const EvaluatorSummarySchema = z.object({
 export const RecommendationPayloadSchema = z.object({
     brief: EvidenceBriefSchema,
     bullets: z.array(z.string().trim().min(1).max(BRIEF_BULLET_MAX)).default([]),
-    source_trace_pointers: z
-        .array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX))
-        .default([]),
+    source_trace_pointers: z.array(z.string().trim().min(1).max(BRIEF_TRACE_POINTER_MAX)).default([]),
     evaluator_summary: EvaluatorSummarySchema.default({
-        one_liner: "",
-        risk_tags: [],
-    }),
+        one_liner: '',
+        risk_tags: []
+    })
 });
 /* ---------------------------------------------------------------------- */
 /* Errors                                                                 */
 /* ---------------------------------------------------------------------- */
 export class BriefSectionError extends Error {
-    code = "MISSING_BRIEF_SECTION";
+    code = 'MISSING_BRIEF_SECTION';
     findings;
     constructor(message, findings = []) {
         super(message);
-        this.name = "BriefSectionError";
+        this.name = 'BriefSectionError';
         this.findings = findings;
     }
 }
@@ -164,15 +160,15 @@ export function buildEvidenceBrief(trace, evaluatorSummary) {
         what_happened: parsedTrace.what_happened,
         why_it_matters: parsedTrace.why_it_matters,
         what_learned: parsedTrace.what_learned,
-        what_action: parsedTrace.what_action,
+        what_action: parsedTrace.what_action
     };
     const result = EvidenceBriefSchema.safeParse(candidate);
     if (!result.success) {
         const findings = result.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
+            path: i.path.join('.'),
+            message: i.message
         }));
-        throw new BriefSectionError("evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)", findings);
+        throw new BriefSectionError('evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)', findings);
     }
     // Silence the unused-var lint on evaluatorSummary at this layer —
     // the builder currently does not consume it (the brief is NL
@@ -188,22 +184,22 @@ export function buildEvidenceBrief(trace, evaluatorSummary) {
 function translateBriefZodError(err) {
     if (err instanceof z.ZodError) {
         const issues = err.issues;
-        const allBrief = issues.every((i) => BRIEF_SECTION_KEYS.has(i.path.join(".")));
+        const allBrief = issues.every((i) => BRIEF_SECTION_KEYS.has(i.path.join('.')));
         if (allBrief) {
             const findings = issues.map((i) => ({
-                path: i.path.join("."),
-                message: i.message,
+                path: i.path.join('.'),
+                message: i.message
             }));
-            throw new BriefSectionError("evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)", findings);
+            throw new BriefSectionError('evidence_brief must contain all 4 sections (what_happened, why_it_matters, what_learned, what_action) with non-empty content (spec §4.7 / RL-7)', findings);
         }
     }
     throw err;
 }
 const BRIEF_SECTION_KEYS = new Set([
-    "what_happened",
-    "why_it_matters",
-    "what_learned",
-    "what_action",
+    'what_happened',
+    'why_it_matters',
+    'what_learned',
+    'what_action'
 ]);
 /**
  * Render the user-facing recommendation envelope (brief + bullets +
@@ -214,13 +210,13 @@ const BRIEF_SECTION_KEYS = new Set([
  * On success, returns the validated `RecommendationPayload`. On a
  * missing-section brief, throws `BriefSectionError`.
  */
-export function renderRecommendationPayload(trace, evaluatorSummary = { one_liner: "", risk_tags: [] }) {
+export function renderRecommendationPayload(trace, evaluatorSummary = { one_liner: '', risk_tags: [] }) {
     const brief = buildEvidenceBrief(trace, evaluatorSummary);
     const payload = RecommendationPayloadSchema.parse({
         brief,
         bullets: trace.bullets ?? [],
         source_trace_pointers: trace.source_trace_pointers ?? [],
-        evaluator_summary: evaluatorSummary,
+        evaluator_summary: evaluatorSummary
     });
     return payload;
 }
@@ -235,17 +231,15 @@ export function safeRenderRecommendationPayload(input) {
     if (r.success)
         return { ok: true, payload: r.data };
     const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
+        path: i.path.join('.'),
+        message: i.message
     }));
     // Map brief failures to MISSING_BRIEF_SECTION. A failure is
     // recognized as brief iff (a) every issue points at the brief or
     // its sections, OR (b) the explicit refine message is present.
-    const isBrief = r.error.issues.every((i) => i.message.includes("evidence_brief must contain all 4 sections") ||
-        BRIEF_SECTION_KEYS.has(i.path.join(".")) ||
-        i.path[0] === "brief" ||
-        (i.path.length >= 2 && i.path[0] === "brief"));
-    return isBrief
-        ? { ok: false, code: "MISSING_BRIEF_SECTION", findings }
-        : { ok: false, findings };
+    const isBrief = r.error.issues.every((i) => i.message.includes('evidence_brief must contain all 4 sections') ||
+        BRIEF_SECTION_KEYS.has(i.path.join('.')) ||
+        i.path[0] === 'brief' ||
+        (i.path.length >= 2 && i.path[0] === 'brief'));
+    return isBrief ? { ok: false, code: 'MISSING_BRIEF_SECTION', findings } : { ok: false, findings };
 }