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

package/dist/commands/eval.js

@@ -3,22 +3,8 @@ 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";
+import { lifecycleStateSchema, } from "../application/evaluation/types.js";
+const USAGE = "usage: eval <replay|report|candidate> ...; candidate <register|show|list|transition> [--json|--markdown]";
 function parseFormatFlags(args) {
     const json = args.includes("--json");
     const markdown = args.includes("--markdown");
@@ -27,15 +13,6 @@ function parseFormatFlags(args) {
     }
     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) {
@@ -48,37 +25,6 @@ function flagValue(args, flag) {
     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];
@@ -88,7 +34,16 @@ function assertKnownFlags(args, allowed) {
         if (!allowed.includes(key)) {
             throw new Error(`unknown eval argument: ${arg}`);
         }
-        if (VALUE_FLAGS.includes(key) && !arg.includes("=")) {
+        if ([
+            "--spec",
+            "--output",
+            "--replay-id",
+            "--manifest",
+            "--candidate-id",
+            "--to",
+            "--reason",
+        ].includes(key) &&
+            !arg.includes("=")) {
             i += 1;
         }
     }
@@ -161,511 +116,6 @@ function parseCandidateArgs(rest) {
     }
     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") {
@@ -690,48 +140,8 @@ export function parseEvalArgs(args) {
     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));
@@ -746,80 +156,6 @@ function printCandidate(input) {
     }
     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") {
@@ -846,505 +182,6 @@ export async function runEval(repoRoot, args) {
         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({
@@ -1380,7 +217,7 @@ export async function runEval(repoRoot, args) {
         const lines = [
             "# Candidates",
             "",
-            ...rows.map((row) => `- \`${row.candidateId}\` status=\`${row.status}\` hash=\`${row.bundleHash}\` promotionApplied=${row.promotionApplied}`),
+            ...rows.map((row) => `- \`${row.candidateId}\` status=\`${row.status}\` hash=\`${row.bundleHash}\` promotionApplied=false`),
             "",
         ];
         process.stdout.write(`${lines.join("\n")}\n`);