peaks-loop 4.0.0-beta.2 → 4.0.0-beta.20

package/dist/services/skillhub/migrations/005-evolution-evaluation.sql

@@ -0,0 +1,81 @@
+-- 005-evolution-evaluation.sql — M4 / spec §4.4 / §6
+-- Adds the `evolution_evaluation` table for the Darwin-style ratchet
+-- evaluation layer. Non-breaking: this migration does NOT touch any
+-- pre-existing table. The new table lives alongside the existing
+-- skillhub schema (see 001-initial.sql, 002-loop-release.sql,
+-- 003-loop-bee-relation.sql, 004-loop-bee-extension.sql).
+--
+-- The table stores the durable evidence of an evolution round:
+--   - target_kind / target_release_id / single_optimization_dimension
+--     (AC-8: single editable asset + single dimension per round).
+--   - before_score / after_score / score_delta_min / score_delta
+--     (AC-11: numeric delta; promotion blocked when delta < delta_min).
+--   - author_id / evaluator_id / skeptic_id
+--     (AC-10: author != scorer; the regression skeptic is a SEPARATE
+--     agent, not the same as the independent evaluator).
+--   - verdict (keep / revert / needs-user-decision).
+--   - user_confirmation_pointer / brief_pointer
+--     (spec §4.4: pointers, not inlined big JSON BLOBs).
+--
+-- Schema versioning: every new table carries `schema_version`
+-- pinned to the literal `peaks.evolution/1` via CHECK constraint.
+--
+-- All JSON-shaped payloads (diff, brief_pointer, source_traces_json)
+-- are stored as TEXT and parsed at the store / Zod boundary — same
+-- convention as the existing tables; no big JSON BLOB at the SQLite
+-- layer.
+
+CREATE TABLE IF NOT EXISTS evolution_evaluation (
+  id                          TEXT PRIMARY KEY,
+  target_kind                 TEXT NOT NULL CHECK (target_kind IN ('loop','bee','policy','gate','evaluator')),
+  target_release_id           TEXT NOT NULL,
+  -- The M4 spec requires exactly one optimization dimension per round.
+  -- The TEXT column carries the dimension name; the service layer
+  -- (EvolutionService) enforces `dimensions.length === 1` on input.
+  -- A JSON array is used here only so future schema versions can
+  -- relax the single-dimension rule without a column-rename
+  -- migration; for now the array is always exactly length 1.
+  optimization_dimensions_json TEXT NOT NULL,
+  -- AC-8: target_count must be exactly 1. Stored as INTEGER for
+  -- explicit service-layer enforcement; CHECK pins it to 1 in this
+  -- schema version (a future multi-target table would relax this).
+  target_count                INTEGER NOT NULL DEFAULT 1 CHECK (target_count = 1),
+  before_snapshot_json        TEXT NOT NULL DEFAULT '{}',
+  after_snapshot_json         TEXT NOT NULL DEFAULT '{}',
+  diff_json                   TEXT NOT NULL DEFAULT '{}',
+  before_score                REAL NOT NULL,
+  after_score                 REAL NOT NULL,
+  score_delta_min             REAL NOT NULL DEFAULT 1.0 CHECK (score_delta_min >= 0),
+  score_delta                 REAL NOT NULL,
+  author_id                   TEXT NOT NULL,
+  evaluator_id                TEXT NOT NULL,
+  skeptic_id                  TEXT NOT NULL,
+  -- Verdict is the FINAL aggregation result; `needs-user-decision`
+  -- is the default after the scoring + skeptic step.
+  verdict                     TEXT NOT NULL CHECK (verdict IN ('keep','revert','needs-user-decision')),
+  -- Pointer columns (NOT inlined JSON): user_confirmation_pointer and
+  -- brief_pointer are spec §4.4 fields. We keep them as TEXT paths /
+  -- ids so the table stays small and queryable.
+  user_confirmation_pointer   TEXT,
+  brief_pointer               TEXT,
+  -- Audit columns: rubric + red_lines + source_traces are
+  -- JSON-encoded TEXT — same convention as the other tables.
+  rubric_json                 TEXT NOT NULL DEFAULT '{}',
+  red_lines_json              TEXT NOT NULL DEFAULT '[]',
+  source_traces_json          TEXT NOT NULL DEFAULT '[]',
+  schema_version              TEXT NOT NULL CHECK (schema_version = 'peaks.evolution/1'),
+  created_at                  TEXT NOT NULL,
+  -- Defense in depth: the author MUST NOT equal the evaluator.
+  -- Cross-column CHECK rejected by older SQLite versions; we let the
+  -- service layer enforce this so the constraint stays portable.
+  CHECK (length(id) > 0)
+);
+
+CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_target
+  ON evolution_evaluation(target_kind, target_release_id);
+CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_verdict
+  ON evolution_evaluation(verdict);
+CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_author
+  ON evolution_evaluation(author_id);
+CREATE INDEX IF NOT EXISTS idx_evolution_evaluation_evaluator
+  ON evolution_evaluation(evaluator_id);

package/dist/services/skillhub/migrations/006-crystallization-event.sql

@@ -0,0 +1,92 @@
+-- 006-crystallization-event.sql — M5 / spec §4.5 / §4.7 / §5 / §7.2
+-- Adds the `crystallization_event` table for the post-run
+-- crystallization layer. Non-breaking: this migration does NOT
+-- touch any pre-existing table. The new table lives alongside the
+-- existing skillhub schema (see 001-initial.sql, 002-loop-release.sql,
+-- 003-loop-bee-relation.sql, 004-loop-bee-extension.sql,
+-- 005-evolution-evaluation.sql).
+--
+-- The table stores the durable evidence of a crystallization event:
+--   - trigger                          (user_explicit | llm_suggested |
+--                                       success_default_prompt |
+--                                       similar_task_recurrence)
+--   - evidence_brief                   (JSON: 4 sections)
+--       * what_happened                (1-2 sentence factual account)
+--       * why_it_matters               (1-2 sentence explanation)
+--       * what_learned                 (1-2 sentence learning)
+--       * what_action                  (1 sentence recommended action)
+--   - source_trace_pointers            (JSON array of workflow trace ids)
+--   - evaluator_summary                (short NL summary from scorers)
+--   - user_decision_summary            (NL account of the user choice)
+--   - created_loop_release_id          (FK to loop_release, optional)
+--   - updated_loop_release_id          (FK to loop_release, optional)
+--   - created_bee_release_id           (FK to bee_release, optional)
+--   - updated_bee_release_id           (FK to bee_release, optional)
+--   - lifecycle_status                 (candidate | stable | retired;
+--                                       the EVENT's status, distinct
+--                                       from the loop_release status).
+--
+-- The four-section brief (spec §4.7 / §10 RL-7) is required at the
+-- service layer; the DB stores whatever JSON the service persists. A
+-- schema-version bump can introduce a CHECK shape constraint on the
+-- brief in a future migration; the service layer is the authoritative
+-- guard today.
+--
+-- Schema versioning: every new table carries `schema_version` pinned
+-- to the literal `peaks.crystallization/1` via CHECK constraint.
+--
+-- All JSON-shaped payloads (brief, source_trace_pointers, bullets)
+-- are stored as TEXT and parsed at the store / Zod boundary —
+-- same convention as the existing tables; no big JSON BLOB at the
+-- SQLite layer.
+
+CREATE TABLE IF NOT EXISTS crystallization_event (
+  id                          TEXT PRIMARY KEY,
+  trigger                     TEXT NOT NULL CHECK (trigger IN (
+                                'user_explicit',
+                                'llm_suggested',
+                                'success_default_prompt',
+                                'similar_task_recurrence'
+                              )),
+  -- The 4-section brief. The shape guard (all four sections present)
+  -- is enforced at the service layer (CrystallizationService); the
+  -- DB stores whatever the service persists. See spec §4.7 / §10 RL-7.
+  evidence_brief_json         TEXT NOT NULL,
+  evidence_bullets_json       TEXT NOT NULL DEFAULT '[]',
+  source_trace_pointers_json  TEXT NOT NULL DEFAULT '[]',
+  evaluator_summary           TEXT NOT NULL DEFAULT '',
+  user_decision_summary       TEXT NOT NULL DEFAULT '',
+  created_loop_release_id     TEXT REFERENCES loop_release(id) ON DELETE SET NULL,
+  updated_loop_release_id     TEXT REFERENCES loop_release(id) ON DELETE SET NULL,
+  created_bee_release_id      INTEGER REFERENCES bee_release(id) ON DELETE SET NULL,
+  updated_bee_release_id      INTEGER REFERENCES bee_release(id) ON DELETE SET NULL,
+  -- The EVENT's lifecycle (independent of any created/updated asset).
+  -- 'candidate' after crystallization; 'stable' after user-confirmed
+  -- promotion; 'retired' after explicit dispose. Mirrors the loop
+  -- status union (spec §4.1) without a 1:1 identity — these are
+  -- orthogonal lifecycles.
+  lifecycle_status            TEXT NOT NULL DEFAULT 'candidate'
+                                CHECK (lifecycle_status IN ('candidate','stable','retired')),
+  schema_version              TEXT NOT NULL CHECK (schema_version = 'peaks.crystallization/1'),
+  created_at                  TEXT NOT NULL,
+  CHECK (length(id) > 0),
+  -- Defense in depth on the brief shape: at least one of the four
+  -- keys must be present in the JSON object. SQLite JSON1 (>= 3.38)
+  -- supports json_extract; we keep the check loose (length > 2 to
+  -- rule out '{}') so older SQLite still accepts the row, and rely
+  -- on the service-layer guard for the strict 4-section rule.
+  CHECK (length(evidence_brief_json) >= 2)
+);
+
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_created_loop
+  ON crystallization_event(created_loop_release_id);
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_updated_loop
+  ON crystallization_event(updated_loop_release_id);
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_created_bee
+  ON crystallization_event(created_bee_release_id);
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_updated_bee
+  ON crystallization_event(updated_bee_release_id);
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_lifecycle
+  ON crystallization_event(lifecycle_status);
+CREATE INDEX IF NOT EXISTS idx_crystallization_event_created_at
+  ON crystallization_event(created_at);

package/dist/services/skillhub/release-import.js

@@ -0,0 +1,64 @@
+import { readFileSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { assertNotSystemPath } from "../sediment/pool-paths.js";
+import { runTar } from "./tar-runtime.js";
+export function importRelease({ db, blobsDir, inPath, asName, }) {
+    const stageDir = inPath + ".extract";
+    if (existsSync(stageDir))
+        rmSync(stageDir, { recursive: true, force: true });
+    mkdirSync(stageDir, { recursive: true });
+    let extractOk = false;
+    try {
+        runTar(["-xzf", inPath, "-C", stageDir]);
+        extractOk = true;
+    }
+    finally {
+        if (!extractOk)
+            rmSync(stageDir, { recursive: true, force: true });
+    }
+    // ExportPayload (defined in ./types.ts) is the structural contract
+    // shared with release-export.ts, which writes the same JSON shape
+    // into <stageDir>/manifest.json. Minor #13: replace the previous
+    // inline anonymous type so producer and consumer stay in lock-step.
+    const payload = JSON.parse(readFileSync(join(stageDir, "manifest.json"), "utf-8"));
+    const beeName = asName ?? payload.bee_name;
+    assertNotSystemPath(beeName);
+    // Always check collision (the asName path previously skipped it and
+    // fell through to a UNIQUE-constraint mid-INSERT failure). Whether
+    // the user gave an explicit asName or relied on payload.bee_name, a
+    // pre-existing row must be reported cleanly.
+    if (db.prepare("SELECT 1 FROM bee_release WHERE bee_name = ?").get(beeName)) {
+        throw new Error("IMPORT_NAME_COLLIDES");
+    }
+    // Copy blobs
+    for (const f of payload.fileRows) {
+        const dest = join(blobsDir, f.sha256.slice(0, 2));
+        mkdirSync(dest, { recursive: true });
+        writeFileSync(join(dest, f.sha256), readFileSync(join(stageDir, "blobs", f.sha256)));
+    }
+    // Re-insert rows: pick a new release id, mirror payload rows.
+    // M3 / spec §4.2: the new `shareable` and `desktop_visible` columns
+    // are written with their spec defaults (true). Future import
+    // payloads may carry these explicitly (M7 bundle format); until
+    // then M3 keeps defaulting on the insert path so existing call
+    // sites stay source-compatible.
+    const tx = db.transaction(() => {
+        const ins = db.prepare(`INSERT INTO bee_release (bee_name, version, source, archived_at, archived_by, user_intent_raw, description, parent_version, changelog, shareable, desktop_visible) VALUES (?, ?, 'user', ?, 'user', ?, ?, ?, ?, 1, 1)`);
+        const id = ins.run(beeName, payload.version, new Date().toISOString(), null, null, null, null).lastInsertRowid;
+        db.prepare(`INSERT OR REPLACE INTO bee_release_pointer (bee_name, latest_version, released_at) VALUES (?, ?, ?)`).run(beeName, payload.version, new Date().toISOString());
+        for (const m of payload.manifestRows) {
+            db.prepare(`INSERT INTO bee_manifest (release_id, schema_version, description, segments_json, entrypoint_preamble, promotion, min_cycles, requires_human, requires_smoke, retire_on_misses) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, m.schema_version, m.description, m.segments_json, m.entrypoint_preamble, m.promotion, m.min_cycles, m.requires_human, m.requires_smoke, m.retire_on_misses);
+        }
+        for (const s of payload.segRows) {
+            db.prepare(`INSERT INTO bee_segment_ref (release_id, segment_name, inputs_json, outputs_json, side_effects) VALUES (?, ?, ?, ?, ?)`).run(id, s.segment_name, s.inputs_json, s.outputs_json, s.side_effects);
+        }
+        for (const f of payload.fileRows) {
+            db.prepare(`INSERT INTO bee_file (release_id, owner_kind, owner_name, path, kind, size_bytes, sha256, blob_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`).run(id, f.owner_kind, beeName, f.path, f.kind, f.size_bytes, f.sha256, f.blob_path);
+        }
+        for (const c of payload.changeRows) {
+            db.prepare(`INSERT INTO bee_change (release_id, change_kind, target_kind, target_name, detail) VALUES (?, ?, ?, ?, ?)`).run(id, c.change_kind, c.target_kind, c.target_name, c.detail);
+        }
+    });
+    tx();
+    rmSync(stageDir, { recursive: true, force: true });
+}

package/dist/services/skillhub/release-retain.js

@@ -0,0 +1,94 @@
+import { createHash } from "node:crypto";
+import { readFileSync, readdirSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { join, relative } from "node:path";
+/** Compute the sha256 hash and byte length of a single file. */
+export function sha256OfFile(p) {
+    const buf = readFileSync(p);
+    return { sha: createHash("sha256").update(buf).digest("hex"), bytes: buf.length };
+}
+/** Copy a file into the content-addressed blob store under `blobsDir/<aa>/<sha>`
+ *  if not already present, and return the relative blob_path used by `bee_file`. */
+export function ensureBlob(blobsDir, sha, srcPath) {
+    const dir = join(blobsDir, sha.slice(0, 2));
+    const dest = join(dir, sha);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    if (!existsSync(dest))
+        writeFileSync(dest, readFileSync(srcPath));
+    return `blobs/${sha.slice(0, 2)}/${sha}`;
+}
+export function* walk(root, base = root) {
+    for (const ent of readdirSync(base, { withFileTypes: true })) {
+        const abs = join(base, ent.name);
+        if (ent.isDirectory())
+            yield* walk(root, abs);
+        else {
+            const relPosix = relative(root, abs).split(/[\\/]/).join("/");
+            yield { abs, rel: relPosix };
+        }
+    }
+}
+function warnOverflow(column, length) {
+    // Soft warning, no truncation: the spec does not mandate truncation,
+    // but a stale over-16KB row would silently break downstream readers
+    // that assume <16KB. Surface it for ops review.
+    // eslint-disable-next-line no-console
+    console.warn(`[release-retain] WARN: column ${column} overflowed 16KB guard (${length} bytes) — review and consider truncation`);
+}
+/**
+ * Defensive 16KB check: if the value would exceed SQLite's
+ * recommended 16KB single-column limit, log a warning. Not a hard
+ * error — we let SQLite handle overflow. The columns covered are the
+ * four TEXT columns previously unchecked: bee_manifest.segments_json,
+ * bee_segment_ref.inputs_json, bee_segment_ref.outputs_json,
+ * bee_segment_ref.side_effects.
+ */
+function checkOverflow({ table, col }, value) {
+    const len = Buffer.byteLength(value, "utf-8");
+    if (len > 16 * 1024)
+        warnOverflow(`${table}.${col}`, len);
+}
+export function retainRelease({ db, blobsDir, scratchDir, manifest, version: explicitVersion, parentVersion, changelog, }) {
+    const version = explicitVersion ?? "0.1.0";
+    const tx = db.transaction(() => {
+        // M3 / spec §4.2: `shareable` and `desktop_visible` are written
+        // with their spec defaults (true). M7 will add a CLI flag to
+        // override on retain; M3 keeps the defaulting on the insert path
+        // so existing call sites stay source-compatible. The two new
+        // columns were added by migration 004-loop-bee-extension.sql.
+        const ins = db.prepare(`INSERT INTO bee_release (bee_name, version, source, archived_at, archived_by, user_intent_raw, description, parent_version, changelog, shareable, desktop_visible) VALUES (?, ?, 'user', ?, ?, ?, ?, ?, ?, 1, 1)`);
+        const info = ins.run(manifest.name, version, new Date().toISOString(), "llm", null, manifest.description, parentVersion ?? null, changelog ?? null);
+        const id = info.lastInsertRowid;
+        db.prepare(`INSERT OR REPLACE INTO bee_release_pointer (bee_name, latest_version, released_at) VALUES (?, ?, ?)`).run(manifest.name, version, new Date().toISOString());
+        for (const s of manifest.segments) {
+            const inputsJson = JSON.stringify(s.inputs);
+            const outputsJson = JSON.stringify(s.outputs);
+            const sideEffectsStr = s.sideEffects.join(",");
+            checkOverflow({ table: "bee_segment_ref", col: "inputs_json" }, inputsJson);
+            checkOverflow({ table: "bee_segment_ref", col: "outputs_json" }, outputsJson);
+            checkOverflow({ table: "bee_segment_ref", col: "side_effects" }, sideEffectsStr);
+            db.prepare(`INSERT INTO bee_segment_ref (release_id, segment_name, inputs_json, outputs_json, side_effects) VALUES (?, ?, ?, ?, ?)`).run(id, s.name, inputsJson, outputsJson, sideEffectsStr);
+        }
+        // Also guard the manifest-level JSON column that holds the segment
+        // name list (can exceed 16KB if a bee advertises thousands of
+        // segments).
+        const segmentsJson = JSON.stringify(manifest.segments.map((s) => s.name));
+        checkOverflow({ table: "bee_manifest", col: "segments_json" }, segmentsJson);
+        db.prepare(`INSERT INTO bee_manifest (release_id, schema_version, description, segments_json, entrypoint_preamble, promotion, min_cycles, requires_human, requires_smoke, retire_on_misses) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(id, manifest.schemaVersion, manifest.description, segmentsJson, manifest.entrypoint.preamble, manifest.promotion_status, manifest.promotion.minCycles, manifest.promotion.requiresHumanApproval ? 1 : 0, manifest.promotion.requiresSmokeTest ? 1 : 0, manifest.promotion.retireOnMissesInRow ?? null);
+        const insFile = db.prepare(`INSERT INTO bee_file (release_id, owner_kind, owner_name, path, kind, size_bytes, sha256, blob_path) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+        for (const f of walk(scratchDir)) {
+            const { sha, bytes } = sha256OfFile(f.abs);
+            const blobPath = ensureBlob(blobsDir, sha, f.abs);
+            const kind = f.rel.endsWith(".md")
+                ? "markdown"
+                : f.rel.startsWith("scripts/")
+                    ? "script"
+                    : f.rel.startsWith("references/")
+                        ? "reference"
+                        : "other";
+            insFile.run(id, "bee", manifest.name, f.rel, kind, bytes, sha, blobPath);
+        }
+        return id;
+    });
+    return tx();
+}

package/dist/services/skillhub/sqlite-store.js

@@ -0,0 +1,63 @@
+import Database from "better-sqlite3";
+import { readFileSync, readdirSync, existsSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+/**
+ * Open (or create) a SkillHub state database at the given path.
+ *
+ * Behavior:
+ *   - Creates the parent directory if it does not exist.
+ *   - Enables WAL journal mode and foreign-key enforcement.
+ *   - Applies every `migrations/*.sql` file in lexicographic order.
+ *     Migrations must be idempotent (CREATE TABLE IF NOT EXISTS, etc.).
+ *
+ * The migrations directory lives next to this source file at build time;
+ * we resolve it via `import.meta.url` so the lookup survives vitest ESM
+ * (where `__dirname` is undefined). Migration files are discovered by
+ * globbing (`*.sql`) and sorted lexicographically so future
+ * `002-…`, `003-…` additions are picked up automatically.
+ */
+export function openStateDb(path) {
+    const parent = dirname(path);
+    if (!existsSync(parent))
+        mkdirSync(parent, { recursive: true });
+    const db = new Database(path);
+    db.pragma("journal_mode = WAL");
+    db.pragma("foreign_keys = ON");
+    const here = dirname(fileURLToPath(import.meta.url));
+    const migrationsDir = join(here, "migrations");
+    if (existsSync(migrationsDir)) {
+        const files = readdirSync(migrationsDir).filter((f) => f.endsWith(".sql")).sort();
+        for (const f of files) {
+            const sql = readFileSync(join(migrationsDir, f), "utf-8");
+            try {
+                db.exec(sql);
+            }
+            catch (err) {
+                // Tolerate idempotent re-runs of `ALTER TABLE ... ADD COLUMN`
+                // migrations (e.g. 004-loop-bee-extension). The migration
+                // files themselves are NOT idempotent (SQLite has no
+                // `ALTER TABLE ADD COLUMN IF NOT EXISTS`); the runner is
+                // made idempotent here so the same state.db can be opened
+                // by multiple CLI processes within one workflow.
+                const msg = err instanceof Error ? err.message : String(err);
+                if (msg.includes("duplicate column name") ||
+                    msg.includes("already exists")) {
+                    continue;
+                }
+                throw err;
+            }
+        }
+    }
+    return db;
+}
+/**
+ * Return the user-defined table names present in `db` (excluding SQLite
+ * system tables such as `sqlite_sequence`).
+ */
+export function listTables(db) {
+    const rows = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'")
+        .all();
+    return rows.map((r) => r.name);
+}

package/dist/services/skillhub/types.d.ts

@@ -0,0 +1,115 @@
+export interface BeeReleaseRow {
+    id: number;
+    bee_name: string;
+    version: string;
+    source: "user";
+    archived_at: string;
+    archived_by: "user" | "llm";
+    user_intent_raw: string | null;
+    description: string | null;
+    parent_version: string | null;
+    changelog: string | null;
+    /**
+     * M3 / spec §4.2: `shareable` defaults to true (1 in SQLite).
+     * Enforced at the export CLI layer in M7; M3 only adds the column.
+     */
+    shareable: 0 | 1;
+    /**
+     * M3 / spec §4.2: `desktop_visible` defaults to true (1 in SQLite).
+     * Desktop visibility is a UI accelerator filter; M7 reads this.
+     */
+    desktop_visible: 0 | 1;
+}
+export interface BeeReleasePointerRow {
+    bee_name: string;
+    latest_version: string;
+    released_at: string;
+}
+export interface BeeManifestRow {
+    release_id: number;
+    schema_version: string;
+    description: string;
+    segments_json: string;
+    entrypoint_preamble: string | null;
+    promotion: string;
+    min_cycles: number | null;
+    requires_human: number;
+    requires_smoke: number;
+    retire_on_misses: number | null;
+}
+export interface BeeSegmentRefRow {
+    id: number;
+    release_id: number;
+    segment_name: string;
+    inputs_json: string | null;
+    outputs_json: string | null;
+    side_effects: string | null;
+}
+export interface BeeFileRow {
+    id: number;
+    release_id: number;
+    owner_kind: "bee" | "segment";
+    owner_name: string;
+    path: string;
+    kind: "markdown" | "script" | "reference" | "binary" | "other";
+    size_bytes: number;
+    sha256: string;
+    blob_path: string;
+}
+export interface BeeChangeRow {
+    id: number;
+    release_id: number;
+    change_kind: string;
+    target_kind: string;
+    target_name: string;
+    detail: string | null;
+}
+/**
+ * Shape of `manifest.json` inside a release export tarball.
+ *
+ * Producer: `src/services/skillhub/release-export.ts` writes this file via
+ *   `JSON.stringify({ bee_name, version, manifestRows, segRows, fileRows, changeRows })`.
+ * Consumer: `src/services/skillhub/release-import.ts` parses it back with
+ *   `JSON.parse(readFileSync(join(stageDir, "manifest.json"), "utf-8"))`.
+ *
+ * Defining it once here (rather than as an inline anonymous type at the
+ * call-site) lets both sides share a structural contract. If a future
+ * field is added — e.g. an exported schema-version stamp — it lands in
+ * one place and TypeScript flags every consumer that needs updating.
+ */
+export interface ExportPayload {
+    bee_name: string;
+    version: string;
+    manifestRows: Array<{
+        schema_version: string;
+        description: string;
+        segments_json: string;
+        entrypoint_preamble: string | null;
+        promotion: string;
+        min_cycles: number | null;
+        requires_human: number;
+        requires_smoke: number;
+        retire_on_misses: number | null;
+    }>;
+    segRows: Array<{
+        segment_name: string;
+        inputs_json: string | null;
+        outputs_json: string | null;
+        side_effects: string | null;
+    }>;
+    fileRows: Array<{
+        owner_kind: string;
+        owner_name: string;
+        path: string;
+        kind: string;
+        size_bytes: number;
+        sha256: string;
+        blob_path: string;
+    }>;
+    changeRows: Array<{
+        change_kind: string;
+        target_kind: string;
+        target_name: string;
+        detail: string | null;
+    }>;
+}

package/dist/services/skills/skill-registry.d.ts

@@ -0,0 +1,18 @@
+export type SkillMetadata = {
+    name: string;
+    description: string;
+    directory: string;
+    skillPath: string;
+    visibility?: string;
+};
+export type SkillLoadFailure = {
+    directory: string;
+    skillPath: string;
+    message: string;
+};
+export type SkillRegistryResult = {
+    skills: SkillMetadata[];
+    failures: SkillLoadFailure[];
+};
+export declare function loadSkillRegistry(baseDir?: string): Promise<SkillRegistryResult>;
+export declare function listSkills(baseDir?: string): Promise<SkillMetadata[]>;

package/dist/services/skills/skill-registry.js

@@ -0,0 +1,69 @@
+import { join } from 'node:path';
+import { listDirectories, pathExists, readText } from 'peaks-loop-shared/fs';
+import { parseFrontmatter } from '../../shared/frontmatter.js';
+import { skillsDir } from 'peaks-loop-shared/paths';
+function getLoadFailureMessage(error) {
+    return error instanceof Error ? error.message : 'Unable to parse skill metadata';
+}
+export async function loadSkillRegistry(baseDir = skillsDir) {
+    if (!(await pathExists(baseDir))) {
+        return { skills: [], failures: [] };
+    }
+    const directories = await listDirectories(baseDir);
+    const skills = [];
+    const failures = [];
+    for (const directory of directories) {
+        // LLM-internal skills (bees) live under `bee/` per spec 2026-07-05.
+        // Recurse one level into `bee/`; treat each child as a separate skill.
+        if (directory === 'bee') {
+            const subEntries = await listDirectories(join(baseDir, 'bee'));
+            for (const subDir of subEntries) {
+                const skillPath = join(baseDir, 'bee', subDir, 'SKILL.md');
+                if (!(await pathExists(skillPath))) {
+                    continue;
+                }
+                try {
+                    const frontmatter = parseFrontmatter(await readText(skillPath));
+                    // `directory` is the on-disk skill folder name; for bees that is the
+                    // basename of the bee child, NOT `bee/<name>` (keeps the
+                    // doctor skill-name-matches-directory invariant working).
+                    skills.push({
+                        name: frontmatter.name,
+                        description: frontmatter.description,
+                        directory: subDir,
+                        skillPath,
+                        ...(frontmatter.visibility !== undefined ? { visibility: frontmatter.visibility } : {})
+                    });
+                }
+                catch (error) {
+                    failures.push({ directory: subDir, skillPath, message: getLoadFailureMessage(error) });
+                }
+            }
+            continue;
+        }
+        const skillPath = join(baseDir, directory, 'SKILL.md');
+        if (!(await pathExists(skillPath))) {
+            continue;
+        }
+        try {
+            const frontmatter = parseFrontmatter(await readText(skillPath));
+            skills.push({
+                name: frontmatter.name,
+                description: frontmatter.description,
+                directory,
+                skillPath,
+                ...(frontmatter.visibility !== undefined ? { visibility: frontmatter.visibility } : {})
+            });
+        }
+        catch (error) {
+            failures.push({ directory, skillPath, message: getLoadFailureMessage(error) });
+        }
+    }
+    return {
+        skills: skills.sort((left, right) => left.name.localeCompare(right.name)),
+        failures: failures.sort((left, right) => left.directory.localeCompare(right.directory))
+    };
+}
+export async function listSkills(baseDir = skillsDir) {
+    return (await loadSkillRegistry(baseDir)).skills;
+}