peaks-loop 4.0.53 → 4.1.0

package/dist/services/crystallization/crystallization-brief-schema.js

@@ -0,0 +1,159 @@
+/**
+ * Crystallization evidence-brief schema — hoisted VERBATIM out of
+ * `crystallization-types.ts` so that file clears the 300 raw-line cap.
+ * Nothing here was rewritten: same constraints, same `.superRefine`
+ * guard, same issue message, same MISSING_BRIEF_SECTION mapping.
+ *
+ * `crystallization-types.ts` re-exports every public name from this
+ * path, so `EvidenceBriefSchema` / `EvidenceBrief` /
+ * `hasAllFourBriefSections` / `parseEvidenceBrief` /
+ * `safeParseEvidenceBrief` stay importable from their original module
+ * and from `crystallization/index.js`.
+ */
+import { z } from 'zod';
+/* ---------------------------------------------------------------------- */
+/* 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.                  */
+/* ---------------------------------------------------------------------- */
+/** Brief-section cap; the event-level free-text columns in
+ *  `crystallization-types.ts` reuse the same bound. */
+export const CRYS_BRIEF_SECTION_MAX = 4000;
+/* ---------------------------------------------------------------------- */
+/* 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);
+}
+/**
+ * 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 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.
+ */
+export 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');
+    });
+}

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

@@ -1,7 +1,7 @@
-import type Database from "better-sqlite3";
-import { z } from "zod";
-import { type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus, type EvidenceBrief } from "./crystallization-types.js";
-import { listCrystallizationEvents } from "./crystallization-store.js";
+import type Database from 'better-sqlite3';
+import { z } from 'zod';
+import { type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus, type EvidenceBrief } from './crystallization-types.js';
+import { listCrystallizationEvents } from './crystallization-store.js';
 type LoopReleaseZodSchema = {
     parse: (input: unknown) => unknown;
 };
@@ -72,9 +72,9 @@ export declare const CrystallizationTaskStateSchema: z.ZodObject<{
     evidence_collected: z.ZodLiteral<true>;
 }, z.core.$strip>;
 export type CrystallizationTaskState = z.infer<typeof CrystallizationTaskStateSchema>;
-export type CrystallizationIntegrityErrorCode = "CRYSTALLIZATION_PRE_RUN" | "CRYSTALLIZATION_INVALID_TASK_STATE" | "CRYSTALLIZATION_TX_FAILED" | "MISSING_BRIEF_SECTION";
+export type CrystallizationIntegrityErrorCode = 'CRYSTALLIZATION_PRE_RUN' | 'CRYSTALLIZATION_INVALID_TASK_STATE' | 'CRYSTALLIZATION_TX_FAILED' | 'MISSING_BRIEF_SECTION';
 export declare class CrystallizationIntegrityError extends Error {
-    readonly code: CrystallizationIntegrityErrorCode | "MISSING_BRIEF_SECTION";
+    readonly code: CrystallizationIntegrityErrorCode | 'MISSING_BRIEF_SECTION';
     readonly findings: ReadonlyArray<{
         path: string;
         message: string;
@@ -115,7 +115,7 @@ export interface CrystallizePayload {
     /** Optional user decision summary (spec §4.5). */
     user_decision_summary?: string;
     /** Trigger classification (spec §5.4). */
-    trigger: CrystallizationEventInput["trigger"];
+    trigger: CrystallizationEventInput['trigger'];
 }
 /**
  * Minimum bee_release payload the service needs to create a main bee

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

@@ -1,7 +1,7 @@
-import { z, ZodError } from "zod";
-import { CrystallizationEventSchema, EvidenceBriefSchema, } from "./crystallization-types.js";
-import { BriefSectionError } from "./evidence-brief-builder.js";
-import { CRYSTALLIZATION_SCHEMA_VERSION, ensureCrystallizationEventTable, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus, } from "./crystallization-store.js";
+import { z, ZodError } from 'zod';
+import { CrystallizationEventSchema, EvidenceBriefSchema } from './crystallization-types.js';
+import { BriefSectionError } from './evidence-brief-builder.js';
+import { CRYSTALLIZATION_SCHEMA_VERSION, ensureCrystallizationEventTable, getCrystallizationEvent, listCrystallizationEvents, newCrystallizationId, updateCrystallizationEventStatus } from './crystallization-store.js';
 /**
  * CrystallizationService — spec §5 (post-run crystallization)
  * + §4.5 + §4.7 + §10 RL-2 / RL-3 / RL-7.
@@ -50,11 +50,11 @@ import { CRYSTALLIZATION_SCHEMA_VERSION, ensureCrystallizationEventTable, getCry
 /* Pre-run task gate — AC-4 / RL-2                                        */
 /* ---------------------------------------------------------------------- */
 export const CRYSTALLIZATION_TASK_STATUSES = [
-    "completed",
-    "in_progress",
-    "scratch",
-    "blocked",
-    "failed",
+    'completed',
+    'in_progress',
+    'scratch',
+    'blocked',
+    'failed'
 ];
 /**
  * The pre-run task state the service requires. Crystallization is
@@ -64,22 +64,22 @@ export const CRYSTALLIZATION_TASK_STATUSES = [
  */
 export const CrystallizationTaskStateSchema = z.object({
     task_id: z.string().trim().min(1).max(256),
-    task_status: z.literal("completed", {
-        error: () => "task_status must be 'completed' for crystallization (AC-4 / RL-2)",
+    task_status: z.literal('completed', {
+        error: () => "task_status must be 'completed' for crystallization (AC-4 / RL-2)"
     }),
     gates_passed: z.literal(true, {
-        error: () => "gates_passed must be true for crystallization (AC-4 / RL-2)",
+        error: () => 'gates_passed must be true for crystallization (AC-4 / RL-2)'
     }),
     evidence_collected: z.literal(true, {
-        error: () => "evidence_collected must be true for crystallization (AC-4 / RL-2)",
-    }),
+        error: () => 'evidence_collected must be true for crystallization (AC-4 / RL-2)'
+    })
 });
 export class CrystallizationIntegrityError extends Error {
     code;
     findings;
     constructor(code, message, findings = []) {
         super(message);
-        this.name = "CrystallizationIntegrityError";
+        this.name = 'CrystallizationIntegrityError';
         this.code = code;
         this.findings = findings;
     }
@@ -99,22 +99,20 @@ export class CrystallizationIntegrityError extends Error {
 const BeeNameSchema = z
     .string()
     .trim()
-    .min(1, "bee_name is required")
+    .min(1, 'bee_name is required')
     .max(200)
     .regex(/^[a-z0-9][a-z0-9._-]*$/, {
-    message: "bee_name must be kebab-/snake-case starting with a lowercase letter or digit",
+    message: 'bee_name must be kebab-/snake-case starting with a lowercase letter or digit'
 });
 const BeeCrystallizeInputSchema = z.object({
     bee_name: BeeNameSchema,
-    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)'
     }),
     description: z.string().trim().min(1).max(4000),
     user_intent_raw: z.string().trim().max(4000).optional(),
     parent_version: z.string().trim().max(64).optional(),
-    changelog: z.string().trim().max(8000).optional(),
+    changelog: z.string().trim().max(8000).optional()
 });
 export class CrystallizationService {
     db;
@@ -170,23 +168,23 @@ export class CrystallizationService {
         catch (err) {
             if (err instanceof ZodError) {
                 const findings = err.issues.map((i) => ({
-                    path: i.path.join("."),
-                    message: i.message,
+                    path: i.path.join('.'),
+                    message: i.message
                 }));
                 const first = err.issues[0];
-                throw new CrystallizationIntegrityError("CRYSTALLIZATION_PRE_RUN", `pre-run gate failed: ${first?.message ?? "invalid task state"}`, findings);
+                throw new CrystallizationIntegrityError('CRYSTALLIZATION_PRE_RUN', `pre-run gate failed: ${first?.message ?? 'invalid task state'}`, findings);
             }
             throw err;
         }
         // Defense in depth — re-assert at the service boundary.
-        if (parsed.task_status !== "completed" ||
+        if (parsed.task_status !== 'completed' ||
             parsed.gates_passed !== true ||
             parsed.evidence_collected !== true) {
-            throw new CrystallizationIntegrityError("CRYSTALLIZATION_PRE_RUN", "pre-run gate failed: task must be completed with gates_passed=true AND evidence_collected=true (AC-4 / RL-2)", [
+            throw new CrystallizationIntegrityError('CRYSTALLIZATION_PRE_RUN', 'pre-run gate failed: task must be completed with gates_passed=true AND evidence_collected=true (AC-4 / RL-2)', [
                 {
-                    path: "task",
-                    message: "task_status must equal 'completed' and gates_passed and evidence_collected must both be true",
-                },
+                    path: 'task',
+                    message: "task_status must equal 'completed' and gates_passed and evidence_collected must both be true"
+                }
             ]);
         }
         return parsed;
@@ -235,11 +233,11 @@ export class CrystallizationService {
             if (err instanceof ZodError || err instanceof BriefSectionError) {
                 const findings = err instanceof ZodError
                     ? err.issues.map((i) => ({
-                        path: i.path.join("."),
-                        message: i.message,
+                        path: i.path.join('.'),
+                        message: i.message
                     }))
                     : err.findings;
-                throw new CrystallizationIntegrityError("MISSING_BRIEF_SECTION", "evidence_brief is missing at least one of the 4 required sections (spec §4.7 / RL-7)", [...findings]);
+                throw new CrystallizationIntegrityError('MISSING_BRIEF_SECTION', 'evidence_brief is missing at least one of the 4 required sections (spec §4.7 / RL-7)', [...findings]);
             }
             throw err;
         }
@@ -252,14 +250,16 @@ export class CrystallizationService {
         // account the LLM authored). We validate the shape WITHOUT
         // bee_release_id (which is filled in by the bee insert below),
         // then validate the final tuple after the SQL writes.
-        const relationInputShape = this.opts.loopBeeRelationSchema.omit({
+        const relationInputShape = this.opts.loopBeeRelationSchema
+            .omit({
             id: true,
             created_at: true,
-            bee_release_id: true,
-        }).parse({
+            bee_release_id: true
+        })
+            .parse({
             loop_release_id: loopRow.id,
-            role: "main",
-            reason: payload.bee_relation_reason,
+            role: 'main',
+            reason: payload.bee_relation_reason
         });
         const eventId = newCrystallizationId();
         const eventCreatedAt = new Date().toISOString();
@@ -280,7 +280,7 @@ export class CrystallizationService {
            user_intent_raw, description, parent_version, changelog,
            shareable, desktop_visible
          ) VALUES (?, ?, 'user', ?, ?, ?, ?, ?, ?, 1, 1)`);
-            const beeInfo = beeInsert.run(beeRow.bee_name, beeRow.version, eventCreatedAt, "llm", beeRow.user_intent_raw ?? null, beeRow.description, beeRow.parent_version ?? null, beeRow.changelog ?? null);
+            const beeInfo = beeInsert.run(beeRow.bee_name, beeRow.version, eventCreatedAt, 'llm', beeRow.user_intent_raw ?? null, beeRow.description, beeRow.parent_version ?? null, beeRow.changelog ?? null);
             beeReleaseId = Number(beeInfo.lastInsertRowid);
             // Update the bee_release_pointer row so the latest version is
             // discoverable via list tooling.
@@ -296,18 +296,20 @@ export class CrystallizationService {
              entrypoint_preamble, promotion, min_cycles,
              requires_human, requires_smoke, retire_on_misses
            ) VALUES (?, ?, ?, '[]', '', 'candidate', NULL, 0, 0, NULL)`)
-                .run(beeReleaseId, "peaks.bee/1", beeRow.description);
+                .run(beeReleaseId, 'peaks.bee/1', beeRow.description);
             // 4. Insert the loop_bee_relation row (FKs now valid). Re-parse
             // through the input schema so the bee_release_id is validated
             // too — defense in depth. `id` is autoincrement (not in input).
-            const fullRelation = this.opts.loopBeeRelationSchema.omit({
+            const fullRelation = this.opts.loopBeeRelationSchema
+                .omit({
                 id: true,
-                created_at: true,
-            }).parse({
+                created_at: true
+            })
+                .parse({
                 loop_release_id: relationInputShape.loop_release_id,
                 bee_release_id: beeReleaseId,
                 role: relationInputShape.role,
-                reason: relationInputShape.reason,
+                reason: relationInputShape.reason
             });
             const relationRow = this.opts.insertLoopBeeRelation(this.db, fullRelation);
             relationId = relationRow.id;
@@ -318,13 +320,13 @@ export class CrystallizationService {
                 evidence_brief: brief,
                 evidence_bullets: payload.evidence_bullets ?? [],
                 source_trace_pointers: payload.source_trace_pointers ?? [],
-                evaluator_summary: payload.evaluator_summary ?? "",
-                user_decision_summary: payload.user_decision_summary ?? "",
+                evaluator_summary: payload.evaluator_summary ?? '',
+                user_decision_summary: payload.user_decision_summary ?? '',
                 created_loop_release_id: loopReleaseId,
                 created_bee_release_id: beeReleaseId,
                 // updated_* are not set on a CREATE crystallization; they will
                 // be set on future UPDATE crystallizations.
-                lifecycle_status: "candidate",
+                lifecycle_status: 'candidate'
             };
             const persisted = insertCrystallizationEventRaw(this.db, eventInput, eventId, eventCreatedAt);
             eventPersistedId = persisted.id;
@@ -336,16 +338,15 @@ export class CrystallizationService {
             // Map known SQLite constraint errors to friendlier codes; raise
             // CrystallizationIntegrityError so the CLI can render the JSON
             // envelope.
-            if (err instanceof CrystallizationIntegrityError ||
-                err instanceof BriefSectionError) {
+            if (err instanceof CrystallizationIntegrityError || err instanceof BriefSectionError) {
                 throw err;
             }
             const message = err instanceof Error ? err.message : String(err);
-            throw new CrystallizationIntegrityError("CRYSTALLIZATION_TX_FAILED", `crystallization transaction failed: ${message}`, [
+            throw new CrystallizationIntegrityError('CRYSTALLIZATION_TX_FAILED', `crystallization transaction failed: ${message}`, [
                 {
-                    path: "tx",
-                    message: "transaction rolled back; verify loop/bee ids are unique and FK targets exist",
-                },
+                    path: 'tx',
+                    message: 'transaction rolled back; verify loop/bee ids are unique and FK targets exist'
+                }
             ]);
         }
         // Silence the unused-variable lint; the parsed task is the source
@@ -356,7 +357,7 @@ export class CrystallizationService {
             bee_release_id: beeReleaseId,
             loop_bee_relation_id: relationId,
             crystallization_event_id: eventPersistedId,
-            loop_release_lifecycle_status: "candidate",
+            loop_release_lifecycle_status: 'candidate'
         };
     }
 }
@@ -370,7 +371,7 @@ function insertCrystallizationEventRaw(db, row, id, createdAt) {
         ...row,
         id,
         schema_version: CRYSTALLIZATION_SCHEMA_VERSION,
-        created_at: createdAt,
+        created_at: createdAt
     });
     const stmt = db.prepare(`INSERT INTO crystallization_event (
        id, trigger, evidence_brief_json, evidence_bullets_json,

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

@@ -1,5 +1,5 @@
-import type Database from "better-sqlite3";
-import { type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus } from "./crystallization-types.js";
+import type Database from 'better-sqlite3';
+import { type CrystallizationEvent, type CrystallizationEventInput, type CrystallizationEventStatus } from './crystallization-types.js';
 /**
  * Low-level SQLite access for the `crystallization_event` table.
  * The migration is registered with the existing `openStateDb()`

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;