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

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

@@ -1,135 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { readCampaignEvidence, readCampaignManifest, readCampaignPlan, readCampaignScorecard, writeCampaignScorecard, } from "../../infrastructure/evaluation/campaign-store.js";
-import { evaluatePromotionPolicy } from "./promotion-policy.js";
-import { campaignEvidenceSchema, } from "./types.js";
-export async function loadCampaignEvidence(input) {
-    const absolute = path.resolve(input.repoRoot, input.evidencePath);
-    const raw = JSON.parse(await readFile(absolute, "utf-8"));
-    return campaignEvidenceSchema.parse(raw);
-}
-export async function buildCampaignScorecard(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; run eval campaign plan first`);
-    }
-    if (input.evidence.campaignId !== input.campaignId) {
-        throw new Error(`evidence campaignId mismatch: expected ${input.campaignId}, got ${input.evidence.campaignId}`);
-    }
-    const policy = evaluatePromotionPolicy({
-        campaignId: input.campaignId,
-        incumbentCandidateId: manifest.incumbentCandidateId,
-        evidence: input.evidence,
-        acknowledgeReview: input.acknowledgeReview,
-    });
-    const scorecard = {
-        schemaVersion: 1,
-        campaignId: input.campaignId,
-        planHash: plan.planHash,
-        createdAt: new Date().toISOString(),
-        evidenceCellCount: input.evidence.cells.length,
-        policy,
-    };
-    if (input.persist !== false) {
-        await writeCampaignScorecard({
-            repoRoot: input.repoRoot,
-            scorecard,
-            evidence: input.evidence,
-        });
-    }
-    return scorecard;
-}
-export async function auditCampaignEvidence(input) {
-    const scorecard = await buildCampaignScorecard({
-        ...input,
-        persist: false,
-    });
-    return {
-        findings: scorecard.policy.findings,
-        policy: scorecard.policy,
-    };
-}
-export async function requireCampaignPromotionGate(input) {
-    let evidence;
-    if (input.evidencePath) {
-        evidence = await loadCampaignEvidence({
-            repoRoot: input.repoRoot,
-            evidencePath: input.evidencePath,
-        });
-    }
-    else {
-        evidence = await readCampaignEvidence(input.repoRoot, input.campaignId);
-    }
-    let scorecard;
-    if (evidence) {
-        scorecard = await buildCampaignScorecard({
-            repoRoot: input.repoRoot,
-            campaignId: input.campaignId,
-            evidence,
-            acknowledgeReview: input.acknowledgeReview,
-            persist: true,
-        });
-    }
-    else {
-        const existing = await readCampaignScorecard(input.repoRoot, input.campaignId);
-        if (!existing) {
-            throw new Error(`campaign ${input.campaignId} has no scorecard; run eval campaign scorecard --evidence <path> first`);
-        }
-        if (input.acknowledgeReview &&
-            existing.policy.gates.safetyOk === "review" &&
-            !existing.policy.promotionEligible) {
-            throw new Error(`campaign ${input.campaignId} scorecard needs re-evaluation with evidence; provide --evidence or re-run scorecard`);
-        }
-        scorecard = existing;
-    }
-    if (scorecard.policy.challengerCandidateId !== input.toCandidateId) {
-        throw new Error(`promotion target mismatch: scorecard challenger=${scorecard.policy.challengerCandidateId}, --to-candidate=${input.toCandidateId}`);
-    }
-    if (!scorecard.policy.promotionEligible) {
-        throw new Error(`campaign promotion policy rejected: ${scorecard.policy.reasons.join("; ")}`);
-    }
-    return scorecard;
-}
-export function formatCampaignScorecardMarkdown(scorecard) {
-    const { policy } = scorecard;
-    const lines = [
-        `# Campaign Scorecard: ${scorecard.campaignId}`,
-        "",
-        `- planHash: \`${scorecard.planHash}\``,
-        `- createdAt: \`${scorecard.createdAt}\``,
-        `- evidenceCells: ${scorecard.evidenceCellCount}`,
-        `- policy: \`${policy.policyVersion}\``,
-        `- promotionEligible: **${policy.promotionEligible}**`,
-        "",
-        "## Gates",
-        "",
-        `- privateImprovement: \`${policy.gates.privateImprovement}\``,
-        `- heldOutNonRegression: \`${policy.gates.heldOutNonRegression}\``,
-        `- budgetOk: \`${policy.gates.budgetOk}\``,
-        `- safetyOk: \`${policy.gates.safetyOk}\``,
-        `- humanRequired: \`${policy.gates.humanRequired}\``,
-        "",
-        "## Paired tallies",
-        "",
-        `- private: challengerWins=${policy.paired.private.challengerWins} incumbentWins=${policy.paired.private.incumbentWins} ties=${policy.paired.private.ties}`,
-        `- held_out: challengerWins=${policy.paired.held_out.challengerWins} incumbentWins=${policy.paired.held_out.incumbentWins} ties=${policy.paired.held_out.ties}`,
-        `- public: challengerWins=${policy.paired.public.challengerWins} incumbentWins=${policy.paired.public.incumbentWins} ties=${policy.paired.public.ties}`,
-        "",
-    ];
-    if (policy.findings.length > 0) {
-        lines.push("## Integrity findings", "");
-        for (const finding of policy.findings) {
-            lines.push(`- [${finding.severity}] \`${finding.code}\`${finding.path ? ` @ ${finding.path}` : ""}: ${finding.message}`);
-        }
-        lines.push("");
-    }
-    if (policy.reasons.length > 0) {
-        lines.push("## Reasons", "");
-        for (const reason of policy.reasons) {
-            lines.push(`- ${reason}`);
-        }
-        lines.push("");
-    }
-    return `${lines.join("\n")}\n`;
-}

package/dist/application/evaluation/campaign.js

@@ -1,370 +0,0 @@
-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/corpus-hash.js

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

@@ -1,56 +0,0 @@
-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`;
-}