peaks-loop 4.0.54 → 4.1.0

package/dist/services/context/tokenizer.js

@@ -16,7 +16,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: doc.sections.map((s) => s.title),
             conflictScore: 0, // v1: no cross-source conflict detection yet
             timeDecayScore: freshDecayScore(doc.fetchedAt, now),
-            tags: ['fetched', doc.source, doc.stale ? 'stale' : 'fresh'],
+            tags: ['fetched', doc.source, doc.stale ? 'stale' : 'fresh']
         });
     }
     for (const mem of collector.memoryEntries) {
@@ -26,7 +26,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: [mem.title],
             conflictScore: 0,
             timeDecayScore: mem.relevanceScore,
-            tags: ['memory'],
+            tags: ['memory']
         });
     }
     for (const file of collector.files) {
@@ -36,7 +36,7 @@ export function tokenize(collector, docRetriever, now = new Date()) {
             blastRadius: [file.path],
             conflictScore: 0,
             timeDecayScore: 1,
-            tags: [file.kind],
+            tags: [file.kind]
         });
     }
     return Object.freeze({ metadata: Object.freeze(metadata) });

package/dist/services/crystallization/crystallization-brief-schema.d.ts

@@ -0,0 +1,80 @@
+/**
+ * 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';
+/** Brief-section cap; the event-level free-text columns in
+ *  `crystallization-types.ts` reuse the same bound. */
+export declare const CRYS_BRIEF_SECTION_MAX = 4000;
+/**
+ * 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;
+/**
+ * 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 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';
+    findings: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+/**
+ * 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 declare function isBriefSectionFailure(issues: ReadonlyArray<z.ZodIssue>): boolean;

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()`