@tea-agent/loop-agent 0.16.1-beta.2 → 0.16.2

package/dist/application/evaluation/campaign.js

@@ -0,0 +1,370 @@
+import { spawnSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { campaignBudgetSchema } from "./budget.js";
+import { computeBudgetHash, computeCampaignPlanHash, computeScoringRulesHash, } from "./campaign-hash.js";
+import { showCandidate } from "./candidate.js";
+import { showCorpus } from "./corpus.js";
+import { listCampaignIds, readCampaignManifest, readCampaignPlan, registerCampaignManifest, writeCampaignPlan, } from "../../infrastructure/evaluation/campaign-store.js";
+import { readPrivateVerifierManifest } from "../../infrastructure/evaluation/private-verifier-store.js";
+import { resolveRunningControllerIdentity } from "../../shared/package-metadata.js";
+import { campaignManifestInputSchema, campaignManifestSchema, } from "./types.js";
+const EXECUTABLE_LIFECYCLES = new Set([
+    "eligible",
+    "experimenting",
+    "accepted",
+]);
+function cellId(parts) {
+    const safeTask = parts.taskRef.replace(/[^A-Za-z0-9._-]+/g, "_");
+    return `${parts.candidateId}__${parts.split}__${safeTask}__s${parts.seed}`;
+}
+export function collectPrivateVerifierSecrets(manifest) {
+    const secrets = new Set();
+    secrets.add(manifest.privateVerifierId);
+    secrets.add(manifest.manifestHash);
+    for (const check of manifest.checks) {
+        secrets.add(check.checkId);
+        for (const token of check.command) {
+            if (token.trim().length >= 3)
+                secrets.add(token);
+        }
+    }
+    return [...secrets];
+}
+export async function assertCandidateDoesNotLeakPrivateVerifier(input) {
+    const record = await showCandidate({
+        repoRoot: input.repoRoot,
+        candidateId: input.candidateId,
+    });
+    const secrets = collectPrivateVerifierSecrets(input.privateVerifier);
+    for (const ref of record.manifest.contentRefs) {
+        const absolute = path.resolve(input.repoRoot, ref.path);
+        const bytes = await readFile(absolute, "utf-8");
+        for (const secret of secrets) {
+            if (bytes.includes(secret)) {
+                throw new Error(`private verifier leak: candidate ${input.candidateId} contentRef ${ref.path} contains private token`);
+            }
+        }
+    }
+}
+export async function verifyCampaignIntegrity(repoRoot, manifest) {
+    const corpus = await showCorpus({
+        repoRoot,
+        corpusId: manifest.corpusId,
+    });
+    if (corpus.manifest.corpusHash !== manifest.corpusHash) {
+        throw new Error(`campaign corpusHash drifted: declared ${manifest.corpusHash}, registry ${corpus.manifest.corpusHash}`);
+    }
+    const privateVerifier = await readPrivateVerifierManifest(repoRoot, manifest.privateVerifierId);
+    if (privateVerifier.manifestHash !== manifest.privateVerifierManifestHash) {
+        throw new Error(`campaign privateVerifierManifestHash drifted: declared ${manifest.privateVerifierManifestHash}, registry ${privateVerifier.manifestHash}`);
+    }
+    const budgetHash = computeBudgetHash(manifest.budget);
+    if (budgetHash !== manifest.evaluatorIntegrity.budgetHash) {
+        throw new Error(`campaign budgetHash drifted: declared ${manifest.evaluatorIntegrity.budgetHash}, recomputed ${budgetHash}`);
+    }
+    if (corpus.manifest.corpusHash !== manifest.evaluatorIntegrity.corpusHash) {
+        throw new Error("campaign evaluatorIntegrity.corpusHash mismatch");
+    }
+    if (privateVerifier.manifestHash !==
+        manifest.evaluatorIntegrity.privateVerifierManifestHash) {
+        throw new Error("campaign evaluatorIntegrity.privateVerifierManifestHash mismatch");
+    }
+    const scoringRulesHash = computeScoringRulesHash(manifest.policyVersion);
+    if (scoringRulesHash !== manifest.evaluatorIntegrity.scoringRulesHash) {
+        throw new Error(`campaign scoringRulesHash drifted for policyVersion ${manifest.policyVersion}`);
+    }
+}
+export async function buildCampaignPlan(input) {
+    await verifyCampaignIntegrity(input.repoRoot, input.manifest);
+    const corpus = await showCorpus({
+        repoRoot: input.repoRoot,
+        corpusId: input.manifest.corpusId,
+    });
+    const privateVerifier = await readPrivateVerifierManifest(input.repoRoot, input.manifest.privateVerifierId);
+    const candidateIds = [
+        input.manifest.incumbentCandidateId,
+        ...input.manifest.challengerCandidateIds,
+    ];
+    const cells = [];
+    for (const candidateId of candidateIds) {
+        await assertCandidateDoesNotLeakPrivateVerifier({
+            repoRoot: input.repoRoot,
+            candidateId,
+            privateVerifier,
+        });
+        const record = await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+        });
+        if (!EXECUTABLE_LIFECYCLES.has(record.status)) {
+            throw new Error(`campaign candidate ${candidateId} lifecycle ${record.status} is not executable`);
+        }
+        for (const task of corpus.manifest.tasks) {
+            const seeds = input.manifest.seeds && input.manifest.seeds.length > 0
+                ? input.manifest.seeds.filter((seed) => task.seeds.includes(seed))
+                : task.seeds;
+            if (seeds.length === 0) {
+                throw new Error(`campaign seeds do not intersect task ${task.taskRef} seeds`);
+            }
+            for (const seed of seeds) {
+                const split = task.split;
+                const executionRole = split === "public"
+                    ? "candidate_run"
+                    : split === "private"
+                        ? "private_verify"
+                        : "promotion_gate_only";
+                cells.push({
+                    cellId: cellId({
+                        candidateId,
+                        split,
+                        taskRef: task.taskRef,
+                        seed,
+                    }),
+                    candidateId,
+                    bundleHash: record.manifest.bundleHash,
+                    taskRef: task.taskRef,
+                    seed,
+                    split,
+                    executionRole,
+                    privateVerifierAttached: executionRole === "private_verify",
+                });
+            }
+        }
+    }
+    cells.sort((a, b) => (a.cellId < b.cellId ? -1 : a.cellId > b.cellId ? 1 : 0));
+    const planHash = computeCampaignPlanHash(input.manifest.campaignId, cells);
+    return {
+        schemaVersion: 1,
+        campaignId: input.manifest.campaignId,
+        planHash,
+        createdAt: new Date().toISOString(),
+        cells,
+    };
+}
+export async function materializeCampaignManifest(input) {
+    const parsed = campaignManifestInputSchema.parse(input.raw);
+    const budget = campaignBudgetSchema.parse(parsed.budget);
+    if (budget.mode !== "hard") {
+        throw new Error("campaign budget.mode must be hard");
+    }
+    const corpus = await showCorpus({
+        repoRoot: input.repoRoot,
+        corpusId: parsed.corpusId,
+    });
+    if (corpus.manifest.corpusHash !== parsed.corpusHash) {
+        throw new Error(`corpusHash mismatch: declared ${parsed.corpusHash}, registry ${corpus.manifest.corpusHash}`);
+    }
+    const privateVerifier = await readPrivateVerifierManifest(input.repoRoot, parsed.privateVerifierId);
+    if (privateVerifier.manifestHash !== parsed.privateVerifierManifestHash) {
+        throw new Error(`privateVerifierManifestHash mismatch: declared ${parsed.privateVerifierManifestHash}, registry ${privateVerifier.manifestHash}`);
+    }
+    const candidateIds = [
+        parsed.incumbentCandidateId,
+        ...parsed.challengerCandidateIds,
+    ];
+    for (const candidateId of candidateIds) {
+        const record = await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+        });
+        if (!EXECUTABLE_LIFECYCLES.has(record.status)) {
+            throw new Error(`campaign candidate ${candidateId} lifecycle ${record.status} is not executable`);
+        }
+        await assertCandidateDoesNotLeakPrivateVerifier({
+            repoRoot: input.repoRoot,
+            candidateId,
+            privateVerifier,
+        });
+    }
+    const identity = resolveRunningControllerIdentity();
+    const controllerFingerprint = parsed.controllerFingerprint ??
+        (identity
+            ? `${identity.packageName}@${identity.packageVersion}+${identity.packageFingerprint.value}`
+            : "unresolved-controller");
+    const evaluatorIntegrity = {
+        corpusHash: corpus.manifest.corpusHash,
+        privateVerifierManifestHash: privateVerifier.manifestHash,
+        budgetHash: computeBudgetHash(budget),
+        scoringRulesHash: computeScoringRulesHash(parsed.policyVersion),
+    };
+    if (parsed.evaluatorIntegrity) {
+        if (JSON.stringify(parsed.evaluatorIntegrity) !==
+            JSON.stringify(evaluatorIntegrity)) {
+            throw new Error("evaluatorIntegrity mismatch with recomputed corpus/privateVerifier/budget/scoring hashes");
+        }
+    }
+    return campaignManifestSchema.parse({
+        ...parsed,
+        budget,
+        controllerFingerprint,
+        evaluatorIntegrity,
+    });
+}
+export async function createCampaign(input) {
+    const resolved = path.isAbsolute(input.manifestPath)
+        ? input.manifestPath
+        : path.resolve(input.repoRoot, input.manifestPath);
+    const raw = JSON.parse(await readFile(resolved, "utf-8"));
+    const manifest = await materializeCampaignManifest({
+        repoRoot: input.repoRoot,
+        raw,
+    });
+    const registered = await registerCampaignManifest({
+        repoRoot: input.repoRoot,
+        manifest,
+    });
+    const plan = await buildCampaignPlan({
+        repoRoot: input.repoRoot,
+        manifest: registered.manifest,
+    });
+    const planPath = await writeCampaignPlan({
+        repoRoot: input.repoRoot,
+        plan,
+    });
+    return {
+        manifest: registered.manifest,
+        plan,
+        idempotent: registered.idempotent,
+        manifestPath: registered.manifestPath,
+        planPath,
+    };
+}
+export async function validateCampaign(input) {
+    const resolved = path.isAbsolute(input.manifestPath)
+        ? input.manifestPath
+        : path.resolve(input.repoRoot, input.manifestPath);
+    const raw = JSON.parse(await readFile(resolved, "utf-8"));
+    const manifest = await materializeCampaignManifest({
+        repoRoot: input.repoRoot,
+        raw,
+    });
+    const plan = await buildCampaignPlan({
+        repoRoot: input.repoRoot,
+        manifest,
+    });
+    return { manifest, plan };
+}
+export async function showCampaign(input) {
+    const manifest = await readCampaignManifest(input.repoRoot, input.campaignId);
+    await verifyCampaignIntegrity(input.repoRoot, manifest);
+    const plan = await readCampaignPlan(input.repoRoot, input.campaignId);
+    return {
+        manifest,
+        plan,
+        summary: summarizeCampaign(manifest, plan),
+    };
+}
+export async function listCampaigns(input) {
+    const ids = await listCampaignIds(input.repoRoot);
+    const rows = [];
+    for (const campaignId of ids) {
+        const manifest = await readCampaignManifest(input.repoRoot, campaignId);
+        const plan = await readCampaignPlan(input.repoRoot, campaignId);
+        rows.push(summarizeCampaign(manifest, plan));
+    }
+    return rows;
+}
+export async function planCampaign(input) {
+    const manifest = await readCampaignManifest(input.repoRoot, input.campaignId);
+    const plan = await buildCampaignPlan({
+        repoRoot: input.repoRoot,
+        manifest,
+    });
+    const existing = await readCampaignPlan(input.repoRoot, input.campaignId);
+    if (existing && existing.planHash !== plan.planHash) {
+        throw new Error(`campaign planHash drifted for ${input.campaignId}: stored ${existing.planHash}, recomputed ${plan.planHash}`);
+    }
+    const planPath = await writeCampaignPlan({
+        repoRoot: input.repoRoot,
+        plan: existing ?? plan,
+    });
+    return { manifest, plan: existing ?? plan, planPath };
+}
+/**
+ * M4 campaign run: re-verify integrity, ensure plan repeatability, and execute
+ * controller-only private verifier checks. Does not run Pi candidate DAGs and
+ * never auto-promotes.
+ */
+export async function runCampaignPrivateChecks(input) {
+    const planned = await planCampaign(input);
+    const privateVerifier = await readPrivateVerifierManifest(input.repoRoot, planned.manifest.privateVerifierId);
+    const results = [];
+    for (const cell of planned.plan.cells) {
+        if (cell.executionRole !== "private_verify")
+            continue;
+        if (!cell.privateVerifierAttached) {
+            throw new Error(`private_verify cell ${cell.cellId} missing privateVerifierAttached`);
+        }
+        for (const check of privateVerifier.checks) {
+            const cwd = path.resolve(input.repoRoot, check.cwd);
+            const [bin, ...args] = check.command;
+            const spawned = spawnSync(bin, args, {
+                cwd,
+                encoding: "utf-8",
+                timeout: check.timeoutMs,
+                env: process.env,
+            });
+            const exitCode = typeof spawned.status === "number" ? spawned.status : null;
+            results.push({
+                cellId: cell.cellId,
+                checkId: check.checkId,
+                ok: exitCode === check.expectedExitCode,
+                exitCode,
+                stderr: (spawned.stderr ?? "").slice(0, 2_000),
+            });
+        }
+    }
+    return {
+        manifest: planned.manifest,
+        plan: planned.plan,
+        results,
+    };
+}
+function summarizeCampaign(manifest, plan) {
+    return {
+        campaignId: manifest.campaignId,
+        status: manifest.status,
+        corpusId: manifest.corpusId,
+        incumbentCandidateId: manifest.incumbentCandidateId,
+        challengerCount: manifest.challengerCandidateIds.length,
+        ...(plan
+            ? { cellCount: plan.cells.length, planHash: plan.planHash }
+            : {}),
+    };
+}
+export function formatCampaignMarkdown(input) {
+    const { manifest, plan } = input;
+    const lines = [
+        `# Campaign: ${manifest.campaignId}`,
+        "",
+        `- status: \`${manifest.status}\``,
+        `- corpus: \`${manifest.corpusId}\` (\`${manifest.corpusHash}\`)`,
+        `- incumbent: \`${manifest.incumbentCandidateId}\``,
+        `- challengers: ${manifest.challengerCandidateIds.map((id) => `\`${id}\``).join(", ")}`,
+        `- privateVerifier: \`${manifest.privateVerifierId}\``,
+        `- budget.mode: \`${manifest.budget.mode}\``,
+        `- policyVersion: \`${manifest.policyVersion}\``,
+        "",
+        "## Evaluator integrity",
+        "",
+        `- corpusHash: \`${manifest.evaluatorIntegrity.corpusHash}\``,
+        `- privateVerifierManifestHash: \`${manifest.evaluatorIntegrity.privateVerifierManifestHash}\``,
+        `- budgetHash: \`${manifest.evaluatorIntegrity.budgetHash}\``,
+        `- scoringRulesHash: \`${manifest.evaluatorIntegrity.scoringRulesHash}\``,
+        "",
+        "> M4: private verifier is controller-only; held_out cells are promotion_gate_only; promotion remains human-gated.",
+        "",
+    ];
+    if (plan) {
+        const counts = {
+            candidate_run: 0,
+            private_verify: 0,
+            promotion_gate_only: 0,
+        };
+        for (const cell of plan.cells)
+            counts[cell.executionRole] += 1;
+        lines.push(`## Plan`, "", `- planHash: \`${plan.planHash}\``, `- cells: ${plan.cells.length} (candidate_run=${counts.candidate_run}, private_verify=${counts.private_verify}, promotion_gate_only=${counts.promotion_gate_only})`, "");
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/application/evaluation/candidate.js

@@ -1,33 +1,50 @@
 import { loadManifestInputFromPath, listCandidateIds, materializeManifest, readCandidateRecord, registerCandidateManifest, transitionCandidateLifecycle, } from "../../infrastructure/evaluation/candidate-store.js";
+import { isCandidatePromotionApplied } from "./alias.js";
+async function withPromotionFlag(repoRoot, record) {
+    const promotionApplied = await isCandidatePromotionApplied({
+        repoRoot,
+        candidateId: record.manifest.candidateId,
+    });
+    return { ...record, promotionApplied };
+}
 export async function registerCandidate(input) {
     const raw = await loadManifestInputFromPath(input.repoRoot, input.manifestPath);
     const manifest = await materializeManifest(input.repoRoot, raw);
-    return registerCandidateManifest({
+    const result = await registerCandidateManifest({
         repoRoot: input.repoRoot,
         manifest,
         now: input.now,
     });
+    return {
+        ...result,
+        record: await withPromotionFlag(input.repoRoot, result.record),
+    };
 }
 export async function showCandidate(input) {
-    return readCandidateRecord(input.repoRoot, input.candidateId);
+    const record = await readCandidateRecord(input.repoRoot, input.candidateId);
+    return withPromotionFlag(input.repoRoot, record);
 }
 export async function listCandidates(input) {
     const ids = await listCandidateIds(input.repoRoot);
     const rows = [];
     for (const candidateId of ids) {
-        const record = await readCandidateRecord(input.repoRoot, candidateId);
+        const record = await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+        });
         rows.push({
             candidateId: record.manifest.candidateId,
             bundleHash: record.manifest.bundleHash,
             candidateKind: record.manifest.candidateKind,
             status: record.status,
-            promotionApplied: false,
+            promotionApplied: record.promotionApplied,
         });
     }
     return rows;
 }
 export async function transitionCandidate(input) {
-    return transitionCandidateLifecycle(input);
+    const record = await transitionCandidateLifecycle(input);
+    return withPromotionFlag(input.repoRoot, record);
 }
 export function formatCandidateMarkdown(record) {
     const lines = [
@@ -37,7 +54,7 @@ export function formatCandidateMarkdown(record) {
         `- kind: \`${record.manifest.candidateKind}\``,
         `- bundleHash: \`${record.manifest.bundleHash}\``,
         `- parent: \`${record.manifest.parentCandidateId ?? "null"}\``,
-        `- promotionApplied: \`false\` (registry lifecycle only; no alias/incumbent)`,
+        `- promotionApplied: \`${record.promotionApplied}\` (true only when an incumbent alias points here)`,
         "",
         "## Content refs",
         "",

package/dist/application/evaluation/corpus-hash.js

@@ -0,0 +1,38 @@
+import { createHash } from "node:crypto";
+import { formatContentSha, normalizeContentSha, stableStringify, } from "./candidate-hash.js";
+function normalizeTask(task) {
+    return {
+        taskRef: task.taskRef.replace(/\\/g, "/"),
+        class: task.class,
+        split: task.split,
+        seeds: [...task.seeds].sort((a, b) => a - b),
+        featureId: task.featureId ?? null,
+    };
+}
+/**
+ * Canonical payload for corpusHash.
+ * Excludes corpusId, createdAt, description, corpusHash, and free-text notes.
+ */
+export function buildCanonicalCorpusPayload(manifest) {
+    const tasks = manifest.tasks
+        .map((task) => normalizeTask(task))
+        .sort((a, b) => (a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0));
+    return {
+        schemaVersion: 1,
+        tasks,
+    };
+}
+export function computeCorpusHash(manifest) {
+    const payload = buildCanonicalCorpusPayload(manifest);
+    const digest = createHash("sha256")
+        .update(stableStringify(payload))
+        .digest("hex");
+    return formatContentSha(digest);
+}
+export function assertCorpusHashMatches(manifest) {
+    const expected = computeCorpusHash(manifest);
+    const actual = formatContentSha(normalizeContentSha(manifest.corpusHash));
+    if (expected !== actual) {
+        throw new Error(`corpusHash mismatch: expected ${expected}, got ${actual}`);
+    }
+}

package/dist/application/evaluation/corpus.js

@@ -0,0 +1,56 @@
+import { loadCorpusManifestFromPath, listCorpusIds, materializeCorpusManifest, readCorpusManifest, registerCorpusManifest, summarizeCorpus, } from "../../infrastructure/evaluation/corpus-store.js";
+export async function validateCorpus(input) {
+    const raw = await loadCorpusManifestFromPath(input.repoRoot, input.manifestPath);
+    const manifest = await materializeCorpusManifest(raw);
+    return { manifest, summary: summarizeCorpus(manifest) };
+}
+export async function registerCorpus(input) {
+    const validated = await validateCorpus(input);
+    const result = await registerCorpusManifest({
+        repoRoot: input.repoRoot,
+        manifest: validated.manifest,
+    });
+    return {
+        manifest: result.manifest,
+        summary: summarizeCorpus(result.manifest),
+        idempotent: result.idempotent,
+        manifestPath: result.manifestPath,
+    };
+}
+export async function showCorpus(input) {
+    const manifest = await readCorpusManifest(input.repoRoot, input.corpusId);
+    return { manifest, summary: summarizeCorpus(manifest) };
+}
+export async function listCorpora(input) {
+    const ids = await listCorpusIds(input.repoRoot);
+    const rows = [];
+    for (const corpusId of ids) {
+        const manifest = await readCorpusManifest(input.repoRoot, corpusId);
+        rows.push(summarizeCorpus(manifest));
+    }
+    return rows;
+}
+export function formatCorpusMarkdown(input) {
+    const { manifest, summary } = input;
+    const lines = [
+        `# Corpus: ${manifest.corpusId}`,
+        "",
+        `- corpusHash: \`${manifest.corpusHash}\``,
+        `- taskCount: \`${summary.taskCount}\``,
+        `- splits: public=${summary.splits.public} private=${summary.splits.private} held_out=${summary.splits.held_out}`,
+        `- classes: ${summary.classes.map((value) => `\`${value}\``).join(", ")}`,
+        `- createdAt: \`${manifest.createdAt}\``,
+        "",
+        "> Contract-only corpus. Registration does not execute live campaigns or authorize promotion.",
+        "",
+        "## Tasks",
+        "",
+        "| taskRef | class | split | seeds | featureId |",
+        "|---|---|---|---|---|",
+    ];
+    for (const task of manifest.tasks) {
+        lines.push(`| \`${task.taskRef}\` | ${task.class} | ${task.split} | ${task.seeds.join(",")} | ${task.featureId ?? "-"} |`);
+    }
+    lines.push("");
+    return `${lines.join("\n")}\n`;
+}