peaks-loop 4.0.0-beta.6 → 4.0.0-beta.8

package/dist/src/services/loop/loop-bee-relation-service.js

@@ -1,211 +0,0 @@
-import { ZodError } from "zod";
-import { LoopBeeRelationSchema, } from "./loop-bee-relation-types.js";
-import { ensureLoopBeeRelationTable, insertLoopBeeRelation, listLoopBeeRelationsByLoop, listLoopBeeRelationsByBee, updateLoopBeeRelationRole, removeLoopBeeRelation, getLoopBeeRelation, } from "./loop-bee-relation-store.js";
-export class LoopBeeRelationIntegrityError extends Error {
-    code;
-    findings;
-    constructor(code, message, findings = []) {
-        super(message);
-        this.name = "LoopBeeRelationIntegrityError";
-        this.code = code;
-        this.findings = findings;
-    }
-}
-/**
- * LoopBeeRelationService — thin service over the loop_bee_relation
- * store. M2 keeps the surface narrow: create / listByLoop / listByBee /
- * updateRole / remove. Promotion, evaluation, and crystallization
- * flows land in later slices.
- *
- * Integrity rules enforced here (spec §4.6 + RL-3):
- *
- *   1. The referenced loop_release row must exist (FK to loop_release.id).
- *      — enforced at DB level (FK constraint).
- *      — surfaced as FK_LOOP_NOT_FOUND for friendlier errors.
- *
- *   2. The referenced bee_release row must exist (FK to bee_release.id).
- *      — enforced at DB level (FK constraint).
- *      — surfaced as FK_BEE_NOT_FOUND for friendlier errors.
- *
- *   3. Cannot relate a bee to a retired loop.
- *      — enforced in service by checking loop_release.lifecycle_status.
- *      — Throws LoopBeeRelationIntegrityError(LOOP_RETIRED).
- *
- *   4. A loop cannot have two `main` bees.
- *      — enforced at DB level via partial unique index.
- *      — surfaced as TWO_MAIN_BEES for friendlier errors.
- *
- *   5. (loop_release_id, bee_release_id) must be unique per row.
- *      — enforced at DB level (UNIQUE).
- *      — surfaced as DUP_RELATION for friendlier errors.
- *
- * The constructor takes an open better-sqlite3 database (the existing
- * `peaks state` boundary) so callers do not have to thread a path
- * through this layer; this matches the LoopReleaseService pattern.
- *
- * All write paths re-validate the input via the Zod schema, mirroring
- * the boundary-check discipline used elsewhere.
- */
-export class LoopBeeRelationService {
-    db;
-    constructor(db) {
-        this.db = db;
-        // Idempotent — safe to call on every constructor invocation; the
-        // openStateDb pipeline already applied the SQL migration, but a
-        // caller-built DB (e.g. tests) needs this.
-        ensureLoopBeeRelationTable(this.db);
-    }
-    /**
-     * Persist a new LoopBeeRelation row.
-     *
-     * Throws:
-     *   - ZodError if the input fails schema validation.
-     *   - LoopBeeRelationIntegrityError(LOOP_RETIRED) if the loop's
-     *     lifecycle_status is "retired".
-     *   - LoopBeeRelationIntegrityError(FK_LOOP_NOT_FOUND) if the loop
-     *     row does not exist.
-     *   - LoopBeeRelationIntegrityError(FK_BEE_NOT_FOUND) if the bee
-     *     row does not exist.
-     *   - LoopBeeRelationIntegrityError(DUP_RELATION) if a relation
-     *     for the same (loop, bee) already exists.
-     *   - LoopBeeRelationIntegrityError(TWO_MAIN_BEES) if a `main` row
-     *     already exists for the loop.
-     */
-    create(input) {
-        const parsed = LoopBeeRelationSchema.omit({
-            id: true,
-            created_at: true,
-        }).parse(input);
-        // (a) Verify the loop_release row exists and is not retired.
-        const loopRow = this.db
-            .prepare("SELECT lifecycle_status FROM loop_release WHERE id = ?")
-            .get(parsed.loop_release_id);
-        if (!loopRow) {
-            throw new LoopBeeRelationIntegrityError("FK_LOOP_NOT_FOUND", `loop_release row '${parsed.loop_release_id}' does not exist`, [{ path: "loop_release_id", message: "loop_release row not found" }]);
-        }
-        if (loopRow.lifecycle_status === "retired") {
-            throw new LoopBeeRelationIntegrityError("LOOP_RETIRED", `cannot relate bee to retired loop '${parsed.loop_release_id}'`, [
-                {
-                    path: "loop_release_id",
-                    message: "loop_release.lifecycle_status is 'retired'; retirement severs new relations",
-                },
-            ]);
-        }
-        // (b) Verify the bee_release row exists.
-        const beeRow = this.db
-            .prepare("SELECT id FROM bee_release WHERE id = ?")
-            .get(parsed.bee_release_id);
-        if (!beeRow) {
-            throw new LoopBeeRelationIntegrityError("FK_BEE_NOT_FOUND", `bee_release row ${parsed.bee_release_id} does not exist`, [
-                {
-                    path: "bee_release_id",
-                    message: "bee_release row not found",
-                },
-            ]);
-        }
-        // (c) Insert; the storage-layer partial unique index will raise
-        // SQLITE_CONSTRAINT if (a) another `main` row exists for this
-        // loop, or (b) the same (loop, bee) pair already exists. Map those
-        // to friendly error codes.
-        try {
-            return insertLoopBeeRelation(this.db, parsed);
-        }
-        catch (err) {
-            const code = typeof err === "object" && err !== null && "code" in err
-                ? err.code
-                : undefined;
-            // Partial unique index on (loop_release_id) WHERE role='main'.
-            // better-sqlite3 surfaces this as SQLITE_CONSTRAINT_UNIQUE with
-            // a message naming only `loop_bee_relation.loop_release_id`
-            // (the column the partial index covers), NOT the index name.
-            // It is distinguished from the (loop_release_id, bee_release_id)
-            // composite UNIQUE violation by the absence of bee_release_id
-            // in the message.
-            if (code === "SQLITE_CONSTRAINT_UNIQUE") {
-                const msg = err instanceof Error ? err.message : String(err);
-                if (msg.includes("loop_bee_relation.bee_release_id")) {
-                    // Composite UNIQUE(loop_release_id, bee_release_id).
-                    throw new LoopBeeRelationIntegrityError("DUP_RELATION", `relation between loop '${parsed.loop_release_id}' and bee ${parsed.bee_release_id} already exists`, [
-                        {
-                            path: "loop_release_id,bee_release_id",
-                            message: "duplicate relation",
-                        },
-                    ]);
-                }
-                // Otherwise: partial unique index on (loop_release_id) WHERE role='main'.
-                throw new LoopBeeRelationIntegrityError("TWO_MAIN_BEES", `loop '${parsed.loop_release_id}' already has a main bee`, [
-                    {
-                        path: "role",
-                        message: "at most one main bee per loop; promote / retire the existing main first",
-                    },
-                ]);
-            }
-            // FK violations from better-sqlite3 (foreign_keys = ON).
-            if (code === "SQLITE_CONSTRAINT_FOREIGNKEY") {
-                // Distinguish by re-checking which row is missing; the friendly
-                // pre-check above should have caught these, but defense in depth.
-                const loopStill = this.db
-                    .prepare("SELECT 1 FROM loop_release WHERE id = ?")
-                    .get(parsed.loop_release_id);
-                if (!loopStill) {
-                    throw new LoopBeeRelationIntegrityError("FK_LOOP_NOT_FOUND", `loop_release row '${parsed.loop_release_id}' does not exist`, [{ path: "loop_release_id", message: "FK violation" }]);
-                }
-                throw new LoopBeeRelationIntegrityError("FK_BEE_NOT_FOUND", `bee_release row ${parsed.bee_release_id} does not exist`, [{ path: "bee_release_id", message: "FK violation" }]);
-            }
-            // Re-throw unexpected errors unchanged.
-            throw err;
-        }
-    }
-    /** Read a LoopBeeRelation row by id; returns undefined if absent. */
-    read(id) {
-        return getLoopBeeRelation(this.db, id);
-    }
-    /**
-     * List relations for a given loop. Filter by `role` when supplied.
-     */
-    listByLoop(opts) {
-        return listLoopBeeRelationsByLoop(this.db, opts.loop_release_id, opts.role);
-    }
-    /**
-     * List relations for a given bee. Filter by `role` when supplied.
-     */
-    listByBee(opts) {
-        return listLoopBeeRelationsByBee(this.db, opts.bee_release_id, opts.role);
-    }
-    /**
-     * Update the role of an existing relation. The storage-level partial
-     * unique index on `main` re-asserts "at most one main per loop" if
-     * the new role is `main`. Returns the updated row or undefined if
-     * the id is absent.
-     */
-    updateRole(id, newRole) {
-        // The TS type already enforces the four-value union. Try update;
-        // if partial unique index trips, raise friendly error.
-        try {
-            return updateLoopBeeRelationRole(this.db, id, newRole);
-        }
-        catch (err) {
-            const code = typeof err === "object" && err !== null && "code" in err
-                ? err.code
-                : undefined;
-            if (code === "SQLITE_CONSTRAINT_UNIQUE") {
-                const existing = getLoopBeeRelation(this.db, id);
-                const loopId = existing?.loop_release_id ?? "<unknown>";
-                throw new LoopBeeRelationIntegrityError("TWO_MAIN_BEES", `loop '${loopId}' already has a main bee`, [{ path: "role", message: "at most one main bee per loop" }]);
-            }
-            throw err;
-        }
-    }
-    /** Remove a relation by id. Returns true if a row was deleted. */
-    remove(id) {
-        return removeLoopBeeRelation(this.db, id);
-    }
-}
-/**
- * Convenience: re-export the Zod error class guard so callers can do
- * `if (err instanceof ZodError)`. Avoids forcing every caller to import
- * zod directly.
- */
-export function isZodError(err) {
-    return err instanceof ZodError;
-}

package/dist/src/services/loop/loop-bee-relation-store.d.ts

@@ -1,53 +0,0 @@
-import type Database from "better-sqlite3";
-import type { LoopBeeRelation, LoopBeeRelationRole } from "./loop-bee-relation-types.js";
-/**
- * Low-level SQLite access for the `loop_bee_relation` table. The
- * migration is registered with the existing `openStateDb()` pipeline
- * via `src/services/skillhub/migrations/003-loop-bee-relation.sql`
- * (it applies every `*.sql` file in lexicographic order). The function
- * `ensureLoopBeeRelationTable` below is a belt-and-suspenders re-applier
- * for callers that pass a database they built themselves (e.g. tests).
- *
- * Defense in depth:
- *   - FK constraints enforce loop_release and bee_release referential
- *     integrity (better-sqlite3 + foreign_keys = ON).
- *   - Partial unique index `WHERE role = 'main'` enforces "at most one
- *     main bee per loop" at the storage layer (the service layer adds
- *     a friendlier error path on top).
- *   - UNIQUE (loop_release_id, bee_release_id) prevents accidental
- *     duplicate relations between the same loop and same bee release.
- *   - The migration does NOT touch any 4.x `bee_release` column (AC-3).
- *   - Lifecycle_status check on loop_release is NOT a DB-level constraint
- *     (the retirement rule is enforced in the service layer — see
- *     `LoopBeeRelationService.create`) so the DB stays decoupled from
- *     cross-table policies that need richer error reporting.
- */
-/**
- * Re-apply the loop_bee_relation table migration against an already-open
- * database. Used by tests that build their own DB without the
- * openStateDb pipeline. Idempotent.
- */
-export declare function ensureLoopBeeRelationTable(db: Database.Database): void;
-/**
- * Insert a LoopBeeRelation row. The row's `schema_version` is taken from
- * the input (must equal `peaks.loop-bee-relation/1`); `id` and
- * `created_at` are stamped here, so callers cannot backdate a row.
- *
- * Idempotent in the UNIQUE sense — re-inserting the same
- * (loop_release_id, bee_release_id) pair throws a UNIQUE-constraint
- * error; inserting two `main` rows for the same loop throws a partial
- * unique index error.
- *
- * Returns the persisted row (with `id` filled in).
- */
-export declare function insertLoopBeeRelation(db: Database.Database, row: Omit<LoopBeeRelation, "id" | "created_at">): LoopBeeRelation;
-/** Read a single LoopBeeRelation row by id; returns undefined if absent. */
-export declare function getLoopBeeRelation(db: Database.Database, id: number): LoopBeeRelation | undefined;
-/** List LoopBeeRelation rows for a given loop_release_id (optionally filtered by role). */
-export declare function listLoopBeeRelationsByLoop(db: Database.Database, loop_release_id: string, role?: LoopBeeRelationRole): LoopBeeRelation[];
-/** List LoopBeeRelation rows for a given bee_release_id (optionally filtered by role). */
-export declare function listLoopBeeRelationsByBee(db: Database.Database, bee_release_id: number, role?: LoopBeeRelationRole): LoopBeeRelation[];
-/** Update the role of an existing relation. Returns the new row, or undefined if absent. */
-export declare function updateLoopBeeRelationRole(db: Database.Database, id: number, newRole: LoopBeeRelationRole): LoopBeeRelation | undefined;
-/** Remove a LoopBeeRelation row by id. Returns true if a row was deleted. */
-export declare function removeLoopBeeRelation(db: Database.Database, id: number): boolean;

package/dist/src/services/loop/loop-bee-relation-store.js

@@ -1,130 +0,0 @@
-/**
- * Low-level SQLite access for the `loop_bee_relation` table. The
- * migration is registered with the existing `openStateDb()` pipeline
- * via `src/services/skillhub/migrations/003-loop-bee-relation.sql`
- * (it applies every `*.sql` file in lexicographic order). The function
- * `ensureLoopBeeRelationTable` below is a belt-and-suspenders re-applier
- * for callers that pass a database they built themselves (e.g. tests).
- *
- * Defense in depth:
- *   - FK constraints enforce loop_release and bee_release referential
- *     integrity (better-sqlite3 + foreign_keys = ON).
- *   - Partial unique index `WHERE role = 'main'` enforces "at most one
- *     main bee per loop" at the storage layer (the service layer adds
- *     a friendlier error path on top).
- *   - UNIQUE (loop_release_id, bee_release_id) prevents accidental
- *     duplicate relations between the same loop and same bee release.
- *   - The migration does NOT touch any 4.x `bee_release` column (AC-3).
- *   - Lifecycle_status check on loop_release is NOT a DB-level constraint
- *     (the retirement rule is enforced in the service layer — see
- *     `LoopBeeRelationService.create`) so the DB stays decoupled from
- *     cross-table policies that need richer error reporting.
- */
-/**
- * Re-apply the loop_bee_relation table migration against an already-open
- * database. Used by tests that build their own DB without the
- * openStateDb pipeline. Idempotent.
- */
-export function ensureLoopBeeRelationTable(db) {
-    db.exec(`
-    CREATE TABLE IF NOT EXISTS loop_bee_relation (
-      id                INTEGER PRIMARY KEY AUTOINCREMENT,
-      loop_release_id   TEXT NOT NULL REFERENCES loop_release(id) ON DELETE CASCADE,
-      bee_release_id    INTEGER NOT NULL REFERENCES bee_release(id) ON DELETE CASCADE,
-      role              TEXT NOT NULL CHECK (role IN ('main','supporting','candidate','retired')),
-      reason            TEXT NOT NULL,
-      schema_version    TEXT NOT NULL CHECK (schema_version = 'peaks.loop-bee-relation/1'),
-      created_at        TEXT NOT NULL,
-      UNIQUE(loop_release_id, bee_release_id)
-    );
-    CREATE INDEX IF NOT EXISTS idx_loop_bee_relation_loop_id ON loop_bee_relation(loop_release_id);
-    CREATE INDEX IF NOT EXISTS idx_loop_bee_relation_bee_id ON loop_bee_relation(bee_release_id);
-    CREATE INDEX IF NOT EXISTS idx_loop_bee_relation_loop_role ON loop_bee_relation(loop_release_id, role);
-    -- Partial unique index: at most one main bee per loop. SQLite supports
-    -- partial indexes; this is the storage-level enforcement of the
-    -- "exactly one main" invariant. Multiple supporting / candidate /
-    -- retired rows per loop remain allowed.
-    CREATE UNIQUE INDEX IF NOT EXISTS idx_loop_bee_relation_one_main_per_loop
-      ON loop_bee_relation(loop_release_id) WHERE role = 'main';
-  `);
-}
-function rowToLoopBeeRelation(row) {
-    return {
-        id: row.id,
-        loop_release_id: row.loop_release_id,
-        bee_release_id: row.bee_release_id,
-        role: row.role,
-        reason: row.reason,
-        schema_version: row.schema_version,
-        created_at: row.created_at,
-    };
-}
-/**
- * Insert a LoopBeeRelation row. The row's `schema_version` is taken from
- * the input (must equal `peaks.loop-bee-relation/1`); `id` and
- * `created_at` are stamped here, so callers cannot backdate a row.
- *
- * Idempotent in the UNIQUE sense — re-inserting the same
- * (loop_release_id, bee_release_id) pair throws a UNIQUE-constraint
- * error; inserting two `main` rows for the same loop throws a partial
- * unique index error.
- *
- * Returns the persisted row (with `id` filled in).
- */
-export function insertLoopBeeRelation(db, row) {
-    const createdAt = new Date().toISOString();
-    const stmt = db.prepare(`INSERT INTO loop_bee_relation (
-       loop_release_id, bee_release_id, role, reason, schema_version, created_at
-     ) VALUES (?, ?, ?, ?, ?, ?)`);
-    const info = stmt.run(row.loop_release_id, row.bee_release_id, row.role, row.reason, row.schema_version, createdAt);
-    return {
-        id: Number(info.lastInsertRowid),
-        loop_release_id: row.loop_release_id,
-        bee_release_id: row.bee_release_id,
-        role: row.role,
-        reason: row.reason,
-        schema_version: row.schema_version,
-        created_at: createdAt,
-    };
-}
-/** Read a single LoopBeeRelation row by id; returns undefined if absent. */
-export function getLoopBeeRelation(db, id) {
-    const row = db
-        .prepare("SELECT * FROM loop_bee_relation WHERE id = ?")
-        .get(id);
-    if (!row)
-        return undefined;
-    return rowToLoopBeeRelation(row);
-}
-/** List LoopBeeRelation rows for a given loop_release_id (optionally filtered by role). */
-export function listLoopBeeRelationsByLoop(db, loop_release_id, role) {
-    const sql = role === undefined
-        ? "SELECT * FROM loop_bee_relation WHERE loop_release_id = ? ORDER BY id ASC"
-        : "SELECT * FROM loop_bee_relation WHERE loop_release_id = ? AND role = ? ORDER BY id ASC";
-    const params = role === undefined ? [loop_release_id] : [loop_release_id, role];
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(rowToLoopBeeRelation);
-}
-/** List LoopBeeRelation rows for a given bee_release_id (optionally filtered by role). */
-export function listLoopBeeRelationsByBee(db, bee_release_id, role) {
-    const sql = role === undefined
-        ? "SELECT * FROM loop_bee_relation WHERE bee_release_id = ? ORDER BY id ASC"
-        : "SELECT * FROM loop_bee_relation WHERE bee_release_id = ? AND role = ? ORDER BY id ASC";
-    const params = role === undefined ? [bee_release_id] : [bee_release_id, role];
-    const rows = db.prepare(sql).all(...params);
-    return rows.map(rowToLoopBeeRelation);
-}
-/** Update the role of an existing relation. Returns the new row, or undefined if absent. */
-export function updateLoopBeeRelationRole(db, id, newRole) {
-    const stmt = db.prepare("UPDATE loop_bee_relation SET role = ? WHERE id = ?");
-    const info = stmt.run(newRole, id);
-    if (info.changes === 0)
-        return undefined;
-    return getLoopBeeRelation(db, id);
-}
-/** Remove a LoopBeeRelation row by id. Returns true if a row was deleted. */
-export function removeLoopBeeRelation(db, id) {
-    const stmt = db.prepare("DELETE FROM loop_bee_relation WHERE id = ?");
-    const info = stmt.run(id);
-    return info.changes > 0;
-}

package/dist/src/services/loop/loop-bee-relation-types.d.ts

@@ -1,118 +0,0 @@
-import { z } from "zod";
-/**
- * LoopBeeRelation — spec §4.6.
- *
- * The loop↔bee coupling row. M2 scope:
- *   - four roles: main / supporting / candidate / retired.
- *   - exactly one main per loop (enforced by partial unique index + service).
- *   - FK to loop_release (TEXT id) and bee_release (INTEGER id).
- *   - cannot link to a retired loop (enforced in service).
- *
- * Out of scope (deferred to later slices):
- *   - share/desktop fields on the relation itself (none in spec §4.6).
- *   - evolution evidence references (M4).
- *
- * Field semantics — see the spec for full prose. Highlights:
- *
- *   - `id` is the autoincrement row id; storage key.
- *   - `loop_release_id` is the FK to loop_release.id (TEXT).
- *   - `bee_release_id` is the FK to bee_release.id (INTEGER). Note that
- *     `bee_release.id` is an autoincrement INTEGER (not bee_name) — this
- *     matches the existing 4.x schema convention used by bee_manifest,
- *     bee_segment_ref, bee_file, bee_change.
- *   - `role` is the four-value union. A loop can have at most one `main`
- *     row; multiple supporting / candidate / retired rows are allowed.
- *   - `reason` is an NL string the LLM authors at crystallization time
- *     (e.g. "primary bee — implements the loop's success_criteria").
- *   - `created_at` is server-stamped from the system clock; the input
- *     schema does not let clients supply it (would be a backdate hole).
- */
-export declare const LoopBeeRelationRoleSchema: z.ZodEnum<["main", "supporting", "candidate", "retired"]>;
-export type LoopBeeRelationRole = z.infer<typeof LoopBeeRelationRoleSchema>;
-export declare const LOOP_BEE_RELATION_ROLES: readonly LoopBeeRelationRole[];
-/**
- * Zod schema for the create payload (LoopBeeRelationInput).
- *
- * `loop_release_id` must match the same kebab-case pattern as
- * `LoopRelease.id` — this is a defensive duplicate of the FK target's
- * shape, but the authoritative check is the FK constraint at insert
- * time (better-sqlite3 with `foreign_keys = ON`).
- *
- * `bee_release_id` is a positive integer; matching the
- * `bee_release.id` autoincrement INTEGER PK.
- */
-export declare const LoopBeeRelationInputSchema: z.ZodObject<{
-    loop_release_id: z.ZodString;
-    bee_release_id: z.ZodNumber;
-    role: z.ZodEnum<["main", "supporting", "candidate", "retired"]>;
-    reason: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
-    bee_release_id: number;
-    loop_release_id: string;
-}, {
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
-    bee_release_id: number;
-    loop_release_id: string;
-}>;
-export type LoopBeeRelationInput = z.input<typeof LoopBeeRelationInputSchema>;
-/**
- * Full Zod schema for a LoopBeeRelation row as persisted. Differs from
- * the input schema only in that `schema_version` is exposed (and
- * defaulted to the fixed literal). The literal constraint still rejects
- * any client-supplied value other than `"peaks.loop-bee-relation/1"`;
- * the default means omitting the key is fine and the output always
- * carries the constant.
- *
- * We expose this as the canonical "row schema" used by service.create /
- * read paths.
- */
-export declare const LoopBeeRelationSchema: z.ZodObject<{
-    loop_release_id: z.ZodString;
-    bee_release_id: z.ZodNumber;
-    role: z.ZodEnum<["main", "supporting", "candidate", "retired"]>;
-    reason: z.ZodString;
-} & {
-    id: z.ZodNumber;
-    schema_version: z.ZodDefault<z.ZodLiteral<"peaks.loop-bee-relation/1">>;
-    created_at: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    schema_version: "peaks.loop-bee-relation/1";
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
-    id: number;
-    created_at: string;
-    bee_release_id: number;
-    loop_release_id: string;
-}, {
-    role: "main" | "candidate" | "retired" | "supporting";
-    reason: string;
-    id: number;
-    created_at: string;
-    bee_release_id: number;
-    loop_release_id: string;
-    schema_version?: "peaks.loop-bee-relation/1" | undefined;
-}>;
-export type LoopBeeRelation = z.infer<typeof LoopBeeRelationSchema>;
-/**
- * Convenience: strict-parse an unknown payload into a LoopBeeRelation
- * row. Throws ZodError on failure. This is the public validation
- * boundary.
- */
-export declare function parseLoopBeeRelation(input: unknown): LoopBeeRelation;
-/**
- * Convenience: safe-parse that returns a Result-like shape so callers
- * can render findings without try/catch noise.
- */
-export declare function safeParseLoopBeeRelation(input: unknown): {
-    ok: true;
-    row: LoopBeeRelation;
-} | {
-    ok: false;
-    findings: Array<{
-        path: string;
-        message: string;
-    }>;
-};

package/dist/src/services/loop/loop-bee-relation-types.js

@@ -1,114 +0,0 @@
-import { z } from "zod";
-/**
- * LoopBeeRelation — spec §4.6.
- *
- * The loop↔bee coupling row. M2 scope:
- *   - four roles: main / supporting / candidate / retired.
- *   - exactly one main per loop (enforced by partial unique index + service).
- *   - FK to loop_release (TEXT id) and bee_release (INTEGER id).
- *   - cannot link to a retired loop (enforced in service).
- *
- * Out of scope (deferred to later slices):
- *   - share/desktop fields on the relation itself (none in spec §4.6).
- *   - evolution evidence references (M4).
- *
- * Field semantics — see the spec for full prose. Highlights:
- *
- *   - `id` is the autoincrement row id; storage key.
- *   - `loop_release_id` is the FK to loop_release.id (TEXT).
- *   - `bee_release_id` is the FK to bee_release.id (INTEGER). Note that
- *     `bee_release.id` is an autoincrement INTEGER (not bee_name) — this
- *     matches the existing 4.x schema convention used by bee_manifest,
- *     bee_segment_ref, bee_file, bee_change.
- *   - `role` is the four-value union. A loop can have at most one `main`
- *     row; multiple supporting / candidate / retired rows are allowed.
- *   - `reason` is an NL string the LLM authors at crystallization time
- *     (e.g. "primary bee — implements the loop's success_criteria").
- *   - `created_at` is server-stamped from the system clock; the input
- *     schema does not let clients supply it (would be a backdate hole).
- */
-export const LoopBeeRelationRoleSchema = z.enum([
-    "main",
-    "supporting",
-    "candidate",
-    "retired",
-]);
-export const LOOP_BEE_RELATION_ROLES = [
-    "main",
-    "supporting",
-    "candidate",
-    "retired",
-];
-/**
- * Zod schema for the create payload (LoopBeeRelationInput).
- *
- * `loop_release_id` must match the same kebab-case pattern as
- * `LoopRelease.id` — this is a defensive duplicate of the FK target's
- * shape, but the authoritative check is the FK constraint at insert
- * time (better-sqlite3 with `foreign_keys = ON`).
- *
- * `bee_release_id` is a positive integer; matching the
- * `bee_release.id` autoincrement INTEGER PK.
- */
-export const LoopBeeRelationInputSchema = z.object({
-    loop_release_id: z
-        .string()
-        .min(1)
-        .max(64)
-        .regex(/^[a-z][a-z0-9]*(-[a-z0-9]+)*$/, {
-        message: "loop_release_id must be kebab-case starting with a lowercase letter",
-    }),
-    bee_release_id: z
-        .number()
-        .int()
-        .positive()
-        .max(2 ** 31 - 1, "bee_release_id out of 32-bit range"),
-    role: LoopBeeRelationRoleSchema,
-    reason: z
-        .string()
-        .trim()
-        .min(1, "reason is required (LLM-authored NL explanation)")
-        .max(2000),
-});
-/**
- * Full Zod schema for a LoopBeeRelation row as persisted. Differs from
- * the input schema only in that `schema_version` is exposed (and
- * defaulted to the fixed literal). The literal constraint still rejects
- * any client-supplied value other than `"peaks.loop-bee-relation/1"`;
- * the default means omitting the key is fine and the output always
- * carries the constant.
- *
- * We expose this as the canonical "row schema" used by service.create /
- * read paths.
- */
-export const LoopBeeRelationSchema = LoopBeeRelationInputSchema.extend({
-    id: z.number().int().positive(),
-    schema_version: z
-        .literal("peaks.loop-bee-relation/1")
-        .default("peaks.loop-bee-relation/1"),
-    created_at: z.string().datetime(),
-});
-/**
- * Convenience: strict-parse an unknown payload into a LoopBeeRelation
- * row. Throws ZodError on failure. This is the public validation
- * boundary.
- */
-export function parseLoopBeeRelation(input) {
-    return LoopBeeRelationSchema.parse(input);
-}
-/**
- * Convenience: safe-parse that returns a Result-like shape so callers
- * can render findings without try/catch noise.
- */
-export function safeParseLoopBeeRelation(input) {
-    const r = LoopBeeRelationSchema.safeParse(input);
-    if (r.success)
-        return { ok: true, row: r.data };
-    return {
-        ok: false,
-        findings: r.error.issues.map((i) => ({
-            path: i.path.join("."),
-            message: i.message,
-        })),
-    };
-}

package/dist/src/services/loop/loop-release-service.d.ts

@@ -1,46 +0,0 @@
-import type Database from "better-sqlite3";
-import { type LoopRelease, type LoopReleaseInput, type LoopReleaseLifecycleStatus } from "./loop-release-types.js";
-/**
- * Thin service wrapper around the loop_release store. M1 keeps the
- * surface tiny on purpose: create / read / list / search. Promotion,
- * retirement, evaluation, and the `loop_bee_relation` joins are
- * deliberately deferred to M2 / M4 / M5 — shipping them here would
- * lock in an interface that the ratchet has not yet ratified.
- *
- * The constructor takes an open better-sqlite3 database (the existing
- * `peaks state` boundary) so callers do not have to thread a path
- * through this layer; this matches the `retainRelease` pattern in
- * `src/services/skillhub/release-retain.ts`.
- *
- * All write paths re-validate the input via the Zod schema, mirroring
- * the boundary-check discipline used elsewhere (e.g.
- * `lintManifestStrict` in `src/services/sediment/manifest-lint.ts`).
- */
-export declare class LoopReleaseService {
-    private readonly db;
-    constructor(db: Database.Database);
-    /**
-     * Persist a new LoopRelease row. Re-validates the input via the
-     * Zod schema; throws ZodError on failure.
-     */
-    create(input: LoopReleaseInput): LoopRelease;
-    /** Read a LoopRelease row by id; returns undefined if absent. */
-    read(id: string): LoopRelease | undefined;
-    /**
-     * List LoopRelease rows. Filter by `status` when supplied; without
-     * it, returns ALL rows (across `candidate` / `stable` / `retired`).
-     * Sort is newest-first by `archived_at`.
-     */
-    list(opts?: {
-        status?: LoopReleaseLifecycleStatus;
-    }): LoopRelease[];
-    /**
-     * Search LoopRelease rows whose `scenario` contains the query
-     * string (case-insensitive substring match via LIKE). Filter by
-     * `status` to scope the search.
-     */
-    search(opts: {
-        query: string;
-        status?: LoopReleaseLifecycleStatus;
-    }): LoopRelease[];
-}