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

package/dist/src/services/loop/evaluator-dispatcher.js

@@ -1,552 +0,0 @@
-/**
- * peaks-loop v3.0.0 — Slice B.1
- *
- * Evaluator-as-primitive dispatcher. Each of the 4 evaluator types
- * (karpathy / code-review / security-review / perf-baseline) maps to
- * an existing peaks-loop CLI surface; the dispatcher shells out to the
- * same binary so verdict shape stays byte-compatible with the
- * `verdict-aggregator` envelope union (`karpathy` / `security` / `perf`).
- *
- * Karpathy §2 Simplicity First: no new dependencies, no LLM scheduling,
- * one binary per evaluator. Each evaluator returns the same envelope
- * shape the existing reviewer fan-out produces; verdict-aggregator
- * accepts them via `envelopesToAggregatorInput` unchanged (BC).
- *
- * File budget: ≤ 800 lines.
- */
-import { execFileSync } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { runMonotonicCheck } from './monotonic-runner.js';
-/** Dispatch a single evaluator against the given rid and project. */
-export function dispatchEvaluator(kind, options) {
-    const started = Date.now();
-    switch (kind) {
-        case 'karpathy':
-            return dispatchKarpathy(options, started);
-        case 'code-review':
-            return dispatchCodeReview(options, started);
-        case 'security-review':
-            return dispatchSecurityReview(options, started);
-        case 'perf-baseline':
-            return dispatchPerfBaseline(options, started);
-        case 'verdict-aggregate':
-            return dispatchVerdictAggregate(options, started);
-        case 'monotonic-improvement':
-            return dispatchMonotonicImprovement(options, started);
-        case 'impact-scan':
-            return dispatchImpactScan(options, started);
-        case 'smoke-run':
-            return dispatchSmokeRun(options, started);
-        case 'canary-watch':
-            return dispatchCanaryWatch(options, started);
-        default: {
-            // Exhaustiveness guard.
-            const exhaustive = kind;
-            throw new Error(`dispatchEvaluator: unknown evaluator kind ${String(exhaustive)}`);
-        }
-    }
-}
-function peaksCommand(opts) {
-    if (opts.peaksBin !== undefined) {
-        // Already a full command (e.g. `node bin/peaks.js` or `/usr/local/bin/peaks`).
-        return [opts.peaksBin];
-    }
-    return ['node', 'bin/peaks.js'];
-}
-function execPeaks(args, cwd, peaksBin) {
-    try {
-        const cmd = peaksCommand({ projectRoot: cwd, rid: '', ...(peaksBin !== undefined ? { peaksBin } : {}) });
-        const stdout = execFileSync(cmd[0], [...cmd.slice(1), ...args], {
-            cwd,
-            stdio: ['ignore', 'pipe', 'ignore'],
-            encoding: 'utf8'
-        });
-        return { stdout, exitCode: 0 };
-    }
-    catch (error) {
-        // Surface the error envelope as stdout so the dispatcher can still
-        // parse it; treat non-zero exit as a degraded verdict (not a hard
-        // throw — evaluators must always return an envelope).
-        const err = error;
-        return {
-            stdout: typeof err.stdout === 'string' ? err.stdout : Buffer.isBuffer(err.stdout) ? err.stdout.toString('utf8') : '',
-            exitCode: typeof err.status === 'number' ? err.status : 1
-        };
-    }
-}
-function dispatchKarpathy(opts, started) {
-    const args = [
-        'code-review',
-        'karpathy',
-        '--project', opts.projectRoot,
-        '--rid', opts.rid,
-        '--json'
-    ];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseKarpathyEnvelope(stdout, exitCode, started);
-}
-function dispatchCodeReview(opts, started) {
-    const args = [
-        'code-review',
-        'run',
-        '--project', opts.projectRoot,
-        '--rid', opts.rid,
-        '--json'
-    ];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseCodeReviewEnvelope(stdout, exitCode, started);
-}
-function dispatchSecurityReview(opts, started) {
-    const args = [
-        'security-audit',
-        'run',
-        '--project', opts.projectRoot,
-        '--rid', opts.rid,
-        '--json'
-    ];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseSecurityEnvelope(stdout, exitCode, started);
-}
-function dispatchPerfBaseline(opts, started) {
-    const args = [
-        'perf-audit',
-        'run',
-        '--project', opts.projectRoot,
-        '--rid', opts.rid,
-        '--json'
-    ];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parsePerfEnvelope(stdout, exitCode, started);
-}
-function dispatchVerdictAggregate(opts, started) {
-    const args = [
-        'verdict',
-        'aggregate',
-        '--from-rid', opts.rid,
-        '--project', opts.projectRoot,
-        '--json'
-    ];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseVerdictAggregateEnvelope(stdout, exitCode, started);
-}
-function dispatchImpactScan(opts, started) {
-    // `peaks impact scan --files <list>` requires a comma-separated file
-    // list. From the loop dispatcher we forward `scope` (which is the
-    // evaluator scope expression) as the file list when present; when
-    // absent we degrade to a warn envelope (sketch-grade acceptance).
-    const files = opts.scope && opts.scope.length > 0 ? opts.scope : '';
-    if (files.length === 0) {
-        const wall = (Date.now() - started) / 1000;
-        return {
-            kind: 'impact-scan',
-            passed: false,
-            gateAction: 'warn',
-            violations: [{
-                    severity: 'MED',
-                    file: '<loop>',
-                    line: 0,
-                    hint: 'impact-scan dispatcher requires scope (a comma-separated file list); set the evaluator scope on the workflow yaml'
-                }],
-            summary: 'impact-scan: missing scope/files',
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const args = ['impact', 'scan', '--files', files, '--project', opts.projectRoot, '--json'];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseGenericEnvelope(stdout, exitCode, started, 'impact-scan', 'impact-scan: ');
-}
-function dispatchSmokeRun(opts, started) {
-    // `peaks smoke run` is a no-op recorder (returns a dry summary by
-    // default). Pure sketch-grade surface.
-    const args = ['smoke', 'run', '--project', opts.projectRoot, '--json'];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseGenericEnvelope(stdout, exitCode, started, 'smoke-run', 'smoke-run: ');
-}
-function dispatchCanaryWatch(opts, started) {
-    // `peaks release canary --version <v>` requires a version label. We
-    // forward `scope` when supplied (interpreted as the canary version),
-    // otherwise degrade to a warn envelope (sketch-grade acceptance).
-    const version = opts.scope && opts.scope.length > 0 ? opts.scope : '';
-    if (version.length === 0) {
-        const wall = (Date.now() - started) / 1000;
-        return {
-            kind: 'canary-watch',
-            passed: false,
-            gateAction: 'warn',
-            violations: [{
-                    severity: 'MED',
-                    file: '<loop>',
-                    line: 0,
-                    hint: 'canary-watch dispatcher requires scope (the canary version label); set the evaluator scope on the workflow yaml'
-                }],
-            summary: 'canary-watch: missing version',
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const args = ['release', 'canary', '--version', version, '--project', opts.projectRoot, '--json'];
-    const { stdout, exitCode } = execPeaks(args, opts.projectRoot, opts.peaksBin);
-    return parseGenericEnvelope(stdout, exitCode, started, 'canary-watch', 'canary-watch: ');
-}
-/** Generic envelope parser for the 3 G13/G14/G15 sketch-grade evaluators
- *  — they share shape (data.ok + data.count + data.summary). */
-function parseGenericEnvelope(stdout, exitCode, started, kind, summaryPrefix) {
-    const wall = (Date.now() - started) / 1000;
-    const parsed = safeJson(stdout);
-    if (!parsed.ok) {
-        return {
-            kind,
-            passed: exitCode === 0,
-            gateAction: exitCode === 0 ? 'pass' : 'warn',
-            violations: [],
-            summary: stdout.slice(0, 200),
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const obj = parsed.value;
-    const data = (obj['data'] ?? obj);
-    return {
-        kind,
-        passed: exitCode === 0,
-        gateAction: exitCode === 0 ? 'pass' : 'warn',
-        violations: [],
-        summary: typeof data['summary'] === 'string' ? summaryPrefix + data['summary'] : summaryPrefix + (exitCode === 0 ? 'ok' : 'failed'),
-        wallSeconds: wall,
-        degraded: false
-    };
-}
-function dispatchMonotonicImprovement(opts, started) {
-    // The monotonic guard is intra-process logic — we do not need to
-    // shell out to the peaks CLI for the score walk itself. The CLI
-    // shapes (`peaks loop check-monotonic`, `peaks loop eval
-    // --evaluator monotonic-improvement`) both converge here.
-    const sid = opts.sessionId;
-    if (sid === undefined || sid.length === 0) {
-        return {
-            kind: 'monotonic-improvement',
-            passed: false,
-            gateAction: 'warn',
-            violations: [{
-                    severity: 'MED',
-                    file: '<loop>',
-                    line: 0,
-                    hint: 'monotonic-improvement dispatcher requires sessionId; pass --session <sid> or call peaks loop check-monotonic directly'
-                }],
-            summary: 'monotonic-improvement: missing sessionId',
-            wallSeconds: 0,
-            degraded: true
-        };
-    }
-    const thresholdNum = opts.threshold !== undefined ? Number(opts.threshold) : undefined;
-    if (thresholdNum !== undefined && !Number.isFinite(thresholdNum)) {
-        return {
-            kind: 'monotonic-improvement',
-            passed: false,
-            gateAction: 'warn',
-            violations: [{
-                    severity: 'MED',
-                    file: '<loop>',
-                    line: 0,
-                    hint: `invalid threshold "${opts.threshold}" — must be a finite number in [0,1]`
-                }],
-            summary: 'monotonic-improvement: invalid threshold',
-            wallSeconds: 0,
-            degraded: true
-        };
-    }
-    try {
-        const result = runMonotonicCheck({
-            projectRoot: opts.projectRoot,
-            sid,
-            rid: opts.rid,
-            ...(thresholdNum !== undefined ? { threshold: thresholdNum } : {})
-        });
-        const wall = (Date.now() - started) / 1000;
-        const violations = result.report.regressions.map((r) => ({
-            severity: 'HIGH',
-            file: '<loop>',
-            line: 0,
-            hint: `${r.evaluator} regressed ${r.previousScore.toFixed(4)}→${r.currentScore.toFixed(4)} (Δ=${r.delta.toFixed(4)})`
-        }));
-        return {
-            kind: 'monotonic-improvement',
-            passed: !result.report.monotonicityViolation,
-            gateAction: result.report.monotonicityViolation ? 'block' : result.report.status === 'skip' ? 'warn' : 'pass',
-            violations,
-            summary: result.report.reason,
-            wallSeconds: wall,
-            degraded: false
-        };
-    }
-    catch (error) {
-        const wall = (Date.now() - started) / 1000;
-        return {
-            kind: 'monotonic-improvement',
-            passed: false,
-            gateAction: 'warn',
-            violations: [{
-                    severity: 'MED',
-                    file: '<loop>',
-                    line: 0,
-                    hint: `runMonotonicCheck threw: ${error instanceof Error ? error.message : String(error)}`
-                }],
-            summary: 'monotonic-improvement: dispatcher error',
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-}
-// ─── envelope parsers (pure, never throw) ──────────────────────────────
-function gateActionFromVerdict(verdict) {
-    if (verdict === 'pass' || verdict === 'warn' || verdict === 'block')
-        return verdict;
-    return 'warn';
-}
-function parseKarpathyEnvelope(stdout, exitCode, started) {
-    const wall = (Date.now() - started) / 1000;
-    const parsed = safeJson(stdout);
-    if (!parsed.ok) {
-        return {
-            kind: 'karpathy',
-            passed: exitCode === 0,
-            gateAction: exitCode === 0 ? 'pass' : 'block',
-            violations: [],
-            summary: stdout.slice(0, 200),
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const obj = parsed.value;
-    const data = (obj['data'] ?? obj);
-    const passed = data['passed'] === true;
-    const gateAction = typeof data['gateAction'] === 'string' ? gateActionFromVerdict(data['gateAction']) : (passed ? 'pass' : 'block');
-    const violationsRaw = Array.isArray(data['violations']) ? data['violations'] : [];
-    const violations = violationsRaw.map((v) => normalizeViolation(v));
-    return {
-        kind: 'karpathy',
-        passed,
-        gateAction,
-        violations,
-        summary: typeof data['summary'] === 'string' ? data['summary'] : 'karpathy review',
-        wallSeconds: wall,
-        degraded: false
-    };
-}
-function parseCodeReviewEnvelope(stdout, exitCode, started) {
-    // code-review emits the same shape as karpathy (Karpathy §4 envelope).
-    return envelopeAs(parseKarpathyEnvelope(stdout, exitCode, started), 'code-review');
-}
-function parseSecurityEnvelope(stdout, exitCode, started) {
-    const wall = (Date.now() - started) / 1000;
-    const parsed = safeJson(stdout);
-    if (!parsed.ok) {
-        return {
-            kind: 'security-review',
-            passed: exitCode === 0,
-            gateAction: exitCode === 0 ? 'pass' : 'warn',
-            violations: [],
-            summary: stdout.slice(0, 200),
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const obj = parsed.value;
-    const data = (obj['data'] ?? obj);
-    const verdict = typeof data['verdict'] === 'string' ? data['verdict'] : (exitCode === 0 ? 'pass' : 'warn');
-    const violationsRaw = Array.isArray(data['violations']) ? data['violations'] : [];
-    const violations = violationsRaw.map((v) => normalizeViolation(v));
-    return {
-        kind: 'security-review',
-        passed: verdict === 'pass',
-        gateAction: gateActionFromVerdict(verdict),
-        violations,
-        summary: typeof data['summary'] === 'string' ? data['summary'] : 'security review',
-        wallSeconds: wall,
-        degraded: false
-    };
-}
-function parsePerfEnvelope(stdout, exitCode, started) {
-    const wall = (Date.now() - started) / 1000;
-    const parsed = safeJson(stdout);
-    if (!parsed.ok) {
-        return {
-            kind: 'perf-baseline',
-            passed: exitCode === 0,
-            gateAction: exitCode === 0 ? 'pass' : 'warn',
-            violations: [],
-            summary: stdout.slice(0, 200),
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const obj = parsed.value;
-    const data = (obj['data'] ?? obj);
-    const verdict = typeof data['verdict'] === 'string' ? data['verdict'] : (exitCode === 0 ? 'pass' : 'warn');
-    const violationsRaw = Array.isArray(data['violations']) ? data['violations'] : [];
-    const violations = violationsRaw.map((v) => normalizeViolation(v));
-    return {
-        kind: 'perf-baseline',
-        passed: verdict === 'pass',
-        gateAction: gateActionFromVerdict(verdict),
-        violations,
-        summary: typeof data['summary'] === 'string' ? data['summary'] : 'perf baseline review',
-        wallSeconds: wall,
-        degraded: false
-    };
-}
-function parseVerdictAggregateEnvelope(stdout, exitCode, started) {
-    const wall = (Date.now() - started) / 1000;
-    const parsed = safeJson(stdout);
-    if (!parsed.ok) {
-        return {
-            kind: 'verdict-aggregate',
-            passed: exitCode === 0,
-            gateAction: exitCode === 0 ? 'pass' : 'block',
-            violations: [],
-            summary: stdout.slice(0, 200),
-            wallSeconds: wall,
-            degraded: true
-        };
-    }
-    const obj = parsed.value;
-    const data = (obj['data'] ?? obj);
-    const verdict = typeof data['verdict'] === 'string' ? data['verdict'] : (exitCode === 0 ? 'pass' : 'block');
-    const reasonsRaw = Array.isArray(data['reasons']) ? data['reasons'] : [];
-    const violations = reasonsRaw.map((r) => reasonToViolation(r));
-    return {
-        kind: 'verdict-aggregate',
-        passed: verdict === 'pass',
-        gateAction: gateActionFromVerdict(verdict),
-        violations,
-        summary: `verdict-aggregate: ${verdict}`,
-        wallSeconds: wall,
-        degraded: false
-    };
-}
-function reasonToViolation(reason) {
-    if (typeof reason === 'string') {
-        return { severity: 'MED', file: '<verdict>', line: 0, hint: reason };
-    }
-    if (reason !== null && typeof reason === 'object') {
-        const r = reason;
-        return {
-            severity: typeof r['severity'] === 'string' ? r['severity'] : 'MED',
-            file: typeof r['file'] === 'string' ? r['file'] : '<verdict>',
-            line: typeof r['line'] === 'number' ? r['line'] : 0,
-            hint: typeof r['hint'] === 'string' ? r['hint'] : JSON.stringify(reason)
-        };
-    }
-    return { severity: 'MED', file: '<verdict>', line: 0, hint: String(reason) };
-}
-function normalizeViolation(raw) {
-    if (raw === null || typeof raw !== 'object') {
-        return { severity: 'MED', file: '<unknown>', line: 0, hint: String(raw) };
-    }
-    const v = raw;
-    const sev = typeof v['severity'] === 'string' ? v['severity'] : 'MED';
-    const file = typeof v['file'] === 'string' ? v['file'] : '<unknown>';
-    const line = typeof v['line'] === 'number' ? v['line'] : 0;
-    const hint = typeof v['hint'] === 'string' ? v['hint'] : '';
-    const dimension = typeof v['dimension'] === 'string' ? v['dimension'] : undefined;
-    const out = dimension !== undefined
-        ? { severity: sev, file, line, hint, dimension }
-        : { severity: sev, file, line, hint };
-    return out;
-}
-function safeJson(raw) {
-    if (typeof raw !== 'string' || raw.length === 0) {
-        return { ok: false, reason: 'PARSE_ERROR' };
-    }
-    try {
-        return { ok: true, value: JSON.parse(raw) };
-    }
-    catch {
-        return { ok: false, reason: 'PARSE_ERROR' };
-    }
-}
-// Tiny ergonomic helper so we can re-emit an envelope with a different `kind`.
-// (Implementation note: this is a free function rather than a method — the
-// EvaluatorVerdictEnvelope interface is plain data, and adding methods via
-// `declare module` makes TS treat them as required properties.)
-export function envelopeAs(envelope, kind) {
-    return { ...envelope, kind };
-}
-// ─── Markdown → envelope fallbacks (used when peaks CLI is unavailable) ─
-/**
- * Best-effort markdown parse for karpathy-review.md / security.md / perf.md.
- * Mirrors the shape accepted by `parseKarpathyEnvelope` /
- * `parseSecurityEnvelope` / `parsePerfEnvelope` in `services/verdict/envelopes.ts`,
- * keeping verdict-aggregator backward-compat intact.
- */
-export function parseAuditMarkdownEnvelope(md, kind) {
-    if (typeof md !== 'string' || md.length === 0)
-        return null;
-    const verdict = matchVerdict(md);
-    if (verdict === null)
-        return null;
-    const violations = parseFindingBullets(md).map((b) => ({ ...b, dimension: kind }));
-    return {
-        kind,
-        passed: verdict === 'pass',
-        gateAction: verdict,
-        violations,
-        summary: extractSection(md, 'Summary') ?? '',
-        wallSeconds: 0,
-        degraded: true
-    };
-}
-function matchVerdict(md) {
-    const m = md.match(/^\s*verdict\s*:\s*(pass|warn|block)\s*$/m);
-    if (m === null)
-        return null;
-    return m[1];
-}
-function parseFindingBullets(body) {
-    const section = body.split(/^##\s+Findings\s*$/m)[1];
-    if (section === undefined)
-        return [];
-    const lines = section.split('\n').filter((l) => l.trim().startsWith('- '));
-    const out = [];
-    for (const line of lines) {
-        const a = line.match(/^\s*-\s*\[(CRITICAL|HIGH|MED|LOW)\]\s+(\S+)\s+@\s+([^:\s]+):(\d+)\s+[—-]\s+(.+)$/);
-        if (a !== null) {
-            const [, severity, , file, lineNo, hint] = a;
-            out.push({ severity: severity, file: file ?? '<unknown>', line: parseInt(lineNo ?? '0', 10), hint: (hint ?? '').trim() });
-            continue;
-        }
-        const b = line.match(/^\s*-\s*(CRITICAL|HIGH|MED|LOW)\s*:\s+(.+?)\s+in\s+([^:\s]+):(\d+)\s*$/);
-        if (b !== null) {
-            const [, severity, hint, file, lineNo] = b;
-            out.push({ severity: severity, file: file ?? '<unknown>', line: parseInt(lineNo ?? '0', 10), hint: (hint ?? '').trim() });
-        }
-    }
-    return out;
-}
-function extractSection(body, heading) {
-    const re = new RegExp(`^##\\s+${heading}\\s*$`, 'm');
-    const sectionStart = body.search(re);
-    if (sectionStart === -1)
-        return null;
-    const after = body.slice(sectionStart).split('\n');
-    after.shift();
-    const lines = [];
-    for (const line of after) {
-        if (/^##\s+/.test(line))
-            break;
-        lines.push(line);
-    }
-    return lines.join('\n').trim();
-}
-/** Load an on-disk audit file (e.g. `.peaks/_runtime/<sid>/audit/security.md`)
- *  and project it to an `EvaluatorVerdictEnvelope`. Used by workflow yaml
- *  evaluators that point at on-disk artifacts. */
-export function loadEnvelopeFromDisk(projectRoot, sid, rel, kind) {
-    const path = join(projectRoot, '.peaks', '_runtime', sid, rel);
-    if (!existsSync(path))
-        return null;
-    const md = readFileSync(path, 'utf8');
-    return parseAuditMarkdownEnvelope(md, kind);
-}

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

@@ -1,107 +0,0 @@
-import type Database from "better-sqlite3";
-import { ZodError } from "zod";
-import { type LoopBeeRelation, type LoopBeeRelationInput, type LoopBeeRelationRole } from "./loop-bee-relation-types.js";
-/**
- * Domain error thrown by LoopBeeRelationService when an invariant is
- * violated. The error code is machine-readable; the message is
- * NL-friendly. The CLI layer (M5) maps these into user-facing prompts.
- */
-export type LoopBeeRelationIntegrityErrorCode = "LOOP_RETIRED" | "DUP_RELATION" | "TWO_MAIN_BEES" | "FK_LOOP_NOT_FOUND" | "FK_BEE_NOT_FOUND";
-export declare class LoopBeeRelationIntegrityError extends Error {
-    readonly code: LoopBeeRelationIntegrityErrorCode;
-    readonly findings: ReadonlyArray<{
-        path: string;
-        message: string;
-    }>;
-    constructor(code: LoopBeeRelationIntegrityErrorCode, message: string, findings?: ReadonlyArray<{
-        path: string;
-        message: string;
-    }>);
-}
-/**
- * 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 declare class LoopBeeRelationService {
-    private readonly db;
-    constructor(db: Database.Database);
-    /**
-     * 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: LoopBeeRelationInput): LoopBeeRelation;
-    /** Read a LoopBeeRelation row by id; returns undefined if absent. */
-    read(id: number): LoopBeeRelation | undefined;
-    /**
-     * List relations for a given loop. Filter by `role` when supplied.
-     */
-    listByLoop(opts: {
-        loop_release_id: string;
-        role?: LoopBeeRelationRole;
-    }): LoopBeeRelation[];
-    /**
-     * List relations for a given bee. Filter by `role` when supplied.
-     */
-    listByBee(opts: {
-        bee_release_id: number;
-        role?: LoopBeeRelationRole;
-    }): LoopBeeRelation[];
-    /**
-     * 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: number, newRole: LoopBeeRelationRole): LoopBeeRelation | undefined;
-    /** Remove a relation by id. Returns true if a row was deleted. */
-    remove(id: number): boolean;
-}
-/**
- * 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 declare function isZodError(err: unknown): err is ZodError;