@tea-agent/loop-agent 0.8.0 → 0.10.0-alpha.0

package/dist/cli/program.js

@@ -1,15 +1,16 @@
-import { readFileSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 import { Command } from "commander";
+import { readPackageVersion } from "../shared/package-metadata.js";
 import { resolveAdapter } from "../adapters/index.js";
 import { runCloseout } from "../commands/closeout.js";
 import { runCoverageAudit } from "../commands/coverage-audit.js";
-import { runCursorWorker } from "../commands/cursor-worker.js";
 import { parseCursorPromptArgs, printCursorPromptUsage, runCursorPrompt, } from "../commands/cursor-prompt.js";
 import { runDagApprove } from "../commands/dag-approve.js";
 import { runDagFinalVerification } from "../commands/dag-final-verification.js";
 import { runDagInitHybrid } from "../commands/dag-init-hybrid.js";
 import { runDagReconcileTasks } from "../commands/dag-reconcile-tasks.js";
+import { runDagReconcileRun } from "../commands/dag-reconcile-run.js";
 import { runDagReject } from "../commands/dag-reject.js";
 import { runDagCloseoutDraft, runDagReport } from "../commands/dag-report.js";
 import { runDagResume } from "../commands/dag-resume.js";
@@ -52,18 +53,6 @@ import { handleStandaloneOneShotCommandError } from "../shared/one-shot-prompt-a
 import { runDagDecisionInspect, runDagDecisionValidate, } from "../workflows/dag/decision-envelope.js";
 import { runDagDoctor, runDagStatus } from "../workflows/dag/lifecycle.js";
 import { CODE_AGENT_COMMAND_MANIFEST } from "./catalog.js";
-function readPackageVersion() {
-    try {
-        const raw = readFileSync(new URL("../../package.json", import.meta.url), "utf-8");
-        const parsed = JSON.parse(raw);
-        if (typeof parsed.version === "string")
-            return parsed.version;
-    }
-    catch {
-        // Fall back only if the package metadata is unexpectedly unavailable.
-    }
-    return "0.0.0";
-}
 function resolveRepoRootOnly(command, defaultRepoRoot, behavior) {
     const options = collectGlobalOptions(command);
     const repoRoot = path.resolve(options.repoRoot ?? defaultRepoRoot);
@@ -230,9 +219,6 @@ async function runCommanderAction(ctx, command, subcommand, rest) {
         case "harvest":
             await runHarvest(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
-        case "cursor-worker":
-            await runCursorWorker(ctx.repoRoot, compactArgs([subcommand, ...rest]));
-            return;
         case "knowledge":
             await runKnowledge(ctx.repoRoot, compactArgs([subcommand, ...rest]));
             return;
@@ -300,6 +286,9 @@ async function runDagAction(repoRoot, subcommand, rest) {
         case "closeout-draft":
             await runDagCloseoutDraft(repoRoot, args);
             return;
+        case "reconcile-run":
+            await runDagReconcileRun(repoRoot, args);
+            return;
         case "reconcile-tasks":
             await runDagReconcileTasks(repoRoot, args);
             return;
@@ -319,7 +308,7 @@ async function runDagAction(repoRoot, subcommand, rest) {
             throw new Error("usage: dag decision <inspect|validate> --run-id <id> [--node-id <node-id>]");
         }
         default:
-            throw new Error("usage: dag <init-hybrid|run-task|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-tasks|final-verification|decision> ...");
+            throw new Error("usage: dag <init-hybrid|run-task|validate|workflow-plan|workflow-validate|workflow-compile|approve|reject|resume|status|doctor|report|closeout-draft|reconcile-run|reconcile-tasks|final-verification|decision> ...");
     }
 }
 function compactArgs(args) {
@@ -371,7 +360,6 @@ function configureRunDag(command) {
         .option("--dry-run", "validate and plan without executing")
         .option("--max-concurrent <n>", "maximum concurrent nodes")
         .option("--run-id <id>", "run id")
-        .option("--no-cursor", "disable Cursor execution")
         .option("--canvas-path <path>", "absolute canvas output path")
         .option("--canvas <name>", "canvas name")
         .option("--canvases-dir <dir>", "canvas output directory")
@@ -383,7 +371,6 @@ function configureDagRunTask(command) {
         .option("-o, --output <path>", "output DAG path")
         .option("--profile <profile>", "auto|minimal|standard|reviewed|supervised")
         .option("--strict-models", "fail on model routing warnings")
-        .option("--no-cursor", "disable Cursor execution")
         .option("--execute", "execute after creating the DAG")
         .option("--init-only", "initialize run artifacts without executing")
         .option("--dry-run", "validate and plan without executing")
@@ -450,6 +437,7 @@ function addDagCommand(program, defaultRepoRoot) {
         "doctor",
         "report",
         "closeout-draft",
+        "reconcile-run",
         "reconcile-tasks",
         "final-verification",
     ], defaultRepoRoot);
@@ -502,7 +490,7 @@ export function buildLoopAgentProgram(options) {
     program
         .name("loop-agent")
         .description("Loop Agent task and DAG automation CLI")
-        .version(readPackageVersion(), "-V, --version", "display version")
+        .version(readPackageVersion(path.dirname(path.dirname(path.dirname(fileURLToPath(import.meta.url))))) ?? "0.0.0", "-V, --version", "display version")
         .showHelpAfterError()
         .option("--repo-root <path>", "repository root")
         .option("--adapter <name>", "harness adapter name")

package/dist/commands/cursor-prompt.js

@@ -1,5 +1,5 @@
 /**
- * Cursor Prompt — one-shot CLI for Cursor SDK tasks.
+ * Cursor Prompt — one-shot CLI for Cursor SDK tasks (sidecar).
  *
  * Usage:
  *   cursor-prompt "Fix lint errors"                    # one-shot
@@ -9,7 +9,7 @@
  *   cursor-prompt --model gpt-5.5 "Deep analysis"       # pick model
  *   cursor-prompt --cwd /path --timeout 120000 "task"   # cwd + timeout
  */
-import { executeCursorTask, DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, buildCursorPrompt, classifyCursorFailure, mapRunStatusToExecutionStatus, } from "../executors/cursor-executor.js";
+import { executeCursorTask, executeCursorPromptStream, DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, } from "../sidecars/cursor-prompt/index.js";
 import { createOneShotPromptParseAccum, formatUnknownFlagError, parseOneShotCommonFlag, printOneShotHelpAndExit, resolveOneShotCwd, resolveOneShotTask, } from "../shared/one-shot-prompt-args.js";
 import { persistCursorRunLog, computeRunDir } from "../records/one-shot-runs.js";
 const CURSOR_PROMPT_USAGE = [
@@ -111,12 +111,17 @@ async function runCursorPromptBatch(task, cwd, model, timeoutMs) {
     const startedAt = Date.now();
     process.stderr.write(`[cursor-prompt] running "${task.slice(0, 80)}${task.length > 80 ? "..." : ""}" (model=${model}, cwd=${cwd})\n`);
     const runDir = (await computeRunDir(cwd, task)) ?? undefined;
-    const result = await executeCursorTask({ task, cwd, model, timeoutMs, runDir });
-    // Persist human-readable run log under .harness/runs/
+    const result = await executeCursorTask({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+    });
     await persistCursorRunLog(cwd, {
         task,
         model,
-        channel: 'tool',
+        channel: "tool",
         cwd,
         result,
         runDir,
@@ -135,87 +140,42 @@ async function runCursorPromptBatch(task, cwd, model, timeoutMs) {
     }
 }
 async function runCursorPromptStreaming(task, cwd, model, timeoutMs) {
-    const apiKey = process.env.CURSOR_API_KEY;
-    if (!apiKey?.trim()) {
-        process.stderr.write("[cursor-prompt] CURSOR_API_KEY not set\n");
-        process.exit(1);
-    }
-    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
-    const prompt = buildCursorPrompt(task, { runDir });
     const startedAt = Date.now();
-    process.stderr.write(`[cursor-prompt] streaming (model=${model}, cwd=${cwd})\n`);
-    let timeoutHandle;
-    try {
-        const { Agent } = await import("@cursor/sdk");
-        const agent = await Agent.create({
-            apiKey,
-            name: "pi-cursor-prompt",
-            model: { id: model },
-            local: { cwd },
-        });
-        const runPromise = (async () => {
-            const run = await agent.send(prompt);
-            for await (const event of run.stream()) {
-                if (event.type === "assistant") {
-                    for (const block of event.message.content) {
-                        if (block.type === "text") {
-                            process.stdout.write(block.text);
-                        }
-                    }
-                }
-            }
-            const result = await run.wait();
-            await agent[Symbol.asyncDispose]();
-            return result;
-        })();
-        const timeoutRace = new Promise((resolve) => {
-            timeoutHandle = setTimeout(() => {
-                resolve("timeout");
-            }, timeoutMs);
-        });
-        const raced = await Promise.race([
-            runPromise.then((v) => ({ kind: "done", value: v })),
-            timeoutRace.then(() => ({ kind: "timeout" })),
-        ]);
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-        if (raced.kind === "timeout") {
-            process.stderr.write(`\n[cursor-prompt] TIMEOUT after ${timeoutMs}ms\n`);
-            process.exit(1);
-        }
-        const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
-        const sdkResult = raced.value;
-        process.stderr.write(`\n[cursor-prompt] done in ${elapsed}s, status=${sdkResult.status}\n`);
-        const runStatus = sdkResult.status;
-        const status = mapRunStatusToExecutionStatus(runStatus, false);
-        const ok = status === 'completed';
-        // Persist human-readable run log under .harness/runs/
-        await persistCursorRunLog(cwd, {
-            task,
-            model,
-            channel: 'tool',
-            cwd,
-            result: {
-                ok,
-                status,
-                failureCategory: ok ? 'success' : classifyCursorFailure({ runStatus, stderr: '', stdout: '' }),
-                model,
-                durationMs: sdkResult.durationMs ?? Date.now() - startedAt,
-                stdout: '', // Streaming output went directly to stdout
-                stderr: '',
-            },
-            runDir,
-        });
+    process.stderr.write(`[cursor-prompt] streaming (model=${model}, cwd=${cwd})
+`);
+    const runDir = (await computeRunDir(cwd, task)) ?? undefined;
+    const result = await executeCursorPromptStream({
+        task,
+        cwd,
+        model,
+        timeoutMs,
+        runDir,
+        callbacks: {
+            onAssistantText: (text) => process.stdout.write(text),
+        },
+    });
+    await persistCursorRunLog(cwd, {
+        task,
+        model,
+        channel: "tool",
+        cwd,
+        result,
+        runDir,
+    });
+    const elapsed = ((Date.now() - startedAt) / 1000).toFixed(1);
+    if (result.ok) {
+        process.stderr.write(`
+[cursor-prompt] done in ${elapsed}s, status=${result.status}
+`);
     }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        process.stderr.write(`\n[cursor-prompt] ERROR: ${message}\n`);
+    else {
+        const stderr = result.stderr || "(no output)";
+        process.stderr.write(`
+[cursor-prompt] FAILED in ${elapsed}s (${result.failureCategory}):
+${stderr}
+`);
         process.exit(1);
     }
-    finally {
-        if (timeoutHandle)
-            clearTimeout(timeoutHandle);
-    }
 }
 export function printCursorPromptUsage() {
     console.log(CURSOR_PROMPT_USAGE);

package/dist/commands/dag-approve.js

@@ -1,5 +1,7 @@
 import path from "node:path";
+import { access } from "node:fs/promises";
 import { assertDagRunTransferTargetAvailable, getDagRunDir, readHumanEscalation, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanApprovalArtifact, } from "../workflows/dag/lifecycle.js";
+import { assertSkillSnapshotCoversSpec, readSkillSnapshot, SKILL_SNAPSHOT_REL_PATH, } from "../workflows/dag/skill-snapshot.js";
 export function parseDagApproveArgs(args) {
     if (args.length === 0) {
         throw new Error("usage: dag approve --run-id <id> --option <A|B|...> [--notes \"...\"]");
@@ -59,6 +61,34 @@ export async function runDagApprove(repoRoot, rawArgs) {
     if (!optionIds.has(parsed.option)) {
         throw new Error(`option ${parsed.option} is not valid; expected one of: ${[...optionIds].join(", ")}`);
     }
+    // Fail closed before any approval/state/lifecycle mutation. Snapshot-backed
+    // runs must validate fully. A true pre-snapshot legacy run (no ref and no
+    // artifact) may still be approved so resume can perform the established
+    // legacy-resume-backfill. An artifact without a ref is an orphan and cannot
+    // be trusted or silently adopted.
+    if (state.skillSnapshotRef) {
+        try {
+            const snapshot = await readSkillSnapshot(runDir, state.skillSnapshotRef, {
+                expectedRunId: state.runId,
+            });
+            assertSkillSnapshotCoversSpec(snapshot, spec, state);
+        }
+        catch (error) {
+            throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+        }
+    }
+    else {
+        const snapshotPath = path.join(runDir, ...SKILL_SNAPSHOT_REL_PATH.split("/"));
+        try {
+            await access(snapshotPath);
+            throw new Error("skill snapshot artifact exists without a state ref; refusing approval");
+        }
+        catch (error) {
+            if (!isNotFound(error)) {
+                throw new Error(`skill snapshot pre-approval validation failed: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+            }
+        }
+    }
     const activeRunDir = getDagRunDir(repoRoot, "active", state.runId);
     await assertDagRunTransferTargetAvailable(activeRunDir);
     const approvedAt = new Date().toISOString();
@@ -100,3 +130,9 @@ export async function runDagApprove(repoRoot, rawArgs) {
         nextRecommendedAction: "Run is approved; use dag resume to continue.",
     }, null, 2));
 }
+function isNotFound(error) {
+    return Boolean(error
+        && typeof error === "object"
+        && "code" in error
+        && error.code === "ENOENT");
+}

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

@@ -0,0 +1,118 @@
+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");
+}
+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));
+}

package/dist/commands/delegate.js

@@ -1,12 +1,11 @@
-import os from 'node:os';
-import path from 'node:path';
-import { delegateTask } from '../task/delegate.js';
-import { runCursorDelegatedTask } from '../executors/cursor-run.js';
-import { buildCursorRecoverySteps } from '../executors/cursor-executor-artifacts.js';
-import { formatCursorFailureMessage } from '../executors/cursor-execution-log.js';
-import { loadHarnessManifest } from '../governance/harness.js';
-const DELEGATE_USAGE = 'usage: delegate <taskId> [--executor pi|cursor] [--base <branch>] [--branch <name>] '
-    + '[--no-symlink] [--auto-run] [--no-auto-run]';
+import os from "node:os";
+import path from "node:path";
+import { delegateTask } from "../task/delegate.js";
+import { loadHarnessManifest } from "../governance/harness.js";
+import { generateTaskDagUseCase } from "../application/dag/generate-task-dag.js";
+import { validateDagUseCase } from "../application/dag/validate-dag.js";
+import { runDagUseCase } from "../application/dag/run-dag.js";
+const DELEGATE_USAGE = "usage: delegate <taskId> [--base <branch>] [--branch <name>] [--no-symlink] [--auto-run]";
 export function parseDelegateArgs(args) {
     if (args.length === 0) {
         throw new Error(DELEGATE_USAGE);
@@ -15,44 +14,37 @@ export function parseDelegateArgs(args) {
     let base;
     let branch;
     let symlinkNodeModules = true;
-    let autoRun = true;
-    let executor;
+    let autoRun = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
-        if (arg === '--base') {
+        if (arg === "--base") {
             base = args[i + 1];
             if (!base)
-                throw new Error('--base requires a value');
+                throw new Error("--base requires a value");
             i += 1;
         }
-        else if (arg === '--branch') {
+        else if (arg === "--branch") {
             branch = args[i + 1];
             if (!branch)
-                throw new Error('--branch requires a value');
+                throw new Error("--branch requires a value");
             i += 1;
         }
-        else if (arg === '--executor') {
-            const value = args[i + 1];
-            if (value !== 'pi' && value !== 'cursor') {
-                throw new Error('--executor must be "pi" or "cursor"');
-            }
-            executor = value;
-            i += 1;
+        else if (arg === "--executor") {
+            throw new Error("--executor was removed; delegate is worktree isolation only; use --auto-run for Pi DAG execution");
         }
-        else if (arg === '--no-symlink') {
+        else if (arg === "--no-symlink") {
             symlinkNodeModules = false;
         }
-        else if (arg === '--auto-run') {
+        else if (arg === "--auto-run") {
             autoRun = true;
         }
-        else if (arg === '--no-auto-run') {
-            autoRun = false;
+        else if (arg === "--no-auto-run") {
+            throw new Error("--no-auto-run was removed; delegate defaults to worktree-only (omit --auto-run)");
         }
-        else if (arg === '--supervised') {
-            throw new Error('--supervised was removed with the tmux white-box subagent lifecycle. '
-                + 'Use `delegate <taskId> --executor cursor --auto-run` for in-process Cursor SDK.');
+        else if (arg === "--supervised") {
+            throw new Error("--supervised was removed with the tmux white-box subagent lifecycle. Use `delegate <taskId> --auto-run` for Pi DAG execution in the worktree.");
         }
-        else if (!arg.startsWith('--')) {
+        else if (!arg.startsWith("--")) {
             if (taskId)
                 throw new Error(`unexpected positional argument: ${arg}`);
             taskId = arg;
@@ -62,71 +54,77 @@ export function parseDelegateArgs(args) {
         }
     }
     if (!taskId) {
-        throw new Error('delegate requires <taskId> as the first positional argument');
+        throw new Error("delegate requires <taskId> as the first positional argument");
     }
-    return { taskId, base, branch, symlinkNodeModules, autoRun, executor };
+    return { taskId, base, branch, symlinkNodeModules, autoRun };
 }
-export function printCursorFailureRecovery(taskId, result, cursorResult) {
-    console.error(`[delegate] cursor direct run failed: ${formatCursorFailureMessage(cursorResult.failureCategory)}`);
-    console.error(`  logs: .harness/tasks/${taskId}/logs/result.summary.md`);
-    for (const line of buildCursorRecoverySteps({
-        channel: 'delegate',
-        taskId,
-        sessionName: result.sessionName,
-        worktreePath: result.worktreePath,
-        failureCategory: cursorResult.failureCategory,
-    })) {
-        console.error(line);
-    }
-}
-export function printCursorDelegateNextSteps(taskId, result) {
+export function printDelegateNextSteps(taskId, result) {
+    const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
     const lines = [
-        `[delegate] cursor worktree ready (SDK direct).`,
+        `[delegate] worktree ready (Pi-only).`,
         `  worktree: ${result.worktreePath}`,
-        `  Next — run Cursor SDK in-process:`,
-        `    npm run dev -- delegate ${taskId} --executor cursor --auto-run`,
+        `  Next — generate, validate, and run DAG in the worktree:`,
+        `    loop-agent dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`,
+        `    loop-agent dag validate --dag ${JSON.stringify(dagPath)} --strict-models --strict-governance`,
+        `    loop-agent run-dag --dag ${JSON.stringify(dagPath)} --cwd ${JSON.stringify(result.worktreePath)}`,
+        `  Or: loop-agent delegate ${taskId} --auto-run`,
         `  After work completes:`,
-        `    npm run dev -- harvest ${taskId}`,
+        `    loop-agent harvest ${taskId}`,
     ];
     for (const line of lines) {
         console.error(line);
     }
 }
-export function buildPiAutoRunMigrationMessage(taskId, worktreePath) {
-    const dagPath = path.join(os.tmpdir(), `${taskId}-dag.json`);
-    const cwd = worktreePath ?? '<repo-root>';
-    return [
-        'delegate --executor pi --auto-run has been removed.',
-        'Use the DAG path instead:',
-        `  1. npm run dev -- dag run-task ${taskId} --profile auto --strict-models --output ${JSON.stringify(dagPath)}`,
-        `  2. npm run dev -- dag validate --dag ${JSON.stringify(dagPath)} --strict-models --strict-governance`,
-        `  3. npm run dev -- run-dag --dag ${JSON.stringify(dagPath)} --cwd ${JSON.stringify(cwd)}`,
-    ].join('\n');
-}
-export async function runDelegate(repoRoot, rawArgs) {
+const DEFAULT_RUN_DELEGATE_DEPENDENCIES = {
+    generateTaskDag: generateTaskDagUseCase,
+    validateDag: validateDagUseCase,
+    runDag: runDagUseCase,
+};
+export async function runDelegate(repoRoot, rawArgs, dependencies = DEFAULT_RUN_DELEGATE_DEPENDENCIES) {
     const parsed = parseDelegateArgs(rawArgs);
     const manifest = await loadHarnessManifest(repoRoot);
     const result = await delegateTask(repoRoot, manifest, parsed.taskId, {
         base: parsed.base,
         branch: parsed.branch,
         symlinkNodeModules: parsed.symlinkNodeModules,
-        executor: parsed.executor,
     });
     if (parsed.autoRun) {
-        if (result.executor === 'cursor') {
-            const cursorResult = await runCursorDelegatedTask(result.worktreePath, parsed.taskId, manifest, {
-                executionMode: 'direct',
-            });
-            if (!cursorResult.ok) {
-                printCursorFailureRecovery(parsed.taskId, result, cursorResult);
-            }
-        }
-        else if (result.executor === 'pi') {
-            throw new Error(buildPiAutoRunMigrationMessage(parsed.taskId, result.worktreePath));
-        }
-    }
-    else if (result.executor === 'cursor') {
-        printCursorDelegateNextSteps(parsed.taskId, result);
+        const dagPath = path.join(os.tmpdir(), `${parsed.taskId}-delegate-dag.json`);
+        await dependencies.generateTaskDag({
+            repoRoot,
+            taskId: parsed.taskId,
+            outputPath: dagPath,
+            strictModels: true,
+            execute: false,
+            initOnly: false,
+            dryRun: false,
+            cwd: result.worktreePath,
+            profile: "auto",
+            profileExplicit: false,
+        });
+        await dependencies.validateDag({
+            repoRoot,
+            dagPath,
+            strictModelMatrix: true,
+            strictGovernance: true,
+            forbidExecutors: [],
+        });
+        const runSummary = await dependencies.runDag({
+            repoRoot,
+            dagPath,
+            cwd: result.worktreePath,
+            initOnly: false,
+            dryRun: false,
+        });
+        console.log(JSON.stringify({
+            ...result,
+            autoRun: {
+                dagPath,
+                runSummary,
+            },
+        }, null, 2));
+        return;
     }
+    printDelegateNextSteps(parsed.taskId, result);
     console.log(JSON.stringify(result, null, 2));
 }

package/dist/commands/doctor.js

@@ -2,14 +2,6 @@ import { access } from 'node:fs/promises';
 import path from 'node:path';
 import { checkPiAvailability, resolvePiBackend } from '../executors/pi-executor.js';
 import { checkPiSdkAvailability } from '../executors/pi-sdk-executor.js';
-import { resolveCursorExecutorConfig } from '../executors/config-core.js';
-import { isCursorWorkerEnabled, isCursorWorkerRunning } from '../executors/cursor-worker-client.js';
-function checkCursorAvailability() {
-    if (!process.env.CURSOR_API_KEY?.trim()) {
-        return { ok: false, detail: 'CURSOR_API_KEY not set' };
-    }
-    return { ok: true, detail: 'CURSOR_API_KEY configured' };
-}
 export async function runDoctor(adapter, repoRoot) {
     const manifest = await adapter.loadHarnessManifest(repoRoot);
     const requiredPaths = [];
@@ -36,15 +28,5 @@ export async function runDoctor(adapter, repoRoot) {
     if (backendMode === 'sdk-first' && !sdk.ok) {
         console.error(`doctor warning: CODE_AGENT_PI_BACKEND=sdk-first but pi SDK unavailable (${sdk.detail}); steps will fall back to CLI`);
     }
-    const cursorCfg = resolveCursorExecutorConfig(manifest);
-    if (cursorCfg) {
-        const cursor = checkCursorAvailability();
-        if (!cursor.ok) {
-            console.error(`doctor warning: executors.cursor registered but ${cursor.detail}`);
-        }
-        if (isCursorWorkerEnabled()) {
-            console.log(`doctor: CURSOR_USE_WORKER=1 (running=${isCursorWorkerRunning()})`);
-        }
-    }
     console.log('doctor ok');
 }