@tea-agent/loop-agent 0.1.0

package/dist/commands/cursor-prompt.js

@@ -0,0 +1,222 @@
+/**
+ * Cursor Prompt — one-shot CLI for Cursor SDK tasks.
+ *
+ * Usage:
+ *   cursor-prompt "Fix lint errors"                    # one-shot
+ *   cursor-prompt --stdin                               # read task from stdin
+ *   cursor-prompt --file task.md                        # read task from file
+ *   cursor-prompt --stream "Analyze this code"          # stream output
+ *   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 { 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 = [
+    "usage: cursor-prompt [options] [task]",
+    "",
+    '  cursor-prompt "Fix lint errors in src/"              One-shot task',
+    "  cursor-prompt --stdin                                 Read task from stdin",
+    "  cursor-prompt --file task.md                          Read task from a file",
+    '  cursor-prompt --stream "Analyze this"                 Stream output in real-time',
+    '  cursor-prompt --model gpt-5.5 "Deep analysis"         Use a specific model',
+    '  cursor-prompt --cwd /path --timeout 60000 "task"      Custom cwd + timeout',
+    "  cursor-prompt --list-models                           List commonly used models",
+    "",
+    "options:",
+    "  --stdin              Read task from stdin (ignores positional task)",
+    "  --file <path>        Read task from a file",
+    "  --stream             Stream agent output in real-time",
+    "  --model <id>         Model id (default: account default)",
+    "  --cwd <path>         Working directory (default: cwd)",
+    "  --timeout <ms>       Timeout in ms (default: 1,800,000 = 30min)",
+    "  --list-models        List commonly used models",
+    "  --no-stream          Force non-streaming output (default for non-tty)",
+].join("\n");
+const COMMON_MODELS = {
+    "composer-2.5": "Cursor Composer 2.5 (fast, small tasks)",
+    "composer-3": "Cursor Composer 3",
+    default: "Account default",
+    "gpt-5.5": "GPT 5.5 (deep reasoning)",
+    "gpt-5": "GPT 5",
+    "claude-sonnet-4": "Claude Sonnet 4",
+    "claude-opus-4": "Claude Opus 4",
+    "gemini-3-flash": "Gemini 3 Flash (fast/cheap)",
+    "gemini-3-pro": "Gemini 3 Pro",
+};
+export function listModels() {
+    console.log("Common Cursor models:\n");
+    for (const [id, desc] of Object.entries(COMMON_MODELS)) {
+        console.log(`  ${id.padEnd(22)} ${desc}`);
+    }
+}
+export function parseCursorPromptArgs(args) {
+    const accum = createOneShotPromptParseAccum();
+    let model;
+    let stream;
+    for (let i = 0; i < args.length; i += 1) {
+        const common = parseOneShotCommonFlag(args, i, accum);
+        if (common.kind === "help") {
+            printOneShotHelpAndExit(CURSOR_PROMPT_USAGE);
+        }
+        if (common.kind === "consumed") {
+            i = common.nextIndex;
+            continue;
+        }
+        const arg = args[i];
+        if (arg === "--stream") {
+            stream = true;
+        }
+        else if (arg === "--no-stream") {
+            stream = false;
+        }
+        else if (arg === "--list-models") {
+            return { listModels: true };
+        }
+        else if (arg === "--model") {
+            model = args[i + 1];
+            if (!model)
+                throw new Error("--model requires a model id");
+            i += 1;
+        }
+        else {
+            throw formatUnknownFlagError(arg, CURSOR_PROMPT_USAGE);
+        }
+    }
+    const task = resolveOneShotTask(accum, CURSOR_PROMPT_USAGE);
+    // Default: stream if stdout is a TTY
+    if (stream === undefined) {
+        stream = process.stdout.isTTY === true;
+    }
+    return {
+        task,
+        cwd: resolveOneShotCwd(accum.cwd),
+        model,
+        timeoutMs: accum.timeoutMs,
+        stream,
+    };
+}
+export async function runCursorPrompt(args) {
+    const effectiveCwd = args.cwd ?? process.cwd();
+    const model = args.model ?? DEFAULT_CURSOR_MODEL;
+    const timeoutMs = args.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
+    if (args.stream) {
+        await runCursorPromptStreaming(args.task, effectiveCwd, model, timeoutMs);
+    }
+    else {
+        await runCursorPromptBatch(args.task, effectiveCwd, model, timeoutMs);
+    }
+}
+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/
+    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}\n`);
+        process.stdout.write(result.stdout);
+        if (!result.stdout.endsWith("\n"))
+            process.stdout.write("\n");
+    }
+    else {
+        const stderr = result.stderr || result.stdout || "(no output)";
+        process.stderr.write(`[cursor-prompt] FAILED in ${elapsed}s (${result.failureCategory}):\n${stderr}\n`);
+        process.exit(1);
+    }
+}
+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,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`\n[cursor-prompt] ERROR: ${message}\n`);
+        process.exit(1);
+    }
+    finally {
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+    }
+}
+export function printCursorPromptUsage() {
+    console.log(CURSOR_PROMPT_USAGE);
+}

package/dist/commands/cursor-worker.js

@@ -0,0 +1,43 @@
+import { executeCursorTaskViaWorker, getCursorWorkerEntryPath, isCursorWorkerChild, isCursorWorkerEnabled, isCursorWorkerRunning, stopCursorWorker, } from '../executors/cursor-worker-client.js';
+export function parseCursorWorkerArgs(args) {
+    const action = args[0];
+    if (action === 'status' || action === 'stop' || action === 'ping') {
+        return { action };
+    }
+    throw new Error('usage: cursor-worker <status|stop|ping>');
+}
+export async function runCursorWorker(repoRoot, rawArgs) {
+    const { action } = parseCursorWorkerArgs(rawArgs);
+    if (action === 'status') {
+        console.log(JSON.stringify({
+            enabled: isCursorWorkerEnabled(),
+            running: isCursorWorkerRunning(),
+            child: isCursorWorkerChild(),
+            entry: getCursorWorkerEntryPath(),
+            repoRoot,
+        }, null, 2));
+        return;
+    }
+    if (action === 'stop') {
+        await stopCursorWorker();
+        console.log('cursor worker stopped');
+        return;
+    }
+    if (action === 'ping') {
+        if (!isCursorWorkerEnabled()) {
+            console.error('Set CURSOR_USE_WORKER=1 to enable the worker path.');
+        }
+        try {
+            const result = await executeCursorTaskViaWorker({
+                task: 'Reply with exactly: WORKER_PING_OK',
+                cwd: repoRoot,
+                model: 'default',
+                timeoutMs: 120_000,
+            });
+            console.log(JSON.stringify({ ok: result.ok, stdout: result.stdout.trim() }, null, 2));
+        }
+        finally {
+            await stopCursorWorker();
+        }
+    }
+}

package/dist/commands/dag-approve.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { assertDagRunTransferTargetAvailable, getDagRunDir, readHumanEscalation, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanApprovalArtifact, } from "../workflows/dag/lifecycle.js";
+export function parseDagApproveArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag approve --run-id <id> --option <A|B|...> [--notes \"...\"]");
+    }
+    let runId;
+    let option;
+    let notes;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg === "--option") {
+            option = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--option=")) {
+            option = arg.slice("--option=".length);
+            continue;
+        }
+        if (arg === "--notes") {
+            notes = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--notes=")) {
+            notes = arg.slice("--notes=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag approve flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId) {
+        throw new Error("dag approve requires --run-id <id>");
+    }
+    if (!option) {
+        throw new Error("dag approve requires --option <id>");
+    }
+    return { runId, option, notes };
+}
+export async function runDagApprove(repoRoot, rawArgs) {
+    const parsed = parseDagApproveArgs(rawArgs);
+    const { runDir, state, spec } = await requirePausedDagRun(repoRoot, parsed.runId);
+    const nodeId = state.pausedByNodeId;
+    const node = state.nodes[nodeId];
+    if (!node) {
+        throw new Error(`paused node ${nodeId} not found in run state`);
+    }
+    const escalation = await readHumanEscalation(runDir, nodeId);
+    const optionIds = new Set(escalation.humanEscalation.options.map((entry) => entry.id));
+    if (!optionIds.has(parsed.option)) {
+        throw new Error(`option ${parsed.option} is not valid; expected one of: ${[...optionIds].join(", ")}`);
+    }
+    const activeRunDir = getDagRunDir(repoRoot, "active", state.runId);
+    await assertDagRunTransferTargetAvailable(activeRunDir);
+    const approvedAt = new Date().toISOString();
+    const artifact = {
+        schemaVersion: 1,
+        runId: state.runId,
+        nodeId,
+        decision: "approved",
+        selectedOption: parsed.option,
+        approvedAt,
+        escalationArtifactPath: node.escalationArtifactPath,
+    };
+    if (parsed.notes) {
+        artifact.notes = parsed.notes;
+    }
+    const approvalPath = await writeHumanApprovalArtifact({
+        runDir,
+        nodeId,
+        artifact,
+    });
+    node.pauseReason = undefined;
+    node.humanApprovalArtifactPath = approvalPath;
+    state.status = "running";
+    state.humanDecisionNodeId = nodeId;
+    delete state.pausedAt;
+    delete state.pausedByNodeId;
+    delete state.pauseReason;
+    await writeDagRunState(runDir, state);
+    const nextRunDir = await transferDagRunDir(runDir, activeRunDir);
+    console.log(JSON.stringify({
+        action: "approve",
+        runId: state.runId,
+        nodeId,
+        selectedOption: parsed.option,
+        approvalPath: path.relative(repoRoot, approvalPath),
+        runDir: nextRunDir,
+        title: spec.title,
+        status: state.status,
+        nextRecommendedAction: "Run is approved; use dag resume to continue.",
+    }, null, 2));
+}

package/dist/commands/dag-final-verification.js

@@ -0,0 +1,76 @@
+import { defaultFinalVerificationDagOutputPath, initFinalVerificationDagFromTask, } from '../workflows/dag/final-verification.js';
+import { resolveCliPath } from '../shared/path-refs.js';
+export function parseDagFinalVerificationArgs(args) {
+    if (args.length === 0) {
+        throw new Error('usage: dag final-verification <task-id> [--output <path>] [--task-glob <pattern>] [--closeout <path>]');
+    }
+    let taskId;
+    let outputPath;
+    let taskGlob;
+    let closeoutPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--output' || arg === '-o') {
+            outputPath = requiredValue(args[++i], '--output');
+        }
+        else if (arg.startsWith('--output=')) {
+            outputPath = arg.slice('--output='.length);
+        }
+        else if (arg === '--task-glob') {
+            taskGlob = requiredValue(args[++i], '--task-glob');
+        }
+        else if (arg.startsWith('--task-glob=')) {
+            taskGlob = arg.slice('--task-glob='.length);
+        }
+        else if (arg === '--closeout') {
+            closeoutPath = requiredValue(args[++i], '--closeout');
+        }
+        else if (arg.startsWith('--closeout=')) {
+            closeoutPath = arg.slice('--closeout='.length);
+        }
+        else if (arg.startsWith('-')) {
+            throw new Error(`unknown dag final-verification flag: ${arg}`);
+        }
+        else if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        else {
+            taskId = arg;
+        }
+    }
+    if (!taskId) {
+        throw new Error('dag final-verification requires <task-id>');
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? resolveCliPath(outputPath) : undefined,
+        taskGlob,
+        closeoutPath: closeoutPath ? resolveCliPath(closeoutPath) : undefined,
+    };
+}
+export async function runDagFinalVerification(repoRoot, rawArgs) {
+    const parsed = parseDagFinalVerificationArgs(rawArgs);
+    const result = await initFinalVerificationDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+        taskGlob: parsed.taskGlob,
+        closeoutPath: parsed.closeoutPath,
+    });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId: result.taskId,
+        outputPath: result.outputPath,
+        defaultOutputPath: defaultFinalVerificationDagOutputPath(parsed.taskId),
+        taskCount: result.taskCount,
+        nodeIds: result.nodeIds,
+        next: [
+            `Review ${result.outputPath}`,
+            `npm run dev -- dag validate --dag ${result.outputPath} --strict-models --strict-governance`,
+            `npm run dev -- run-dag --dag ${result.outputPath} --cwd ${repoRoot}`,
+        ],
+    }, null, 2));
+}
+function requiredValue(value, flag) {
+    if (!value)
+        throw new Error(`dag final-verification requires a value for ${flag}`);
+    return value;
+}

package/dist/commands/dag-init-hybrid.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import { defaultHybridDagOutputPath, initHybridDagFromTask, } from "../workflows/dag/init-hybrid.js";
+export function parseDagInitHybridArgs(args) {
+    if (args.length === 0) {
+        throw new Error("usage: dag init-hybrid <task-id> [--output <path>]");
+    }
+    let taskId;
+    let outputPath;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--output" || arg === "-o") {
+            outputPath = args[++i];
+            if (!outputPath) {
+                throw new Error("dag init-hybrid --output requires a path");
+            }
+            continue;
+        }
+        if (arg.startsWith("--output=")) {
+            outputPath = arg.slice("--output=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag init-hybrid flag: ${arg}`);
+        }
+        if (taskId) {
+            throw new Error(`unexpected positional argument: ${arg}`);
+        }
+        taskId = arg;
+    }
+    if (!taskId) {
+        throw new Error("dag init-hybrid requires <task-id>");
+    }
+    return {
+        taskId,
+        outputPath: outputPath ? path.resolve(outputPath) : undefined,
+    };
+}
+export async function runDagInitHybrid(repoRoot, rawArgs) {
+    const parsed = parseDagInitHybridArgs(rawArgs);
+    const result = await initHybridDagFromTask(repoRoot, parsed.taskId, {
+        outputPath: parsed.outputPath,
+    });
+    console.log(JSON.stringify({
+        ok: true,
+        taskId: result.taskId,
+        outputPath: result.outputPath,
+        defaultOutputPath: defaultHybridDagOutputPath(parsed.taskId),
+        taskCount: result.taskCount,
+        nodeIds: result.nodeIds,
+        next: [
+            `Review ${result.outputPath}`,
+            `npm run dev -- dag validate --dag ${result.outputPath}`,
+            "Use run-dag --dry-run only when you intentionally need an active run snapshot.",
+        ],
+    }, null, 2));
+}

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

@@ -0,0 +1,51 @@
+import { formatTaskReconcileJson, formatTaskReconcileMarkdown, runTaskReconcile, } from '../workflows/dag/reconcile-tasks.js';
+export async function runDagReconcileTasks(repoRoot, args) {
+    const options = parseDagReconcileTasksArgs(args);
+    const report = await runTaskReconcile(repoRoot, {
+        glob: options.glob,
+        patch: options.patch,
+    });
+    const output = options.markdown
+        ? formatTaskReconcileMarkdown(report)
+        : formatTaskReconcileJson(report);
+    process.stdout.write(output);
+    if (!report.ok) {
+        process.exitCode = 1;
+    }
+}
+export function parseDagReconcileTasksArgs(args) {
+    let glob = '*';
+    let patch = false;
+    let json = false;
+    let markdown = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === '--glob') {
+            glob = requiredValue(args[++i], '--glob');
+        }
+        else if (arg.startsWith('--glob=')) {
+            glob = arg.slice('--glob='.length);
+        }
+        else if (arg === '--patch') {
+            patch = true;
+        }
+        else if (arg === '--json') {
+            json = true;
+        }
+        else if (arg === '--markdown') {
+            markdown = true;
+        }
+        else {
+            throw new Error(`unknown dag reconcile-tasks flag: ${arg}`);
+        }
+    }
+    if (json && markdown) {
+        throw new Error('dag reconcile-tasks accepts only one of --json or --markdown');
+    }
+    return { glob, patch, json, markdown };
+}
+function requiredValue(value, flag) {
+    if (!value)
+        throw new Error(`dag reconcile-tasks requires a value for ${flag}`);
+    return value;
+}

package/dist/commands/dag-reject.js

@@ -0,0 +1,91 @@
+import path from "node:path";
+import { assertDagRunTransferTargetAvailable, getDagRunDir, requirePausedDagRun, transferDagRunDir, writeDagRunState, writeHumanRejectionArtifact, } from "../workflows/dag/lifecycle.js";
+export function parseDagRejectArgs(args) {
+    if (args.length === 0) {
+        throw new Error('usage: dag reject --run-id <id> --reason "..."');
+    }
+    let runId;
+    let reason;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--run-id") {
+            runId = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--run-id=")) {
+            runId = arg.slice("--run-id=".length);
+            continue;
+        }
+        if (arg === "--reason") {
+            reason = args[++i];
+            continue;
+        }
+        if (arg.startsWith("--reason=")) {
+            reason = arg.slice("--reason=".length);
+            continue;
+        }
+        if (arg.startsWith("-")) {
+            throw new Error(`unknown dag reject flag: ${arg}`);
+        }
+        throw new Error(`unexpected positional argument: ${arg}`);
+    }
+    if (!runId) {
+        throw new Error("dag reject requires --run-id <id>");
+    }
+    if (!reason?.trim()) {
+        throw new Error("dag reject requires --reason <text>");
+    }
+    return { runId, reason: reason.trim() };
+}
+export async function runDagReject(repoRoot, rawArgs) {
+    const parsed = parseDagRejectArgs(rawArgs);
+    const { runDir, state } = await requirePausedDagRun(repoRoot, parsed.runId);
+    const nodeId = state.pausedByNodeId;
+    const node = state.nodes[nodeId];
+    if (!node) {
+        throw new Error(`paused node ${nodeId} not found in run state`);
+    }
+    const completedRunDir = getDagRunDir(repoRoot, "completed", state.runId);
+    await assertDagRunTransferTargetAvailable(completedRunDir);
+    const rejectedAt = new Date().toISOString();
+    const artifact = {
+        schemaVersion: 1,
+        runId: state.runId,
+        nodeId,
+        decision: "rejected",
+        reason: parsed.reason,
+        rejectedAt,
+    };
+    const rejectionPath = await writeHumanRejectionArtifact({
+        runDir,
+        nodeId,
+        artifact,
+    });
+    node.pauseReason = undefined;
+    node.humanRejectionArtifactPath = rejectionPath;
+    for (const pendingNode of Object.values(state.nodes)) {
+        if (pendingNode.status === "PENDING") {
+            pendingNode.status = "SKIPPED";
+            pendingNode.skippedReason = "human rejection";
+        }
+    }
+    state.status = "failed";
+    state.failureCategory = "human-rejected";
+    state.humanDecisionNodeId = nodeId;
+    state.finishedAt = rejectedAt;
+    delete state.pausedAt;
+    delete state.pausedByNodeId;
+    delete state.pauseReason;
+    await writeDagRunState(runDir, state);
+    const nextRunDir = await transferDagRunDir(runDir, completedRunDir);
+    console.log(JSON.stringify({
+        action: "reject",
+        runId: state.runId,
+        nodeId,
+        reason: parsed.reason,
+        failureCategory: state.failureCategory,
+        rejectionPath: path.relative(repoRoot, rejectionPath),
+        runDir: nextRunDir,
+        status: state.status,
+    }, null, 2));
+}