dsh-continual-evolve 0.1.0

package/lib/apply.js

@@ -0,0 +1,131 @@
+import { SOURCE_SESSION_KEY, SOURCE_SEQS_KEY, ARCHIVED_AT_KEY, cloneEntry, isArchived, slug } from "./types.js";
+import { entryChangedSince } from "./state.js";
+import { validateEdit } from "./validate.js";
+export function applyRefinementProposal(state, proposal, options) {
+    const appliedEdits = [];
+    const touched = new Set();
+    const now = new Date().toISOString();
+    for (const edit of proposal.edits) {
+        const computedId = edit.id ?? (edit.action === "create" ? slug(edit.title ?? edit.kind, edit.kind) : undefined);
+        const id = computedId ?? "";
+        const validationError = validateEdit(edit, computedId);
+        if (validationError) {
+            appliedEdits.push({ ...edit, id, applied: false, error: validationError });
+            continue;
+        }
+        const records = state.entries[edit.kind];
+        const before = cloneEntry(records[id]);
+        const entryKey = `${edit.kind}:${id}`;
+        const baseline = cloneEntry(options.baselineState?.entries[edit.kind][id]);
+        if (options.baselineState && !touched.has(entryKey) && JSON.stringify(before ?? null) !== JSON.stringify(baseline ?? null)) {
+            appliedEdits.push({
+                ...edit,
+                id,
+                ...(before ? { before } : {}),
+                applied: false,
+                error: "entry changed during planning",
+            });
+            continue;
+        }
+        if (edit.action === "delete") {
+            if (!before) {
+                appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
+                continue;
+            }
+            delete records[id];
+            touched.add(entryKey);
+            appliedEdits.push({ ...edit, id, before, applied: true });
+            continue;
+        }
+        if (edit.action === "archive") {
+            // Archive hides an entry from injection but never deletes it:
+            // metadata.archivedAt is stamped through the normal apply path, so
+            // the edit gets a before/after snapshot, a version bump, and a
+            // rollback inverse like any other edit (restoring the snapshot
+            // clears the stamp). Idempotency is explicit: re-archiving an
+            // already-archived entry is an error, not a silent no-op.
+            if (!before) {
+                appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
+                continue;
+            }
+            if (isArchived(before)) {
+                appliedEdits.push({ ...edit, id, before, applied: false, error: "entry already archived" });
+                continue;
+            }
+            const after = {
+                ...before,
+                metadata: { ...before.metadata, [ARCHIVED_AT_KEY]: now },
+                updated_at: now,
+                version: before.version + 1,
+            };
+            records[id] = after;
+            touched.add(entryKey);
+            appliedEdits.push({ ...edit, id, before, after: cloneEntry(after) ?? after, applied: true });
+            continue;
+        }
+        if (edit.action === "create" && before) {
+            appliedEdits.push({ ...edit, id, before, applied: false, error: "entry already exists" });
+            continue;
+        }
+        if (edit.action === "update" && !before) {
+            appliedEdits.push({ ...edit, id, applied: false, error: "entry not found" });
+            continue;
+        }
+        // Trajectory citation: stamped on create (the distillation moment),
+        // never re-stamped on update (the entry keeps its original source).
+        // Model-supplied metadata wins on key collision.
+        const sourceMetadata = !before && options.source
+            ? {
+                [SOURCE_SESSION_KEY]: options.source.sessionId,
+                ...(options.source.seqs && options.source.seqs.length > 0
+                    ? { [SOURCE_SEQS_KEY]: options.source.seqs }
+                    : {}),
+            }
+            : {};
+        const after = {
+            id,
+            kind: edit.kind,
+            title: edit.title ?? before?.title ?? id,
+            content: edit.content ?? before?.content ?? "",
+            path: edit.path ?? before?.path ?? "general",
+            scope: before?.scope ?? options.scope ?? "local",
+            reference: edit.reference ?? before?.reference ?? {},
+            arguments: edit.arguments ?? before?.arguments ?? {},
+            metadata: { ...sourceMetadata, ...(edit.metadata ?? before?.metadata ?? {}) },
+            source: "evolve",
+            created_at: before?.created_at ?? now,
+            updated_at: now,
+            version: before ? before.version + 1 : 1,
+        };
+        records[id] = after;
+        touched.add(entryKey);
+        appliedEdits.push({
+            ...edit,
+            id,
+            ...(before ? { before } : {}),
+            after: cloneEntry(after) ?? after,
+            applied: true,
+        });
+    }
+    const changes = appliedEdits.filter((edit) => edit.applied).map((edit) => `${edit.action} ${edit.kind}:${edit.id}`);
+    state.refinements.push({
+        id: options.id,
+        trigger: proposal.summary,
+        changes,
+        evidence: proposal.rationale,
+        outcome: proposal.expectedOutcome,
+        created_at: now,
+    });
+    return {
+        id: options.id,
+        summary: proposal.summary,
+        rationale: proposal.rationale,
+        expectedOutcome: proposal.expectedOutcome,
+        appliedEdits,
+        harnessStatePath: "",
+        ...(options.rollbackOf ? { rollbackOf: options.rollbackOf } : {}),
+        ...(options.scope ? { scope: options.scope } : {}),
+    };
+}
+export { entryChangedSince };
+//# sourceMappingURL=apply.js.map

package/lib/approval.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Human approval gate for cross-session (global) evolution edits. Forward
+ * edits to the shared global store require an explicit human "批准" before
+ * they are applied; rollbacks (which restore prior recorded state) do not.
+ * The engine itself stays a pure library — this is a policy at the boundary.
+ */
+import type { Context } from "@deepseek-ai/cordis";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+/**
+ * Ask the user to approve a global edit. Throws when the service is missing,
+ * the user declines, or the question cannot be answered.
+ */
+export declare function requireGlobalApproval(ctx: Context, agent: Agent | undefined, signal: AbortSignal | undefined, what: string): Promise<void>;
+//# sourceMappingURL=approval.d.ts.map

package/lib/approval.js

@@ -0,0 +1,27 @@
+/**
+ * Ask the user to approve a global edit. Throws when the service is missing,
+ * the user declines, or the question cannot be answered.
+ */
+export async function requireGlobalApproval(ctx, agent, signal, what) {
+    const userQuestions = ctx.userQuestions;
+    if (!userQuestions) {
+        throw new Error("global evolution edits require the userQuestions service (load @deepseek-ai/dsh-user-questions)");
+    }
+    const answer = await userQuestions.ask({
+        questions: [
+            {
+                id: "approve-global-evolve",
+                question: `批准写入跨会话全局 store？\n\n${what}`,
+                options: [{ label: "批准" }, { label: "拒绝" }],
+            },
+        ],
+        ...(agent ? { agent } : {}),
+        ...(signal ? { signal } : {}),
+    });
+    const item = answer.answers?.find((entry) => entry.id === "approve-global-evolve");
+    const approved = item?.selected?.includes("批准") ?? false;
+    if (!approved) {
+        throw new Error("global evolution edit rejected by the user");
+    }
+}
+//# sourceMappingURL=approval.js.map

package/lib/auto.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { HarnessState } from "./types.js";
+import type { EvolutionEngine } from "./service.js";
+export interface AutoReviewConfig {
+    intervalTurns: number;
+    maxInputChars: number;
+    budgetTokens: number;
+    /** Queue a visible follow-up notice after an approved, applied gate run. */
+    notifyOnAutoReview: boolean;
+}
+export interface GateState {
+    turns: number;
+    lastReviewAt: number;
+    running: boolean;
+}
+/**
+ * Count completed turns from agent/status transitions alone. The runtime
+ * emits `agent/status` with a `{status}` payload and (per host consumers like
+ * dsh-host-apiproxy) an injected `agent` subject; `agent/turn-stopping` does
+ * not reliably carry the agent, so it is NOT used for counting.
+ */
+export declare function advanceGateState(state: GateState, status: string): boolean;
+export declare function registerAutoReview(ctx: Context, engine: EvolutionEngine, config: AutoReviewConfig): void;
+/**
+ * The state view the gate and planner judge: the session's local entries
+ * merged with the global store, each entry carrying its real scope. Without
+ * the global half the gate cannot see that a topic is already covered
+ * cross-session and happily re-sediments a local duplicate of it.
+ *
+ * The merged view is read-only context — applying still targets the raw
+ * local state (baseline checks compare local entries only).
+ */
+export declare function loadGateHarnessView(engine: EvolutionEngine, sessionId: string): HarnessState;
+//# sourceMappingURL=auto.d.ts.map

package/lib/auto.js

@@ -0,0 +1,217 @@
+/**
+ * The automatic review driver: watches agent turns and session compaction,
+ * runs the cheap review gate, and — when the gate approves — runs the
+ * local-scope planner and applies the result. All auxiliary work is
+ * fire-and-forget with error containment: an auto-review failure never
+ * disturbs the agent loop.
+ *
+ * Every gate decision (approved / declined / failed) is appended to
+ * `<dshHome>/evolve/reviews.jsonl` so auto-review activity is durably
+ * auditable — the server console is not a reliable place to look.
+ *
+ * Hook wiring:
+ * - `agent/turn-stopping` increments a per-session turn counter (sync, cheap).
+ * - `agent/status` (idle) checks the interval and may start the gate.
+ * - `session/event` (compaction/start) starts an unconditional gate run so
+ *   experiences about to be summarized away are persisted first.
+ */
+import { appendFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { planWithLlm } from "./planner.js";
+import { reviewAutoRefine, serializeSurface } from "./review.js";
+import { goalServiceOf } from "./goal.js";
+import { notifyAutoReview } from "./notify.js";
+import { entrySourceOf } from "./source.js";
+import { mergeHarnessStates } from "./state.js";
+/**
+ * Count completed turns from agent/status transitions alone. The runtime
+ * emits `agent/status` with a `{status}` payload and (per host consumers like
+ * dsh-host-apiproxy) an injected `agent` subject; `agent/turn-stopping` does
+ * not reliably carry the agent, so it is NOT used for counting.
+ */
+export function advanceGateState(state, status) {
+    if (status === "running") {
+        state.running = true;
+        return false;
+    }
+    if (status === "idle" && state.running) {
+        state.running = false;
+        state.turns += 1;
+        return true;
+    }
+    return false;
+}
+export function registerAutoReview(ctx, engine, config) {
+    const perSession = new Map();
+    const logger = ctx.logger("continual-evolve");
+    const reviewsPath = join(engine.baseDir, "evolve", "reviews.jsonl");
+    const record = (entry) => {
+        try {
+            mkdirSync(join(engine.baseDir, "evolve"), { recursive: true });
+            appendFileSync(reviewsPath, `${JSON.stringify({ ...entry, timestamp: new Date().toISOString() })}\n`, "utf8");
+        }
+        catch (cause) {
+            logger.warn(`failed to record auto-review: ${cause instanceof Error ? cause.message : String(cause)}`);
+        }
+    };
+    // Turn counting uses `agent/turn-stopping` — empirically the only event
+    // whose payload carries the agent subject in every dispatch (verified: the
+    // gate fired under it at 20:56). `agent/status` serves as the idle trigger.
+    ctx.on("agent/turn-stopping", (payload) => {
+        const agent = payload.agent;
+        if (!agent) {
+            logger.warn(`auto-review gate: agent/turn-stopping payload missing agent; skipping count`);
+            return;
+        }
+        const state = stateFor(perSession, agent.id);
+        state.turns += 1;
+    });
+    ctx.on("agent/status", (payload) => {
+        const agent = payload.agent;
+        if (!agent || payload.status !== "idle")
+            return;
+        const state = stateFor(perSession, agent.id);
+        // v3 optional: an active evolution goal drives the gate EVERY round
+        // (the goal's round machine keeps the session continuing); without a
+        // goal the plain turn interval applies.
+        const goalDriven = goalServiceOf(ctx)?.get(agent)?.phase === "active";
+        if (!goalDriven && state.turns - state.lastReviewAt < config.intervalTurns)
+            return;
+        // Run the gate outside the listener turn: agent is idle, work is auxiliary.
+        // Every failure is durably recorded — nothing fails silently.
+        void runGate(ctx, engine, agent, config, state, "turn_interval", record).catch((cause) => {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            logger.warn(`auto-review failed for ${agent.id}: ${message}`);
+            record({
+                sessionId: agent.id,
+                reason: "turn_interval",
+                turnsSinceLastReview: state.turns - state.lastReviewAt,
+                outcome: "failed",
+                rationale: `gate error: ${message}`,
+            });
+            state.lastReviewAt = state.turns; // back off until the interval elapses again
+        });
+    });
+    // Diagnostic: the armed marker proves registerAutoReview ran with the
+    // configured interval; a restart that writes it but nothing after means the
+    // trigger events are not reaching this listener.
+    try {
+        mkdirSync(join(engine.baseDir, "evolve"), { recursive: true });
+        appendFileSync(reviewsPath, `${JSON.stringify({
+            timestamp: new Date().toISOString(),
+            sessionId: "boot",
+            reason: "boot",
+            turnsSinceLastReview: 0,
+            outcome: "armed",
+            rationale: `auto-review gate registered (interval=${config.intervalTurns})`,
+        })}\n`, "utf8");
+    }
+    catch (cause) {
+        logger.warn(`failed to write armed marker: ${cause instanceof Error ? cause.message : String(cause)}`);
+    }
+    ctx.on("session/event", (session, event) => {
+        if (event.type !== "compaction/start")
+            return;
+        const agents = ctx.agents;
+        const agent = agents?.get(session.id);
+        if (!agent)
+            return; // no live agent for that session (e.g. cold read)
+        const state = stateFor(perSession, agent.id);
+        // Compaction is unconditional: persist what is about to be summarized away.
+        void runGate(ctx, engine, agent, config, state, "compact", record).catch((cause) => {
+            logger.warn(`auto-review failed at compaction for ${agent.id}: ${cause instanceof Error ? cause.message : String(cause)}`);
+            record({
+                sessionId: agent.id,
+                reason: "compact",
+                turnsSinceLastReview: state.turns - state.lastReviewAt,
+                outcome: "failed",
+                rationale: `gate error at compaction: ${cause instanceof Error ? cause.message : String(cause)}`,
+            });
+        });
+    });
+}
+function stateFor(map, sessionId) {
+    let state = map.get(sessionId);
+    if (!state) {
+        state = { turns: 0, lastReviewAt: 0, running: false };
+        map.set(sessionId, state);
+    }
+    return state;
+}
+/**
+ * The state view the gate and planner judge: the session's local entries
+ * merged with the global store, each entry carrying its real scope. Without
+ * the global half the gate cannot see that a topic is already covered
+ * cross-session and happily re-sediments a local duplicate of it.
+ *
+ * The merged view is read-only context — applying still targets the raw
+ * local state (baseline checks compare local entries only).
+ */
+export function loadGateHarnessView(engine, sessionId) {
+    return mergeHarnessStates(engine.load("global", undefined), engine.load("local", sessionId));
+}
+async function runGate(ctx, engine, agent, config, state, reason, record) {
+    const sessionId = agent.id;
+    const turnsSinceLastReview = state.turns - state.lastReviewAt;
+    const logger = ctx.logger("continual-evolve");
+    const trajectory = await readTrajectory(ctx, agent, config.maxInputChars).catch((cause) => {
+        logger.warn(`auto-review skipped for ${sessionId}: trajectory unavailable: ${cause instanceof Error ? cause.message : String(cause)}`);
+        record({ sessionId, reason, turnsSinceLastReview, outcome: "failed", rationale: `trajectory unavailable: ${cause instanceof Error ? cause.message : String(cause)}` });
+        return undefined;
+    });
+    if (!trajectory) {
+        state.lastReviewAt = state.turns;
+        return;
+    }
+    // The gate judges the merged view (global + local, scopes labeled) so it
+    // can recognize topics already covered globally and decline duplicates;
+    // applying still targets the raw local store.
+    const localState = engine.load("local", sessionId);
+    const harnessState = loadGateHarnessView(engine, sessionId);
+    const history = engine.history("local", sessionId);
+    const review = await reviewAutoRefine(ctx, {
+        agent,
+        state: harnessState,
+        history,
+        trajectory,
+        context: { reason, turnsSinceLastReview },
+        budgetTokens: config.budgetTokens,
+    });
+    state.lastReviewAt = state.turns;
+    if (!review.shouldRefine) {
+        logger.info(`auto-review declined (${reason}) [${sessionId}] after ${turnsSinceLastReview} turns: ${review.rationale}`);
+        record({ sessionId, reason, turnsSinceLastReview, outcome: "declined", rationale: review.rationale });
+        return;
+    }
+    const proposal = await planWithLlm(ctx, {
+        agent,
+        state: harnessState,
+        history,
+        ...(review.instructions ? { instructions: review.instructions } : {}),
+        global: false,
+    });
+    const source = entrySourceOf(agent, sessionId);
+    const result = engine.apply("local", sessionId, proposal, {
+        scope: "local",
+        baselineState: localState,
+        ...(source ? { source } : {}),
+    });
+    logger.info(`auto-review approved (${reason}) [${sessionId}] after ${turnsSinceLastReview} turns; auto-refine ${result.id}: ${result.appliedEdits.filter((e) => e.applied).length} applied, ${result.appliedEdits.filter((e) => !e.applied).length} failed — ${review.rationale}`);
+    record({ sessionId, reason, turnsSinceLastReview, outcome: "approved", rationale: review.rationale, refinementId: result.id });
+    // Visibility: tell the user what the gate just persisted. Only the
+    // turn-interval path notifies — a compaction-triggered gate must not wake
+    // the agent mid-compaction — and only when something was actually applied
+    // (a notice for zero edits is noise). Failure is contained in notifyAutoReview.
+    if (config.notifyOnAutoReview && reason === "turn_interval" && result.appliedEdits.some((e) => e.applied)) {
+        notifyAutoReview(ctx, agent, result, turnsSinceLastReview);
+    }
+}
+async function readTrajectory(ctx, agent, maxChars) {
+    const sessionQuery = ctx.sessionQuery;
+    if (!sessionQuery) {
+        throw new Error("sessionQuery unavailable");
+    }
+    const snapshot = await sessionQuery.readSurface(agent.id);
+    return serializeSurface(snapshot.events, maxChars);
+}
+//# sourceMappingURL=auto.js.map

package/lib/benchmark.d.ts

@@ -0,0 +1,72 @@
+import type { EvolutionEngine } from "./service.js";
+export interface BenchmarkCase {
+    id: string;
+    title: string;
+    statement: string;
+    rubric: string;
+}
+export interface BenchmarkDefinition {
+    id: string;
+    title: string;
+    description: string;
+    runs: number;
+    passThreshold: number;
+    createdAt: string;
+}
+export interface CellScore {
+    caseId: string;
+    run: number;
+    score: number;
+    passed: boolean;
+    notes: string;
+}
+export interface EvaluationEntry {
+    label: string;
+    refinementId?: string;
+    createdAt: string;
+    cells: CellScore[];
+    /** Code-owned aggregates (model never writes these). */
+    aggregate: Record<string, number | null>;
+    overall: number | null;
+}
+export interface Scoreboard {
+    reference?: EvaluationEntry;
+    candidates: EvaluationEntry[];
+    decisions: {
+        candidateLabel: string;
+        refinementId?: string;
+        accepted: boolean;
+        reasons: string[];
+        createdAt: string;
+    }[];
+}
+export interface AutoRollbackOutcome {
+    rolledBack: boolean;
+    message: string;
+}
+/**
+ * Close the acceptance loop: when the code-owned decision rejects a
+ * candidate refinement, revert it deterministically. The rollback is the
+ * same engine path as `/evolve rollback` (inverse edits rebuilt from the
+ * applied result — no LLM re-guessing), so it snapshots, versions, and
+ * audits like any other mutation. Failures (e.g. the refinement belongs to
+ * another session's history) are reported, never thrown: the command shows
+ * the manual fallback instead.
+ */
+export declare function rollbackRejectedCandidate(engine: EvolutionEngine, sessionId: string | undefined, candidateId: string): AutoRollbackOutcome;
+export declare function benchmarkDir(baseDir: string, bid: string): string;
+export declare function sanitizeId(raw: string): string;
+export declare function createBenchmark(baseDir: string, opts: {
+    title: string;
+    description?: string;
+    runs?: number;
+    passThreshold?: number;
+}): BenchmarkDefinition;
+export declare function listBenchmarks(baseDir: string): BenchmarkDefinition[];
+export declare function loadBenchmark(baseDir: string, bid: string): BenchmarkDefinition | undefined;
+export declare function addCase(baseDir: string, bid: string, title: string, statement: string, rubric: string, rubricKey?: Buffer): BenchmarkCase;
+export declare function listCases(baseDir: string, bid: string): BenchmarkCase[];
+export declare function loadScoreboard(baseDir: string, bid: string): Scoreboard;
+export declare function saveScoreboard(baseDir: string, bid: string, board: Scoreboard): void;
+export declare function removeBenchmark(baseDir: string, bid: string): void;
+//# sourceMappingURL=benchmark.d.ts.map

package/lib/benchmark.js

@@ -0,0 +1,167 @@
+/**
+ * Benchmark store: file-backed case definitions and scoreboards under
+ * `<baseDir>/evolve/benchmarks/<bid>/`.
+ *
+ * Layout:
+ *   benchmark.json          title, runs (repeats per case), passThreshold
+ *   cases/<cid>/statement.md   public task text
+ *   cases/<cid>/rubric.json    encrypted scoring criteria (AES-256-GCM, see src/rubric.ts)
+ *   scoreboard.json         code-owned aggregates + acceptance history
+ *
+ * Rubric isolation is code-enforced: rubric plaintext never reaches the
+ * disk. Only the evaluation runner decrypts (into the child prompt); the
+ * optimizer can read the file and sees ciphertext only. Legacy files that
+ * predate encryption carry plaintext and are still readable.
+ */
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { encryptRubric, DEV_RUBRIC_KEY, deriveKey } from "./rubric.js";
+/**
+ * Close the acceptance loop: when the code-owned decision rejects a
+ * candidate refinement, revert it deterministically. The rollback is the
+ * same engine path as `/evolve rollback` (inverse edits rebuilt from the
+ * applied result — no LLM re-guessing), so it snapshots, versions, and
+ * audits like any other mutation. Failures (e.g. the refinement belongs to
+ * another session's history) are reported, never thrown: the command shows
+ * the manual fallback instead.
+ */
+export function rollbackRejectedCandidate(engine, sessionId, candidateId) {
+    try {
+        const result = engine.rollback("local", sessionId, candidateId);
+        const applied = result.appliedEdits.filter((edit) => edit.applied).length;
+        return {
+            rolledBack: true,
+            message: `auto-rollback: reverted refinement ${candidateId} — ${applied} edits restored to the pre-refinement snapshot`,
+        };
+    }
+    catch (cause) {
+        return {
+            rolledBack: false,
+            message: `auto-rollback failed: ${cause instanceof Error ? cause.message : String(cause)} — roll back manually with /evolve rollback <${candidateId}>`,
+        };
+    }
+}
+export function benchmarkDir(baseDir, bid) {
+    return join(baseDir, "evolve", "benchmarks", bid);
+}
+export function sanitizeId(raw) {
+    const id = raw.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "").slice(0, 40);
+    if (!id) {
+        throw new Error("benchmark id must be a non-empty slug");
+    }
+    return id;
+}
+export function createBenchmark(baseDir, opts) {
+    const id = sanitizeId(opts.title);
+    const dir = benchmarkDir(baseDir, id);
+    if (existsSync(dir)) {
+        throw new Error(`benchmark ${id} already exists`);
+    }
+    const definition = {
+        id,
+        title: opts.title.trim(),
+        description: opts.description?.trim() ?? "",
+        runs: opts.runs ?? 1,
+        passThreshold: opts.passThreshold ?? 60,
+        createdAt: new Date().toISOString(),
+    };
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "benchmark.json"), `${JSON.stringify(definition, null, 2)}\n`, "utf8");
+    writeFileSync(join(dir, "scoreboard.json"), `${JSON.stringify({ candidates: [], decisions: [] }, null, 2)}\n`, "utf8");
+    return definition;
+}
+export function listBenchmarks(baseDir) {
+    const root = join(baseDir, "evolve", "benchmarks");
+    if (!existsSync(root))
+        return [];
+    return readdirSafe(root)
+        .map((id) => loadBenchmark(baseDir, id))
+        .filter((b) => b !== undefined);
+}
+export function loadBenchmark(baseDir, bid) {
+    const path = join(benchmarkDir(baseDir, bid), "benchmark.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function addCase(baseDir, bid, title, statement, rubric, rubricKey) {
+    const definition = loadBenchmark(baseDir, bid);
+    if (!definition) {
+        throw new Error(`benchmark ${bid} not found`);
+    }
+    const id = sanitizeId(title);
+    const caseDir = join(benchmarkDir(baseDir, bid), "cases", id);
+    if (existsSync(caseDir)) {
+        throw new Error(`case ${id} already exists in ${bid}`);
+    }
+    mkdirSync(caseDir, { recursive: true });
+    writeFileSync(join(caseDir, "statement.md"), statement, "utf8");
+    // Rubric plaintext never touches the disk; callers pass a resolved key
+    // (config → env → per-installation key file → dev fallback, see
+    // resolveRubricKey) and the dev key here is only a defensive last resort.
+    const stored = rubricKey ? encryptRubric(rubric, rubricKey) : encryptRubric(rubric, deriveKey(DEV_RUBRIC_KEY));
+    writeFileSync(join(caseDir, "rubric.json"), `${JSON.stringify(stored, null, 2)}\n`, "utf8");
+    return { id, title: title.trim(), statement, rubric };
+}
+export function listCases(baseDir, bid) {
+    const casesDir = join(benchmarkDir(baseDir, bid), "cases");
+    if (!existsSync(casesDir))
+        return [];
+    return readdirSafe(casesDir)
+        .map((id) => {
+        const statementPath = join(casesDir, id, "statement.md");
+        const rubricPath = join(casesDir, id, "rubric.json");
+        if (!existsSync(statementPath) || !existsSync(rubricPath))
+            return undefined;
+        try {
+            const statement = readFileSync(statementPath, "utf8");
+            const rubric = JSON.parse(readFileSync(rubricPath, "utf8"));
+            return { id, title: id, statement, rubric };
+        }
+        catch {
+            return undefined;
+        }
+    })
+        .filter((c) => c !== undefined);
+}
+export function loadScoreboard(baseDir, bid) {
+    const path = join(benchmarkDir(baseDir, bid), "scoreboard.json");
+    if (!existsSync(path)) {
+        return { candidates: [], decisions: [] };
+    }
+    try {
+        const raw = JSON.parse(readFileSync(path, "utf8"));
+        return {
+            ...(raw.reference ? { reference: raw.reference } : {}),
+            candidates: raw.candidates ?? [],
+            decisions: raw.decisions ?? [],
+        };
+    }
+    catch {
+        return { candidates: [], decisions: [] };
+    }
+}
+export function saveScoreboard(baseDir, bid, board) {
+    writeFileSync(join(benchmarkDir(baseDir, bid), "scoreboard.json"), `${JSON.stringify(board, null, 2)}\n`, "utf8");
+}
+export function removeBenchmark(baseDir, bid) {
+    const dir = benchmarkDir(baseDir, bid);
+    if (existsSync(dir)) {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+import { readdirSync } from "node:fs";
+function readdirSafe(dir) {
+    try {
+        return readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=benchmark.js.map