peaks-loop 3.1.1 → 4.0.0-beta

package/dist/src/services/migrate-skill-name/migrate.d.ts

@@ -0,0 +1,17 @@
+import type { MigrateResult } from './schema.js';
+export interface MigrateOpts {
+    projectRoot: string;
+    from: string;
+    to: string;
+    /** false = dry-run (default); true = write through. */
+    apply: boolean;
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export declare function shouldSkip(projectRoot: string, absPath: string): boolean;
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export declare function walkRuntimeFiles(root: string): string[];
+export declare function migrateSkillName(opts: MigrateOpts): MigrateResult;

package/dist/src/services/migrate-skill-name/migrate.js

@@ -0,0 +1,152 @@
+/**
+ * `peaks session migrate-skill-name` core service (slice 2 of the
+ * peaks-code → peaks-code rename plan).
+ *
+ * Walks `.peaks/_runtime/**` and rewrites two patterns:
+ *   1. Key-value:   `"skill": "<old>"`  →  `"skill": "<new>"`
+ *   2. Slash-trig:  `/<old>`            →  `/<new>`
+ *
+ * Files under known skip-paths (`.peaks/memory/**`,
+ * `.peaks/skills/.system/bees/<old>/manifest.json`) are recorded in
+ * `skipped` but never opened. The operation is idempotent: re-running
+ * with the same `--from` on a tree already migrated reports 0
+ * modifications.
+ *
+ * Dry-run (`apply: false`) counts what WOULD change without writing;
+ * apply (`apply: true`) validates each `.json` payload with
+ * `JSON.parse` before writing so a broken mid-edit never lands on
+ * disk. Errors are pushed into `result.errors` (never swallowed).
+ */
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+/**
+ * Skip-paths are matched against the path relative to `projectRoot`,
+ * forward-slashed (Windows-friendly). Each entry is a SUBSTRING —
+ * the brief pins two specific exclusions: the memory dir, and the
+ * .system bee manifest for the old skill (which the renamer must
+ * leave alone until the bee itself is moved in a later slice).
+ */
+const SKIP_DIRS = ['.peaks/memory', '.peaks/skills/.system/bees'];
+const TARGET_ROOT = '.peaks/_runtime';
+const KEY_VALUE_PATTERN = (from, to) => new RegExp(`"skill"\\s*:\\s*"${escapeRe(from)}"`, 'g');
+const STRING_PATTERN = (from, to) => new RegExp(`/${escapeRe(from)}`, 'g');
+/**
+ * Escape regex metachars so an aggressive `--from` value (e.g.
+ * `peaks.code`) doesn't blow up the regex compiler. The two regexes
+ * above use `from` inside both body and character-class territory,
+ * so escaping is the safe path regardless of input.
+ */
+function escapeRe(input) {
+    return input.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/** True iff `absPath` falls under any skip-path (substring match). */
+export function shouldSkip(projectRoot, absPath) {
+    const rel = relative(projectRoot, absPath).replace(/\\/g, '/');
+    return SKIP_DIRS.some((skip) => rel.includes(skip));
+}
+/**
+ * Recursively walk a directory and return every `.json` / `.md`
+ * path. Missing root → empty list (the CLI reports scannedFiles:0,
+ * which is the truthful "nothing to look at" signal).
+ */
+export function walkRuntimeFiles(root) {
+    const out = [];
+    if (!existsSync(root))
+        return out;
+    const visit = (dir) => {
+        for (const entry of readdirSync(dir)) {
+            const full = join(dir, entry);
+            const stat = statSync(full);
+            if (stat.isDirectory()) {
+                visit(full);
+            }
+            else if (entry.endsWith('.json') || entry.endsWith('.md')) {
+                out.push(full);
+            }
+        }
+    };
+    visit(root);
+    return out;
+}
+export function migrateSkillName(opts) {
+    const runtimeRoot = join(opts.projectRoot, TARGET_ROOT);
+    const files = walkRuntimeFiles(runtimeRoot);
+    const result = {
+        ok: true,
+        scannedFiles: files.length,
+        modifiedFiles: 0,
+        keyValueReplacements: 0,
+        stringReplacements: 0,
+        skipped: [...SKIP_DIRS],
+        errors: [],
+    };
+    for (const file of files) {
+        if (shouldSkip(opts.projectRoot, file))
+            continue;
+        let original;
+        try {
+            original = readFileSync(file, 'utf-8');
+        }
+        catch (e) {
+            // Unreadable file: surface the error and keep going (other
+            // files may be fine). `ok` flips to false; reporting stops
+            // hiding the failure from the operator.
+            result.errors.push(`${file}: read failed: ${e.message}`);
+            result.ok = false;
+            continue;
+        }
+        // Pin the broken-JSON test: any .json runtime file that fails
+        // to parse MUST be surfaced as an error, EVEN when it does not
+        // contain the from-name (the operator still needs to know the
+        // file is unparseable so they can fix it before re-running).
+        // Per Karpathy §4 honesty, silent skip is the worst kind of
+        // fake-green.
+        if (file.endsWith('.json')) {
+            try {
+                JSON.parse(original);
+            }
+            catch (e) {
+                result.errors.push(`${file}: invalid JSON: ${e.message}`);
+                result.ok = false;
+                continue;
+            }
+        }
+        let mutated = original;
+        const kvPattern = KEY_VALUE_PATTERN(opts.from, opts.to);
+        const kvMatches = mutated.match(kvPattern);
+        if (kvMatches) {
+            mutated = mutated.replace(kvPattern, `"skill": "${opts.to}"`);
+            result.keyValueReplacements += kvMatches.length;
+        }
+        const strPattern = STRING_PATTERN(opts.from, opts.to);
+        const strMatches = mutated.match(strPattern);
+        if (strMatches) {
+            mutated = mutated.replace(strPattern, `/${opts.to}`);
+            result.stringReplacements += strMatches.length;
+        }
+        if (mutated === original)
+            continue;
+        if (opts.apply) {
+            try {
+                if (file.endsWith('.json')) {
+                    // Validate the post-edit JSON before touching the disk —
+                    // catches accidents (e.g., stray quotes in the renamed
+                    // from/to values) without leaving a corrupted runtime file
+                    // behind.
+                    JSON.parse(mutated);
+                }
+                writeFileSync(file, mutated, 'utf-8');
+                result.modifiedFiles += 1;
+            }
+            catch (e) {
+                result.errors.push(`${file}: ${e.message}`);
+                result.ok = false;
+            }
+        }
+        // Dry-run path intentionally does not bump `modifiedFiles` —
+        // pin: `expect(result.modifiedFiles).toBe(0)` in the dry-run
+        // test. The would-be count lives implicitly in the *Replacement
+        // counters, which both dry-run and apply share.
+    }
+    return result;
+}

package/dist/src/services/migrate-skill-name/schema.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export declare const MigrateResultSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    scannedFiles: z.ZodNumber;
+    modifiedFiles: z.ZodNumber;
+    keyValueReplacements: z.ZodNumber;
+    stringReplacements: z.ZodNumber;
+    skipped: z.ZodArray<z.ZodString, "many">;
+    errors: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}, {
+    ok: boolean;
+    skipped: string[];
+    scannedFiles: number;
+    modifiedFiles: number;
+    keyValueReplacements: number;
+    stringReplacements: number;
+    errors: string[];
+}>;
+export type MigrateResult = z.infer<typeof MigrateResultSchema>;

package/dist/src/services/migrate-skill-name/schema.js

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+/**
+ * Result shape for `peaks session migrate-skill-name`.
+ *
+ * Counters:
+ *   - `scannedFiles` — every .json / .md under `.peaks/_runtime/**` (excluding
+ *     skip dirs below).
+ *   - `modifiedFiles` — files whose contents would change (dry-run reports
+ *     the predicted count; --apply reports the actually-written count).
+ *   - `keyValueReplacements` — `"skill": "<old>"` → `"skill": "<new>"`.
+ *   - `stringReplacements` — `/<old>` → `/<new>` slash-trigger mentions.
+ *
+ * Errors are surfaced per-file with `errors: [ "<absPath>: <message>", … ]`;
+ * the tool never silently skips a broken JSON file (Karpathy §4 honesty:
+ * silence on bad data is the worst kind of fake-green).
+ */
+export const MigrateResultSchema = z.object({
+    ok: z.boolean(),
+    scannedFiles: z.number().int().nonnegative(),
+    modifiedFiles: z.number().int().nonnegative(),
+    keyValueReplacements: z.number().int().nonnegative(),
+    stringReplacements: z.number().int().nonnegative(),
+    skipped: z.array(z.string()),
+    errors: z.array(z.string()),
+});

package/dist/src/services/observability/aggregation.d.ts

@@ -51,7 +51,7 @@ export type RepairCycleReport = {
         cycleCount: number;
     }>;
 };
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
 export declare const REPAIR_CYCLE_CAP = 3;
 export declare function aggregateStatus(events: readonly ObservabilityEvent[]): StatusAggregate;
 export declare function aggregateSlices(events: readonly ObservabilityEvent[]): SliceRollup[];

package/dist/src/services/observability/aggregation.js

@@ -28,7 +28,7 @@ const TERMINAL_HAPPY_STATES = new Set([
     'boundary-recorded'
 ]);
 const TERMINAL_FAIL_STATES = new Set(['blocked']);
-/** RD/QA repair-loop cap (matches the peaks-solo repair-loop contract). */
+/** RD/QA repair-loop cap (matches the peaks-code repair-loop contract). */
 export const REPAIR_CYCLE_CAP = 3;
 // v2.12.0 fan-out collapse: see OBSERVABILITY_SUBAGENT_ROLES for the
 // rationale on why `security-reviewer` was dropped and `peaks-security-audit`

package/dist/src/services/perf/perf-baseline-service.d.ts

@@ -1,7 +1,7 @@
 /**
  * Performance baseline scaffolding for the RD stage.
  *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
+ * peaks-code's RD stage runs before the QA stage. The user-facing pain is
  * that performance tests (lighthouse / k6 / project-local benches / etc.)
  * have historically only been run at QA Gate A4 — too late in the loop,
  * because a slow regression discovered at QA triggers a return-to-rd

package/dist/src/services/perf/perf-baseline-service.js

@@ -1,7 +1,7 @@
 /**
  * Performance baseline scaffolding for the RD stage.
  *
- * peaks-solo's RD stage runs before the QA stage. The user-facing pain is
+ * peaks-code's RD stage runs before the QA stage. The user-facing pain is
  * that performance tests (lighthouse / k6 / project-local benches / etc.)
  * have historically only been run at QA Gate A4 — too late in the loop,
  * because a slow regression discovered at QA triggers a return-to-rd

package/dist/src/services/prd/handoff-types.d.ts

@@ -4,7 +4,7 @@
  * The handoff is the **immutable** single source of truth that all
  * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
  * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
+ * (per `skills/bee/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
  * peaks-rd tech-doc handoff (v2.10.0 and earlier).
  *
  * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex

package/dist/src/services/prd/handoff-types.js

@@ -4,7 +4,7 @@
  * The handoff is the **immutable** single source of truth that all
  * downstream consumers (peaks-rd main loop + 4 audit sub-agents +
  * peaks-qa) read. It is written by peaks-prd AFTER user confirmation
- * (per `skills/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
+ * (per `skills/bee/peaks-prd/SKILL.md` Step 5.5) and replaces the legacy
  * peaks-rd tech-doc handoff (v2.10.0 and earlier).
  *
  * Frontmatter invariant: `handoffHash` MUST equal the lowercase hex

package/dist/src/services/progress/progress-service.d.ts

@@ -1,5 +1,5 @@
 /**
- * Sub-agent progress file for the RD/QA sub-agents in `peaks-solo`'s
+ * Sub-agent progress file for the RD/QA sub-agents in `peaks-code`'s
  * Swarm phase. A sub-agent (or the LLM via the `peaks progress step`
  * CLI) writes a stable JSON file at
  * `.peaks/_sub_agents/<sid>/subagent-progress.json`. The dispatch +

package/dist/src/services/progress/progress-service.js

@@ -1,5 +1,5 @@
 /**
- * Sub-agent progress file for the RD/QA sub-agents in `peaks-solo`'s
+ * Sub-agent progress file for the RD/QA sub-agents in `peaks-code`'s
  * Swarm phase. A sub-agent (or the LLM via the `peaks progress step`
  * CLI) writes a stable JSON file at
  * `.peaks/_sub_agents/<sid>/subagent-progress.json`. The dispatch +

package/dist/src/services/rd/standards-diagnostic.js

@@ -2,7 +2,7 @@
  * Slice 2026-06-16-peaks-rd-no-gates — missing-project-standards diagnostic
  * + JSON gate list shape for the RD bootstrap path.
  *
- * Background: when `peaks-rd` (or `peaks-qa` / `peaks-solo`) starts in a
+ * Background: when `peaks-rd` (or `peaks-qa` / `peaks-code`) starts in a
  * project whose `.claude/rules/{common,typescript}/` is missing or empty,
  * the existing code-review / security / performance gates were silently
  * dropped. This module makes the missing-standards condition observable:

package/dist/src/services/recommendations/capability-seed-mappings.js

@@ -6,7 +6,7 @@ export const seedCapabilityLandingMappings = [
     mapping({ capabilityId: 'codegraph.impact-analysis', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Dry-run reference only: peaks-rd may use peaks codegraph affected --project <path> <files...> --json to inspect likely impact before slice planning and red-line checks when execution is approved.' }),
     mapping({ capabilityId: 'codegraph.impact-analysis', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use affected output as regression-surface evidence only; QA validation and test evidence remain authoritative.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-rd', skillName: 'peaks-rd', guidance: 'Dry-run reference only: peaks-rd may use peaks codegraph context --project <path> <task> to gather local evidence for RD analysis when execution is approved, without replacing standards dry-runs.' }),
-    mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-solo', skillName: 'peaks-solo', guidance: 'Solo may attach local context packs or affected summaries before role handoff so RD, QA, and TXT share the same project evidence.' }),
+    mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-code', skillName: 'peaks-code', guidance: 'Solo may attach local context packs or affected summaries before role handoff so RD, QA, and TXT share the same project evidence.' }),
     mapping({ capabilityId: 'codegraph.context-pack', sourceId: 'codegraph', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-txt', skillName: 'peaks-txt', guidance: 'TXT may summarize recorded codegraph context packs into handoffs while treating them as supporting evidence only.' }),
     mapping({ capabilityId: 'playwright-mcp.browser-validation', sourceId: 'playwright-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-qa', skillName: 'peaks-qa', guidance: 'Use for browser and E2E validation after user-approved app targets are available.' }),
     mapping({ capabilityId: 'chrome-devtools-mcp.browser-debug', sourceId: 'chrome-devtools-mcp', sourceGroup: 'access-repo', landingKind: 'skill', target: 'peaks-ui', skillName: 'peaks-ui', guidance: 'Use for runtime UI, console, network, and performance inspection.' }),

package/dist/src/services/sc/sc-service.js

@@ -473,7 +473,7 @@ export function validateArtifactRetention(sliceId) {
     };
     if (!workspace) {
         // No workspace: validate against the resolved session dir directly
-        // (this is the common peaks-solo / peaks-rd invocation: the slice
+        // (this is the common peaks-code / peaks-rd invocation: the slice
         // lives under the project-root `.peaks/_runtime/<sessionId>/`, and the
         // workspace artifact path is irrelevant). When the resolution also
         // fails, fall back to the legacy "No workspace configured" failure

package/dist/src/services/sediment/dispose-confirm.d.ts

@@ -0,0 +1,9 @@
+import type { BeeManifest } from "./types.js";
+export type DisposePlan = {
+    decision: "destroy";
+    auto: true;
+} | {
+    decision: null;
+    requiresUserPrompt: true;
+};
+export declare function planDispose(m: BeeManifest): DisposePlan;

package/dist/src/services/sediment/dispose-confirm.js

@@ -0,0 +1,5 @@
+export function planDispose(m) {
+    if (m.source === "system")
+        return { decision: "destroy", auto: true };
+    return { decision: null, requiresUserPrompt: true };
+}

package/dist/src/services/sediment/json-schema.d.ts

@@ -0,0 +1,247 @@
+import { z } from "zod";
+export declare const BeeManifestSchema: z.ZodEffects<z.ZodObject<{
+    schemaVersion: z.ZodLiteral<"peaks.bee/1">;
+    name: z.ZodString;
+    source: z.ZodEnum<["system", "user"]>;
+    promotion_status: z.ZodEnum<["candidate", "stable", "retired", "system-stable"]>;
+    description: z.ZodString;
+    segments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        inputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "json"]>;
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }>, "many">;
+        outputs: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "json"]>;
+            required: z.ZodBoolean;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }, {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }>, "many">;
+        sideEffects: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }, {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }>, "many">;
+    entrypoint: z.ZodObject<{
+        preamble: z.ZodString;
+        refs: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            kind: z.ZodEnum<["file", "dir", "script"]>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }, {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    }, {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    }>;
+    promotion: z.ZodObject<{
+        minCycles: z.ZodNumber;
+        requiresHumanApproval: z.ZodBoolean;
+        requiresSmokeTest: z.ZodBoolean;
+        retireOnMissesInRow: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    }, {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    }>;
+    createdBy: z.ZodEnum<["human", "llm"]>;
+    lastTouchedAt: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}>, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}, {
+    name: string;
+    source: "user" | "system";
+    description: string;
+    schemaVersion: "peaks.bee/1";
+    promotion: {
+        minCycles: number;
+        requiresHumanApproval: boolean;
+        requiresSmokeTest: boolean;
+        retireOnMissesInRow?: number | undefined;
+    };
+    segments: {
+        name: string;
+        outputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        inputs: {
+            name: string;
+            type: "string" | "number" | "boolean" | "json";
+            required: boolean;
+        }[];
+        sideEffects: string[];
+    }[];
+    promotion_status: "candidate" | "stable" | "retired" | "system-stable";
+    entrypoint: {
+        preamble: string;
+        refs: {
+            path: string;
+            kind: "file" | "script" | "dir";
+        }[];
+    };
+    createdBy: "llm" | "human";
+    lastTouchedAt: string;
+}>;

package/dist/src/services/sediment/json-schema.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+export const BeeManifestSchema = z.object({
+    schemaVersion: z.literal("peaks.bee/1"),
+    name: z.string().regex(/^bee-[a-z0-9][a-z0-9-]*$|^peaks-[a-z0-9][a-z0-9-]*$/),
+    source: z.enum(["system", "user"]),
+    promotion_status: z.enum(["candidate", "stable", "retired", "system-stable"]),
+    description: z.string().min(1).max(200),
+    segments: z.array(z.object({
+        name: z.string(),
+        inputs: z.array(z.object({ name: z.string(), type: z.enum(["string", "number", "boolean", "json"]), required: z.boolean() })),
+        outputs: z.array(z.object({ name: z.string(), type: z.enum(["string", "number", "boolean", "json"]), required: z.boolean() })),
+        sideEffects: z.array(z.string()),
+    })),
+    entrypoint: z.object({
+        preamble: z.string(),
+        refs: z.array(z.object({ path: z.string(), kind: z.enum(["file", "dir", "script"]) })),
+    }),
+    promotion: z.object({
+        minCycles: z.number().int().nonnegative(),
+        requiresHumanApproval: z.boolean(),
+        requiresSmokeTest: z.boolean(),
+        retireOnMissesInRow: z.number().int().positive().optional(),
+    }),
+    createdBy: z.enum(["human", "llm"]),
+    lastTouchedAt: z.string().datetime(),
+}).refine((m) => !(m.source === "system" && m.promotion_status !== "system-stable"), { message: "source=system must have promotion_status=system-stable" });

package/dist/src/services/sediment/manifest-lint.d.ts

@@ -0,0 +1,13 @@
+import type { BeeManifest } from "./types.js";
+export type Finding = {
+    path: string;
+    message: string;
+};
+export type LintResult = {
+    ok: true;
+} | {
+    ok: false;
+    findings: Finding[];
+};
+export declare function lintManifest(m: unknown): LintResult;
+export declare function lintManifestStrict(m: unknown): BeeManifest;

package/dist/src/services/sediment/manifest-lint.js

@@ -0,0 +1,11 @@
+import { BeeManifestSchema } from "./json-schema.js";
+export function lintManifest(m) {
+    const r = BeeManifestSchema.safeParse(m);
+    if (r.success)
+        return { ok: true };
+    return { ok: false, findings: r.error.issues.map((i) => ({ path: i.path.join("."), message: i.message })) };
+}
+export function lintManifestStrict(m) {
+    const r = BeeManifestSchema.parse(m);
+    return r;
+}