@tea-agent/loop-agent 0.26.5-beta.2 → 0.27.1-beta.0

package/dist/application/task-lifecycle/plan-transitions.js

@@ -0,0 +1,224 @@
+/**
+ * Pure reducer: given a lifecycle snapshot + intent flags, decide the next
+ * safe automatic transitions until a stop condition.
+ */
+export function planTransitions(input) {
+    const { snapshot } = input;
+    const actions = [];
+    const expectedTransitions = [];
+    const blockers = [...snapshot.blockers];
+    if (input.rejectGate) {
+        return {
+            actions: [{ type: "stop", reason: "terminal" }],
+            gate: snapshot.gate ?? null,
+            blockers,
+            next: {
+                kind: "advance",
+                command: `loop-agent task advance ${snapshot.taskId} --json`,
+            },
+            expectedTransitions: ["write-set-rejected"],
+        };
+    }
+    if (!snapshot.exists) {
+        // Create is always allowed when advance is invoked for a missing task.
+        // Further intake (PRD/boundaries) is required before contract/DAG steps.
+        actions.push({ type: "create-task" });
+        expectedTransitions.push("task-created");
+        if (!input.hasPrdInput && !input.hasEngineeringBoundary) {
+            actions.push({ type: "stop", reason: "blocker" });
+            blockers.push({
+                code: "INTAKE_REQUIRED",
+                message: "task created or creatable; provide --prd and engineering boundary flags (or --from-text) to continue",
+            });
+            return {
+                actions,
+                gate: null,
+                blockers,
+                next: {
+                    kind: "advance",
+                    command: `loop-agent task advance ${snapshot.taskId} --prd <path> --allowed-path <glob> --json`,
+                },
+                expectedTransitions,
+            };
+        }
+    }
+    if (snapshot.contract?.transactionIncomplete) {
+        actions.push({ type: "recover-contract" });
+        expectedTransitions.push("contract-recovered");
+    }
+    const sourceReady = snapshot.source?.requirementReady === true;
+    const contractManaged = snapshot.contract?.effectiveStatus === "managed" ||
+        Boolean(snapshot.contract?.revision && snapshot.contract.revision > 0);
+    const alreadyImportedPrd = (snapshot.source?.importedPrdCount ?? 0) > 0;
+    // Prefer prepare once PRDs are on disk; re-import only when caller still
+    // signals hasPrdInput (advance.ts latches this after one import per call).
+    const shouldImportPrd = input.hasPrdInput;
+    if (input.forcePrepareContract) {
+        if (shouldImportPrd) {
+            actions.push({ type: "import-prd" });
+            expectedTransitions.push("prd-imported");
+        }
+        actions.push({ type: "prepare-contract" });
+        expectedTransitions.push("contract-managed");
+    }
+    else if (!sourceReady || !contractManaged) {
+        if ((shouldImportPrd || alreadyImportedPrd) &&
+            !input.hasEngineeringBoundary) {
+            // Console bootstrap / import-only: archive PRD(s), do not prepare contract yet.
+            if (shouldImportPrd) {
+                actions.push({ type: "import-prd" });
+                expectedTransitions.push("prd-imported");
+            }
+            actions.push({ type: "stop", reason: "blocker" });
+            blockers.push({
+                code: "BOUNDARY_REQUIRED",
+                message: "PRD imported; provide --allowed-path / --verify (or --from-text with boundaries) to prepare contract and open writeSet gate",
+            });
+            return {
+                actions,
+                gate: null,
+                blockers,
+                next: {
+                    kind: "advance",
+                    command: `loop-agent task advance ${snapshot.taskId} --allowed-path <glob> --verify <label:command> --json`,
+                },
+                expectedTransitions,
+            };
+        }
+        if (shouldImportPrd ||
+            input.hasEngineeringBoundary ||
+            alreadyImportedPrd ||
+            snapshot.exists) {
+            if (shouldImportPrd) {
+                actions.push({ type: "import-prd" });
+                expectedTransitions.push("prd-imported");
+            }
+            actions.push({ type: "prepare-contract" });
+            expectedTransitions.push("contract-managed");
+        }
+        else {
+            blockers.push({
+                code: "CONTRACT_INCOMPLETE",
+                message: "source/contract not ready; re-run advance with PRD and boundaries",
+            });
+            return stopWith(actions, expectedTransitions, blockers, snapshot, "blocker");
+        }
+    }
+    const dagExists = snapshot.dagDraft?.exists === true;
+    const strictValidated = snapshot.dagDraft?.strictValidated === true;
+    if (!dagExists) {
+        actions.push({ type: "generate-dag" });
+        expectedTransitions.push("dag-generated");
+    }
+    if (!strictValidated) {
+        actions.push({ type: "strict-validate-dag" });
+        expectedTransitions.push("dag-strict-validated");
+    }
+    // After validate, open write-set gate unless already approved/rejected for current digest.
+    const gate = snapshot.gate ?? null;
+    const postRunState = snapshot.lifecycleState === "running" ||
+        snapshot.lifecycleState === "run-succeeded" ||
+        snapshot.lifecycleState === "run-failed" ||
+        snapshot.lifecycleState === "evidence-closed" ||
+        snapshot.lifecycleState === "needs-attention" ||
+        snapshot.lifecycleState === "awaiting-decision";
+    const approvedForCurrent = postRunState || (input.approveGate && gate !== null);
+    if (!approvedForCurrent && (strictValidated || !dagExists)) {
+        // Gate opens after generate+validate in the advance loop; plan includes open.
+        if (!input.approveGate) {
+            actions.push({ type: "open-write-set-gate" });
+            expectedTransitions.push("write-set-gate-opened");
+            if (input.dryRun) {
+                actions.push({ type: "stop", reason: "dry-run" });
+            }
+            else {
+                actions.push({ type: "stop", reason: "gate" });
+            }
+            return {
+                actions,
+                gate,
+                blockers,
+                next: gate
+                    ? { kind: "approve-gate", command: gate.approveCommand }
+                    : {
+                        kind: "advance",
+                        command: `loop-agent task advance ${snapshot.taskId} --json`,
+                    },
+                expectedTransitions,
+            };
+        }
+    }
+    // Only start/monitor when not already in a terminal post-run state.
+    const alreadyTerminalRun = snapshot.lifecycleState === "run-succeeded" ||
+        snapshot.lifecycleState === "run-failed" ||
+        snapshot.lifecycleState === "evidence-closed";
+    if (!alreadyTerminalRun) {
+        if (input.approveGate && !postRunState) {
+            expectedTransitions.push("write-set-approved");
+            actions.push({ type: "start-or-monitor-run" });
+            expectedTransitions.push("dag-run-started", "dag-run-monitored");
+        }
+        else if (snapshot.lifecycleState === "running" ||
+            snapshot.activeRun ||
+            (input.approveGate && Boolean(snapshot.activeRun))) {
+            actions.push({ type: "start-or-monitor-run" });
+            expectedTransitions.push("dag-run-monitored");
+        }
+    }
+    if (!input.skipFinalize &&
+        (snapshot.lifecycleState === "run-succeeded" ||
+            (snapshot.latestRun?.lifecycle === "completed" &&
+                snapshot.latestRun.status === "finished"))) {
+        if (!snapshot.promotion?.ready) {
+            actions.push({ type: "promote" });
+            expectedTransitions.push("promotion-completed");
+        }
+        if (!snapshot.closeout?.exists) {
+            actions.push({ type: "closeout" });
+            expectedTransitions.push("closeout-completed");
+        }
+    }
+    if (snapshot.lifecycleState === "evidence-closed") {
+        return {
+            actions: [{ type: "stop", reason: "terminal" }],
+            gate: null,
+            blockers,
+            next: { kind: "none" },
+            expectedTransitions: [],
+        };
+    }
+    if (input.dryRun) {
+        actions.push({ type: "stop", reason: "dry-run" });
+    }
+    return {
+        actions,
+        gate,
+        blockers,
+        next: deriveNext(snapshot, gate, input.approveGate),
+        expectedTransitions,
+    };
+}
+function stopWith(actions, expectedTransitions, blockers, snapshot, reason) {
+    return {
+        actions: [...actions, { type: "stop", reason }],
+        gate: snapshot.gate ?? null,
+        blockers,
+        next: {
+            kind: "advance",
+            command: `loop-agent task advance ${snapshot.taskId} --json`,
+        },
+        expectedTransitions,
+    };
+}
+function deriveNext(snapshot, gate, approveGate) {
+    if (gate && !approveGate) {
+        return { kind: "approve-gate", command: gate.approveCommand };
+    }
+    if (snapshot.lifecycleState === "evidence-closed") {
+        return { kind: "none" };
+    }
+    return {
+        kind: "advance",
+        command: `loop-agent task advance ${snapshot.taskId} --json`,
+    };
+}

package/dist/application/task-lifecycle/recommendations.js

@@ -0,0 +1,180 @@
+import { createHash } from "node:crypto";
+import { access, readFile } from "node:fs/promises";
+import path from "node:path";
+import { loadTaskConfig } from "../../task/runtime.js";
+function sha256Canonical(value) {
+    const json = JSON.stringify(value);
+    return `sha256:${createHash("sha256").update(json, "utf8").digest("hex")}`;
+}
+async function pathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function readPackageScripts(repoRoot) {
+    const packageJsonPath = path.join(repoRoot, "package.json");
+    if (!(await pathExists(packageJsonPath)))
+        return {};
+    try {
+        const raw = await readFile(packageJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return parsed.scripts ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Deterministic engineering-boundary recommendations (P1).
+ *
+ * Priority:
+ * 1. managed task config (highest)
+ * 2. package.json scripts (typecheck/test/check-repo)
+ * 3. PRD path-like tokens as weak candidates only (never auto-elevated)
+ *
+ * Recommendations never enter contract draft unless acceptDigest matches.
+ */
+export async function buildTaskLifecycleRecommendations(input) {
+    const allowedPaths = [];
+    const verifyCommands = [];
+    // 1) managed task config
+    try {
+        const config = await loadTaskConfig(input.repoRoot, input.taskId);
+        for (const glob of config.allowedPaths ?? []) {
+            if (!glob.trim())
+                continue;
+            allowedPaths.push({
+                glob: glob.trim(),
+                reason: "existing managed task.json.allowedPaths",
+                source: "managed-task-config",
+            });
+        }
+        for (const cmd of config.verifyCommands ?? []) {
+            const label = cmd.label?.trim() || "verify";
+            const command = cmd.command?.trim();
+            if (!command)
+                continue;
+            verifyCommands.push({
+                label,
+                command,
+                reason: "existing managed task.json.verifyCommands",
+                source: "managed-task-config",
+            });
+        }
+    }
+    catch {
+        // task may not exist yet
+    }
+    // 2) package.json scripts (only if not already covered by managed config)
+    const scripts = await readPackageScripts(input.repoRoot);
+    const hasVerifyLabel = (label) => verifyCommands.some((entry) => entry.label === label);
+    const scriptCandidates = [
+        { label: "typecheck", script: "typecheck" },
+        { label: "test", script: "test" },
+        { label: "check-repo", script: "check:repo" },
+        { label: "check-repo", script: "check-repo" },
+    ];
+    for (const candidate of scriptCandidates) {
+        const scriptBody = scripts[candidate.script];
+        if (!scriptBody)
+            continue;
+        if (hasVerifyLabel(candidate.label))
+            continue;
+        verifyCommands.push({
+            label: candidate.label,
+            command: `npm run ${candidate.script}`,
+            reason: `package.json scripts.${candidate.script}`,
+            source: "package-scripts",
+        });
+    }
+    // 3) weak PRD path candidates (never auto-accepted alone)
+    const prdTexts = input.prdTexts ?? [];
+    const seenGlobs = new Set(allowedPaths.map((entry) => entry.glob));
+    const pathLike = /(?:^|[\s`"'(])((?:src|test|tests|docs|website|scripts|skills)\/[A-Za-z0-9_./ conf-]+(?:\/\*\*)?)/gm;
+    for (const text of prdTexts) {
+        for (const match of text.matchAll(pathLike)) {
+            const raw = match[1]?.trim();
+            if (!raw)
+                continue;
+            const glob = raw.endsWith("/**")
+                ? raw
+                : raw.endsWith("/")
+                    ? `${raw}**`
+                    : raw.includes("*")
+                        ? raw
+                        : `${raw.replace(/\/$/, "")}/**`;
+            if (seenGlobs.has(glob))
+                continue;
+            // Skip overly broad roots
+            if (glob === "src/**" || glob === "docs/**" || glob === "test/**") {
+                // still allow as weak candidate with explicit reason
+            }
+            seenGlobs.add(glob);
+            allowedPaths.push({
+                glob,
+                reason: "path-like token in PRD (weak candidate; not auto-elevated)",
+                source: "prd-weak-candidate",
+            });
+        }
+    }
+    // Stable sort for digest
+    allowedPaths.sort((a, b) => a.glob.localeCompare(b.glob));
+    verifyCommands.sort((a, b) => a.label.localeCompare(b.label));
+    const digestPayload = {
+        schemaVersion: 1,
+        taskId: input.taskId,
+        allowedPaths: allowedPaths.map((entry) => ({
+            glob: entry.glob,
+            source: entry.source,
+        })),
+        verifyCommands: verifyCommands.map((entry) => ({
+            label: entry.label,
+            command: entry.command,
+            source: entry.source,
+        })),
+    };
+    const digest = sha256Canonical(digestPayload);
+    return {
+        allowedPaths,
+        verifyCommands,
+        digest,
+        requiresAccept: true,
+    };
+}
+export function applyAcceptedRecommendations(input) {
+    const explicitAllowed = input.explicitAllowedPaths ?? [];
+    const explicitVerify = input.explicitVerifyCommands ?? [];
+    if (explicitAllowed.length > 0 || explicitVerify.length > 0) {
+        return {
+            allowedPaths: explicitAllowed.length > 0 ? explicitAllowed : undefined,
+            verifyCommands: explicitVerify.length > 0 ? explicitVerify : undefined,
+            accepted: false,
+            staleAccept: false,
+        };
+    }
+    const accept = input.acceptDigest?.trim();
+    if (!accept) {
+        return { accepted: false, staleAccept: false };
+    }
+    if (accept !== input.recommendations.digest) {
+        return { accepted: false, staleAccept: true };
+    }
+    // Only elevate non-weak sources automatically when accepted.
+    const allowedPaths = input.recommendations.allowedPaths
+        .filter((entry) => entry.source !== "prd-weak-candidate")
+        .map((entry) => entry.glob);
+    const verifyCommands = input.recommendations.verifyCommands.map((entry) => ({
+        label: entry.label,
+        command: entry.command,
+    }));
+    return {
+        allowedPaths: allowedPaths.length > 0 ? allowedPaths : undefined,
+        verifyCommands: verifyCommands.length > 0 ? verifyCommands : undefined,
+        accepted: true,
+        staleAccept: false,
+    };
+}

package/dist/application/task-lifecycle/record.js

@@ -0,0 +1,73 @@
+import { access, mkdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { getTaskDir } from "../../task/runtime.js";
+export function getLifecycleRecordPath(repoRoot, taskId) {
+    return path.join(getTaskDir(repoRoot, taskId), "lifecycle.json");
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function loadLifecycleRecord(repoRoot, taskId) {
+    const filePath = getLifecycleRecordPath(repoRoot, taskId);
+    if (!(await exists(filePath)))
+        return null;
+    try {
+        const raw = JSON.parse(await readFile(filePath, "utf-8"));
+        if (raw.schemaVersion !== 1 || raw.taskId !== taskId)
+            return null;
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+export function emptyLifecycleRecord(taskId) {
+    return {
+        schemaVersion: 1,
+        taskId,
+        updatedAt: new Date().toISOString(),
+        completedTransitions: [],
+        runAssociations: [],
+    };
+}
+export async function saveLifecycleRecord(repoRoot, record) {
+    const filePath = getLifecycleRecordPath(repoRoot, record.taskId);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const next = {
+        ...record,
+        updatedAt: new Date().toISOString(),
+    };
+    await writeJsonAtomic(filePath, next);
+}
+export function appendTransition(record, transition) {
+    if (record.completedTransitions.includes(transition)) {
+        return record;
+    }
+    return {
+        ...record,
+        completedTransitions: [...record.completedTransitions, transition],
+    };
+}
+export function recordRunAssociation(record, run) {
+    if (record.runAssociations.some((entry) => entry.runId === run.runId)) {
+        return record;
+    }
+    return {
+        ...record,
+        runAssociations: [
+            ...record.runAssociations,
+            {
+                runId: run.runId,
+                recordedAt: new Date().toISOString(),
+                source: run.source,
+            },
+        ],
+    };
+}

package/dist/application/task-lifecycle/types.js

@@ -0,0 +1 @@
+export const TASK_LIFECYCLE_SCHEMA_VERSION = 1;

package/dist/cli/command-definitions.js

@@ -5,21 +5,16 @@ import { runEval } from "../commands/eval.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
 import { runCoverageReport } from "../commands/coverage-report.js";
 import { runExamples } from "../commands/examples.js";
-import { runCloseout } from "../commands/closeout.js";
 import { runHandoffCheck } from "../commands/handoff-check.js";
 import { runInspect } from "../commands/inspect.js";
 import { runInstructions } from "../commands/instructions.js";
-import { runNewTask } from "../commands/new-task.js";
-import { runImportPrd } from "../commands/import-prd.js";
-import { runTaskContract } from "../commands/task-contract.js";
-import { runTaskSourcePrepare } from "../commands/task-source-prepare.js";
+import { runTaskAdvance } from "../commands/task-advance.js";
+import { runTaskStatus } from "../commands/task-status.js";
 import { runOperator } from "../commands/operator.js";
 import { runPlanList } from "../commands/plan-list.js";
 import { runPlanCheck, runPlanComplete, runPlanCreate, } from "../commands/plan.js";
-import { runPromoteRun } from "../commands/promote-run.js";
 import { runSpine } from "../commands/spine.js";
 import { runStats } from "../commands/stats.js";
-import { runStatus } from "../commands/status.js";
 import { runWorktreeCreate } from "../commands/worktree-create.js";
 import { runWorktreeList } from "../commands/worktree-list.js";
 import { runWorktreeRemove } from "../commands/worktree-remove.js";
@@ -42,7 +37,6 @@ import { runDagRerun } from "../commands/dag-rerun.js";
 import { runDagResume } from "../commands/dag-resume.js";
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
 import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
-import { runDagRunTask } from "../commands/dag-run-task.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
 import { runDagFinalVerification } from "../commands/dag-final-verification.js";
 import { runKnowledge } from "../commands/knowledge.js";
@@ -121,7 +115,7 @@ const KNOWLEDGE_SUBCOMMANDS = [
 ];
 const DAG_SUBCOMMANDS = [
     "init-hybrid",
-    "run-task",
+    "execute",
     "validate",
     "workflow-plan",
     "workflow-validate",
@@ -140,17 +134,7 @@ const DAG_SUBCOMMANDS = [
     "final-verification",
     "decision",
 ];
-const TASK_SUBCOMMANDS = ["contract", "source"];
-const TASK_CONTRACT_SUBCOMMANDS = [
-    "show",
-    "validate",
-    "diff",
-    "apply",
-    "adopt",
-    "doctor",
-    "recover",
-];
-const TASK_SOURCE_SUBCOMMANDS = ["prepare"];
+const TASK_SUBCOMMANDS = ["advance", "status"];
 const OPERATOR_SUBCOMMANDS = ["capabilities"];
 const WORKFLOW_SUBCOMMANDS = [
     "list",
@@ -246,57 +230,21 @@ export const COMMAND_DEFINITIONS = [
             await runEval(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
         },
     },
-    {
-        name: "new-task",
-        adapter: "required",
-        tier: "primary",
-        intent: "Create a harness task before DAG autonomous work.",
-        usage: "new-task <task-id> [title]",
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            const [taskId, ...titleParts] = [subcommand, ...rest];
-            if (!taskId)
-                throw new Error("taskId required");
-            await runNewTask(repoRoot, taskId, titleParts.join(" ") || undefined);
-        },
-    },
-    {
-        name: "import-prd",
-        adapter: "required",
-        tier: "primary",
-        intent: "Copy a user PRD into source/references as an immutable fact source before deriving source/需求.md.",
-        usage: "import-prd <task-id> --file <path> [--name requirement] [--role requirement] [--json]",
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            await runImportPrd(repoRoot, [subcommand, ...rest].filter(Boolean));
-        },
-    },
     {
         name: "task",
         adapter: "required",
         tier: "primary",
-        intent: "Task Contract and source intake: contract show/validate/diff/apply/adopt/doctor/recover; source prepare (PRD-first Draft projection).",
-        usage: "task <contract|source> ...  (contract <show|validate|diff|apply|adopt|doctor|recover>; source prepare ...)",
+        intent: "Task lifecycle: advance (mutation) and status (read).",
+        usage: "task <advance|status> ...",
         subcommands: [...TASK_SUBCOMMANDS],
         handler: async ({ repoRoot, subcommand, rest }) => {
-            if (subcommand === "contract") {
-                const [contractSub, ...contractRest] = rest;
-                if (!contractSub ||
-                    !TASK_CONTRACT_SUBCOMMANDS.includes(contractSub)) {
-                    throw new Error(`usage: task contract <${TASK_CONTRACT_SUBCOMMANDS.join("|")}> ...`);
-                }
-                await runTaskContract(repoRoot, [contractSub, ...contractRest]);
+            if (subcommand === "advance") {
+                await runTaskAdvance(repoRoot, rest);
                 return;
             }
-            if (subcommand === "source") {
-                const [sourceSub, ...sourceRest] = rest;
-                if (!sourceSub ||
-                    !TASK_SOURCE_SUBCOMMANDS.includes(sourceSub)) {
-                    throw new Error(`usage: task source <${TASK_SOURCE_SUBCOMMANDS.join("|")}> ...`);
-                }
-                if (sourceSub === "prepare") {
-                    await runTaskSourcePrepare(repoRoot, sourceRest);
-                    return;
-                }
-                throw new Error(`usage: task source <${TASK_SOURCE_SUBCOMMANDS.join("|")}> ...`);
+            if (subcommand === "status") {
+                await runTaskStatus(repoRoot, rest);
+                return;
             }
             throw new Error(formatSubcommandUsageError("task", TASK_SUBCOMMANDS));
         },
@@ -312,19 +260,6 @@ export const COMMAND_DEFINITIONS = [
             await runOperator(repoRoot, [subcommand, ...rest].filter((arg) => Boolean(arg)));
         },
     },
-    {
-        name: "status",
-        adapter: "required",
-        tier: "operator",
-        intent: "Inspect a task state and machine-readable action context.",
-        usage: "status <task-id> [--json]",
-        handler: async ({ repoRoot, subcommand }) => {
-            const taskId = subcommand;
-            if (!taskId)
-                throw new Error("taskId required");
-            await runStatus(repoRoot, taskId);
-        },
-    },
     {
         name: "instructions",
         adapter: "required",
@@ -335,27 +270,6 @@ export const COMMAND_DEFINITIONS = [
             await runInstructions(repoRoot, [subcommand, ...rest].filter(Boolean));
         },
     },
-    {
-        name: "promote-run",
-        adapter: "required",
-        tier: "operator",
-        intent: "Promote completed DAG or one-shot run evidence into task artifacts without mutating run facts.",
-        usage: "promote-run <task-id> --run-id <run-id>",
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            await runPromoteRun(repoRoot, [subcommand, ...rest].filter(Boolean));
-        },
-    },
-    {
-        name: "closeout",
-        adapter: "required",
-        tier: "operator",
-        intent: "Create deterministic task closeout/progress records from promoted task artifacts.",
-        usage: "closeout task <task-id>",
-        subcommands: [...CLOSEOUT_SUBCOMMANDS],
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            await runCloseout(repoRoot, [subcommand, ...rest].filter(Boolean));
-        },
-    },
     {
         name: "stats",
         adapter: "required",
@@ -614,9 +528,9 @@ export const COMMAND_DEFINITIONS = [
                 await runDagDoctor(repoRoot, doctorArgs);
                 return;
             }
-            if (subcommand === "run-task") {
-                const runTaskArgs = rest.filter((arg) => Boolean(arg));
-                await runDagRunTask(repoRoot, runTaskArgs);
+            if (subcommand === "execute") {
+                const executeArgs = rest.filter((arg) => Boolean(arg));
+                await runRunDag(repoRoot, executeArgs);
                 return;
             }
             if (subcommand === "report") {
@@ -672,17 +586,6 @@ export const COMMAND_DEFINITIONS = [
             throw new Error(formatSubcommandUsageError("dag", DAG_SUBCOMMANDS));
         },
     },
-    {
-        name: "run-dag",
-        adapter: "required",
-        tier: "primary",
-        intent: "Execute a reviewed Agent DAG spec.",
-        usage: "run-dag --dag <path> [--cwd <dir>] [--init-only] [--dry-run] [--max-concurrent N] [--run-id id] [--quiet] [--progress-interval-ms N] [--canvas-path <abs-path> | --canvas <name> [--canvases-dir <dir>]] [--events-jsonl <path>] [--worker-association <json>]",
-        handler: async ({ repoRoot, subcommand, rest }) => {
-            const runDagArgs = [subcommand, ...rest].filter((arg) => Boolean(arg));
-            await runRunDag(repoRoot, runDagArgs);
-        },
-    },
     {
         name: "workflow",
         adapter: "required",