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

package/dist/application/evaluation/types.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { campaignBudgetSchema } from "./budget.js";
 export const evalSplitSchema = z.enum(["public", "private", "held_out"]);
 export const replayEvidenceRefSchema = z
     .object({
@@ -128,3 +129,524 @@ export const lifecycleEventSchema = z
     eventHash: z.string().regex(/^[a-f0-9]{64}$/),
 })
     .strict();
+// --- Incumbent Alias + Promotion Decision (M2 W2.4) ---
+export const aliasNameSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "alias must be one safe path segment");
+export const incumbentAliasSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    alias: aliasNameSchema,
+    candidateId: candidateIdSchema,
+    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    updatedAt: z.string().min(1),
+    updatedByDecisionId: z.string().min(1),
+    previousCandidateId: candidateIdSchema.nullable(),
+})
+    .strict();
+export const aliasHistoryEventSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    seq: z.number().int().positive(),
+    decisionId: z.string().min(1),
+    action: z.enum(["promote", "rollback"]),
+    fromCandidateId: candidateIdSchema.nullable(),
+    toCandidateId: candidateIdSchema,
+    toBundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    at: z.string().min(1),
+})
+    .strict();
+export const promotionDecisionSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    decisionId: z.string().min(1),
+    alias: aliasNameSchema,
+    action: z.enum(["promote", "rollback"]),
+    fromCandidateId: candidateIdSchema.nullable(),
+    toCandidateId: candidateIdSchema,
+    toBundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    reason: z.string().min(1),
+    actor: z.literal("human"),
+    humanRequired: z.literal(true),
+    applied: z.boolean(),
+    createdAt: z.string().min(1),
+    campaignId: z.string().min(1).nullable().optional(),
+})
+    .strict();
+// --- Corpus Manifest (W1.5) ---
+export const corpusIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "corpusId must be one safe path segment");
+export const corpusTaskClassSchema = z.enum([
+    "docs",
+    "bugfix",
+    "implement",
+    "frontend",
+    "backend-test",
+    "fullstack",
+    "bootstrap",
+    "refactor",
+]);
+export const corpusTaskSchema = z
+    .object({
+    taskRef: z
+        .string()
+        .min(1)
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/, "taskRef must be a safe relative id (letters, numbers, . _ - /)")
+        .refine((value) => !value.includes(".."), "taskRef must not contain .."),
+    class: corpusTaskClassSchema,
+    split: evalSplitSchema,
+    seeds: z
+        .array(z.number().int().nonnegative())
+        .min(2)
+        .max(3)
+        .superRefine((seeds, ctx) => {
+        const seen = new Set();
+        for (let i = 0; i < seeds.length; i += 1) {
+            const seed = seeds[i];
+            if (seen.has(seed)) {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    message: `duplicate seed ${seed}`,
+                    path: [i],
+                });
+            }
+            seen.add(seed);
+        }
+    }),
+    description: z.string().optional(),
+    featureId: z.string().min(1).optional(),
+})
+    .strict();
+function refineCorpusTasks(manifest, ctx) {
+    const refs = new Set();
+    const classes = new Set();
+    const splits = new Set();
+    for (let i = 0; i < manifest.tasks.length; i += 1) {
+        const task = manifest.tasks[i];
+        if (refs.has(task.taskRef)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `duplicate taskRef: ${task.taskRef}`,
+                path: ["tasks", i, "taskRef"],
+            });
+        }
+        refs.add(task.taskRef);
+        classes.add(task.class);
+        splits.add(task.split);
+    }
+    if (classes.size < 3) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "corpus requires at least 3 distinct task classes",
+            path: ["tasks"],
+        });
+    }
+    for (const required of ["public", "private", "held_out"]) {
+        if (!splits.has(required)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `corpus requires at least one ${required} task`,
+                path: ["tasks"],
+            });
+        }
+    }
+}
+const corpusManifestObjectSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    corpusId: corpusIdSchema,
+    createdAt: z.string().min(1),
+    description: z.string().optional(),
+    tasks: z.array(corpusTaskSchema).min(12).max(20),
+    corpusHash: z
+        .string()
+        .regex(/^(sha256:)?[a-f0-9]{64}$/i)
+        .optional(),
+})
+    .strict();
+export const corpusManifestInputSchema = corpusManifestObjectSchema.superRefine(refineCorpusTasks);
+export const corpusManifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    corpusId: corpusIdSchema,
+    createdAt: z.string().min(1),
+    description: z.string().optional(),
+    tasks: z.array(corpusTaskSchema).min(12).max(20),
+    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+})
+    .strict()
+    .superRefine(refineCorpusTasks);
+// --- Private Verifier + Campaign (M4) ---
+export const privateVerifierIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "privateVerifierId must be one safe path segment");
+export const privateVerifierCheckSchema = z
+    .object({
+    checkId: z
+        .string()
+        .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "checkId must be a safe id"),
+    kind: z.literal("shell"),
+    command: z.array(z.string().min(1)).min(1),
+    cwd: z.string().min(1).default("."),
+    timeoutMs: z.number().int().positive().max(3_600_000).default(60_000),
+    expectedExitCode: z.number().int().default(0),
+})
+    .strict();
+export const privateVerifierManifestInputSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    privateVerifierId: privateVerifierIdSchema,
+    createdAt: z.string().min(1),
+    description: z.string().optional(),
+    checks: z.array(privateVerifierCheckSchema).min(1),
+    manifestHash: z
+        .string()
+        .regex(/^(sha256:)?[a-f0-9]{64}$/i)
+        .optional(),
+})
+    .strict();
+export const privateVerifierManifestSchema = privateVerifierManifestInputSchema
+    .extend({
+    manifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+})
+    .strict();
+export const campaignIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "campaignId must be one safe path segment");
+export const campaignStatusSchema = z.enum([
+    "prepared",
+    "running",
+    "completed",
+    "invalid",
+    "aborted",
+]);
+export const campaignEvaluatorIntegritySchema = z
+    .object({
+    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    budgetHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    scoringRulesHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+})
+    .strict();
+function refineCampaignCandidates(manifest, ctx) {
+    if (manifest.budget.mode !== "hard") {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "campaign budget.mode must be hard (record-only campaigns cannot enter promotion path)",
+            path: ["budget", "mode"],
+        });
+    }
+    if (manifest.challengerCandidateIds.includes(manifest.incumbentCandidateId)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: "challengerCandidateIds must not include incumbentCandidateId",
+            path: ["challengerCandidateIds"],
+        });
+    }
+    const seen = new Set();
+    for (let i = 0; i < manifest.challengerCandidateIds.length; i += 1) {
+        const id = manifest.challengerCandidateIds[i];
+        if (seen.has(id)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: `duplicate challengerCandidateId: ${id}`,
+                path: ["challengerCandidateIds", i],
+            });
+        }
+        seen.add(id);
+    }
+}
+const campaignManifestObjectSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    campaignId: campaignIdSchema,
+    createdAt: z.string().min(1),
+    status: campaignStatusSchema.default("prepared"),
+    controllerFingerprint: z.string().min(1).optional(),
+    policyVersion: z.string().min(1).default("promotion-policy-v1"),
+    incumbentCandidateId: candidateIdSchema,
+    challengerCandidateIds: z.array(candidateIdSchema).min(1),
+    corpusId: corpusIdSchema,
+    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    privateVerifierId: privateVerifierIdSchema,
+    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    budget: campaignBudgetSchema,
+    seeds: z.array(z.number().int().nonnegative()).min(1).optional(),
+    notes: z.string().optional(),
+    evaluatorIntegrity: campaignEvaluatorIntegritySchema.optional(),
+})
+    .strict();
+export const campaignManifestInputSchema = campaignManifestObjectSchema.superRefine(refineCampaignCandidates);
+export const campaignManifestSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    campaignId: campaignIdSchema,
+    createdAt: z.string().min(1),
+    status: campaignStatusSchema,
+    controllerFingerprint: z.string().min(1).optional(),
+    policyVersion: z.string().min(1),
+    incumbentCandidateId: candidateIdSchema,
+    challengerCandidateIds: z.array(candidateIdSchema).min(1),
+    corpusId: corpusIdSchema,
+    corpusHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    privateVerifierId: privateVerifierIdSchema,
+    privateVerifierManifestHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    budget: campaignBudgetSchema,
+    seeds: z.array(z.number().int().nonnegative()).min(1).optional(),
+    notes: z.string().optional(),
+    evaluatorIntegrity: campaignEvaluatorIntegritySchema,
+})
+    .strict()
+    .superRefine(refineCampaignCandidates);
+export const campaignCellExecutionRoleSchema = z.enum([
+    "candidate_run",
+    "private_verify",
+    "promotion_gate_only",
+]);
+export const campaignPlanCellSchema = z
+    .object({
+    cellId: z.string().min(1),
+    candidateId: candidateIdSchema,
+    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    taskRef: z.string().min(1),
+    seed: z.number().int().nonnegative(),
+    split: evalSplitSchema,
+    executionRole: campaignCellExecutionRoleSchema,
+    /** Controller-only flag; never serialized into candidate DAG prompts. */
+    privateVerifierAttached: z.boolean(),
+})
+    .strict();
+export const campaignPlanSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    campaignId: campaignIdSchema,
+    planHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    createdAt: z.string().min(1),
+    cells: z.array(campaignPlanCellSchema).min(1),
+})
+    .strict();
+// --- Campaign Evidence + Promotion Policy (M5) ---
+export const campaignEvidenceCellSchema = z
+    .object({
+    cellId: z.string().min(1).optional(),
+    candidateId: candidateIdSchema,
+    taskRef: z.string().min(1),
+    seed: z.number().int().nonnegative(),
+    split: evalSplitSchema,
+    verifyPassed: z.boolean(),
+    runId: z.string().min(1).optional(),
+    score: z.number().optional(),
+})
+    .strict();
+export const campaignEvidenceDiffSchema = z
+    .object({
+    path: z.string().min(1),
+    unifiedDiff: z.string(),
+})
+    .strict();
+export const campaignEvidenceSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    campaignId: campaignIdSchema,
+    challengerCandidateId: candidateIdSchema,
+    cells: z.array(campaignEvidenceCellSchema).min(1),
+    diffs: z.array(campaignEvidenceDiffSchema).default([]),
+    verifyCommands: z
+        .object({
+        incumbent: z.array(z.string().min(1)).default([]),
+        challenger: z.array(z.string().min(1)).default([]),
+    })
+        .strict()
+        .default({ incumbent: [], challenger: [] }),
+    budgetStatus: z
+        .object({
+        incumbent: z.enum(["ok", "breached", "missing"]),
+        challenger: z.enum(["ok", "breached", "missing"]),
+    })
+        .strict()
+        .default({ incumbent: "missing", challenger: "missing" }),
+})
+    .strict();
+// --- Learned Guidance Experiment (M6) ---
+export const experimentIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "experimentId must be one safe path segment");
+export const experimentPatternEvidenceSchema = z
+    .object({
+    key: z.string().min(1),
+    failureClass: z.string().min(1),
+    fixScopeShape: z.string().min(1),
+    invariant: z.string().min(1),
+    count: z.number().int().positive(),
+    sourceRunIds: z.array(z.string().min(1)).default([]),
+    whenToApply: z.string().min(1),
+    whenNotToApply: z.string().min(1),
+})
+    .strict();
+export const experimentDispositionSchema = z
+    .object({
+    status: z.enum(["accepted", "rejected"]),
+    at: z.string().min(1),
+    reason: z.string().min(1),
+    campaignId: campaignIdSchema.optional(),
+    scorecardPlanHash: z.string().min(1).optional(),
+    heldOutNonRegression: z
+        .enum(["pass", "fail", "insufficient", "review"])
+        .optional(),
+})
+    .strict();
+export const experimentRecordSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    experimentId: experimentIdSchema,
+    candidateId: candidateIdSchema,
+    source: z.literal("knowledge-curate"),
+    createdAt: z.string().min(1),
+    proposalPath: z.string().min(1),
+    proposalSha256: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    patterns: z.array(experimentPatternEvidenceSchema).default([]),
+    status: z.enum(["experimenting", "accepted", "rejected"]),
+    disposition: experimentDispositionSchema.optional(),
+})
+    .strict();
+// --- Outer-loop Proposer + Candidate Matrix (M7) ---
+export const proposerRunIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "proposerRunId must be one safe path segment");
+export const proposerProposalSchema = z
+    .object({
+    candidateId: candidateIdSchema,
+    experimentId: experimentIdSchema,
+    proposalPath: z.string().min(1),
+    bundleHash: z.string().regex(/^sha256:[a-f0-9]{64}$/),
+    status: z.literal("proposed_experimenting"),
+})
+    .strict();
+export const proposerRunSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    proposerRunId: proposerRunIdSchema,
+    source: z.literal("knowledge-curate"),
+    createdAt: z.string().min(1),
+    maxCandidates: z.number().int().positive(),
+    proposals: z.array(proposerProposalSchema),
+    skippedReasons: z.array(z.string().min(1)).default([]),
+    /** Always false: proposer must never promote aliases. */
+    autoPromote: z.literal(false),
+})
+    .strict();
+export const matrixModeSchema = z.enum([
+    "dry-run",
+    "stub",
+    "pi-plan",
+    "pi",
+]);
+export const matrixCellResultSchema = z
+    .object({
+    cellId: z.string().min(1),
+    candidateId: candidateIdSchema,
+    taskRef: z.string().min(1),
+    seed: z.number().int().nonnegative(),
+    split: evalSplitSchema,
+    executionRole: z.enum([
+        "candidate_run",
+        "private_verify",
+        "promotion_gate_only",
+    ]),
+    mode: matrixModeSchema,
+    verifyPassed: z.boolean().optional(),
+    runId: z.string().min(1).optional(),
+    jobPath: z.string().min(1).optional(),
+    detail: z.string().optional(),
+    skipped: z.boolean().default(false),
+})
+    .strict();
+export const matrixRunSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    campaignId: campaignIdSchema,
+    planHash: z.string().min(1),
+    mode: matrixModeSchema,
+    createdAt: z.string().min(1),
+    cells: z.array(matrixCellResultSchema),
+    privateCheckCount: z.number().int().nonnegative(),
+    privateCheckFailed: z.number().int().nonnegative(),
+    evidencePath: z.string().min(1).optional(),
+    /** Always false: matrix must never promote aliases. */
+    autoPromote: z.literal(false),
+})
+    .strict();
+export const matrixFixtureSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    defaultVerifyPassed: z.boolean().default(false),
+    results: z
+        .array(z
+        .object({
+        cellId: z.string().min(1).optional(),
+        candidateId: candidateIdSchema.optional(),
+        taskRef: z.string().min(1).optional(),
+        seed: z.number().int().nonnegative().optional(),
+        split: evalSplitSchema.optional(),
+        verifyPassed: z.boolean(),
+        runId: z.string().min(1).optional(),
+    })
+        .strict())
+        .default([]),
+})
+    .strict();
+// --- Ignition research gate (M8) ---
+export const ignitionIdSchema = z
+    .string()
+    .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/, "ignitionId must be one safe path segment");
+export const ignitionGenerationSchema = z
+    .object({
+    generation: z.number().int().nonnegative(),
+    parentCandidateId: candidateIdSchema.nullable(),
+    proposerRunId: proposerRunIdSchema,
+    proposedCandidateIds: z.array(candidateIdSchema).default([]),
+    proposalCount: z.number().int().nonnegative(),
+    campaignId: campaignIdSchema.optional(),
+    promotionEligible: z.boolean().optional(),
+    heldOutNonRegression: z
+        .enum(["pass", "fail", "insufficient", "review"])
+        .optional(),
+    privateImprovement: z
+        .enum(["pass", "fail", "insufficient", "review"])
+        .optional(),
+    recordedAt: z.string().min(1),
+})
+    .strict();
+export const ignitionVerdictSchema = z.enum([
+    "insufficient_evidence",
+    "trend_positive",
+    "trend_flat",
+    "trend_negative",
+    "inconclusive",
+]);
+export const ignitionReportSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    ignitionId: ignitionIdSchema,
+    createdAt: z.string().min(1),
+    updatedAt: z.string().min(1),
+    generations: z.array(ignitionGenerationSchema).default([]),
+    metrics: z
+        .object({
+        generationCount: z.number().int().nonnegative(),
+        meanProposalsPerGeneration: z.number().nonnegative(),
+        proposalYieldDelta: z.number().nullable(),
+        scorecardObservedRate: z.number().nullable(),
+        minGenerationsForSignal: z.number().int().positive(),
+        sampleSufficient: z.boolean(),
+    })
+        .strict(),
+    verdict: ignitionVerdictSchema,
+    reasons: z.array(z.string().min(1)).default([]),
+    /** Research gate only — never authorizes product RSI Level 1 claims. */
+    rsiLevel1ClaimAllowed: z.literal(false),
+    /** Always false — ignition never promotes. */
+    autoPromote: z.literal(false),
+})
+    .strict();

package/dist/cli/command-definitions.js

@@ -77,7 +77,23 @@ const INIT_SUBCOMMANDS = [
     "update",
 ];
 const EXAMPLES_SUBCOMMANDS = ["list", "show", "copy"];
-const EVAL_SUBCOMMANDS = ["replay", "report", "candidate"];
+const EVAL_SUBCOMMANDS = [
+    "replay",
+    "report",
+    "candidate",
+    "alias",
+    "promote",
+    "rollback",
+    "corpus",
+    "context-policy",
+    "budget",
+    "private-verifier",
+    "campaign",
+    "experiment",
+    "propose",
+    "outer-loop",
+    "ignition",
+];
 const CLOSEOUT_SUBCOMMANDS = ["task"];
 const PLAN_SUBCOMMANDS = ["list", "create", "complete", "check"];
 const SPINE_SUBCOMMANDS = ["audit"];
@@ -200,8 +216,8 @@ export const COMMAND_DEFINITIONS = [
         name: "eval",
         adapter: "required",
         tier: "operator",
-        intent: "Replay completed DAG evidence and manage immutable Candidate Registry lifecycle without live model execution or promotion.",
-        usage: "eval <replay|report|candidate> ...; candidate <register|show|list|transition> [--json|--markdown]",
+        intent: "Replay completed DAG evidence, manage Candidate Registry and corpus contracts, and human-gate incumbent alias promote/rollback without live campaigns.",
+        usage: "eval <…|propose|outer-loop|ignition> ...; propose from-curate; outer-loop run; campaign matrix; ignition <record|evaluate|show|list>; promote remains human-gated (no auto-promote; ignition never claims RSI Level 1)",
         subcommands: [...EVAL_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
             await runEval(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));

package/dist/commands/dag-reconcile-run.js

@@ -1,118 +1,5 @@
-import path from "node:path";
-import { writeJsonAtomic } from "../infrastructure/harness/atomic-write.js";
-import { assessDagRunLiveness, assessDagRunRecoveryEligibility, assertDagRunTransferTargetAvailable, getDagRunDir, locateDagRun, readDagRunState, transferDagRunDir, writeDagRunState, } from "../workflows/dag/lifecycle.js";
-export function parseDagReconcileRunArgs(args) {
-    let runId;
-    let action;
-    let reason;
-    for (let index = 0; index < args.length; index += 1) {
-        const arg = args[index];
-        if (arg === "--run-id")
-            runId = args[++index];
-        else if (arg.startsWith("--run-id="))
-            runId = arg.slice("--run-id=".length);
-        else if (arg === "--action")
-            action = parseAction(args[++index]);
-        else if (arg.startsWith("--action="))
-            action = parseAction(arg.slice("--action=".length));
-        else if (arg === "--reason")
-            reason = args[++index];
-        else if (arg.startsWith("--reason="))
-            reason = arg.slice("--reason=".length);
-        else if (arg.startsWith("-"))
-            throw new Error(`unknown dag reconcile-run flag: ${arg}`);
-        else
-            throw new Error(`unexpected positional argument: ${arg}`);
-    }
-    if (!runId)
-        throw new Error("dag reconcile-run requires --run-id <id>");
-    if (action && !reason?.trim()) {
-        throw new Error("dag reconcile-run mutation requires --reason <text>");
-    }
-    return { runId, action, ...(reason?.trim() ? { reason: reason.trim() } : {}) };
-}
-function parseAction(value) {
-    if (value === "supersede" || value === "abandon")
-        return value;
-    throw new Error("dag reconcile-run --action must be supersede or abandon");
-}
+import { executeDagReconcileRun, parseDagReconcileRunArgs, } from "../workflows/dag/reconcile-run.js";
+export { executeDagReconcileRun, parseDagReconcileRunArgs };
 export async function runDagReconcileRun(repoRoot, rawArgs) {
-    const parsed = parseDagReconcileRunArgs(rawArgs);
-    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 liveness = assessDagRunLiveness({ state });
-    const eligibility = assessDagRunRecoveryEligibility({
-        lifecycle: located.lifecycle,
-        state,
-        liveness: liveness.status,
-    });
-    if (!parsed.action) {
-        console.log(JSON.stringify({
-            action: "inspect",
-            runId: state.runId,
-            lifecycle: located.lifecycle,
-            status: state.status,
-            liveness: liveness.status,
-            eligibility,
-            nextRecommendedAction: eligibility.canReconcile
-                ? "Re-run with --action supersede|abandon and --reason <text>."
-                : "Do not reconcile this run; inspect runner and lifecycle evidence first.",
-        }, null, 2));
-        return;
-    }
-    if (!eligibility.canReconcile || !eligibility.allowedActions.includes(parsed.action)) {
-        throw new Error(`dag run ${state.runId} is not eligible for reconciliation: ${eligibility.reasons.join(", ") || "unknown reason"}`);
-    }
-    const reconciledAt = new Date().toISOString();
-    const completedRunDir = getDagRunDir(repoRoot, "completed", state.runId);
-    if (located.lifecycle !== "completed") {
-        await assertDagRunTransferTargetAvailable(completedRunDir);
-    }
-    const artifactRelativePath = path.join(".harness", "dag-runs", "completed", state.runId, "reconciliation.json").replace(/\\/g, "/");
-    await writeJsonAtomic(path.join(located.runDir, "reconciliation.json"), {
-        schemaVersion: 1,
-        runId: state.runId,
-        action: parsed.action,
-        reason: parsed.reason,
-        reconciledAt,
-        previousLifecycle: located.lifecycle,
-        previousStatus: state.status,
-        liveness: liveness.status,
-        originalState: state,
-    });
-    const previousStatus = state.status;
-    for (const node of Object.values(state.nodes)) {
-        if (node.status !== "RUNNING")
-            continue;
-        node.status = "ERROR";
-        node.finishedAt = reconciledAt;
-        node.failureCategory = `operator-${parsed.action}`;
-    }
-    state.status = parsed.action === "supersede" ? "superseded" : "abandoned";
-    state.finishedAt = reconciledAt;
-    state.failureCategory = `operator-${parsed.action}`;
-    state.reconciliation = {
-        action: parsed.action,
-        reason: parsed.reason,
-        reconciledAt,
-        previousStatus,
-        previousLifecycle: located.lifecycle,
-        liveness: liveness.status,
-        artifactPath: artifactRelativePath,
-    };
-    await writeDagRunState(located.runDir, state);
-    const runDir = located.lifecycle === "completed"
-        ? located.runDir
-        : await transferDagRunDir(located.runDir, completedRunDir);
-    console.log(JSON.stringify({
-        action: parsed.action,
-        runId: state.runId,
-        status: state.status,
-        lifecycle: "completed",
-        reason: parsed.reason,
-        reconciliationArtifactPath: artifactRelativePath,
-        runDir,
-    }, null, 2));
+    console.log(JSON.stringify(await executeDagReconcileRun(repoRoot, rawArgs), null, 2));
 }