peaks-loop 4.0.53 → 4.1.0

package/dist/services/share/bundle-types.js

@@ -61,92 +61,17 @@
  * Excludes (spec §7A.2 hard rules): private run_state, anything
  * under `.peaks/memory/personal/`, raw `state.db` rows.
  */
-import { z } from "zod";
-/* ---------------------------------------------------------------------- */
-/* Format constant + version                                                */
-/* ---------------------------------------------------------------------- */
-/**
- * The on-the-wire format constant, pinned to the literal
- * `"peaks.bundle/1"`. The CLI is the only writer — see `bundle-writer.ts`.
- * A future format change requires a major-version bump + a new writer.
- */
-export const PEAKS_BUNDLE_FORMAT_CONSTANT = "peaks.bundle/1";
-/**
- * The required `format_version_major` for any current receiver.
- * Bumped only on a breaking schema change. The reader throws when
- * the manifest declares any value other than `1`.
- */
-export const PEAKS_BUNDLE_FORMAT_VERSION_MAJOR = 1;
-/**
- * Default `format_version_minor`. Major-compatible minor bumps emit
- * a soft warning at read time; they never block.
- */
-export const PEAKS_BUNDLE_DEFAULT_MINOR_VERSION = 0;
-/* ---------------------------------------------------------------------- */
-/* Schema-version cross-reference (per asset table)                         */
-/* ---------------------------------------------------------------------- */
-/**
- * The cross-cutting schema literals a bundle is allowed to declare.
- * Each value must match the canonical Zod `literal(...)` literal in
- * the corresponding type module. Used for the
- * `SchemaVersionsMapping` enumeration below.
- */
-export const PEAKS_BUNDLE_SCHEMA_VERSIONS = {
-    loop: "peaks.loop/1",
-    bee: "peaks.bee/1",
-    loop_bee_relation: "peaks.loop-bee-relation/1",
-    crystallization: "peaks.crystallization/1",
-};
-/* ---------------------------------------------------------------------- */
-/* Schema-versions mapping — spec §7A.2                                     */
-/* ---------------------------------------------------------------------- */
-/**
- * Schema-versions mapping. The writer writes the canonical literal
- * for each asset kind it includes; the reader checks every key for
- * presence (and that the value matches the canonical literal).
- *
- * `.strict()` refuses unknown keys; `.refine(...)` enforces that
- * each value matches its canonical literal.
- */
-export const SchemaVersionsMappingSchema = z
-    .object({
-    loop: z.literal(PEAKS_BUNDLE_SCHEMA_VERSIONS.loop),
-    bee: z.literal(PEAKS_BUNDLE_SCHEMA_VERSIONS.bee),
-    loop_bee_relation: z.literal(PEAKS_BUNDLE_SCHEMA_VERSIONS.loop_bee_relation),
-    crystallization: z.literal(PEAKS_BUNDLE_SCHEMA_VERSIONS.crystallization),
-})
-    .strict();
-/* ---------------------------------------------------------------------- */
-/* Exclusion manifest — the explicit excludes per spec §7A.2               */
-/* ---------------------------------------------------------------------- */
-/**
- * The bundle explicitly excludes private run-state, the user's
- * personal memory directory, and raw `state.db` rows. The
- * `ExclusionManifestSchema` is what the writer stamps into the
- * manifest; the reader uses it as a self-declaration (the writer is
- * the only place that can leak those payloads, but the read-time
- * stamp lets the receiver confirm the source understood the
- * exclusion rules).
- */
-export const ExclusionManifestSchema = z
-    .object({
-    private_run_state: z.literal("excluded"),
-    personal_memory: z.literal("excluded"),
-    state_db_rows: z.literal("excluded"),
-})
-    .strict();
-/* ---------------------------------------------------------------------- */
-/* Bundle kind — which asset the bundle is anchored on                     */
-/* ---------------------------------------------------------------------- */
-/**
- * Bundle kind. A bundle is anchored on exactly one asset: either a
- * `loop_release` (and its main bee + supporting bees) or a single
- * `bee_release` (loop-scoped relations may follow but are not
- * required).
- */
-export const PEAKS_BUNDLE_KINDS = ["loop", "bee"];
+import { z } from 'zod';
+import { ExclusionManifestSchema, PEAKS_BUNDLE_DEFAULT_MINOR_VERSION, PEAKS_BUNDLE_FORMAT_CONSTANT, PEAKS_BUNDLE_FORMAT_VERSION_MAJOR, PEAKS_BUNDLE_KINDS, SchemaVersionsMappingSchema } from './bundle-format-constants.js';
 /* ---------------------------------------------------------------------- */
 /* Bundle manifest schema — the on-the-wire shape                          */
+/*                                                                         */
+/* The format constant + version, the schema-version literals, the two     */
+/* mapping schemas built on them and the bundle-kind enumeration live in   */
+/* `bundle-format-constants.ts` (wave 5). That module imports NOTHING from */
+/* this file, which is what lets the schema below read those consts at     */
+/* module-init time without a TDZ cycle; their public names are re-exported*/
+/* at the bottom of this file, so no import path moves.                    */
 /* ---------------------------------------------------------------------- */
 /**
  * The full manifest schema. The asset sub-objects are typed as
@@ -225,24 +150,24 @@ export const BundleManifestSchema = z
      * Exclusion manifest — explicit declarations of the three
      * hard excludes per spec §7A.2.
      */
-    exclusion_manifest: ExclusionManifestSchema,
+    exclusion_manifest: ExclusionManifestSchema
 })
     .strict()
     .superRefine((m, ctx) => {
     // kind === 'loop' implies loop_release is required.
-    if (m.kind === "loop" && m.loop_release === undefined) {
+    if (m.kind === 'loop' && m.loop_release === undefined) {
         ctx.addIssue({
             code: 'custom',
             path: [],
-            message: "bundle manifest is inconsistent: kind='loop' requires loop_release; kind='bee' requires bee_release (spec §7A.2)",
+            message: "bundle manifest is inconsistent: kind='loop' requires loop_release; kind='bee' requires bee_release (spec §7A.2)"
         });
     }
     // kind === 'bee' implies bee_release is required.
-    if (m.kind === "bee" && m.bee_release === undefined) {
+    if (m.kind === 'bee' && m.bee_release === undefined) {
         ctx.addIssue({
             code: 'custom',
             path: [],
-            message: "bundle manifest is inconsistent: kind='loop' requires loop_release; kind='bee' requires bee_release (spec §7A.2)",
+            message: "bundle manifest is inconsistent: kind='loop' requires loop_release; kind='bee' requires bee_release (spec §7A.2)"
         });
     }
 });
@@ -278,27 +203,27 @@ export function safeParseBundleManifest(input) {
     if (r.success)
         return { ok: true, manifest: r.data };
     const findings = r.error.issues.map((i) => ({
-        path: i.path.join("."),
-        message: i.message,
+        path: i.path.join('.'),
+        message: i.message
     }));
-    const joined = findings.map((f) => f.path + ":" + f.message).join("|");
+    const joined = findings.map((f) => f.path + ':' + f.message).join('|');
     const code = detectManifestFailureCode(joined);
     return { ok: false, code, findings };
 }
 function detectManifestFailureCode(joinedIssues) {
-    if (joinedIssues.includes("format_constant")) {
-        return "BUNDLE_FORMAT_CONSTANT_MISMATCH";
+    if (joinedIssues.includes('format_constant')) {
+        return 'BUNDLE_FORMAT_CONSTANT_MISMATCH';
     }
-    if (joinedIssues.includes("format_version_major")) {
-        return "BUNDLE_MAJOR_VERSION_MISMATCH";
+    if (joinedIssues.includes('format_version_major')) {
+        return 'BUNDLE_MAJOR_VERSION_MISMATCH';
     }
-    if (joinedIssues.includes("schema_versions")) {
-        return "BUNDLE_SCHEMA_VERSIONS_MISMATCH";
+    if (joinedIssues.includes('schema_versions')) {
+        return 'BUNDLE_SCHEMA_VERSIONS_MISMATCH';
     }
-    if (joinedIssues.includes("exclusion_manifest")) {
-        return "BUNDLE_EXCLUSION_MANIFEST_MISSING";
+    if (joinedIssues.includes('exclusion_manifest')) {
+        return 'BUNDLE_EXCLUSION_MANIFEST_MISSING';
     }
-    return "BUNDLE_KIND_ANCHOR_MISMATCH";
+    return 'BUNDLE_KIND_ANCHOR_MISMATCH';
 }
 /* ---------------------------------------------------------------------- */
 /* Hard-block error code consts                                              */
@@ -310,15 +235,21 @@ function detectManifestFailureCode(joinedIssues) {
  */
 export const SHARE_BUNDLE_ERROR_CODES = {
     /** Major-version mismatch at read time — HARD block. */
-    MAJOR_VERSION_MISMATCH: "SHARE_BUNDLE_MAJOR_VERSION_MISMATCH",
+    MAJOR_VERSION_MISMATCH: 'SHARE_BUNDLE_MAJOR_VERSION_MISMATCH',
     /** Schema-version mapping is missing or carries non-canonical literals. */
-    SCHEMA_VERSIONS_MISMATCH: "SHARE_BUNDLE_SCHEMA_VERSIONS_MISMATCH",
+    SCHEMA_VERSIONS_MISMATCH: 'SHARE_BUNDLE_SCHEMA_VERSIONS_MISMATCH',
     /** Format constant is not the pinned "peaks.bundle/1". */
-    FORMAT_CONSTANT_MISMATCH: "SHARE_BUNDLE_FORMAT_CONSTANT_MISMATCH",
+    FORMAT_CONSTANT_MISMATCH: 'SHARE_BUNDLE_FORMAT_CONSTANT_MISMATCH',
     /** Source release has `shareable === false` — HARD block at write time. */
-    NOT_SHAREABLE: "SHARE_BUNDLE_NOT_SHAREABLE",
+    NOT_SHAREABLE: 'SHARE_BUNDLE_NOT_SHAREABLE',
     /** Receiver asked to land as `stable` (forbidden — bundles always land as candidate). */
-    IMPORT_TO_STABLE_FORBIDDEN: "SHARE_BUNDLE_IMPORT_TO_STABLE_FORBIDDEN",
+    IMPORT_TO_STABLE_FORBIDDEN: 'SHARE_BUNDLE_IMPORT_TO_STABLE_FORBIDDEN',
     /** Bundle tarball is malformed (missing manifest, bad payload). */
-    BUNDLE_MALFORMED: "SHARE_BUNDLE_MALFORMED",
+    BUNDLE_MALFORMED: 'SHARE_BUNDLE_MALFORMED'
 };
+// ─── public-surface shim (wave-5 hoist) ──────────────────────────────────────
+// `bundle-reader.ts` and `bundle-writer.ts` import the format consts, the
+// schema-version literals, both mapping schemas and the kinds from this path,
+// so re-export everything the hoisted module publishes under their original
+// names. './bundle-types.js' stays the public import path.
+export * from './bundle-format-constants.js';

package/dist/services/share/bundle-writer.d.ts

@@ -38,8 +38,8 @@
  * extract via `runTar(['-xzf', inPath, '-C', stageDir])` with no
  * extra plumbing.
  */
-import type Database from "better-sqlite3";
-import { SHARE_BUNDLE_ERROR_CODES, type PeaksBundleKind } from "./bundle-types.js";
+import type Database from 'better-sqlite3';
+import { SHARE_BUNDLE_ERROR_CODES, type PeaksBundleKind } from './bundle-types.js';
 /**
  * Inputs to `writeBundle`. `kind` decides which asset table the
  * `id` resolves against; the writer throws on unknown assets and
@@ -72,7 +72,7 @@ export declare class BundleNotShareableError extends Error {
  * both fall under `BUNDLE_ASSET_NOT_FOUND` for the CLI envelope.
  */
 export declare class BundleAssetNotFoundError extends Error {
-    readonly code: "BUNDLE_ASSET_NOT_FOUND";
+    readonly code: 'BUNDLE_ASSET_NOT_FOUND';
     readonly assetKind: PeaksBundleKind;
     readonly assetId: string | number;
     constructor(assetKind: PeaksBundleKind, assetId: string | number);

package/dist/services/share/bundle-writer.js

@@ -38,10 +38,30 @@
  * extract via `runTar(['-xzf', inPath, '-C', stageDir])` with no
  * extra plumbing.
  */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, } from "node:fs";
-import { join } from "node:path";
-import { runTar } from "../skillhub/tar-runtime.js";
-import { PEAKS_BUNDLE_DEFAULT_MINOR_VERSION, PEAKS_BUNDLE_FORMAT_CONSTANT, PEAKS_BUNDLE_FORMAT_VERSION_MAJOR, PEAKS_BUNDLE_SCHEMA_VERSIONS, SHARE_BUNDLE_ERROR_CODES, } from "./bundle-types.js";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { z } from 'zod';
+import { parseJson } from '../../shared/json-parse.js';
+import { runTar } from '../skillhub/tar-runtime.js';
+import { PEAKS_BUNDLE_DEFAULT_MINOR_VERSION, PEAKS_BUNDLE_FORMAT_CONSTANT, PEAKS_BUNDLE_FORMAT_VERSION_MAJOR, PEAKS_BUNDLE_SCHEMA_VERSIONS, SHARE_BUNDLE_ERROR_CODES } from './bundle-types.js';
+/* ---------------------------------------------------------------------- */
+/* Inputs                                                                   */
+/* ---------------------------------------------------------------------- */
+/**
+ * The three JSON TEXT columns of `crystallization_event`, as they come back
+ * OUT of SQLite.
+ *
+ * WHY THIS EXISTS (batch B4). `SELECT *` reaches this module as
+ * `Record<string, unknown>`, so the only thing the compiler knew about these
+ * three values was that `JSON.parse` had returned `any`. They are re-serialized
+ * verbatim into the bundle's `evidence_briefs/*.json`, which is why the read
+ * schema is the SHAPE OF THE COLUMN and not a deep domain schema: this module
+ * copies the stored value, it does not reinterpret it. What it must establish
+ * — and SQLite cannot — is the top-level shape its own `?? '{}'` / `?? '[]'`
+ * defaults already assume.
+ */
+const storedJsonObjectSchema = z.record(z.string(), z.unknown());
+const storedStringListSchema = z.array(z.string());
 /* ---------------------------------------------------------------------- */
 /* Hard-block errors                                                        */
 /* ---------------------------------------------------------------------- */
@@ -54,7 +74,7 @@ export class BundleNotShareableError extends Error {
     code;
     constructor(message) {
         super(message);
-        this.name = "BundleNotShareableError";
+        this.name = 'BundleNotShareableError';
         this.code = SHARE_BUNDLE_ERROR_CODES.NOT_SHAREABLE;
     }
 }
@@ -70,8 +90,8 @@ export class BundleAssetNotFoundError extends Error {
     assetId;
     constructor(assetKind, assetId) {
         super(`${assetKind} asset not found for id='${String(assetId)}'`);
-        this.name = "BundleAssetNotFoundError";
-        this.code = "BUNDLE_ASSET_NOT_FOUND";
+        this.name = 'BundleAssetNotFoundError';
+        this.code = 'BUNDLE_ASSET_NOT_FOUND';
         this.assetKind = assetKind;
         this.assetId = assetId;
     }
@@ -88,7 +108,7 @@ export class BundleAssetNotFoundError extends Error {
  * on the way back in.
  */
 function readLoopReleaseRow(db, id) {
-    const row = db.prepare("SELECT * FROM loop_release WHERE id = ?").get(id);
+    const row = db.prepare('SELECT * FROM loop_release WHERE id = ?').get(id);
     if (!row)
         return undefined;
     // Re-shape SQLite 0/1 INTEGER convention to JS boolean; keep
@@ -99,22 +119,22 @@ function readLoopReleaseRow(db, id) {
         name: row.name,
         scenario: row.scenario,
         trigger_policy: row.trigger_policy,
-        success_criteria: JSON.parse(String(row.success_criteria_json ?? "[]")),
+        success_criteria: JSON.parse(String(row.success_criteria_json ?? '[]')),
         interaction_policy: row.interaction_policy,
         feedback_policy: row.feedback_policy,
         evolution_policy: row.evolution_policy,
-        evaluator_policy: JSON.parse(String(row.evaluator_policy_json ?? "[]")),
-        linked_bees: JSON.parse(String(row.linked_bees_json ?? "[]")),
-        run_history: JSON.parse(String(row.run_history_json ?? "[]")),
-        crystallization_evidence: JSON.parse(String(row.crystallization_evidence_json ?? "[]")),
+        evaluator_policy: JSON.parse(String(row.evaluator_policy_json ?? '[]')),
+        linked_bees: JSON.parse(String(row.linked_bees_json ?? '[]')),
+        run_history: JSON.parse(String(row.run_history_json ?? '[]')),
+        crystallization_evidence: JSON.parse(String(row.crystallization_evidence_json ?? '[]')),
         lifecycle_status: row.lifecycle_status,
         version: row.version,
         schema_version: row.schema_version,
         archived_at: row.archived_at,
         shareable: row.shareable === 1,
-        share_excluded_paths: JSON.parse(String(row.share_excluded_paths ?? "[]")),
+        share_excluded_paths: JSON.parse(String(row.share_excluded_paths ?? '[]')),
         desktop_visible: row.desktop_visible === 1,
-        export_bundle_format: row.export_bundle_format,
+        export_bundle_format: row.export_bundle_format
     };
 }
 /**
@@ -125,29 +145,21 @@ function readLoopReleaseRow(db, id) {
  * rows so the receiver can re-materialize the full bee.
  */
 function readBeeReleaseBundle(db, id) {
-    const release = db
-        .prepare("SELECT * FROM bee_release WHERE id = ?")
-        .get(id);
+    const release = db.prepare('SELECT * FROM bee_release WHERE id = ?').get(id);
     if (!release)
         return undefined;
-    const manifest = db
-        .prepare("SELECT * FROM bee_manifest WHERE release_id = ?")
-        .get(id);
+    const manifest = db.prepare('SELECT * FROM bee_manifest WHERE release_id = ?').get(id);
     const segments = db
-        .prepare("SELECT * FROM bee_segment_ref WHERE release_id = ?")
-        .all(id);
-    const files = db
-        .prepare("SELECT * FROM bee_file WHERE release_id = ?")
-        .all(id);
-    const changes = db
-        .prepare("SELECT * FROM bee_change WHERE release_id = ?")
+        .prepare('SELECT * FROM bee_segment_ref WHERE release_id = ?')
         .all(id);
+    const files = db.prepare('SELECT * FROM bee_file WHERE release_id = ?').all(id);
+    const changes = db.prepare('SELECT * FROM bee_change WHERE release_id = ?').all(id);
     return {
         bee_release: release,
         manifest,
         segments,
         files,
-        changes,
+        changes
     };
 }
 /**
@@ -155,7 +167,7 @@ function readBeeReleaseBundle(db, id) {
  */
 function readLoopBeeRelationsForLoop(db, loopId) {
     return db
-        .prepare("SELECT * FROM loop_bee_relation WHERE loop_release_id = ? ORDER BY id ASC")
+        .prepare('SELECT * FROM loop_bee_relation WHERE loop_release_id = ? ORDER BY id ASC')
         .all(loopId);
 }
 /**
@@ -163,7 +175,7 @@ function readLoopBeeRelationsForLoop(db, loopId) {
  */
 function readLoopBeeRelationsForBee(db, beeReleaseId) {
     return db
-        .prepare("SELECT * FROM loop_bee_relation WHERE bee_release_id = ? ORDER BY id ASC")
+        .prepare('SELECT * FROM loop_bee_relation WHERE bee_release_id = ? ORDER BY id ASC')
         .all(beeReleaseId);
 }
 /**
@@ -176,29 +188,29 @@ function readEvidenceBriefsForAsset(db, refs) {
     const wheres = [];
     const params = [];
     if (refs.loopId !== undefined) {
-        wheres.push("created_loop_release_id = ?");
+        wheres.push('created_loop_release_id = ?');
         params.push(refs.loopId);
-        wheres.push("updated_loop_release_id = ?");
+        wheres.push('updated_loop_release_id = ?');
         params.push(refs.loopId);
     }
     if (refs.beeReleaseId !== undefined) {
-        wheres.push("created_bee_release_id = ?");
+        wheres.push('created_bee_release_id = ?');
         params.push(refs.beeReleaseId);
-        wheres.push("updated_bee_release_id = ?");
+        wheres.push('updated_bee_release_id = ?');
         params.push(refs.beeReleaseId);
     }
     if (wheres.length === 0)
         return [];
-    const whereSql = wheres.join(" OR ");
+    const whereSql = wheres.join(' OR ');
     const rows = db
         .prepare(`SELECT * FROM crystallization_event WHERE ${whereSql} ORDER BY created_at DESC`)
         .all(...params);
     return rows.map((row) => ({
         id: row.id,
         trigger: row.trigger,
-        evidence_brief: JSON.parse(String(row.evidence_brief_json ?? "{}")),
-        evidence_bullets: JSON.parse(String(row.evidence_bullets_json ?? "[]")),
-        source_trace_pointers: JSON.parse(String(row.source_trace_pointers_json ?? "[]")),
+        evidence_brief: parseJson(String(row.evidence_brief_json ?? '{}'), storedJsonObjectSchema),
+        evidence_bullets: parseJson(String(row.evidence_bullets_json ?? '[]'), storedStringListSchema),
+        source_trace_pointers: parseJson(String(row.source_trace_pointers_json ?? '[]'), storedStringListSchema),
         evaluator_summary: row.evaluator_summary,
         user_decision_summary: row.user_decision_summary,
         created_loop_release_id: row.created_loop_release_id ?? undefined,
@@ -207,7 +219,7 @@ function readEvidenceBriefsForAsset(db, refs) {
         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
     }));
 }
 /* eslint-enable @typescript-eslint/no-explicit-any */
@@ -229,30 +241,28 @@ function readEvidenceBriefsForAsset(db, refs) {
  */
 export function writeBundle(args) {
     const { db, blobsDir, outPath } = args;
-    if (args.kind === "loop") {
+    if (args.kind === 'loop') {
         return writeLoopBundle({
             db,
             blobsDir,
             loopId: String(args.id),
-            outPath,
+            outPath
         });
     }
     return writeBeeBundle({
         db,
         blobsDir,
-        beeReleaseId: typeof args.id === "number" ? args.id : Number(args.id),
-        outPath,
+        beeReleaseId: typeof args.id === 'number' ? args.id : Number(args.id),
+        outPath
     });
 }
 /* ---------------------------------------------------------------------- */
 /* Loop bundle writer                                                        */
 /* ---------------------------------------------------------------------- */
 function writeLoopBundle(args) {
-    const loopRow = args.db
-        .prepare("SELECT * FROM loop_release WHERE id = ?")
-        .get(args.loopId);
+    const loopRow = args.db.prepare('SELECT * FROM loop_release WHERE id = ?').get(args.loopId);
     if (!loopRow)
-        throw new BundleAssetNotFoundError("loop", args.loopId);
+        throw new BundleAssetNotFoundError('loop', args.loopId);
     // spec §7A.2 hard block: shareable=false blocks the export at the
     // CLI layer. We re-enforce at the writer for defense in depth.
     if (loopRow.shareable === 0) {
@@ -260,7 +270,7 @@ function writeLoopBundle(args) {
     }
     const loop = readLoopReleaseRow(args.db, args.loopId);
     if (!loop)
-        throw new BundleAssetNotFoundError("loop", args.loopId);
+        throw new BundleAssetNotFoundError('loop', args.loopId);
     const relations = readLoopBeeRelationsForLoop(args.db, args.loopId);
     const relatedBees = [];
     const blobHashes = new Set();
@@ -271,14 +281,14 @@ function writeLoopBundle(args) {
             relatedBees.push(bee);
             // Pull every content-addressed sha256 across all bee_files rows.
             for (const f of bee.files) {
-                const sha = String(f.sha256 ?? "");
+                const sha = String(f.sha256 ?? '');
                 if (sha)
                     blobHashes.add(sha);
             }
         }
     }
     const evidenceBriefs = readEvidenceBriefsForAsset(args.db, {
-        loopId: args.loopId,
+        loopId: args.loopId
     });
     const manifest = {
         format_constant: PEAKS_BUNDLE_FORMAT_CONSTANT,
@@ -288,51 +298,51 @@ function writeLoopBundle(args) {
             loop: PEAKS_BUNDLE_SCHEMA_VERSIONS.loop,
             bee: PEAKS_BUNDLE_SCHEMA_VERSIONS.bee,
             loop_bee_relation: PEAKS_BUNDLE_SCHEMA_VERSIONS.loop_bee_relation,
-            crystallization: PEAKS_BUNDLE_SCHEMA_VERSIONS.crystallization,
+            crystallization: PEAKS_BUNDLE_SCHEMA_VERSIONS.crystallization
         },
-        kind: "loop",
+        kind: 'loop',
         loop_release: loop,
         bee_release: undefined,
         related_bee_releases: relatedBees,
         loop_bee_relations: relations,
         evidence_briefs: evidenceBriefs,
         exclusion_manifest: {
-            private_run_state: "excluded",
-            personal_memory: "excluded",
-            state_db_rows: "excluded",
-        },
+            private_run_state: 'excluded',
+            personal_memory: 'excluded',
+            state_db_rows: 'excluded'
+        }
     };
     runStageTarball({
         outPath: args.outPath,
         blobsDir: args.blobsDir,
         blobHashes,
-        manifest,
+        manifest
     });
-    return { outPath: args.outPath, kind: "loop", assetId: args.loopId };
+    return { outPath: args.outPath, kind: 'loop', assetId: args.loopId };
 }
 /* ---------------------------------------------------------------------- */
 /* Bee bundle writer                                                         */
 /* ---------------------------------------------------------------------- */
 function writeBeeBundle(args) {
     const releaseRow = args.db
-        .prepare("SELECT * FROM bee_release WHERE id = ?")
+        .prepare('SELECT * FROM bee_release WHERE id = ?')
         .get(args.beeReleaseId);
     if (!releaseRow)
-        throw new BundleAssetNotFoundError("bee", args.beeReleaseId);
+        throw new BundleAssetNotFoundError('bee', args.beeReleaseId);
     // spec §7A.2 hard block: same as loop kind.
     if (releaseRow.shareable === 0) {
         throw new BundleNotShareableError(`bee_release id='${args.beeReleaseId}' has shareable=false; bundles cannot be exported for non-shareable assets (spec §7A.2)`);
     }
     const bee = readBeeReleaseBundle(args.db, args.beeReleaseId);
     if (!bee)
-        throw new BundleAssetNotFoundError("bee", args.beeReleaseId);
+        throw new BundleAssetNotFoundError('bee', args.beeReleaseId);
     const relations = readLoopBeeRelationsForBee(args.db, args.beeReleaseId);
     const evidenceBriefs = readEvidenceBriefsForAsset(args.db, {
-        beeReleaseId: args.beeReleaseId,
+        beeReleaseId: args.beeReleaseId
     });
     const blobHashes = new Set();
     for (const f of bee.files) {
-        const sha = String(f.sha256 ?? "");
+        const sha = String(f.sha256 ?? '');
         if (sha)
             blobHashes.add(sha);
     }
@@ -344,76 +354,76 @@ function writeBeeBundle(args) {
             loop: PEAKS_BUNDLE_SCHEMA_VERSIONS.loop,
             bee: PEAKS_BUNDLE_SCHEMA_VERSIONS.bee,
             loop_bee_relation: PEAKS_BUNDLE_SCHEMA_VERSIONS.loop_bee_relation,
-            crystallization: PEAKS_BUNDLE_SCHEMA_VERSIONS.crystallization,
+            crystallization: PEAKS_BUNDLE_SCHEMA_VERSIONS.crystallization
         },
-        kind: "bee",
+        kind: 'bee',
         loop_release: undefined,
         bee_release: bee,
         related_bee_releases: [],
         loop_bee_relations: relations,
         evidence_briefs: evidenceBriefs,
         exclusion_manifest: {
-            private_run_state: "excluded",
-            personal_memory: "excluded",
-            state_db_rows: "excluded",
-        },
+            private_run_state: 'excluded',
+            personal_memory: 'excluded',
+            state_db_rows: 'excluded'
+        }
     };
     runStageTarball({
         outPath: args.outPath,
         blobsDir: args.blobsDir,
         blobHashes,
-        manifest,
+        manifest
     });
-    return { outPath: args.outPath, kind: "bee", assetId: args.beeReleaseId };
+    return { outPath: args.outPath, kind: 'bee', assetId: args.beeReleaseId };
 }
 /* ---------------------------------------------------------------------- */
 /* Stage tarball — write the directory, then tar.gz it.                     */
 /* ---------------------------------------------------------------------- */
 function runStageTarball(args) {
     const { outPath, blobsDir, blobHashes, manifest } = args;
-    const stageDir = outPath + ".stage";
+    const stageDir = outPath + '.stage';
     if (existsSync(stageDir))
         rmSync(stageDir, { recursive: true, force: true });
     mkdirSync(stageDir, { recursive: true });
     let tarOk = false;
     try {
-        writeFileSync(join(stageDir, "manifest.json"), JSON.stringify(manifest, null, 2));
-        mkdirSync(join(stageDir, "evidence_briefs"), { recursive: true });
+        writeFileSync(join(stageDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+        mkdirSync(join(stageDir, 'evidence_briefs'), { recursive: true });
         for (const brief of manifest.evidence_briefs) {
             const id = String(brief.id ?? Math.random().toString(16).slice(2));
-            writeFileSync(join(stageDir, "evidence_briefs", `${id}.json`), JSON.stringify(brief, null, 2));
+            writeFileSync(join(stageDir, 'evidence_briefs', `${id}.json`), JSON.stringify(brief, null, 2));
         }
-        writeFileSync(join(stageDir, "relations.json"), JSON.stringify({
+        writeFileSync(join(stageDir, 'relations.json'), JSON.stringify({
             loop_bee_relations: manifest.loop_bee_relations,
-            related_bee_releases: manifest.related_bee_releases,
+            related_bee_releases: manifest.related_bee_releases
         }, null, 2));
         // Copy content-addressed blobs (only ones the bundle actually
         // references). The reader's blob re-materialisation
         // (see bundle-reader.ts) uses the same content-addressed
         // `blobs/<sha256>` layout as the existing SkillHub hashing.
         if (blobHashes.size > 0) {
-            mkdirSync(join(stageDir, "blobs"), { recursive: true });
+            mkdirSync(join(stageDir, 'blobs'), { recursive: true });
             for (const sha of blobHashes) {
                 const src = join(blobsDir, sha.slice(0, 2), sha);
                 if (!existsSync(src))
                     continue;
-                writeFileSync(join(stageDir, "blobs", sha), readFileSync(src));
+                writeFileSync(join(stageDir, 'blobs', sha), readFileSync(src));
             }
         }
         // Write EVALUATION_REQUIRED.md — a marker that signals the
         // receiver to run an independent evaluation before any durable
         // change. Spec §7A.2 hard rules (5th bullet).
-        writeFileSync(join(stageDir, "EVALUATION_REQUIRED.md"), [
-            "# EVALUATION_REQUIRED",
-            "",
-            "The receiver MUST run an independent evaluation before",
-            "any durable change to this loop / bee. Bundles always",
-            "import as `candidate`; promotion to `stable` requires",
-            "an `evolution_evaluation` row with an",
-            "`independent_scorer_verdict` (spec §7A.2 / §10 RL-9).",
-            "",
-        ].join("\n"));
-        runTar(["-czf", outPath, "-C", stageDir, "."]);
+        writeFileSync(join(stageDir, 'EVALUATION_REQUIRED.md'), [
+            '# EVALUATION_REQUIRED',
+            '',
+            'The receiver MUST run an independent evaluation before',
+            'any durable change to this loop / bee. Bundles always',
+            'import as `candidate`; promotion to `stable` requires',
+            'an `evolution_evaluation` row with an',
+            '`independent_scorer_verdict` (spec §7A.2 / §10 RL-9).',
+            ''
+        ].join('\n'));
+        runTar(['-czf', outPath, '-C', stageDir, '.']);
         tarOk = true;
     }
     finally {

package/dist/services/share/run-state-contract.d.ts

@@ -34,7 +34,7 @@
  * bee writes the file via the existing dispatch flow; the desktop
  * client reads via a separate channel.
  */
-import { z } from "zod";
+import { z } from 'zod';
 /**
  * The five status values an in-flight bee may report. The
  * desktop-client UI renders the status badge; only the running bee