@tea-agent/loop-agent 0.1.0-fe-test.0

package/dist/commands/eval.js

@@ -0,0 +1,1398 @@
+import path from "node:path";
+import { writeTextAtomic } from "../infrastructure/harness/atomic-write.js";
+import { readReplayScorecard } from "../infrastructure/evaluation/store.js";
+import { formatReplayMarkdown, replayEvaluation, } from "../application/evaluation/replay.js";
+import { formatCandidateMarkdown, listCandidates, registerCandidate, showCandidate, transitionCandidate, } from "../application/evaluation/candidate.js";
+import { formatAliasMarkdown, formatAliasMoveMarkdown, listAliases, promoteAlias, rollbackAlias, showAlias, } from "../application/evaluation/alias.js";
+import { formatCorpusMarkdown, listCorpora, registerCorpus, showCorpus, validateCorpus, } from "../application/evaluation/corpus.js";
+import { formatBudgetReportMarkdown, } from "../application/evaluation/budget.js";
+import { createCampaign, formatCampaignMarkdown, listCampaigns, planCampaign, runCampaignPrivateChecks, showCampaign, validateCampaign, } from "../application/evaluation/campaign.js";
+import { auditCampaignEvidence, buildCampaignScorecard, formatCampaignScorecardMarkdown, loadCampaignEvidence, requireCampaignPromotionGate, } from "../application/evaluation/campaign-scorecard.js";
+import { acceptExperiment, createExperimentFromCurate, formatExperimentMarkdown, listExperiments, rejectExperiment, showExperiment, } from "../application/evaluation/experiment.js";
+import { formatMatrixRunMarkdown, runCampaignMatrix, } from "../application/evaluation/campaign-matrix.js";
+import { formatOuterLoopMarkdown, runOuterLoop, } from "../application/evaluation/outer-loop.js";
+import { evaluateIgnition, formatIgnitionMarkdown, listIgnitions, recordIgnitionGeneration, showIgnition, } from "../application/evaluation/ignition.js";
+import { createDagDryRunPiCellExecutor } from "../application/evaluation/pi-cell-executor.js";
+import { formatProposerRunMarkdown, proposeFromCurate, } from "../application/evaluation/proposer.js";
+import { formatPrivateVerifierMarkdown, listPrivateVerifiers, registerPrivateVerifier, showPrivateVerifier, validatePrivateVerifier, } from "../application/evaluation/private-verifier.js";
+import { getContextPolicy, isContextPolicyId, listContextPolicies, } from "../workflows/dag/context-policy.js";
+import { locateDagRun, readDagRunState } from "../workflows/dag/lifecycle.js";
+import { lifecycleStateSchema, matrixModeSchema, } from "../application/evaluation/types.js";
+const USAGE = "usage: eval <…|propose|outer-loop|ignition|campaign|experiment> ...; ignition <record|evaluate|show|list>; campaign matrix [--mode pi --dag-template <path>]; promote/ignition never auto-promote; ignition never claims RSI Level 1";
+function parseFormatFlags(args) {
+    const json = args.includes("--json");
+    const markdown = args.includes("--markdown");
+    if (json && markdown) {
+        throw new Error("eval accepts only one of --json or --markdown");
+    }
+    return { json: json || !markdown, markdown };
+}
+function parseDryRunFlags(args) {
+    const dryRun = args.includes("--dry-run");
+    const apply = args.includes("--apply");
+    if (dryRun && apply) {
+        throw new Error("eval accepts only one of --dry-run or --apply");
+    }
+    // Default dry-run: human gate; --apply commits alias move.
+    return !apply;
+}
+function flagValue(args, flag) {
+    const index = args.indexOf(flag);
+    if (index >= 0) {
+        const value = args[index + 1];
+        if (!value || value.startsWith("-")) {
+            throw new Error(`${flag} requires a value`);
+        }
+        return value;
+    }
+    const prefix = `${flag}=`;
+    return args.find((arg) => arg.startsWith(prefix))?.slice(prefix.length);
+}
+const VALUE_FLAGS = [
+    "--spec",
+    "--output",
+    "--replay-id",
+    "--manifest",
+    "--candidate-id",
+    "--corpus-id",
+    "--to",
+    "--to-candidate",
+    "--reason",
+    "--alias",
+    "--policy-id",
+    "--run-id",
+    "--private-verifier-id",
+    "--campaign-id",
+    "--evidence",
+    "--experiment-id",
+    "--mode",
+    "--fixture",
+    "--max-public-cells",
+    "--max",
+    "--proposer-run-id",
+    "--campaign-manifest",
+    "--matrix-mode",
+    "--max-proposals",
+    "--dag-template",
+    "--ignition-id",
+    "--generation",
+    "--parent-candidate",
+    "--proposer-run-id",
+];
+function assertKnownFlags(args, allowed) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg.startsWith("-"))
+            continue;
+        const key = arg.split("=", 1)[0];
+        if (!allowed.includes(key)) {
+            throw new Error(`unknown eval argument: ${arg}`);
+        }
+        if (VALUE_FLAGS.includes(key) && !arg.includes("=")) {
+            i += 1;
+        }
+    }
+}
+function parseCandidateArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "register") {
+        assertKnownFlags(tail, ["--manifest", "--json", "--markdown"]);
+        const manifestPath = flagValue(tail, "--manifest");
+        if (!manifestPath) {
+            throw new Error("eval candidate register requires --manifest <path>");
+        }
+        return {
+            command: "candidate",
+            action: "register",
+            manifestPath,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show") {
+        assertKnownFlags(tail, ["--candidate-id", "--json", "--markdown"]);
+        const candidateId = flagValue(tail, "--candidate-id");
+        if (!candidateId) {
+            throw new Error("eval candidate show requires --candidate-id <id>");
+        }
+        return {
+            command: "candidate",
+            action: "show",
+            candidateId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "candidate",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "transition") {
+        assertKnownFlags(tail, [
+            "--candidate-id",
+            "--to",
+            "--reason",
+            "--json",
+            "--markdown",
+        ]);
+        const candidateId = flagValue(tail, "--candidate-id");
+        const toRaw = flagValue(tail, "--to");
+        const reason = flagValue(tail, "--reason");
+        if (!candidateId) {
+            throw new Error("eval candidate transition requires --candidate-id <id>");
+        }
+        if (!toRaw) {
+            throw new Error("eval candidate transition requires --to <state>");
+        }
+        if (!reason) {
+            throw new Error("eval candidate transition requires --reason <text>");
+        }
+        const to = lifecycleStateSchema.parse(toRaw);
+        return {
+            command: "candidate",
+            action: "transition",
+            candidateId,
+            to,
+            reason,
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval candidate <register|show|list|transition> ...");
+}
+function parseAliasArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "show") {
+        assertKnownFlags(tail, ["--alias", "--json", "--markdown"]);
+        const alias = flagValue(tail, "--alias");
+        if (!alias)
+            throw new Error("eval alias show requires --alias <name>");
+        return {
+            command: "alias",
+            action: "show",
+            alias,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "alias",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval alias <show|list> ...");
+}
+function parseContextPolicyArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "context-policy",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show") {
+        assertKnownFlags(tail, ["--policy-id", "--json", "--markdown"]);
+        const policyId = flagValue(tail, "--policy-id");
+        if (!policyId) {
+            throw new Error("eval context-policy show requires --policy-id <id>");
+        }
+        return {
+            command: "context-policy",
+            action: "show",
+            policyId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval context-policy <list|show> ...");
+}
+function parseBudgetArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "show") {
+        assertKnownFlags(tail, ["--run-id", "--json", "--markdown"]);
+        const runId = flagValue(tail, "--run-id");
+        if (!runId) {
+            throw new Error("eval budget show requires --run-id <id>");
+        }
+        return {
+            command: "budget",
+            action: "show",
+            runId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval budget show --run-id <id> [--json|--markdown]");
+}
+function parsePrivateVerifierArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "register" || action === "validate") {
+        assertKnownFlags(tail, ["--manifest", "--json", "--markdown"]);
+        const manifestPath = flagValue(tail, "--manifest");
+        if (!manifestPath) {
+            throw new Error(`eval private-verifier ${action} requires --manifest <path>`);
+        }
+        return {
+            command: "private-verifier",
+            action,
+            manifestPath,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show") {
+        assertKnownFlags(tail, ["--private-verifier-id", "--json", "--markdown"]);
+        const privateVerifierId = flagValue(tail, "--private-verifier-id");
+        if (!privateVerifierId) {
+            throw new Error("eval private-verifier show requires --private-verifier-id <id>");
+        }
+        return {
+            command: "private-verifier",
+            action: "show",
+            privateVerifierId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "private-verifier",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval private-verifier <register|show|list|validate> ...");
+}
+function parseCampaignArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "create" || action === "validate") {
+        assertKnownFlags(tail, ["--manifest", "--json", "--markdown"]);
+        const manifestPath = flagValue(tail, "--manifest");
+        if (!manifestPath) {
+            throw new Error(`eval campaign ${action} requires --manifest <path>`);
+        }
+        return {
+            command: "campaign",
+            action,
+            manifestPath,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show" || action === "plan" || action === "run") {
+        assertKnownFlags(tail, ["--campaign-id", "--json", "--markdown"]);
+        const campaignId = flagValue(tail, "--campaign-id");
+        if (!campaignId) {
+            throw new Error(`eval campaign ${action} requires --campaign-id <id>`);
+        }
+        return {
+            command: "campaign",
+            action,
+            campaignId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "matrix") {
+        assertKnownFlags(tail, [
+            "--campaign-id",
+            "--mode",
+            "--fixture",
+            "--dag-template",
+            "--max-public-cells",
+            "--json",
+            "--markdown",
+        ]);
+        const campaignId = flagValue(tail, "--campaign-id");
+        const modeRaw = flagValue(tail, "--mode") ?? "dry-run";
+        if (!campaignId) {
+            throw new Error("eval campaign matrix requires --campaign-id <id>");
+        }
+        const mode = matrixModeSchema.parse(modeRaw);
+        const maxRaw = flagValue(tail, "--max-public-cells");
+        return {
+            command: "campaign",
+            action: "matrix",
+            campaignId,
+            mode,
+            fixturePath: flagValue(tail, "--fixture"),
+            dagTemplatePath: flagValue(tail, "--dag-template"),
+            maxPublicCells: maxRaw ? Number(maxRaw) : undefined,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "scorecard" || action === "audit") {
+        assertKnownFlags(tail, [
+            "--campaign-id",
+            "--evidence",
+            "--acknowledge-review",
+            "--json",
+            "--markdown",
+        ]);
+        const campaignId = flagValue(tail, "--campaign-id");
+        const evidencePath = flagValue(tail, "--evidence");
+        if (!campaignId) {
+            throw new Error(`eval campaign ${action} requires --campaign-id <id>`);
+        }
+        if (!evidencePath) {
+            throw new Error(`eval campaign ${action} requires --evidence <path>`);
+        }
+        return {
+            command: "campaign",
+            action,
+            campaignId,
+            evidencePath,
+            acknowledgeReview: tail.includes("--acknowledge-review"),
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "campaign",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval campaign <create|show|list|validate|plan|run|matrix|scorecard|audit> ...");
+}
+function parseProposeArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action !== "from-curate") {
+        throw new Error("usage: eval propose from-curate [--max N] [--dry-run|--apply]");
+    }
+    assertKnownFlags(tail, [
+        "--max",
+        "--proposer-run-id",
+        "--dry-run",
+        "--apply",
+        "--json",
+        "--markdown",
+    ]);
+    const maxRaw = flagValue(tail, "--max");
+    return {
+        command: "propose",
+        action: "from-curate",
+        maxCandidates: maxRaw ? Number(maxRaw) : 1,
+        proposerRunId: flagValue(tail, "--proposer-run-id"),
+        dryRun: parseDryRunFlags(tail),
+        ...parseFormatFlags(tail),
+    };
+}
+function parseOuterLoopArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action !== "run") {
+        throw new Error("usage: eval outer-loop run --matrix-mode <dry-run|stub|pi-plan|pi> [--dag-template <path>] [--campaign-id|--campaign-manifest] [--propose-from-curate] ...");
+    }
+    assertKnownFlags(tail, [
+        "--campaign-id",
+        "--campaign-manifest",
+        "--propose-from-curate",
+        "--max-proposals",
+        "--matrix-mode",
+        "--fixture",
+        "--dag-template",
+        "--max-public-cells",
+        "--scorecard",
+        "--json",
+        "--markdown",
+    ]);
+    const matrixModeRaw = flagValue(tail, "--matrix-mode");
+    if (!matrixModeRaw) {
+        throw new Error("eval outer-loop run requires --matrix-mode <mode>");
+    }
+    const matrixMode = matrixModeSchema.parse(matrixModeRaw);
+    const dagTemplatePath = flagValue(tail, "--dag-template");
+    if (matrixMode === "pi" && !dagTemplatePath) {
+        throw new Error("eval outer-loop refuses mode=pi without --dag-template (bounded dry-run Pi) or injected executor; use pi-plan or stub");
+    }
+    const maxRaw = flagValue(tail, "--max-public-cells");
+    const maxPropRaw = flagValue(tail, "--max-proposals");
+    return {
+        command: "outer-loop",
+        action: "run",
+        campaignId: flagValue(tail, "--campaign-id"),
+        campaignManifestPath: flagValue(tail, "--campaign-manifest"),
+        proposeFromCurate: tail.includes("--propose-from-curate"),
+        maxProposals: maxPropRaw ? Number(maxPropRaw) : 1,
+        matrixMode,
+        fixturePath: flagValue(tail, "--fixture"),
+        dagTemplatePath,
+        maxPublicCells: maxRaw ? Number(maxRaw) : undefined,
+        buildScorecard: tail.includes("--scorecard"),
+        ...parseFormatFlags(tail),
+    };
+}
+function parseIgnitionArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "ignition",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "evaluate" || action === "show") {
+        assertKnownFlags(tail, ["--ignition-id", "--json", "--markdown"]);
+        const ignitionId = flagValue(tail, "--ignition-id");
+        if (!ignitionId) {
+            throw new Error(`eval ignition ${action} requires --ignition-id <id>`);
+        }
+        return {
+            command: "ignition",
+            action,
+            ignitionId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "record") {
+        assertKnownFlags(tail, [
+            "--ignition-id",
+            "--generation",
+            "--parent-candidate",
+            "--proposer-run-id",
+            "--campaign-id",
+            "--json",
+            "--markdown",
+        ]);
+        const ignitionId = flagValue(tail, "--ignition-id");
+        const generationRaw = flagValue(tail, "--generation");
+        const proposerRunId = flagValue(tail, "--proposer-run-id");
+        if (!ignitionId) {
+            throw new Error("eval ignition record requires --ignition-id <id>");
+        }
+        if (generationRaw === undefined) {
+            throw new Error("eval ignition record requires --generation <n>");
+        }
+        if (!proposerRunId) {
+            throw new Error("eval ignition record requires --proposer-run-id <id>");
+        }
+        const parentRaw = flagValue(tail, "--parent-candidate");
+        return {
+            command: "ignition",
+            action: "record",
+            ignitionId,
+            generation: Number(generationRaw),
+            parentCandidateId: parentRaw === undefined || parentRaw === "null" ? null : parentRaw,
+            proposerRunId,
+            campaignId: flagValue(tail, "--campaign-id"),
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval ignition <record|evaluate|show|list> ...");
+}
+function parseExperimentArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "from-curate") {
+        assertKnownFlags(tail, [
+            "--experiment-id",
+            "--candidate-id",
+            "--json",
+            "--markdown",
+        ]);
+        return {
+            command: "experiment",
+            action: "from-curate",
+            experimentId: flagValue(tail, "--experiment-id"),
+            candidateId: flagValue(tail, "--candidate-id"),
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show") {
+        assertKnownFlags(tail, ["--experiment-id", "--json", "--markdown"]);
+        const experimentId = flagValue(tail, "--experiment-id");
+        if (!experimentId) {
+            throw new Error("eval experiment show requires --experiment-id <id>");
+        }
+        return {
+            command: "experiment",
+            action: "show",
+            experimentId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "experiment",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "accept") {
+        assertKnownFlags(tail, [
+            "--experiment-id",
+            "--campaign-id",
+            "--reason",
+            "--acknowledge-review",
+            "--dry-run",
+            "--apply",
+            "--json",
+            "--markdown",
+        ]);
+        const experimentId = flagValue(tail, "--experiment-id");
+        const campaignId = flagValue(tail, "--campaign-id");
+        const reason = flagValue(tail, "--reason");
+        if (!experimentId) {
+            throw new Error("eval experiment accept requires --experiment-id <id>");
+        }
+        if (!campaignId) {
+            throw new Error("eval experiment accept requires --campaign-id <id>");
+        }
+        if (!reason) {
+            throw new Error("eval experiment accept requires --reason <text>");
+        }
+        return {
+            command: "experiment",
+            action: "accept",
+            experimentId,
+            campaignId,
+            reason,
+            acknowledgeReview: tail.includes("--acknowledge-review"),
+            dryRun: parseDryRunFlags(tail),
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "reject") {
+        assertKnownFlags(tail, [
+            "--experiment-id",
+            "--reason",
+            "--dry-run",
+            "--apply",
+            "--json",
+            "--markdown",
+        ]);
+        const experimentId = flagValue(tail, "--experiment-id");
+        const reason = flagValue(tail, "--reason");
+        if (!experimentId) {
+            throw new Error("eval experiment reject requires --experiment-id <id>");
+        }
+        if (!reason) {
+            throw new Error("eval experiment reject requires --reason <text>");
+        }
+        return {
+            command: "experiment",
+            action: "reject",
+            experimentId,
+            reason,
+            dryRun: parseDryRunFlags(tail),
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval experiment <from-curate|show|list|accept|reject> ...");
+}
+function parseCorpusArgs(rest) {
+    const [action, ...tail] = rest;
+    if (action === "register" || action === "validate") {
+        assertKnownFlags(tail, ["--manifest", "--json", "--markdown"]);
+        const manifestPath = flagValue(tail, "--manifest");
+        if (!manifestPath) {
+            throw new Error(`eval corpus ${action} requires --manifest <path>`);
+        }
+        return {
+            command: "corpus",
+            action,
+            manifestPath,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "show") {
+        assertKnownFlags(tail, ["--corpus-id", "--json", "--markdown"]);
+        const corpusId = flagValue(tail, "--corpus-id");
+        if (!corpusId) {
+            throw new Error("eval corpus show requires --corpus-id <id>");
+        }
+        return {
+            command: "corpus",
+            action: "show",
+            corpusId,
+            ...parseFormatFlags(tail),
+        };
+    }
+    if (action === "list") {
+        assertKnownFlags(tail, ["--json", "--markdown"]);
+        return {
+            command: "corpus",
+            action: "list",
+            ...parseFormatFlags(tail),
+        };
+    }
+    throw new Error("usage: eval corpus <register|show|list|validate> ...");
+}
+function parseAliasMoveArgs(command, rest) {
+    const promoteOnlyFlags = command === "promote"
+        ? ["--campaign-id", "--evidence", "--acknowledge-review"]
+        : [];
+    assertKnownFlags(rest, [
+        "--alias",
+        "--to-candidate",
+        "--reason",
+        "--dry-run",
+        "--apply",
+        "--json",
+        "--markdown",
+        ...promoteOnlyFlags,
+    ]);
+    const alias = flagValue(rest, "--alias");
+    const toCandidateId = flagValue(rest, "--to-candidate");
+    const reason = flagValue(rest, "--reason");
+    if (!alias)
+        throw new Error(`eval ${command} requires --alias <name>`);
+    if (!toCandidateId) {
+        throw new Error(`eval ${command} requires --to-candidate <id>`);
+    }
+    if (!reason)
+        throw new Error(`eval ${command} requires --reason <text>`);
+    if (command === "promote") {
+        return {
+            command,
+            alias,
+            toCandidateId,
+            reason,
+            campaignId: flagValue(rest, "--campaign-id"),
+            evidencePath: flagValue(rest, "--evidence"),
+            acknowledgeReview: rest.includes("--acknowledge-review"),
+            dryRun: parseDryRunFlags(rest),
+            ...parseFormatFlags(rest),
+        };
+    }
+    return {
+        command,
+        alias,
+        toCandidateId,
+        reason,
+        dryRun: parseDryRunFlags(rest),
+        ...parseFormatFlags(rest),
+    };
+}
+export function parseEvalArgs(args) {
+    const [command, ...rest] = args;
+    if (command === "replay") {
+        assertKnownFlags(rest, ["--spec", "--output", "--json", "--markdown"]);
+        const specPath = flagValue(rest, "--spec");
+        if (!specPath)
+            throw new Error("eval replay requires --spec <path>");
+        return {
+            command,
+            specPath,
+            outputPath: flagValue(rest, "--output"),
+            ...parseFormatFlags(rest),
+        };
+    }
+    if (command === "report") {
+        assertKnownFlags(rest, ["--replay-id", "--json", "--markdown"]);
+        const replayId = flagValue(rest, "--replay-id");
+        if (!replayId)
+            throw new Error("eval report requires --replay-id <id>");
+        return { command, replayId, ...parseFormatFlags(rest) };
+    }
+    if (command === "candidate") {
+        return parseCandidateArgs(rest);
+    }
+    if (command === "alias") {
+        return parseAliasArgs(rest);
+    }
+    if (command === "promote" || command === "rollback") {
+        return parseAliasMoveArgs(command, rest);
+    }
+    if (command === "corpus") {
+        return parseCorpusArgs(rest);
+    }
+    if (command === "context-policy") {
+        return parseContextPolicyArgs(rest);
+    }
+    if (command === "budget") {
+        return parseBudgetArgs(rest);
+    }
+    if (command === "private-verifier") {
+        return parsePrivateVerifierArgs(rest);
+    }
+    if (command === "campaign") {
+        return parseCampaignArgs(rest);
+    }
+    if (command === "experiment") {
+        return parseExperimentArgs(rest);
+    }
+    if (command === "propose") {
+        return parseProposeArgs(rest);
+    }
+    if (command === "outer-loop") {
+        return parseOuterLoopArgs(rest);
+    }
+    if (command === "ignition") {
+        return parseIgnitionArgs(rest);
+    }
+    throw new Error(USAGE);
+}
+function printIgnition(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.report, null, 2));
+        return;
+    }
+    process.stdout.write(formatIgnitionMarkdown(input.report));
+}
+function printScorecard(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.scorecard, null, 2));
+        return;
+    }
+    process.stdout.write(input.markdown);
+}
+function printCandidate(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.record, null, 2));
+        return;
+    }
+    process.stdout.write(formatCandidateMarkdown(input.record));
+}
+function printAlias(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.alias, null, 2));
+        return;
+    }
+    process.stdout.write(formatAliasMarkdown(input.alias));
+}
+function printAliasMove(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.result, null, 2));
+        return;
+    }
+    process.stdout.write(formatAliasMoveMarkdown(input.result));
+}
+function printPrivateVerifier(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.manifest, null, 2));
+        return;
+    }
+    process.stdout.write(formatPrivateVerifierMarkdown(input.manifest));
+}
+function printCampaign(input) {
+    if (input.json) {
+        console.log(JSON.stringify({
+            manifest: input.manifest,
+            plan: input.plan,
+        }, null, 2));
+        return;
+    }
+    process.stdout.write(formatCampaignMarkdown({
+        manifest: input.manifest,
+        plan: input.plan,
+    }));
+}
+function printExperiment(input) {
+    if (input.json) {
+        console.log(JSON.stringify({
+            record: input.record,
+            candidate: input.candidate,
+            ...input.extra,
+        }, null, 2));
+        return;
+    }
+    process.stdout.write(formatExperimentMarkdown({
+        record: input.record,
+        candidate: input.candidate,
+    }));
+}
+function printExperimentDisposition(input) {
+    if (input.json) {
+        console.log(JSON.stringify(input.result, null, 2));
+        return;
+    }
+    const prefix = input.result.dryRun ? "dry-run " : "";
+    process.stdout.write(`${prefix}experiment ${input.result.record.status} (changed=${input.result.changed})\n`);
+    process.stdout.write(formatExperimentMarkdown({
+        record: input.result.record,
+        candidate: input.result.candidate,
+    }));
+}
+function printCorpus(input) {
+    if (input.json) {
+        console.log(JSON.stringify({
+            summary: input.summary,
+            manifest: input.manifest,
+            ...input.extra,
+        }, null, 2));
+        return;
+    }
+    process.stdout.write(formatCorpusMarkdown({
+        manifest: input.manifest,
+        summary: input.summary,
+    }));
+}
+export async function runEval(repoRoot, args) {
+    const parsed = parseEvalArgs(args);
+    if (parsed.command === "replay") {
+        const result = await replayEvaluation({
+            repoRoot,
+            specPath: parsed.specPath,
+        });
+        if (parsed.outputPath) {
+            const outputPath = path.resolve(repoRoot, parsed.outputPath);
+            await writeTextAtomic(outputPath, parsed.markdown
+                ? result.markdown
+                : `${JSON.stringify(result.scorecard, null, 2)}\n`, { repoRoot });
+        }
+        printScorecard({
+            scorecard: result.scorecard,
+            markdown: result.markdown,
+            json: parsed.json,
+        });
+        return;
+    }
+    if (parsed.command === "report") {
+        const scorecard = (await readReplayScorecard(repoRoot, parsed.replayId));
+        const markdown = formatReplayMarkdown(scorecard);
+        printScorecard({ scorecard, markdown, json: parsed.json });
+        return;
+    }
+    if (parsed.command === "alias") {
+        if (parsed.action === "show") {
+            const alias = await showAlias({ repoRoot, alias: parsed.alias });
+            printAlias({ alias, json: parsed.json });
+            return;
+        }
+        const rows = await listAliases({ repoRoot });
+        if (parsed.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        const lines = [
+            "# Aliases",
+            "",
+            ...rows.map((row) => `- \`${row.alias}\` → \`${row.candidateId}\` hash=\`${row.bundleHash}\` decision=\`${row.updatedByDecisionId}\``),
+            "",
+        ];
+        process.stdout.write(`${lines.join("\n")}\n`);
+        return;
+    }
+    if (parsed.command === "promote" || parsed.command === "rollback") {
+        if (parsed.command === "promote" && parsed.campaignId) {
+            await requireCampaignPromotionGate({
+                repoRoot,
+                campaignId: parsed.campaignId,
+                toCandidateId: parsed.toCandidateId,
+                acknowledgeReview: parsed.acknowledgeReview,
+                evidencePath: parsed.evidencePath,
+            });
+        }
+        const mover = parsed.command === "promote" ? promoteAlias : rollbackAlias;
+        const result = await mover({
+            repoRoot,
+            alias: parsed.alias,
+            toCandidateId: parsed.toCandidateId,
+            reason: parsed.reason,
+            dryRun: parsed.dryRun,
+        });
+        printAliasMove({ result, json: parsed.json });
+        return;
+    }
+    if (parsed.command === "context-policy") {
+        if (parsed.action === "list") {
+            const rows = listContextPolicies().map((policy) => policy.toManifest());
+            if (parsed.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const lines = [
+                "# Context Policies",
+                "",
+                ...rows.map((row) => `- \`${row.policyId}\`: ${row.description}`),
+                "",
+            ];
+            process.stdout.write(`${lines.join("\n")}\n`);
+            return;
+        }
+        if (!isContextPolicyId(parsed.policyId)) {
+            throw new Error(`unknown context policy id: ${parsed.policyId}`);
+        }
+        const manifest = getContextPolicy(parsed.policyId).toManifest();
+        if (parsed.json) {
+            console.log(JSON.stringify(manifest, null, 2));
+            return;
+        }
+        process.stdout.write([
+            `# Context Policy: ${manifest.policyId}`,
+            "",
+            manifest.description,
+            "",
+            "```json",
+            JSON.stringify(manifest.knobs, null, 2),
+            "```",
+            "",
+        ].join("\n"));
+        return;
+    }
+    if (parsed.command === "budget") {
+        const located = await locateDagRun(repoRoot, parsed.runId);
+        if (!located) {
+            throw new Error(`dag run not found: ${parsed.runId}`);
+        }
+        const state = await readDagRunState(located.runDir);
+        const ledger = state.budgetLedger;
+        if (!ledger) {
+            throw new Error(`dag run ${parsed.runId} has no budget ledger (DagSpec.budget was not declared)`);
+        }
+        if (parsed.json) {
+            console.log(JSON.stringify(ledger, null, 2));
+            return;
+        }
+        process.stdout.write(formatBudgetReportMarkdown(ledger));
+        return;
+    }
+    if (parsed.command === "private-verifier") {
+        if (parsed.action === "validate") {
+            const result = await validatePrivateVerifier({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            printPrivateVerifier({ manifest: result.manifest, json: parsed.json });
+            return;
+        }
+        if (parsed.action === "register") {
+            const result = await registerPrivateVerifier({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            printPrivateVerifier({ manifest: result.manifest, json: parsed.json });
+            return;
+        }
+        if (parsed.action === "list") {
+            const rows = await listPrivateVerifiers({ repoRoot });
+            if (parsed.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const lines = [
+                "# Private Verifiers",
+                "",
+                ...rows.map((row) => `- \`${row.privateVerifierId}\`: checks=${row.checkCount} hash=\`${row.manifestHash}\``),
+                "",
+            ];
+            process.stdout.write(`${lines.join("\n")}\n`);
+            return;
+        }
+        if (parsed.action !== "show") {
+            throw new Error("usage: eval private-verifier <register|show|list|validate> ...");
+        }
+        const result = await showPrivateVerifier({
+            repoRoot,
+            privateVerifierId: parsed.privateVerifierId,
+        });
+        printPrivateVerifier({ manifest: result.manifest, json: parsed.json });
+        return;
+    }
+    if (parsed.command === "propose") {
+        const result = await proposeFromCurate({
+            repoRoot,
+            maxCandidates: parsed.maxCandidates,
+            proposerRunId: parsed.proposerRunId,
+            dryRun: parsed.dryRun,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        process.stdout.write(formatProposerRunMarkdown(result));
+        return;
+    }
+    if (parsed.command === "outer-loop") {
+        const piExecutor = parsed.matrixMode === "pi" && parsed.dagTemplatePath
+            ? createDagDryRunPiCellExecutor({
+                dagTemplatePath: parsed.dagTemplatePath,
+            })
+            : undefined;
+        const result = await runOuterLoop({
+            repoRoot,
+            campaignId: parsed.campaignId,
+            campaignManifestPath: parsed.campaignManifestPath,
+            proposeFromCurate: parsed.proposeFromCurate,
+            maxProposals: parsed.maxProposals,
+            matrixMode: parsed.matrixMode,
+            fixturePath: parsed.fixturePath,
+            maxPublicCells: parsed.maxPublicCells,
+            buildScorecard: parsed.buildScorecard,
+            piExecutor,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        process.stdout.write(formatOuterLoopMarkdown(result));
+        return;
+    }
+    if (parsed.command === "ignition") {
+        if (parsed.action === "list") {
+            const rows = await listIgnitions({ repoRoot });
+            if (parsed.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const lines = [
+                "# Ignition Research Gates",
+                "",
+                ...rows.map((row) => `- \`${row.ignitionId}\`: generations=${row.generationCount} verdict=\`${row.verdict}\` rsiLevel1ClaimAllowed=\`${row.rsiLevel1ClaimAllowed}\``),
+                "",
+            ];
+            process.stdout.write(`${lines.join("\n")}\n`);
+            return;
+        }
+        if (parsed.action === "record") {
+            const report = await recordIgnitionGeneration({
+                repoRoot,
+                ignitionId: parsed.ignitionId,
+                generation: parsed.generation,
+                parentCandidateId: parsed.parentCandidateId,
+                proposerRunId: parsed.proposerRunId,
+                campaignId: parsed.campaignId,
+            });
+            printIgnition({ report, json: parsed.json });
+            return;
+        }
+        if (parsed.action === "evaluate") {
+            const report = await evaluateIgnition({
+                repoRoot,
+                ignitionId: parsed.ignitionId,
+            });
+            printIgnition({ report, json: parsed.json });
+            return;
+        }
+        if (parsed.action === "show") {
+            const report = await showIgnition({
+                repoRoot,
+                ignitionId: parsed.ignitionId,
+            });
+            printIgnition({ report, json: parsed.json });
+            return;
+        }
+        throw new Error("usage: eval ignition <record|evaluate|show|list> ...");
+    }
+    if (parsed.command === "experiment") {
+        if (parsed.action === "from-curate") {
+            const result = await createExperimentFromCurate({
+                repoRoot,
+                experimentId: parsed.experimentId,
+                candidateId: parsed.candidateId,
+            });
+            printExperiment({
+                record: result.record,
+                candidate: result.candidate,
+                json: parsed.json,
+                extra: {
+                    idempotent: result.idempotent,
+                    curateMessage: result.curateMessage,
+                },
+            });
+            return;
+        }
+        if (parsed.action === "list") {
+            const rows = await listExperiments({ repoRoot });
+            if (parsed.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const lines = [
+                "# Experiments",
+                "",
+                ...rows.map((row) => `- \`${row.experimentId}\`: status=${row.status} candidate=\`${row.candidateId}\` patterns=${row.patternCount}`),
+                "",
+            ];
+            process.stdout.write(`${lines.join("\n")}\n`);
+            return;
+        }
+        if (parsed.action === "show") {
+            const result = await showExperiment({
+                repoRoot,
+                experimentId: parsed.experimentId,
+            });
+            printExperiment({
+                record: result.record,
+                candidate: result.candidate,
+                json: parsed.json,
+            });
+            return;
+        }
+        if (parsed.action === "accept") {
+            const result = await acceptExperiment({
+                repoRoot,
+                experimentId: parsed.experimentId,
+                campaignId: parsed.campaignId,
+                reason: parsed.reason,
+                acknowledgeReview: parsed.acknowledgeReview,
+                dryRun: parsed.dryRun,
+            });
+            printExperimentDisposition({ result, json: parsed.json });
+            return;
+        }
+        if (parsed.action === "reject") {
+            const result = await rejectExperiment({
+                repoRoot,
+                experimentId: parsed.experimentId,
+                reason: parsed.reason,
+                dryRun: parsed.dryRun,
+            });
+            printExperimentDisposition({ result, json: parsed.json });
+            return;
+        }
+        throw new Error("usage: eval experiment <from-curate|show|list|accept|reject> ...");
+    }
+    if (parsed.command === "campaign") {
+        if (parsed.action === "validate") {
+            const result = await validateCampaign({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            printCampaign({
+                manifest: result.manifest,
+                plan: result.plan,
+                json: parsed.json,
+            });
+            return;
+        }
+        if (parsed.action === "create") {
+            const result = await createCampaign({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            printCampaign({
+                manifest: result.manifest,
+                plan: result.plan,
+                json: parsed.json,
+            });
+            return;
+        }
+        if (parsed.action === "list") {
+            const rows = await listCampaigns({ repoRoot });
+            if (parsed.json) {
+                console.log(JSON.stringify(rows, null, 2));
+                return;
+            }
+            const lines = [
+                "# Campaigns",
+                "",
+                ...rows.map((row) => `- \`${row.campaignId}\`: status=${row.status} corpus=\`${row.corpusId}\` cells=${row.cellCount ?? "-"}`),
+                "",
+            ];
+            process.stdout.write(`${lines.join("\n")}\n`);
+            return;
+        }
+        if (parsed.action === "plan") {
+            const result = await planCampaign({
+                repoRoot,
+                campaignId: parsed.campaignId,
+            });
+            printCampaign({
+                manifest: result.manifest,
+                plan: result.plan,
+                json: parsed.json,
+            });
+            return;
+        }
+        if (parsed.action === "run") {
+            const result = await runCampaignPrivateChecks({
+                repoRoot,
+                campaignId: parsed.campaignId,
+            });
+            if (parsed.json) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const failed = result.results.filter((row) => !row.ok);
+            process.stdout.write(formatCampaignMarkdown({
+                manifest: result.manifest,
+                plan: result.plan,
+            }));
+            process.stdout.write(`\n## Private check results\n\n- total: ${result.results.length}\n- failed: ${failed.length}\n\n`);
+            if (failed.length > 0) {
+                throw new Error(`campaign private checks failed: ${failed.map((row) => `${row.cellId}/${row.checkId}`).join(", ")}`);
+            }
+            return;
+        }
+        if (parsed.action === "matrix") {
+            if (parsed.mode === "pi" && !parsed.dagTemplatePath) {
+                throw new Error("eval campaign matrix refuses mode=pi without --dag-template (bounded dry-run Pi) or injected executor; use --mode pi-plan or stub");
+            }
+            const piExecutor = parsed.mode === "pi" && parsed.dagTemplatePath
+                ? createDagDryRunPiCellExecutor({
+                    dagTemplatePath: parsed.dagTemplatePath,
+                })
+                : undefined;
+            const result = await runCampaignMatrix({
+                repoRoot,
+                campaignId: parsed.campaignId,
+                mode: parsed.mode,
+                fixturePath: parsed.fixturePath,
+                maxPublicCells: parsed.maxPublicCells,
+                piExecutor,
+            });
+            if (parsed.json) {
+                console.log(JSON.stringify(result.matrix, null, 2));
+                return;
+            }
+            process.stdout.write(formatMatrixRunMarkdown(result.matrix));
+            return;
+        }
+        if (parsed.action === "scorecard" || parsed.action === "audit") {
+            const evidence = await loadCampaignEvidence({
+                repoRoot,
+                evidencePath: parsed.evidencePath,
+            });
+            if (parsed.action === "audit") {
+                const result = await auditCampaignEvidence({
+                    repoRoot,
+                    campaignId: parsed.campaignId,
+                    evidence,
+                });
+                if (parsed.json) {
+                    console.log(JSON.stringify(result, null, 2));
+                    return;
+                }
+                const scorecard = {
+                    schemaVersion: 1,
+                    campaignId: parsed.campaignId,
+                    planHash: "(audit-only)",
+                    createdAt: new Date().toISOString(),
+                    evidenceCellCount: evidence.cells.length,
+                    policy: result.policy,
+                };
+                process.stdout.write(formatCampaignScorecardMarkdown(scorecard));
+                return;
+            }
+            const scorecard = await buildCampaignScorecard({
+                repoRoot,
+                campaignId: parsed.campaignId,
+                evidence,
+                acknowledgeReview: parsed.acknowledgeReview,
+                persist: true,
+            });
+            if (parsed.json) {
+                console.log(JSON.stringify(scorecard, null, 2));
+                return;
+            }
+            process.stdout.write(formatCampaignScorecardMarkdown(scorecard));
+            return;
+        }
+        if (parsed.action !== "show") {
+            throw new Error("usage: eval campaign <create|show|list|validate|plan|run|matrix|scorecard|audit> ...");
+        }
+        const result = await showCampaign({
+            repoRoot,
+            campaignId: parsed.campaignId,
+        });
+        printCampaign({
+            manifest: result.manifest,
+            plan: result.plan,
+            json: parsed.json,
+        });
+        return;
+    }
+    if (parsed.command === "corpus") {
+        if (parsed.action === "validate") {
+            const result = await validateCorpus({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            printCorpus({
+                manifest: result.manifest,
+                summary: result.summary,
+                json: parsed.json,
+            });
+            return;
+        }
+        if (parsed.action === "register") {
+            const result = await registerCorpus({
+                repoRoot,
+                manifestPath: parsed.manifestPath,
+            });
+            if (parsed.json) {
+                printCorpus({
+                    manifest: result.manifest,
+                    summary: result.summary,
+                    json: true,
+                    extra: {
+                        idempotent: result.idempotent,
+                        manifestPath: result.manifestPath,
+                    },
+                });
+                return;
+            }
+            process.stdout.write(`${result.idempotent ? "idempotent " : ""}registered ${result.manifest.corpusId}\n${formatCorpusMarkdown(result)}`);
+            return;
+        }
+        if (parsed.action === "show") {
+            const result = await showCorpus({
+                repoRoot,
+                corpusId: parsed.corpusId,
+            });
+            printCorpus({
+                manifest: result.manifest,
+                summary: result.summary,
+                json: parsed.json,
+            });
+            return;
+        }
+        const rows = await listCorpora({ repoRoot });
+        if (parsed.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        const lines = [
+            "# Corpora",
+            "",
+            ...rows.map((row) => `- \`${row.corpusId}\` tasks=${row.taskCount} hash=\`${row.corpusHash}\` splits=public:${row.splits.public}/private:${row.splits.private}/held_out:${row.splits.held_out}`),
+            "",
+        ];
+        process.stdout.write(`${lines.join("\n")}\n`);
+        return;
+    }
+    // candidate subcommands
+    if (parsed.action === "register") {
+        const result = await registerCandidate({
+            repoRoot,
+            manifestPath: parsed.manifestPath,
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                idempotent: result.idempotent,
+                manifestPath: result.manifestPath,
+                lifecyclePath: result.lifecyclePath,
+                record: result.record,
+            }, null, 2));
+            return;
+        }
+        process.stdout.write(`${result.idempotent ? "idempotent " : ""}registered ${result.record.manifest.candidateId}\n${formatCandidateMarkdown(result.record)}`);
+        return;
+    }
+    if (parsed.action === "show") {
+        const record = await showCandidate({
+            repoRoot,
+            candidateId: parsed.candidateId,
+        });
+        printCandidate({ record, json: parsed.json });
+        return;
+    }
+    if (parsed.action === "list") {
+        const rows = await listCandidates({ repoRoot });
+        if (parsed.json) {
+            console.log(JSON.stringify(rows, null, 2));
+            return;
+        }
+        const lines = [
+            "# Candidates",
+            "",
+            ...rows.map((row) => `- \`${row.candidateId}\` status=\`${row.status}\` hash=\`${row.bundleHash}\` promotionApplied=${row.promotionApplied}`),
+            "",
+        ];
+        process.stdout.write(`${lines.join("\n")}\n`);
+        return;
+    }
+    if (parsed.action === "transition") {
+        const record = await transitionCandidate({
+            repoRoot,
+            candidateId: parsed.candidateId,
+            to: parsed.to,
+            reason: parsed.reason,
+        });
+        printCandidate({ record, json: parsed.json });
+    }
+}