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

package/dist/application/evaluation/budget.js

@@ -1,192 +0,0 @@
-import { z } from "zod";
-/**
- * Campaign / DAG hard-budget contract (Eval Lab W3.4–W3.5 / M3).
- *
- * Token incompleteness: missing `tokensUsed` must never be treated as 0.
- * When `maxTokens` is set, only known token samples accumulate; breach fires
- * only when the known sum exceeds the limit. Calls + wall time + repair passes
- * are the primary hard dimensions for v1.
- */
-export const campaignBudgetModeSchema = z.enum(["hard", "record-only"]);
-export const campaignBudgetLimitsSchema = z
-    .object({
-    maxTokens: z.number().int().positive().optional(),
-    maxWallTimeMs: z.number().int().positive().optional(),
-    maxExecutorCalls: z.number().int().positive().optional(),
-    maxRepairPasses: z.number().int().nonnegative().optional(),
-    maxConcurrency: z.number().int().positive().optional(),
-    maxContextChars: z.number().int().positive().optional(),
-})
-    .strict()
-    .superRefine((limits, ctx) => {
-    const hasHardDim = limits.maxTokens !== undefined ||
-        limits.maxWallTimeMs !== undefined ||
-        limits.maxExecutorCalls !== undefined ||
-        limits.maxRepairPasses !== undefined ||
-        limits.maxContextChars !== undefined;
-    if (!hasHardDim) {
-        ctx.addIssue({
-            code: z.ZodIssueCode.custom,
-            message: "budget.limits requires at least one of maxTokens, maxWallTimeMs, maxExecutorCalls, maxRepairPasses, maxContextChars",
-        });
-    }
-});
-export const campaignBudgetSchema = z
-    .object({
-    schemaVersion: z.literal(1),
-    mode: campaignBudgetModeSchema.default("hard"),
-    limits: campaignBudgetLimitsSchema,
-})
-    .strict();
-export function createBudgetLedger(budget) {
-    return {
-        schemaVersion: 1,
-        mode: budget.mode,
-        limits: { ...budget.limits },
-        consumed: {
-            tokens: null,
-            wallTimeMs: 0,
-            executorCalls: 0,
-            repairPasses: 0,
-            peakContextChars: 0,
-            missingTokenNodeIds: [],
-        },
-        breaches: [],
-        status: budget.mode === "record-only" ? "record-only" : "ok",
-    };
-}
-export function resolveEffectiveMaxConcurrent(requested, budget) {
-    const limit = budget?.limits.maxConcurrency;
-    if (limit === undefined) {
-        return { maxConcurrent: Math.max(1, requested), clamped: false };
-    }
-    const maxConcurrent = Math.max(1, Math.min(requested, limit));
-    return { maxConcurrent, clamped: maxConcurrent < requested };
-}
-function pushBreach(ledger, breach) {
-    const full = {
-        ...breach,
-        at: breach.at ?? new Date().toISOString(),
-    };
-    const duplicate = ledger.breaches.some((existing) => existing.dimension === full.dimension &&
-        existing.nodeId === full.nodeId &&
-        existing.limit === full.limit);
-    if (!duplicate) {
-        ledger.breaches.push(full);
-    }
-    if (ledger.mode === "hard") {
-        ledger.status = "breached";
-    }
-}
-function checkLimit(ledger, dimension, consumed, limit, opts) {
-    if (limit === undefined)
-        return undefined;
-    const exceeded = opts?.inclusive ? consumed >= limit : consumed > limit;
-    if (!exceeded)
-        return undefined;
-    const breach = {
-        dimension,
-        limit,
-        consumed,
-        at: new Date().toISOString(),
-        ...(opts?.nodeId ? { nodeId: opts.nodeId } : {}),
-    };
-    pushBreach(ledger, breach);
-    return breach;
-}
-/**
- * Pre-node check (no call increment yet).
- * Discrete call budget uses inclusive compare so maxExecutorCalls=1 allows the
- * first node then blocks starting a second.
- */
-export function checkBudgetPreNode(ledger, sample) {
-    ledger.consumed.wallTimeMs = sample.wallTimeMs;
-    ledger.consumed.repairPasses = sample.repairPasses;
-    return (checkLimit(ledger, "executorCalls", ledger.consumed.executorCalls, ledger.limits.maxExecutorCalls, { inclusive: true }) ??
-        checkLimit(ledger, "wallTimeMs", sample.wallTimeMs, ledger.limits.maxWallTimeMs) ??
-        checkLimit(ledger, "repairPasses", sample.repairPasses, ledger.limits.maxRepairPasses));
-}
-/**
- * Record one finished node execution attempt and evaluate hard limits.
- * Increments executorCalls by 1. Does not invent tokens when missing.
- */
-export function recordNodeBudgetSample(ledger, sample) {
-    ledger.consumed.executorCalls += 1;
-    ledger.consumed.wallTimeMs = sample.wallTimeMs;
-    ledger.consumed.repairPasses = sample.repairPasses;
-    if (sample.tokensUsed === undefined) {
-        if (!ledger.consumed.missingTokenNodeIds.includes(sample.nodeId)) {
-            ledger.consumed.missingTokenNodeIds.push(sample.nodeId);
-        }
-    }
-    else {
-        ledger.consumed.tokens = (ledger.consumed.tokens ?? 0) + sample.tokensUsed;
-    }
-    if (sample.contextChars !== undefined) {
-        ledger.consumed.peakContextChars = Math.max(ledger.consumed.peakContextChars, sample.contextChars);
-    }
-    return (checkLimit(ledger, "executorCalls", ledger.consumed.executorCalls, ledger.limits.maxExecutorCalls, { nodeId: sample.nodeId, inclusive: true }) ??
-        checkLimit(ledger, "wallTimeMs", ledger.consumed.wallTimeMs, ledger.limits.maxWallTimeMs, { nodeId: sample.nodeId }) ??
-        checkLimit(ledger, "repairPasses", ledger.consumed.repairPasses, ledger.limits.maxRepairPasses, { nodeId: sample.nodeId }) ??
-        (ledger.consumed.tokens !== null
-            ? checkLimit(ledger, "tokens", ledger.consumed.tokens, ledger.limits.maxTokens, { nodeId: sample.nodeId })
-            : undefined) ??
-        checkLimit(ledger, "contextChars", ledger.consumed.peakContextChars, ledger.limits.maxContextChars, { nodeId: sample.nodeId }));
-}
-export function isHardBudgetBreached(ledger) {
-    return Boolean(ledger && ledger.mode === "hard" && ledger.status === "breached");
-}
-/** Mark all PENDING nodes as SKIPPED due to budget breach (fail closed). */
-export function skipPendingNodesForBudgetBreach(nodes, breach) {
-    const skipped = [];
-    const reason = `budget_breach:${breach.dimension}`;
-    for (const [id, node] of Object.entries(nodes)) {
-        if (node.status !== "PENDING")
-            continue;
-        node.status = "SKIPPED";
-        node.skippedReason = reason;
-        skipped.push(id);
-    }
-    return skipped;
-}
-export function formatBudgetReportMarkdown(ledger) {
-    const limits = ledger.limits;
-    const c = ledger.consumed;
-    const lines = [
-        `# Budget Ledger`,
-        ``,
-        `- **mode**: ${ledger.mode}`,
-        `- **status**: ${ledger.status}`,
-        ``,
-        `## Limits`,
-        ``,
-        `| dimension | limit |`,
-        `|---|---|`,
-        `| maxTokens | ${limits.maxTokens ?? "n/a"} |`,
-        `| maxWallTimeMs | ${limits.maxWallTimeMs ?? "n/a"} |`,
-        `| maxExecutorCalls | ${limits.maxExecutorCalls ?? "n/a"} |`,
-        `| maxRepairPasses | ${limits.maxRepairPasses ?? "n/a"} |`,
-        `| maxConcurrency | ${limits.maxConcurrency ?? "n/a"} |`,
-        `| maxContextChars | ${limits.maxContextChars ?? "n/a"} |`,
-        ``,
-        `## Consumed`,
-        ``,
-        `| dimension | value |`,
-        `|---|---|`,
-        `| tokens | ${c.tokens ?? "n/a (missing)"} |`,
-        `| wallTimeMs | ${c.wallTimeMs} |`,
-        `| executorCalls | ${c.executorCalls} |`,
-        `| repairPasses | ${c.repairPasses} |`,
-        `| peakContextChars | ${c.peakContextChars} |`,
-        `| missingTokenNodes | ${c.missingTokenNodeIds.join(", ") || "none"} |`,
-    ];
-    if (ledger.breaches.length > 0) {
-        lines.push(``, `## Breaches`, ``);
-        for (const breach of ledger.breaches) {
-            lines.push(`- **${breach.dimension}**: consumed ${breach.consumed} > limit ${breach.limit}` +
-                (breach.nodeId ? ` (node ${breach.nodeId})` : "") +
-                ` at ${breach.at}`);
-        }
-    }
-    return `${lines.join("\n")}\n`;
-}

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

@@ -1,47 +0,0 @@
-import { formatContentSha, sha256Hex, } from "./candidate-hash.js";
-/** Frozen placeholder for M4; M5 may replace with real scoring rules bytes. */
-export const SCORING_RULES_V1 = "promotion-policy-v1";
-export function computeScoringRulesHash(policyVersion = SCORING_RULES_V1) {
-    return formatContentSha(sha256Hex(policyVersion));
-}
-export function computeBudgetHash(budget) {
-    const canonical = {
-        schemaVersion: budget.schemaVersion,
-        mode: budget.mode,
-        limits: Object.fromEntries(Object.entries(budget.limits).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)),
-    };
-    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
-}
-export function computePrivateVerifierManifestHash(manifest) {
-    const checks = [...manifest.checks]
-        .map((check) => ({
-        checkId: check.checkId,
-        kind: check.kind,
-        command: [...check.command],
-        cwd: check.cwd ?? ".",
-        timeoutMs: check.timeoutMs ?? 60_000,
-        expectedExitCode: check.expectedExitCode ?? 0,
-    }))
-        .sort((a, b) => a.checkId < b.checkId ? -1 : a.checkId > b.checkId ? 1 : 0);
-    const canonical = {
-        schemaVersion: 1,
-        privateVerifierId: manifest.privateVerifierId,
-        checks,
-    };
-    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
-}
-export function computeCampaignPlanHash(campaignId, cells) {
-    const sorted = [...cells].sort((a, b) => a.cellId < b.cellId ? -1 : a.cellId > b.cellId ? 1 : 0);
-    const canonical = {
-        schemaVersion: 1,
-        campaignId,
-        cells: sorted,
-    };
-    return formatContentSha(sha256Hex(JSON.stringify(canonical)));
-}
-export function assertPrivateVerifierHash(manifest) {
-    const recomputed = computePrivateVerifierManifestHash(manifest);
-    if (recomputed !== manifest.manifestHash) {
-        throw new Error(`privateVerifier manifestHash mismatch for ${manifest.privateVerifierId}: expected ${recomputed}, got ${manifest.manifestHash}`);
-    }
-}

package/dist/application/evaluation/campaign-matrix.js

@@ -1,372 +0,0 @@
-import { mkdir, readFile } from "node:fs/promises";
-import path from "node:path";
-import { campaignDir, readCampaignManifest, readCampaignPlan, writeCampaignScorecard, } from "../../infrastructure/evaluation/campaign-store.js";
-import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
-import { planCampaign, runCampaignPrivateChecks, } from "./campaign.js";
-import { evaluatePromotionPolicy } from "./promotion-policy.js";
-import { matrixFixtureSchema, matrixRunSchema } from "./types.js";
-function matrixJobsDir(repoRoot, campaignId) {
-    return path.join(campaignDir(repoRoot, campaignId), "matrix-jobs");
-}
-function matrixRunPath(repoRoot, campaignId) {
-    return path.join(campaignDir(repoRoot, campaignId), "matrix-run.json");
-}
-function evidenceDraftPath(repoRoot, campaignId) {
-    return path.join(campaignDir(repoRoot, campaignId), "evidence-draft.json");
-}
-export async function loadMatrixFixture(input) {
-    const absolute = path.resolve(input.repoRoot, input.fixturePath);
-    return matrixFixtureSchema.parse(JSON.parse(await readFile(absolute, "utf-8")));
-}
-function resolveStubResult(fixture, cell) {
-    for (const row of fixture.results) {
-        if (row.cellId && row.cellId === cell.cellId) {
-            return { verifyPassed: row.verifyPassed, runId: row.runId };
-        }
-        const match = (!row.candidateId || row.candidateId === cell.candidateId) &&
-            (!row.taskRef || row.taskRef === cell.taskRef) &&
-            (row.seed === undefined || row.seed === cell.seed) &&
-            (!row.split || row.split === cell.split);
-        if (match &&
-            (row.candidateId || row.taskRef || row.seed !== undefined || row.split)) {
-            return { verifyPassed: row.verifyPassed, runId: row.runId };
-        }
-    }
-    return { verifyPassed: fixture.defaultVerifyPassed };
-}
-export function buildMatrixJobSpec(input) {
-    return {
-        schemaVersion: 1,
-        cellId: input.cell.cellId,
-        evaluation: {
-            campaignId: input.campaignId,
-            candidateId: input.cell.candidateId,
-            bundleHash: input.cell.bundleHash,
-            seed: input.cell.seed,
-            split: input.cell.split,
-            taskRef: input.cell.taskRef,
-        },
-        executor: "pi",
-        autoPromote: false,
-    };
-}
-async function writeMatrixJob(input) {
-    const dir = matrixJobsDir(input.repoRoot, input.campaignId);
-    await mkdir(dir, { recursive: true });
-    const job = buildMatrixJobSpec({
-        cell: input.cell,
-        campaignId: input.campaignId,
-    });
-    const jobPath = path.join(dir, `${input.cell.cellId}.json`);
-    await writeJsonAtomic(jobPath, job, { repoRoot: input.repoRoot });
-    return {
-        jobPath: path.relative(input.repoRoot, jobPath).replace(/\\/g, "/"),
-        evaluation: job.evaluation,
-    };
-}
-/**
- * Candidate matrix runner (M7 companion).
- * Modes:
- * - dry-run: plan public cells only
- * - stub: resolve verifyPassed from fixture (tests / offline)
- * - pi-plan: materialize per-cell Pi evaluation job specs (no spawn)
- * - pi: require injected PiCellExecutor; never auto-promote
- */
-export async function runCampaignMatrix(input) {
-    const planned = await planCampaign({
-        repoRoot: input.repoRoot,
-        campaignId: input.campaignId,
-    });
-    const publicCells = planned.plan.cells.filter((cell) => cell.executionRole === "candidate_run");
-    const limited = input.maxPublicCells !== undefined
-        ? publicCells.slice(0, input.maxPublicCells)
-        : publicCells;
-    let fixture;
-    if (input.mode === "stub") {
-        if (!input.fixturePath) {
-            throw new Error("matrix mode=stub requires --fixture <path>");
-        }
-        fixture = await loadMatrixFixture({
-            repoRoot: input.repoRoot,
-            fixturePath: input.fixturePath,
-        });
-    }
-    if (input.mode === "pi" && !input.piExecutor) {
-        throw new Error("matrix mode=pi requires an injected PiCellExecutor (CLI refuses live Pi by default; use pi-plan or stub)");
-    }
-    const cellResults = [];
-    for (const cell of limited) {
-        if (input.mode === "dry-run") {
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: cell.executionRole,
-                mode: "dry-run",
-                skipped: true,
-                detail: "dry-run: would execute candidate_run cell",
-            });
-            continue;
-        }
-        if (input.mode === "stub") {
-            const resolved = resolveStubResult(fixture, cell);
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: cell.executionRole,
-                mode: "stub",
-                verifyPassed: resolved.verifyPassed,
-                runId: resolved.runId,
-                skipped: false,
-            });
-            continue;
-        }
-        const job = await writeMatrixJob({
-            repoRoot: input.repoRoot,
-            campaignId: input.campaignId,
-            cell,
-        });
-        if (input.mode === "pi-plan") {
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: cell.executionRole,
-                mode: "pi-plan",
-                jobPath: job.jobPath,
-                skipped: true,
-                detail: "pi-plan: job materialized; Pi not spawned",
-            });
-            continue;
-        }
-        const executed = await input.piExecutor({
-            repoRoot: input.repoRoot,
-            cell,
-            jobPath: job.jobPath,
-            evaluation: job.evaluation,
-        });
-        cellResults.push({
-            cellId: cell.cellId,
-            candidateId: cell.candidateId,
-            taskRef: cell.taskRef,
-            seed: cell.seed,
-            split: cell.split,
-            executionRole: cell.executionRole,
-            mode: "pi",
-            verifyPassed: executed.verifyPassed,
-            runId: executed.runId,
-            jobPath: job.jobPath,
-            detail: executed.detail,
-            skipped: false,
-        });
-    }
-    // Mark held_out / remaining public as skipped for transparency
-    for (const cell of planned.plan.cells) {
-        if (cell.executionRole === "candidate_run") {
-            if (limited.some((row) => row.cellId === cell.cellId))
-                continue;
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: cell.executionRole,
-                mode: input.mode,
-                skipped: true,
-                detail: "skipped by maxPublicCells",
-            });
-            continue;
-        }
-        if (cell.executionRole === "promotion_gate_only") {
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: cell.executionRole,
-                mode: input.mode,
-                skipped: true,
-                detail: "held_out remains promotion_gate_only (not executed in matrix)",
-            });
-        }
-    }
-    let privateResults = [];
-    if (input.includePrivateChecks !== false && input.mode !== "dry-run") {
-        const privateRun = await runCampaignPrivateChecks({
-            repoRoot: input.repoRoot,
-            campaignId: input.campaignId,
-        });
-        privateResults = privateRun.results;
-        for (const cell of planned.plan.cells) {
-            if (cell.executionRole !== "private_verify")
-                continue;
-            const related = privateResults.filter((row) => row.cellId === cell.cellId);
-            const ok = related.length > 0 && related.every((row) => row.ok);
-            cellResults.push({
-                cellId: cell.cellId,
-                candidateId: cell.candidateId,
-                taskRef: cell.taskRef,
-                seed: cell.seed,
-                split: cell.split,
-                executionRole: "private_verify",
-                mode: input.mode,
-                verifyPassed: ok,
-                skipped: false,
-                detail: `private checks=${related.length}`,
-            });
-        }
-    }
-    const now = input.now ?? new Date().toISOString();
-    let evidence;
-    let evidencePath;
-    if (input.writeEvidenceDraft !== false && input.mode !== "dry-run") {
-        evidence = buildEvidenceDraft({
-            campaignId: input.campaignId,
-            manifest: planned.manifest,
-            cellResults,
-        });
-        evidencePath = path
-            .relative(input.repoRoot, evidenceDraftPath(input.repoRoot, input.campaignId))
-            .replace(/\\/g, "/");
-        await writeJsonAtomic(evidenceDraftPath(input.repoRoot, input.campaignId), evidence, { repoRoot: input.repoRoot });
-    }
-    const matrix = matrixRunSchema.parse({
-        schemaVersion: 1,
-        campaignId: input.campaignId,
-        planHash: planned.plan.planHash,
-        mode: input.mode,
-        createdAt: now,
-        cells: cellResults,
-        privateCheckCount: privateResults.length,
-        privateCheckFailed: privateResults.filter((row) => !row.ok).length,
-        evidencePath,
-        autoPromote: false,
-    });
-    await writeJsonAtomic(matrixRunPath(input.repoRoot, input.campaignId), matrix, {
-        repoRoot: input.repoRoot,
-    });
-    return { matrix, privateResults, evidence };
-}
-function buildEvidenceDraft(input) {
-    const challengerCandidateId = input.manifest.challengerCandidateIds[0];
-    if (!challengerCandidateId) {
-        throw new Error("campaign has no challenger for evidence draft");
-    }
-    const cells = [];
-    for (const row of input.cellResults) {
-        if (row.verifyPassed === undefined)
-            continue;
-        if (row.executionRole !== "candidate_run" &&
-            row.executionRole !== "private_verify" &&
-            row.executionRole !== "promotion_gate_only") {
-            continue;
-        }
-        // Only include executed public/private pairs; held_out needs external evidence.
-        if (row.executionRole === "promotion_gate_only")
-            continue;
-        cells.push({
-            cellId: row.cellId,
-            candidateId: row.candidateId,
-            taskRef: row.taskRef,
-            seed: row.seed,
-            split: row.split,
-            verifyPassed: row.verifyPassed,
-            runId: row.runId,
-        });
-    }
-    if (cells.length === 0) {
-        // Minimal placeholder so draft is schema-valid for inspection; scorecard needs more.
-        cells.push({
-            candidateId: input.manifest.incumbentCandidateId,
-            taskRef: "matrix/placeholder",
-            seed: 0,
-            split: "public",
-            verifyPassed: false,
-        });
-        cells.push({
-            candidateId: challengerCandidateId,
-            taskRef: "matrix/placeholder",
-            seed: 0,
-            split: "public",
-            verifyPassed: false,
-        });
-    }
-    return {
-        schemaVersion: 1,
-        campaignId: input.campaignId,
-        challengerCandidateId,
-        cells,
-        diffs: [],
-        verifyCommands: { incumbent: [], challenger: [] },
-        budgetStatus: { incumbent: "missing", challenger: "missing" },
-    };
-}
-export async function readMatrixRun(repoRoot, campaignId) {
-    try {
-        const raw = await readFile(matrixRunPath(repoRoot, campaignId), "utf-8");
-        return matrixRunSchema.parse(JSON.parse(raw));
-    }
-    catch (error) {
-        const code = error.code;
-        if (code === "ENOENT")
-            return undefined;
-        throw error;
-    }
-}
-export function formatMatrixRunMarkdown(matrix) {
-    const executed = matrix.cells.filter((cell) => !cell.skipped);
-    const lines = [
-        `# Campaign Matrix: ${matrix.campaignId}`,
-        "",
-        `- mode: \`${matrix.mode}\``,
-        `- planHash: \`${matrix.planHash}\``,
-        `- cells: ${matrix.cells.length} (executed/recorded=${executed.length})`,
-        `- privateChecks: ${matrix.privateCheckCount} (failed=${matrix.privateCheckFailed})`,
-        `- evidencePath: \`${matrix.evidencePath ?? "(none)"}\``,
-        `- autoPromote: \`${matrix.autoPromote}\``,
-        "",
-        "## Cell results",
-        "",
-    ];
-    for (const cell of matrix.cells.slice(0, 40)) {
-        lines.push(`- \`${cell.cellId}\` role=${cell.executionRole} skipped=${cell.skipped} passed=${cell.verifyPassed ?? "-"} ${cell.detail ?? ""}`);
-    }
-    if (matrix.cells.length > 40) {
-        lines.push(`- … ${matrix.cells.length - 40} more`);
-    }
-    lines.push("", "> Matrix never auto-promotes. Use `eval campaign scorecard` + human-gated `eval promote` / `eval experiment accept`.", "");
-    return `${lines.join("\n")}\n`;
-}
-/** Optional helper: build scorecard from matrix evidence draft when complete enough. */
-export async function buildScorecardFromMatrixEvidence(input) {
-    const manifest = await readCampaignManifest(input.repoRoot, input.campaignId);
-    const plan = await readCampaignPlan(input.repoRoot, input.campaignId);
-    if (!plan)
-        throw new Error(`campaign ${input.campaignId} has no plan`);
-    const policy = evaluatePromotionPolicy({
-        campaignId: input.campaignId,
-        incumbentCandidateId: manifest.incumbentCandidateId,
-        evidence: input.evidence,
-    });
-    await writeCampaignScorecard({
-        repoRoot: input.repoRoot,
-        scorecard: {
-            schemaVersion: 1,
-            campaignId: input.campaignId,
-            planHash: plan.planHash,
-            createdAt: new Date().toISOString(),
-            evidenceCellCount: input.evidence.cells.length,
-            policy,
-        },
-        evidence: input.evidence,
-    });
-}