dsh-continual-evolve 0.2.0 → 0.4.0

package/lib/benchmark.js

@@ -106,6 +106,8 @@ export function addCase(baseDir, bid, title, statement, rubric, rubricKey) {
     // 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");
+    // A5: initialize case metadata for quality gate.
+    saveCaseMeta(baseDir, bid, id, defaultCaseMeta());
     return { id, title: title.trim(), statement, rubric };
 }
 export function listCases(baseDir, bid) {
@@ -121,7 +123,8 @@ export function listCases(baseDir, bid) {
         try {
             const statement = readFileSync(statementPath, "utf8");
             const rubric = JSON.parse(readFileSync(rubricPath, "utf8"));
-            return { id, title: id, statement, rubric };
+            const meta = loadCaseMeta(baseDir, bid, id);
+            return { id, title: id, statement, rubric, ...(meta ? { status: meta.status } : {}) };
         }
         catch {
             return undefined;
@@ -149,6 +152,109 @@ export function loadScoreboard(baseDir, bid) {
 export function saveScoreboard(baseDir, bid, board) {
     writeFileSync(join(benchmarkDir(baseDir, bid), "scoreboard.json"), `${JSON.stringify(board, null, 2)}\n`, "utf8");
 }
+// ── Case meta (gap A5: quality gate + calibration history) ────────────
+export function loadCaseMeta(baseDir, bid, cid) {
+    const path = join(benchmarkDir(baseDir, bid), "cases", cid, "meta.json");
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function saveCaseMeta(baseDir, bid, cid, meta) {
+    const metaDir = join(benchmarkDir(baseDir, bid), "cases", cid);
+    mkdirSync(metaDir, { recursive: true });
+    writeFileSync(join(metaDir, "meta.json"), `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+}
+/** List case metas for all cases in a benchmark (missing meta → defaults). */
+export function listCaseMetas(baseDir, bid) {
+    const result = new Map();
+    const cases = listCases(baseDir, bid);
+    for (const c of cases) {
+        const meta = loadCaseMeta(baseDir, bid, c.id);
+        if (meta) {
+            result.set(c.id, meta);
+        }
+    }
+    return result;
+}
+/** Check whether a case is frozen (immutable). */
+export function isCaseFrozen(baseDir, bid, cid) {
+    const meta = loadCaseMeta(baseDir, bid, cid);
+    return meta?.status === "frozen";
+}
+/**
+ * Transition a case's lifecycle state. Throws on illegal transitions.
+ *   draft → calibrating (start pilot)
+ *   calibrating → draft (abandon calibration)
+ *   calibrating → frozen (lock baseline)
+ */
+export function transitionCaseStatus(baseDir, bid, cid, to) {
+    const meta = loadCaseMeta(baseDir, bid, cid) ?? defaultCaseMeta();
+    const from = meta.status;
+    const valid = (from === "draft" && to === "calibrating") ||
+        (from === "calibrating" && to === "draft") ||
+        (from === "calibrating" && to === "frozen");
+    if (!valid) {
+        throw new Error(`illegal case status transition: ${from} → ${to}`);
+    }
+    meta.status = to;
+    saveCaseMeta(baseDir, bid, cid, meta);
+    return meta;
+}
+function defaultCaseMeta() {
+    return {
+        status: "draft",
+        capability: "",
+        distinguisher: "",
+        shortcuts: "",
+        calibrationHistory: [],
+    };
+}
+/**
+ * Quality-check a case: mechanical validation without LLM calls.
+ * Returns human-readable problems; empty array means the case passes.
+ */
+export function caseCheckProblems(baseDir, bid, cid) {
+    const problems = [];
+    const statementPath = join(benchmarkDir(baseDir, bid), "cases", cid, "statement.md");
+    if (!existsSync(statementPath)) {
+        problems.push("statement.md missing");
+        return problems;
+    }
+    const statement = readFileSync(statementPath, "utf8").trim();
+    if (statement.length < 20) {
+        problems.push(`statement too short (${statement.length} chars, minimum 20)`);
+    }
+    const rubricPath = join(benchmarkDir(baseDir, bid), "cases", cid, "rubric.json");
+    if (!existsSync(rubricPath)) {
+        problems.push("rubric.json missing");
+        return problems;
+    }
+    try {
+        const raw = readFileSync(rubricPath, "utf8");
+        JSON.parse(raw);
+    }
+    catch {
+        problems.push("rubric.json is not valid JSON");
+    }
+    const meta = loadCaseMeta(baseDir, bid, cid);
+    if (!meta) {
+        problems.push("meta.json missing (run /evolve benchmark casecheck to initialize)");
+    }
+    else {
+        if (!meta.capability)
+            problems.push("capability contract is empty");
+        if (!meta.distinguisher)
+            problems.push("distinguisher is empty");
+        if (!meta.shortcuts)
+            problems.push("shortcuts annotation is empty");
+    }
+    return problems;
+}
 export function removeBenchmark(baseDir, bid) {
     const dir = benchmarkDir(baseDir, bid);
     if (existsSync(dir)) {

package/lib/command.d.ts

@@ -5,6 +5,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { HarnessEntry, HarnessState, RefinementKind } from "./types.js";
 import type { EvolutionEngine } from "./service.js";
+import type { PromotionPolicy } from "./promotion.js";
 export interface CommandGateOptions {
     requireGlobalApproval: boolean;
 }
@@ -12,6 +13,8 @@ export interface CommandRuntimeOptions {
     rubricKey: Buffer;
     /** When a benchmark decision rejects a candidate, roll the refinement back automatically. */
     autoRollbackOnReject: boolean;
+    /** Mechanical promotion guards for wrapup/fate (2026-08-22 policy). */
+    promotionPolicy: PromotionPolicy;
 }
 export declare function registerEvolveCommand(ctx: Context, engine: EvolutionEngine, opts: CommandGateOptions, runtime: CommandRuntimeOptions): void;
 /**