@tea-agent/loop-agent 0.16.1-beta.1 → 0.16.1

package/dist/commands/init.js

@@ -859,6 +859,12 @@ export function buildManagedGitignoreBlock() {
         ".harness/*.log",
         ".harness/init-surface.json",
         "",
+        "# Eval Lab runtime (candidates, campaigns, scorecards, dogfood scratch)",
+        ".harness/evaluation/",
+        "",
+        "# fullstack / worker dogfood evidence (local campaign scratch)",
+        ".harness/dogfood-evidence/",
+        "",
         "# worker task pool",
         ".harness/task-pool/*",
         ".task-pool/",
@@ -2089,7 +2095,7 @@ export function buildInitInstructions(input) {
         "- Enrich the root `README.md`: keep the deterministic project title and the loop-agent managed block intact, and fill the human-authored sections (项目概览, 技术栈与目录结构, 开发与验证) from the target project's actual files. The root README must serve both as a human-first project entry and as an agent work entry; replace the initialization-model supplement comments when the project files provide the information.",
         `- Populate \`${governanceRoot}/verification-matrix.md\` with the target project's actual quick, standard, and full verification commands derived from its real language and toolchain, keeping the governance rows intact.`,
         "- Project repo-local skills live in `.agents/skills/`. Do not create a root `skills/` directory in the target project; the package's bundled `skills/` remains the built-in fallback.",
-        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
+        "- Merge a loop-agent managed block into `.gitignore` that ignores harness runtime facts (tasks, dag-runs, runs, evaluation, dogfood-evidence, live, cache, init-surface.json, .harness/task-pool, legacy .task-pool residue) while keeping prompts and directory placeholders shareable.",
         "- Do not copy examples by default; examples stay bundled in the tool and are available through `loop-agent examples`.",
         "- Add or update a loop-agent managed block in AGENTS.md.",
         "- The generated AGENTS.md must include documentation convergence and structured DAG write-boundary rules so target projects keep the same working discipline as this repository.",

package/dist/executors/dag-pi-executor.js

@@ -272,7 +272,7 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         persona,
         step,
     });
-    const mapped = mapPiResultToDagNodeResult(result, input.task.firstProtocolLine);
+    const mapped = mapPiResultToDagNodeResult(result);
     if (!isWriteTask) {
         return mapped;
     }
@@ -313,57 +313,17 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep) {
         durationMs: mapped.durationMs || Date.now() - started,
     };
 }
-export function mapPiResultToDagNodeResult(result, firstProtocolLine) {
-    const assistantText = canonicalizeProtocolFirstLine(result.assistantText, firstProtocolLine);
+export function mapPiResultToDagNodeResult(result) {
     return {
         ok: result.ok,
-        stdout: assistantText || result.stdout,
+        stdout: result.assistantText || result.stdout,
         stderr: result.stderr,
         failureCategory: result.failureCategory,
         durationMs: result.durationMs,
-        assistantText,
+        assistantText: result.assistantText,
         backend: result.backend,
         sdkAttempted: result.sdkAttempted,
         tokensUsed: result.tokensUsed,
         parsedEvents: result.parsedEvents,
     };
 }
-function canonicalizeProtocolFirstLine(assistantText, firstProtocolLine) {
-    if (!assistantText || !firstProtocolLine)
-        return assistantText;
-    const lines = assistantText.split(/\r?\n/);
-    let protocolIndex = -1;
-    let protocolLine = "";
-    for (const [index, line] of lines.entries()) {
-        const normalized = normalizeProtocolLine(line);
-        if (normalized.startsWith(firstProtocolLine)) {
-            protocolIndex = index;
-            protocolLine = normalized;
-            break;
-        }
-    }
-    if (protocolIndex < 0)
-        return assistantText;
-    if (protocolIndex === 0) {
-        return [protocolLine, ...lines.slice(1)].join("\n");
-    }
-    const before = lines.slice(0, protocolIndex);
-    const after = lines.slice(protocolIndex + 1);
-    while (before.at(-1)?.trim() === "" &&
-        after.at(0)?.trim() === "") {
-        after.shift();
-    }
-    const bodyLines = [...before, ...after];
-    while (bodyLines.at(0)?.trim() === "")
-        bodyLines.shift();
-    while (bodyLines.at(-1)?.trim() === "")
-        bodyLines.pop();
-    return bodyLines.length > 0
-        ? `${protocolLine}\n\n${bodyLines.join("\n")}`
-        : protocolLine;
-}
-function normalizeProtocolLine(line) {
-    const trimmed = line.trim();
-    const emphasized = trimmed.match(/^(\*{1,3})\s*(.*?)\s*\1$/);
-    return (emphasized?.[2] ?? trimmed).trim();
-}

package/dist/executors/shell-executor.js

@@ -98,7 +98,7 @@ export async function executeShellCommand(input) {
                 HARNESS_DAG_RUN_ID: input.dagRunMeta.runId,
             }
             : undefined;
-        const child = spawn(resolveBashExecutable(), ["-lc", input.command], {
+        const child = spawn(resolveBashExecutable(), ["-c", input.command], {
             cwd: input.cwd,
             env: buildShellProcessEnv(input.envAllowlist, injectedEnv),
             stdio: ["ignore", "pipe", "pipe"],

package/dist/infrastructure/evaluation/alias-store.js

@@ -0,0 +1,199 @@
+import { createHash } from "node:crypto";
+import { access, mkdir, readdir, readFile, rm, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { aliasHistoryEventSchema, aliasNameSchema, incumbentAliasSchema, promotionDecisionSchema, } from "../../application/evaluation/types.js";
+import { appendJsonlLineAtomic, writeJsonAtomic, writeTextAtomic, } from "../harness/atomic-write.js";
+import { EVALUATION_ROOT } from "./store.js";
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const ALIAS_LOCK_DIR = ".lock";
+const ALIAS_LOCK_RETRIES = 40;
+const ALIAS_LOCK_DELAY_MS = 25;
+const CURRENT_INTEGRITY_FILE = "current.sha256";
+export function assertAliasName(value) {
+    aliasNameSchema.parse(value);
+    if (!SAFE_ID.test(value)) {
+        throw new Error(`alias must contain only letters, numbers, dot, underscore, or hyphen: ${value}`);
+    }
+}
+export function aliasDir(repoRoot, alias) {
+    assertAliasName(alias);
+    return path.join(repoRoot, EVALUATION_ROOT, "aliases", alias);
+}
+export function aliasCurrentPath(repoRoot, alias) {
+    return path.join(aliasDir(repoRoot, alias), "current.json");
+}
+export function aliasHistoryPath(repoRoot, alias) {
+    return path.join(aliasDir(repoRoot, alias), "history.jsonl");
+}
+export function decisionDir(repoRoot) {
+    return path.join(repoRoot, EVALUATION_ROOT, "decisions");
+}
+export function decisionPath(repoRoot, decisionId) {
+    if (!SAFE_ID.test(decisionId)) {
+        throw new Error(`decision-id must contain only letters, numbers, dot, underscore, or hyphen: ${decisionId}`);
+    }
+    return path.join(decisionDir(repoRoot), `${decisionId}.json`);
+}
+function sha256Hex(content) {
+    return createHash("sha256").update(content, "utf8").digest("hex");
+}
+function serializeAlias(alias) {
+    return `${JSON.stringify(alias, null, 2)}\n`;
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function acquireAliasLock(repoRoot, alias) {
+    const lockPath = path.join(aliasDir(repoRoot, alias), ALIAS_LOCK_DIR);
+    await mkdir(aliasDir(repoRoot, alias), { recursive: true });
+    for (let attempt = 0; attempt < ALIAS_LOCK_RETRIES; attempt += 1) {
+        try {
+            await mkdir(lockPath);
+            return async () => {
+                await rm(lockPath, { recursive: true, force: true });
+            };
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            await new Promise((resolve) => setTimeout(resolve, ALIAS_LOCK_DELAY_MS));
+        }
+    }
+    throw new Error(`timed out acquiring alias lock for ${alias}`);
+}
+async function assertCurrentIntegrity(repoRoot, alias, raw) {
+    const integrityPath = path.join(aliasDir(repoRoot, alias), CURRENT_INTEGRITY_FILE);
+    if (!(await pathExists(integrityPath))) {
+        throw new Error(`missing alias integrity file for ${alias}`);
+    }
+    const expected = (await readFile(integrityPath, "utf-8")).trim();
+    const actual = sha256Hex(raw);
+    if (expected !== actual) {
+        throw new Error(`alias integrity mismatch for ${alias}: expected ${expected}, got ${actual}`);
+    }
+}
+export async function readIncumbentAlias(repoRoot, alias) {
+    assertAliasName(alias);
+    const currentPath = aliasCurrentPath(repoRoot, alias);
+    if (!(await pathExists(currentPath)))
+        return null;
+    const raw = await readFile(currentPath, "utf-8");
+    await assertCurrentIntegrity(repoRoot, alias, raw);
+    const parsed = incumbentAliasSchema.parse(JSON.parse(raw));
+    if (parsed.alias !== alias) {
+        throw new Error(`alias identity mismatch: directory=${alias}, current=${parsed.alias}`);
+    }
+    return parsed;
+}
+export async function listAliasNames(repoRoot) {
+    const root = path.join(repoRoot, EVALUATION_ROOT, "aliases");
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && SAFE_ID.test(entry.name))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function listIncumbentCandidateIds(repoRoot) {
+    const names = await listAliasNames(repoRoot);
+    const ids = new Set();
+    for (const name of names) {
+        const current = await readIncumbentAlias(repoRoot, name);
+        if (current)
+            ids.add(current.candidateId);
+    }
+    return ids;
+}
+export async function readPromotionDecision(repoRoot, decisionId) {
+    const raw = await readFile(decisionPath(repoRoot, decisionId), "utf-8");
+    return promotionDecisionSchema.parse(JSON.parse(raw));
+}
+async function writeAliasCurrentAtomic(input) {
+    const dir = aliasDir(input.repoRoot, input.alias.alias);
+    await mkdir(dir, { recursive: true });
+    const serialized = serializeAlias(input.alias);
+    await writeTextAtomic(aliasCurrentPath(input.repoRoot, input.alias.alias), serialized, {
+        repoRoot: input.repoRoot,
+    });
+    await writeTextAtomic(path.join(dir, CURRENT_INTEGRITY_FILE), `${sha256Hex(serialized)}\n`, { repoRoot: input.repoRoot });
+}
+export async function commitAliasMove(input) {
+    const { repoRoot, decision, nextAlias, historyEvent } = input;
+    assertAliasName(decision.alias);
+    promotionDecisionSchema.parse(decision);
+    incumbentAliasSchema.parse(nextAlias);
+    aliasHistoryEventSchema.parse(historyEvent);
+    if (decision.decisionId !== nextAlias.updatedByDecisionId) {
+        throw new Error("decisionId must match alias.updatedByDecisionId");
+    }
+    if (decision.decisionId !== historyEvent.decisionId) {
+        throw new Error("decisionId must match history event");
+    }
+    const releaseLock = await acquireAliasLock(repoRoot, decision.alias);
+    const previousRaw = await readFile(aliasCurrentPath(repoRoot, decision.alias), "utf-8").catch(() => null);
+    const previousIntegrity = await readFile(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), "utf-8").catch(() => null);
+    const decisionFile = decisionPath(repoRoot, decision.decisionId);
+    let decisionWritten = false;
+    let historyWritten = false;
+    try {
+        if (await pathExists(decisionFile)) {
+            throw new Error(`decision already exists: ${decision.decisionId}`);
+        }
+        await mkdir(decisionDir(repoRoot), { recursive: true });
+        await writeJsonAtomic(decisionFile, decision, { repoRoot });
+        decisionWritten = true;
+        await writeAliasCurrentAtomic({ repoRoot, alias: nextAlias });
+        await appendJsonlLineAtomic(aliasHistoryPath(repoRoot, decision.alias), historyEvent, { repoRoot });
+        historyWritten = true;
+    }
+    catch (error) {
+        // Best-effort rollback of alias pointer + decision; history append is last.
+        if (previousRaw !== null) {
+            await writeTextAtomic(aliasCurrentPath(repoRoot, decision.alias), previousRaw, { repoRoot }).catch(() => undefined);
+            if (previousIntegrity !== null) {
+                await writeTextAtomic(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), previousIntegrity, { repoRoot }).catch(() => undefined);
+            }
+        }
+        else if (!historyWritten) {
+            await rm(aliasCurrentPath(repoRoot, decision.alias), {
+                force: true,
+            }).catch(() => undefined);
+            await rm(path.join(aliasDir(repoRoot, decision.alias), CURRENT_INTEGRITY_FILE), { force: true }).catch(() => undefined);
+        }
+        if (decisionWritten) {
+            await rm(decisionFile, { force: true }).catch(() => undefined);
+        }
+        throw error;
+    }
+    finally {
+        await releaseLock();
+    }
+}
+export function makeDecisionId(input) {
+    const stamp = input.createdAt.replace(/[^A-Za-z0-9._-]/g, "-");
+    const raw = `dec-${input.alias}-${input.action}-${input.toCandidateId}-${stamp}`;
+    return raw.slice(0, 180);
+}
+/** Test helper: force-corrupt integrity without going through commit. */
+export async function writeAliasCurrentForTest(input) {
+    await writeAliasCurrentAtomic({
+        repoRoot: input.repoRoot,
+        alias: input.alias,
+    });
+    if (input.corruptIntegrity) {
+        await writeFile(path.join(aliasDir(input.repoRoot, input.alias.alias), CURRENT_INTEGRITY_FILE), `${"0".repeat(64)}\n`, "utf-8");
+    }
+}

package/dist/infrastructure/evaluation/campaign-store.js

@@ -0,0 +1,154 @@
+import { access, mkdir, mkdtemp, readdir, readFile, rename, rm } from "node:fs/promises";
+import path from "node:path";
+import { campaignEvidenceSchema, campaignIdSchema, campaignManifestSchema, campaignPlanSchema, } from "../../application/evaluation/types.js";
+import { sha256Hex } from "../../application/evaluation/candidate-hash.js";
+import { writeJsonAtomic, writeTextAtomic } from "../harness/atomic-write.js";
+import { EVALUATION_ROOT } from "./store.js";
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const MANIFEST_INTEGRITY_FILE = "manifest.sha256";
+export function assertCampaignId(value) {
+    campaignIdSchema.parse(value);
+}
+export function campaignDir(repoRoot, campaignId) {
+    assertCampaignId(campaignId);
+    return path.join(repoRoot, EVALUATION_ROOT, "campaigns", campaignId);
+}
+export function campaignManifestPath(repoRoot, campaignId) {
+    return path.join(campaignDir(repoRoot, campaignId), "manifest.json");
+}
+export function campaignPlanPath(repoRoot, campaignId) {
+    return path.join(campaignDir(repoRoot, campaignId), "plan.json");
+}
+export function campaignScorecardPath(repoRoot, campaignId) {
+    return path.join(campaignDir(repoRoot, campaignId), "scorecard.json");
+}
+export function campaignEvidencePath(repoRoot, campaignId) {
+    return path.join(campaignDir(repoRoot, campaignId), "evidence.json");
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function serializeManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function manifestsEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+export async function readCampaignManifest(repoRoot, campaignId) {
+    assertCampaignId(campaignId);
+    const manifestPath = campaignManifestPath(repoRoot, campaignId);
+    const rawText = await readFile(manifestPath, "utf-8");
+    const expected = (await readFile(path.join(campaignDir(repoRoot, campaignId), MANIFEST_INTEGRITY_FILE), "utf-8")).trim();
+    const actual = sha256Hex(rawText);
+    if (expected !== actual) {
+        throw new Error(`campaign manifest integrity mismatch for ${campaignId}`);
+    }
+    const stored = campaignManifestSchema.parse(JSON.parse(rawText));
+    if (stored.campaignId !== campaignId) {
+        throw new Error(`campaign identity mismatch: directory=${campaignId}, manifest=${stored.campaignId}`);
+    }
+    return stored;
+}
+export async function readCampaignPlan(repoRoot, campaignId) {
+    const planPath = campaignPlanPath(repoRoot, campaignId);
+    if (!(await pathExists(planPath)))
+        return undefined;
+    return campaignPlanSchema.parse(JSON.parse(await readFile(planPath, "utf-8")));
+}
+export async function listCampaignIds(repoRoot) {
+    const root = path.join(repoRoot, EVALUATION_ROOT, "campaigns");
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && SAFE_ID.test(entry.name))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function registerCampaignManifest(input) {
+    const { repoRoot, manifest } = input;
+    assertCampaignId(manifest.campaignId);
+    const manifestPath = campaignManifestPath(repoRoot, manifest.campaignId);
+    if (await pathExists(manifestPath)) {
+        const existing = await readCampaignManifest(repoRoot, manifest.campaignId);
+        if (!manifestsEqual(existing, manifest)) {
+            throw new Error(`campaign already exists with different content: ${manifest.campaignId}`);
+        }
+        return { manifest: existing, idempotent: true, manifestPath };
+    }
+    const root = path.dirname(campaignDir(repoRoot, manifest.campaignId));
+    await mkdir(root, { recursive: true });
+    const stagingDir = await mkdtemp(path.join(root, `.${manifest.campaignId}.register-`));
+    try {
+        await writeJsonAtomic(path.join(stagingDir, "manifest.json"), manifest, {
+            repoRoot,
+        });
+        await writeTextAtomic(path.join(stagingDir, MANIFEST_INTEGRITY_FILE), `${sha256Hex(serializeManifest(manifest))}\n`, { repoRoot });
+        try {
+            await rename(stagingDir, campaignDir(repoRoot, manifest.campaignId));
+        }
+        catch (error) {
+            const code = error.code;
+            const isCreateRace = code === "EEXIST" ||
+                code === "ENOTEMPTY" ||
+                (code === "EPERM" &&
+                    (await pathExists(campaignDir(repoRoot, manifest.campaignId))));
+            if (!isCreateRace)
+                throw error;
+            await rm(stagingDir, { recursive: true, force: true });
+            const existing = await readCampaignManifest(repoRoot, manifest.campaignId);
+            if (!manifestsEqual(existing, manifest)) {
+                throw new Error(`campaign already exists with different content: ${manifest.campaignId}`);
+            }
+            return { manifest: existing, idempotent: true, manifestPath };
+        }
+    }
+    catch (error) {
+        await rm(stagingDir, { recursive: true, force: true });
+        throw error;
+    }
+    return { manifest, idempotent: false, manifestPath };
+}
+export async function writeCampaignPlan(input) {
+    const planPath = campaignPlanPath(input.repoRoot, input.plan.campaignId);
+    await writeJsonAtomic(planPath, input.plan, { repoRoot: input.repoRoot });
+    return planPath;
+}
+export async function writeCampaignScorecard(input) {
+    const scorecardPath = campaignScorecardPath(input.repoRoot, input.scorecard.campaignId);
+    await writeJsonAtomic(scorecardPath, input.scorecard, {
+        repoRoot: input.repoRoot,
+    });
+    if (input.evidence) {
+        await writeJsonAtomic(campaignEvidencePath(input.repoRoot, input.scorecard.campaignId), input.evidence, { repoRoot: input.repoRoot });
+    }
+    return scorecardPath;
+}
+export async function readCampaignScorecard(repoRoot, campaignId) {
+    const scorecardPath = campaignScorecardPath(repoRoot, campaignId);
+    if (!(await pathExists(scorecardPath)))
+        return undefined;
+    const raw = JSON.parse(await readFile(scorecardPath, "utf-8"));
+    if (raw.schemaVersion !== 1 || raw.campaignId !== campaignId) {
+        throw new Error(`invalid campaign scorecard for ${campaignId}`);
+    }
+    return raw;
+}
+export async function readCampaignEvidence(repoRoot, campaignId) {
+    const evidencePath = campaignEvidencePath(repoRoot, campaignId);
+    if (!(await pathExists(evidencePath)))
+        return undefined;
+    return campaignEvidenceSchema.parse(JSON.parse(await readFile(evidencePath, "utf-8")));
+}

package/dist/infrastructure/evaluation/corpus-store.js

@@ -0,0 +1,181 @@
+import { access, mkdir, readdir, readFile, rename, rm } from "node:fs/promises";
+import path from "node:path";
+import { mkdtemp } from "node:fs/promises";
+import { computeCorpusHash, } from "../../application/evaluation/corpus-hash.js";
+import { formatContentSha, normalizeContentSha, sha256Hex, } from "../../application/evaluation/candidate-hash.js";
+import { corpusIdSchema, corpusManifestInputSchema, corpusManifestSchema, } from "../../application/evaluation/types.js";
+import { writeJsonAtomic, writeTextAtomic } from "../harness/atomic-write.js";
+import { EVALUATION_ROOT } from "./store.js";
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const MANIFEST_INTEGRITY_FILE = "manifest.sha256";
+export function assertCorpusId(value) {
+    corpusIdSchema.parse(value);
+}
+export function corpusDir(repoRoot, corpusId) {
+    assertCorpusId(corpusId);
+    return path.join(repoRoot, EVALUATION_ROOT, "corpora", corpusId);
+}
+export function corpusManifestPath(repoRoot, corpusId) {
+    return path.join(corpusDir(repoRoot, corpusId), "manifest.json");
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function serializeManifest(manifest) {
+    return `${JSON.stringify(manifest, null, 2)}\n`;
+}
+function normalizeTasksForStorage(tasks) {
+    return [...tasks]
+        .map((task) => ({
+        ...task,
+        taskRef: task.taskRef.replace(/\\/g, "/"),
+        seeds: [...task.seeds].sort((a, b) => a - b),
+    }))
+        .sort((a, b) => a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0);
+}
+export async function materializeCorpusManifest(raw) {
+    const input = corpusManifestInputSchema.parse(raw);
+    const tasks = normalizeTasksForStorage(input.tasks);
+    const withoutHash = {
+        schemaVersion: 1,
+        corpusId: input.corpusId,
+        createdAt: input.createdAt,
+        ...(input.description !== undefined
+            ? { description: input.description }
+            : {}),
+        tasks,
+    };
+    const corpusHash = computeCorpusHash(withoutHash);
+    if (input.corpusHash) {
+        const provided = formatContentSha(normalizeContentSha(input.corpusHash));
+        if (provided !== corpusHash) {
+            throw new Error(`corpusHash mismatch: expected ${corpusHash}, got ${provided}`);
+        }
+    }
+    return corpusManifestSchema.parse({
+        ...withoutHash,
+        corpusHash,
+    });
+}
+async function assertManifestIntegrity(repoRoot, corpusId, rawManifest) {
+    const integrityPath = path.join(corpusDir(repoRoot, corpusId), MANIFEST_INTEGRITY_FILE);
+    const expected = (await readFile(integrityPath, "utf-8")).trim();
+    const actual = sha256Hex(rawManifest);
+    if (expected !== actual) {
+        throw new Error(`corpus manifest integrity mismatch for ${corpusId}: expected ${expected}, got ${actual}`);
+    }
+}
+function manifestsEqual(a, b) {
+    return (a.corpusId === b.corpusId &&
+        a.corpusHash === b.corpusHash &&
+        a.createdAt === b.createdAt &&
+        (a.description ?? "") === (b.description ?? "") &&
+        JSON.stringify(a.tasks) === JSON.stringify(b.tasks));
+}
+export async function loadCorpusManifestFromPath(repoRoot, manifestPath) {
+    const resolved = path.isAbsolute(manifestPath)
+        ? manifestPath
+        : path.resolve(repoRoot, manifestPath);
+    const raw = JSON.parse(await readFile(resolved, "utf-8"));
+    return corpusManifestInputSchema.parse(raw);
+}
+export async function readCorpusManifest(repoRoot, corpusId) {
+    assertCorpusId(corpusId);
+    const manifestPath = corpusManifestPath(repoRoot, corpusId);
+    const rawText = await readFile(manifestPath, "utf-8");
+    await assertManifestIntegrity(repoRoot, corpusId, rawText);
+    const stored = corpusManifestSchema.parse(JSON.parse(rawText));
+    if (stored.corpusId !== corpusId) {
+        throw new Error(`corpus identity mismatch: directory=${corpusId}, manifest=${stored.corpusId}`);
+    }
+    const recomputed = computeCorpusHash(stored);
+    if (recomputed !== stored.corpusHash) {
+        throw new Error(`corpusHash mismatch for ${corpusId}: expected ${recomputed}, got ${stored.corpusHash}`);
+    }
+    return stored;
+}
+export async function listCorpusIds(repoRoot) {
+    const root = path.join(repoRoot, EVALUATION_ROOT, "corpora");
+    try {
+        const entries = await readdir(root, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isDirectory() && SAFE_ID.test(entry.name))
+            .map((entry) => entry.name)
+            .sort();
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT")
+            return [];
+        throw error;
+    }
+}
+export async function registerCorpusManifest(input) {
+    const { repoRoot, manifest } = input;
+    assertCorpusId(manifest.corpusId);
+    const manifestPath = corpusManifestPath(repoRoot, manifest.corpusId);
+    if (await pathExists(manifestPath)) {
+        const existing = await readCorpusManifest(repoRoot, manifest.corpusId);
+        if (!manifestsEqual(existing, manifest)) {
+            throw new Error(`corpus already exists with different content: ${manifest.corpusId}`);
+        }
+        return { manifest: existing, idempotent: true, manifestPath };
+    }
+    const corporaRoot = path.dirname(corpusDir(repoRoot, manifest.corpusId));
+    await mkdir(corporaRoot, { recursive: true });
+    const stagingDir = await mkdtemp(path.join(corporaRoot, `.${manifest.corpusId}.register-`));
+    try {
+        await writeJsonAtomic(path.join(stagingDir, "manifest.json"), manifest, {
+            repoRoot,
+        });
+        await writeTextAtomic(path.join(stagingDir, MANIFEST_INTEGRITY_FILE), `${sha256Hex(serializeManifest(manifest))}\n`, { repoRoot });
+        try {
+            await rename(stagingDir, corpusDir(repoRoot, manifest.corpusId));
+        }
+        catch (error) {
+            const code = error.code;
+            const isCreateRace = code === "EEXIST" ||
+                code === "ENOTEMPTY" ||
+                (code === "EPERM" &&
+                    (await pathExists(corpusDir(repoRoot, manifest.corpusId))));
+            if (!isCreateRace)
+                throw error;
+            await rm(stagingDir, { recursive: true, force: true });
+            const existing = await readCorpusManifest(repoRoot, manifest.corpusId);
+            if (!manifestsEqual(existing, manifest)) {
+                throw new Error(`corpus already exists with different content: ${manifest.corpusId}`);
+            }
+            return { manifest: existing, idempotent: true, manifestPath };
+        }
+    }
+    catch (error) {
+        await rm(stagingDir, { recursive: true, force: true });
+        throw error;
+    }
+    return { manifest, idempotent: false, manifestPath };
+}
+export function summarizeCorpus(manifest) {
+    const splits = {
+        public: 0,
+        private: 0,
+        held_out: 0,
+    };
+    const classes = new Set();
+    for (const task of manifest.tasks) {
+        splits[task.split] += 1;
+        classes.add(task.class);
+    }
+    return {
+        corpusId: manifest.corpusId,
+        corpusHash: manifest.corpusHash,
+        taskCount: manifest.tasks.length,
+        splits,
+        classes: [...classes].sort(),
+    };
+}