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

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

@@ -1,154 +0,0 @@
-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

@@ -1,181 +0,0 @@
-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(),
-    };
-}

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

@@ -1,124 +0,0 @@
-import { access, mkdir, mkdtemp, readdir, readFile, rename, rm } from "node:fs/promises";
-import path from "node:path";
-import { experimentIdSchema, experimentRecordSchema, } 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 assertExperimentId(value) {
-    experimentIdSchema.parse(value);
-}
-export function experimentDir(repoRoot, experimentId) {
-    assertExperimentId(experimentId);
-    return path.join(repoRoot, EVALUATION_ROOT, "experiments", experimentId);
-}
-export function experimentManifestPath(repoRoot, experimentId) {
-    return path.join(experimentDir(repoRoot, experimentId), "manifest.json");
-}
-/** Repo-relative content path for experimental learned proposal (allowed as contentRef). */
-export function experimentProposalRepoPath(experimentId) {
-    assertExperimentId(experimentId);
-    return path.posix.join("ai_workspace/loop-agent/evaluation/experiments", experimentId, "learned-proposal.md");
-}
-async function pathExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function serializeRecord(record) {
-    return `${JSON.stringify(record, null, 2)}\n`;
-}
-function recordsEqual(a, b) {
-    return JSON.stringify(a) === JSON.stringify(b);
-}
-export async function readExperimentRecord(repoRoot, experimentId) {
-    assertExperimentId(experimentId);
-    const manifestPath = experimentManifestPath(repoRoot, experimentId);
-    const rawText = await readFile(manifestPath, "utf-8");
-    const expected = (await readFile(path.join(experimentDir(repoRoot, experimentId), MANIFEST_INTEGRITY_FILE), "utf-8")).trim();
-    const actual = sha256Hex(rawText);
-    if (expected !== actual) {
-        throw new Error(`experiment manifest integrity mismatch for ${experimentId}`);
-    }
-    const stored = experimentRecordSchema.parse(JSON.parse(rawText));
-    if (stored.experimentId !== experimentId) {
-        throw new Error(`experiment identity mismatch: directory=${experimentId}, manifest=${stored.experimentId}`);
-    }
-    return stored;
-}
-export async function listExperimentIds(repoRoot) {
-    const root = path.join(repoRoot, EVALUATION_ROOT, "experiments");
-    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 writeExperimentRecord(input) {
-    const { repoRoot, record } = input;
-    assertExperimentId(record.experimentId);
-    const parsed = experimentRecordSchema.parse(record);
-    const manifestPath = experimentManifestPath(repoRoot, parsed.experimentId);
-    if (await pathExists(manifestPath)) {
-        const existing = await readExperimentRecord(repoRoot, parsed.experimentId);
-        if (!recordsEqual(existing, parsed)) {
-            throw new Error(`experiment already exists with different content: ${parsed.experimentId}`);
-        }
-        return { record: existing, idempotent: true, manifestPath };
-    }
-    const root = path.dirname(experimentDir(repoRoot, parsed.experimentId));
-    await mkdir(root, { recursive: true });
-    const stagingDir = await mkdtemp(path.join(root, `.${parsed.experimentId}.register-`));
-    try {
-        await writeJsonAtomic(path.join(stagingDir, "manifest.json"), parsed, {
-            repoRoot,
-        });
-        await writeTextAtomic(path.join(stagingDir, MANIFEST_INTEGRITY_FILE), `${sha256Hex(serializeRecord(parsed))}\n`, { repoRoot });
-        try {
-            await rename(stagingDir, experimentDir(repoRoot, parsed.experimentId));
-        }
-        catch (error) {
-            const code = error.code;
-            const isCreateRace = code === "EEXIST" ||
-                code === "ENOTEMPTY" ||
-                (code === "EPERM" &&
-                    (await pathExists(experimentDir(repoRoot, parsed.experimentId))));
-            if (!isCreateRace)
-                throw error;
-            await rm(stagingDir, { recursive: true, force: true });
-            const existing = await readExperimentRecord(repoRoot, parsed.experimentId);
-            if (!recordsEqual(existing, parsed)) {
-                throw new Error(`experiment already exists with different content: ${parsed.experimentId}`);
-            }
-            return { record: existing, idempotent: true, manifestPath };
-        }
-    }
-    catch (error) {
-        await rm(stagingDir, { recursive: true, force: true });
-        throw error;
-    }
-    return { record: parsed, idempotent: false, manifestPath };
-}
-export async function updateExperimentRecord(input) {
-    const parsed = experimentRecordSchema.parse(input.record);
-    const manifestPath = experimentManifestPath(input.repoRoot, parsed.experimentId);
-    if (!(await pathExists(manifestPath))) {
-        throw new Error(`experiment not found: ${parsed.experimentId}`);
-    }
-    await writeJsonAtomic(manifestPath, parsed, { repoRoot: input.repoRoot });
-    await writeTextAtomic(path.join(experimentDir(input.repoRoot, parsed.experimentId), MANIFEST_INTEGRITY_FILE), `${sha256Hex(serializeRecord(parsed))}\n`, { repoRoot: input.repoRoot });
-    return manifestPath;
-}

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

@@ -1,82 +0,0 @@
-import { access, mkdir, mkdtemp, readdir, readFile, rename, rm } from "node:fs/promises";
-import path from "node:path";
-import { ignitionIdSchema, ignitionReportSchema, } 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 assertIgnitionId(value) {
-    ignitionIdSchema.parse(value);
-}
-export function ignitionDir(repoRoot, ignitionId) {
-    assertIgnitionId(ignitionId);
-    return path.join(repoRoot, EVALUATION_ROOT, "ignition", ignitionId);
-}
-export function ignitionReportPath(repoRoot, ignitionId) {
-    return path.join(ignitionDir(repoRoot, ignitionId), "report.json");
-}
-async function pathExists(filePath) {
-    try {
-        await access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function serialize(report) {
-    return `${JSON.stringify(report, null, 2)}\n`;
-}
-export async function readIgnitionReport(repoRoot, ignitionId) {
-    assertIgnitionId(ignitionId);
-    const reportPath = ignitionReportPath(repoRoot, ignitionId);
-    if (!(await pathExists(reportPath)))
-        return undefined;
-    const rawText = await readFile(reportPath, "utf-8");
-    const expected = (await readFile(path.join(ignitionDir(repoRoot, ignitionId), MANIFEST_INTEGRITY_FILE), "utf-8")).trim();
-    if (sha256Hex(rawText) !== expected) {
-        throw new Error(`ignition report integrity mismatch for ${ignitionId}`);
-    }
-    return ignitionReportSchema.parse(JSON.parse(rawText));
-}
-export async function writeIgnitionReport(input) {
-    const parsed = ignitionReportSchema.parse(input.report);
-    const reportPath = ignitionReportPath(input.repoRoot, parsed.ignitionId);
-    const root = path.dirname(ignitionDir(input.repoRoot, parsed.ignitionId));
-    await mkdir(root, { recursive: true });
-    if (await pathExists(reportPath)) {
-        await writeJsonAtomic(reportPath, parsed, { repoRoot: input.repoRoot });
-        await writeTextAtomic(path.join(ignitionDir(input.repoRoot, parsed.ignitionId), MANIFEST_INTEGRITY_FILE), `${sha256Hex(serialize(parsed))}\n`, { repoRoot: input.repoRoot });
-        return reportPath;
-    }
-    const stagingDir = await mkdtemp(path.join(root, `.${parsed.ignitionId}.register-`));
-    try {
-        await writeJsonAtomic(path.join(stagingDir, "report.json"), parsed, {
-            repoRoot: input.repoRoot,
-        });
-        await writeTextAtomic(path.join(stagingDir, MANIFEST_INTEGRITY_FILE), `${sha256Hex(serialize(parsed))}\n`, { repoRoot: input.repoRoot });
-        await rename(stagingDir, ignitionDir(input.repoRoot, parsed.ignitionId));
-    }
-    catch (error) {
-        await rm(stagingDir, { recursive: true, force: true });
-        throw error;
-    }
-    return reportPath;
-}
-export async function listIgnitionIds(repoRoot) {
-    const root = path.join(repoRoot, EVALUATION_ROOT, "ignition");
-    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;
-    }
-}

package/dist/infrastructure/evaluation/private-verifier-store.js

@@ -1,145 +0,0 @@
-import { access, mkdir, mkdtemp, readdir, readFile, rename, rm } from "node:fs/promises";
-import path from "node:path";
-import { assertPrivateVerifierHash, computePrivateVerifierManifestHash, } from "../../application/evaluation/campaign-hash.js";
-import { formatContentSha, normalizeContentSha, sha256Hex, } from "../../application/evaluation/candidate-hash.js";
-import { privateVerifierIdSchema, privateVerifierManifestInputSchema, privateVerifierManifestSchema, } 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 assertPrivateVerifierId(value) {
-    privateVerifierIdSchema.parse(value);
-}
-export function privateVerifierDir(repoRoot, privateVerifierId) {
-    assertPrivateVerifierId(privateVerifierId);
-    return path.join(repoRoot, EVALUATION_ROOT, "private-verifiers", privateVerifierId);
-}
-export function privateVerifierManifestPath(repoRoot, privateVerifierId) {
-    return path.join(privateVerifierDir(repoRoot, privateVerifierId), "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`;
-}
-export async function materializePrivateVerifierManifest(raw) {
-    const input = privateVerifierManifestInputSchema.parse(raw);
-    const withoutHash = {
-        schemaVersion: 1,
-        privateVerifierId: input.privateVerifierId,
-        createdAt: input.createdAt,
-        ...(input.description !== undefined
-            ? { description: input.description }
-            : {}),
-        checks: input.checks,
-    };
-    const manifestHash = computePrivateVerifierManifestHash(withoutHash);
-    if (input.manifestHash) {
-        const provided = formatContentSha(normalizeContentSha(input.manifestHash));
-        if (provided !== manifestHash) {
-            throw new Error(`privateVerifier manifestHash mismatch: expected ${manifestHash}, got ${provided}`);
-        }
-    }
-    return privateVerifierManifestSchema.parse({
-        ...withoutHash,
-        manifestHash,
-    });
-}
-export async function loadPrivateVerifierManifestFromPath(repoRoot, manifestPath) {
-    const resolved = path.isAbsolute(manifestPath)
-        ? manifestPath
-        : path.resolve(repoRoot, manifestPath);
-    const raw = JSON.parse(await readFile(resolved, "utf-8"));
-    return privateVerifierManifestInputSchema.parse(raw);
-}
-export async function readPrivateVerifierManifest(repoRoot, privateVerifierId) {
-    assertPrivateVerifierId(privateVerifierId);
-    const manifestPath = privateVerifierManifestPath(repoRoot, privateVerifierId);
-    const rawText = await readFile(manifestPath, "utf-8");
-    const integrityPath = path.join(privateVerifierDir(repoRoot, privateVerifierId), MANIFEST_INTEGRITY_FILE);
-    const expected = (await readFile(integrityPath, "utf-8")).trim();
-    const actual = sha256Hex(rawText);
-    if (expected !== actual) {
-        throw new Error(`privateVerifier manifest integrity mismatch for ${privateVerifierId}`);
-    }
-    const stored = privateVerifierManifestSchema.parse(JSON.parse(rawText));
-    if (stored.privateVerifierId !== privateVerifierId) {
-        throw new Error(`privateVerifier identity mismatch: directory=${privateVerifierId}, manifest=${stored.privateVerifierId}`);
-    }
-    assertPrivateVerifierHash(stored);
-    return stored;
-}
-export async function listPrivateVerifierIds(repoRoot) {
-    const root = path.join(repoRoot, EVALUATION_ROOT, "private-verifiers");
-    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;
-    }
-}
-function manifestsEqual(a, b) {
-    return (a.privateVerifierId === b.privateVerifierId &&
-        a.manifestHash === b.manifestHash &&
-        a.createdAt === b.createdAt &&
-        (a.description ?? "") === (b.description ?? "") &&
-        JSON.stringify(a.checks) === JSON.stringify(b.checks));
-}
-export async function registerPrivateVerifierManifest(input) {
-    const { repoRoot, manifest } = input;
-    assertPrivateVerifierId(manifest.privateVerifierId);
-    const manifestPath = privateVerifierManifestPath(repoRoot, manifest.privateVerifierId);
-    if (await pathExists(manifestPath)) {
-        const existing = await readPrivateVerifierManifest(repoRoot, manifest.privateVerifierId);
-        if (!manifestsEqual(existing, manifest)) {
-            throw new Error(`privateVerifier already exists with different content: ${manifest.privateVerifierId}`);
-        }
-        return { manifest: existing, idempotent: true, manifestPath };
-    }
-    const root = path.dirname(privateVerifierDir(repoRoot, manifest.privateVerifierId));
-    await mkdir(root, { recursive: true });
-    const stagingDir = await mkdtemp(path.join(root, `.${manifest.privateVerifierId}.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, privateVerifierDir(repoRoot, manifest.privateVerifierId));
-        }
-        catch (error) {
-            const code = error.code;
-            const isCreateRace = code === "EEXIST" ||
-                code === "ENOTEMPTY" ||
-                (code === "EPERM" &&
-                    (await pathExists(privateVerifierDir(repoRoot, manifest.privateVerifierId))));
-            if (!isCreateRace)
-                throw error;
-            await rm(stagingDir, { recursive: true, force: true });
-            const existing = await readPrivateVerifierManifest(repoRoot, manifest.privateVerifierId);
-            if (!manifestsEqual(existing, manifest)) {
-                throw new Error(`privateVerifier already exists with different content: ${manifest.privateVerifierId}`);
-            }
-            return { manifest: existing, idempotent: true, manifestPath };
-        }
-    }
-    catch (error) {
-        await rm(stagingDir, { recursive: true, force: true });
-        throw error;
-    }
-    return { manifest, idempotent: false, manifestPath };
-}