@tea-agent/loop-agent 0.1.0

package/dist/commands/workflow.js

@@ -0,0 +1,259 @@
+import { access, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { compileWorkflowToDag } from "../workflows/dynamic/compile.js";
+import { assertValidWorkflowSpec, parseWorkflowSpec, } from "../workflows/dynamic/validate.js";
+import { assertValidDagSpec } from "../workflows/dag/validate.js";
+import { locateDagRun, readDagRunState } from "../workflows/dag/lifecycle.js";
+import { runDag } from "../workflows/dag/runner.js";
+function repoWorkflowDir(repoRoot) {
+    return path.join(repoRoot, ".loop-agent", "workflows");
+}
+function personalWorkflowDir() {
+    return path.join(os.homedir(), ".loop-agent", "workflows");
+}
+function workflowFileName(name) {
+    return name.endsWith(".workflow.json") ? name : `${name}.workflow.json`;
+}
+async function exists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function listWorkflowDir(dir, location) {
+    if (!(await exists(dir)))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() && entry.name.endsWith(".workflow.json"))
+        .map((entry) => ({
+        name: entry.name.slice(0, -".workflow.json".length),
+        location,
+        path: path.join(dir, entry.name),
+    }));
+}
+async function listTaskLocalWorkflows(repoRoot) {
+    const tasksDir = path.join(repoRoot, ".harness", "tasks");
+    if (!(await exists(tasksDir)))
+        return [];
+    const tasks = await readdir(tasksDir, { withFileTypes: true });
+    const results = [];
+    for (const task of tasks) {
+        if (!task.isDirectory())
+            continue;
+        const plannedDir = path.join(tasksDir, task.name, "workflows", "planned");
+        const planned = await listWorkflowDir(plannedDir, "task-local");
+        results.push(...planned.map((entry) => ({
+            ...entry,
+            name: `${task.name}/${entry.name}`,
+        })));
+    }
+    return results;
+}
+async function listSavedWorkflows(repoRoot) {
+    return [
+        ...(await listWorkflowDir(repoWorkflowDir(repoRoot), "repo")),
+        ...(await listWorkflowDir(personalWorkflowDir(), "personal")),
+        ...(await listTaskLocalWorkflows(repoRoot)),
+    ].sort((a, b) => `${a.location}:${a.name}`.localeCompare(`${b.location}:${b.name}`));
+}
+async function resolveWorkflowPath(repoRoot, nameOrPath) {
+    const directPath = path.resolve(repoRoot, nameOrPath);
+    if (await exists(directPath)) {
+        return {
+            name: path.basename(directPath).replace(/\.workflow\.json$/, ""),
+            location: "path",
+            path: directPath,
+        };
+    }
+    const entries = await listSavedWorkflows(repoRoot);
+    const found = entries.find((entry) => entry.name === nameOrPath || workflowFileName(entry.name) === nameOrPath);
+    if (found)
+        return found;
+    throw new Error(`workflow not found: ${nameOrPath}`);
+}
+async function readWorkflowSpec(workflowPath, args = {}) {
+    const raw = JSON.parse(await readFile(workflowPath, "utf-8"));
+    const inputs = {
+        ...(raw.inputs ?? {}),
+        ...args,
+    };
+    return parseWorkflowSpec({ ...raw, inputs });
+}
+function readFlag(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    if (!value)
+        throw new Error(`${flag} requires a value`);
+    return value;
+}
+function requireFlag(args, flag) {
+    const value = readFlag(args, flag);
+    if (!value)
+        throw new Error(`${flag} is required`);
+    return value;
+}
+function parseArgsJson(raw) {
+    if (!raw)
+        return {};
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("--args must be a JSON object");
+    }
+    return parsed;
+}
+function stableJson(value) {
+    return JSON.stringify(sortJson(value), null, 2);
+}
+function sortJson(value) {
+    if (Array.isArray(value))
+        return value.map(sortJson);
+    if (typeof value !== "object" || value === null)
+        return value;
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, entry]) => [key, sortJson(entry)]));
+}
+async function runWorkflowList(repoRoot) {
+    console.log(JSON.stringify({
+        mode: "workflow-list",
+        workflows: (await listSavedWorkflows(repoRoot)).map((entry) => ({
+            ...entry,
+            path: path.relative(repoRoot, entry.path),
+        })),
+    }, null, 2));
+}
+async function runWorkflowInspect(repoRoot, name) {
+    if (!name)
+        throw new Error("usage: workflow inspect <name>");
+    const entry = await resolveWorkflowPath(repoRoot, name);
+    const spec = await readWorkflowSpec(entry.path);
+    console.log(JSON.stringify({
+        mode: "workflow-inspect",
+        name: spec.meta.name,
+        description: spec.meta.description ?? "",
+        riskLevel: spec.meta.riskLevel,
+        location: entry.location,
+        path: path.relative(repoRoot, entry.path),
+        nodes: spec.nodes.map((node) => ({
+            id: node.id,
+            type: node.type,
+            dependsOn: node.dependsOn,
+        })),
+        final: spec.final.from,
+    }, null, 2));
+}
+async function runWorkflowSave(repoRoot, args) {
+    const from = path.resolve(repoRoot, requireFlag(args, "--from"));
+    const name = requireFlag(args, "--name");
+    const scope = readFlag(args, "--scope") ?? "repo";
+    if (scope !== "repo" && scope !== "personal") {
+        throw new Error("workflow save --scope must be repo or personal");
+    }
+    const spec = await readWorkflowSpec(from);
+    assertValidWorkflowSpec(spec);
+    const dir = scope === "repo" ? repoWorkflowDir(repoRoot) : personalWorkflowDir();
+    const savedPath = path.join(dir, workflowFileName(name));
+    await mkdir(dir, { recursive: true });
+    await writeFile(savedPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
+    console.log(JSON.stringify({
+        mode: "workflow-save",
+        name,
+        scope,
+        sourcePath: from,
+        savedPath,
+    }, null, 2));
+}
+async function runWorkflowRun(repoRoot, name, args) {
+    if (!name)
+        throw new Error("usage: workflow run <name> [--args <json>]");
+    const entry = await resolveWorkflowPath(repoRoot, name);
+    const workflowArgs = parseArgsJson(readFlag(args, "--args"));
+    const spec = await readWorkflowSpec(entry.path, workflowArgs);
+    const compiled = compileWorkflowToDag(spec, { sourcePath: entry.path });
+    assertValidDagSpec(compiled.dag, { strictGovernance: true });
+    const summary = await runDag(compiled.dag, {
+        cwd: path.resolve(repoRoot, readFlag(args, "--cwd") ?? "."),
+        runId: readFlag(args, "--run-id"),
+    });
+    console.log(JSON.stringify({
+        mode: "workflow-run",
+        name: spec.meta.name,
+        sourcePath: entry.path,
+        runId: summary.runId,
+        status: summary.status,
+        runDir: summary.runDir,
+        replayed: false,
+    }, null, 2));
+}
+async function runWorkflowDiff(repoRoot, name, args) {
+    if (!name)
+        throw new Error("usage: workflow diff <name> --against <path>");
+    const against = path.resolve(repoRoot, requireFlag(args, "--against"));
+    const entry = await resolveWorkflowPath(repoRoot, name);
+    const left = await readWorkflowSpec(entry.path);
+    const right = await readWorkflowSpec(against);
+    const leftJson = stableJson(left);
+    const rightJson = stableJson(right);
+    console.log(JSON.stringify({
+        mode: "workflow-diff",
+        name,
+        savedPath: entry.path,
+        againstPath: against,
+        different: leftJson !== rightJson,
+        leftNodeCount: left.nodes.length,
+        rightNodeCount: right.nodes.length,
+    }, null, 2));
+}
+async function runWorkflowReplay(repoRoot, runId) {
+    if (!runId)
+        throw new Error("usage: workflow replay <runId>");
+    const located = await locateDagRun(repoRoot, runId);
+    if (!located)
+        throw new Error(`dag run not found: ${runId}`);
+    const state = await readDagRunState(located.runDir);
+    console.log(JSON.stringify({
+        mode: "workflow-replay",
+        runId,
+        lifecycle: located.lifecycle,
+        status: state.status,
+        runDir: located.runDir,
+        replayMode: "inspect-only",
+        reexecutedNodes: [],
+        note: "Replay is inspect-only in v0; completed artifacts are not re-executed.",
+    }, null, 2));
+}
+export async function runWorkflowCommand(repoRoot, args) {
+    const [subcommand, name, ...rest] = args;
+    if (subcommand === "list") {
+        await runWorkflowList(repoRoot);
+        return;
+    }
+    if (subcommand === "inspect") {
+        await runWorkflowInspect(repoRoot, name);
+        return;
+    }
+    if (subcommand === "save") {
+        await runWorkflowSave(repoRoot, [name, ...rest].filter(Boolean));
+        return;
+    }
+    if (subcommand === "run") {
+        await runWorkflowRun(repoRoot, name, rest);
+        return;
+    }
+    if (subcommand === "diff") {
+        await runWorkflowDiff(repoRoot, name, rest);
+        return;
+    }
+    if (subcommand === "replay") {
+        await runWorkflowReplay(repoRoot, name);
+        return;
+    }
+    throw new Error("usage: workflow <list|inspect|save|run|diff|replay> [name] [options]");
+}

package/dist/commands/worktree-create.js

@@ -0,0 +1,31 @@
+import { loadHarnessManifest } from '../governance/harness.js';
+import { createWorktree } from '../task/worktree.js';
+export async function runWorktreeCreate(repoRoot, args) {
+    // Extract optional flags
+    let base;
+    let branch;
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const token = args[i];
+        if (token === '--base') {
+            base = args[++i];
+            if (!base)
+                throw new Error('--base requires a value');
+        }
+        else if (token === '--branch') {
+            branch = args[++i];
+            if (!branch)
+                throw new Error('--branch requires a value');
+        }
+        else {
+            positionalArgs.push(token);
+        }
+    }
+    const [taskId] = positionalArgs;
+    if (!taskId) {
+        throw new Error('usage: worktree create <task-id> [--base <branch>] [--branch <name>]');
+    }
+    const manifest = await loadHarnessManifest(repoRoot);
+    const result = await createWorktree(repoRoot, manifest, { taskId, branch, base });
+    console.log(JSON.stringify(result, null, 2));
+}

package/dist/commands/worktree-list.js

@@ -0,0 +1,5 @@
+import { listWorktrees } from '../task/worktree.js';
+export async function runWorktreeList(repoRoot) {
+    const entries = await listWorktrees(repoRoot);
+    console.log(JSON.stringify(entries, null, 2));
+}

package/dist/commands/worktree-remove.js

@@ -0,0 +1,26 @@
+import { loadHarnessManifest } from '../governance/harness.js';
+import { removeWorktree } from '../task/worktree.js';
+export async function runWorktreeRemove(repoRoot, args) {
+    let force = false;
+    let deleteBranch = false;
+    const positionalArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const token = args[i];
+        if (token === '--force') {
+            force = true;
+        }
+        else if (token === '--delete-branch') {
+            deleteBranch = true;
+        }
+        else {
+            positionalArgs.push(token);
+        }
+    }
+    const [taskId] = positionalArgs;
+    if (!taskId) {
+        throw new Error('usage: worktree remove <task-id> [--force] [--delete-branch]');
+    }
+    const manifest = await loadHarnessManifest(repoRoot);
+    await removeWorktree(repoRoot, manifest, { taskId, force, deleteBranch });
+    console.log(JSON.stringify({ ok: true, taskId, force, deleteBranch }, null, 2));
+}

package/dist/cursor-worker-entry.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Long-lived Cursor SDK worker (NDJSON on stdin/stdout).
+ * Spawned by cursor-worker-client when CURSOR_USE_WORKER=1.
+ */
+import { runCursorWorkerOnStreams } from './executors/cursor-worker-server.js';
+process.env.CURSOR_WORKER_CHILD = '1';
+await runCursorWorkerOnStreams(process.stdin, process.stdout);

package/dist/executors/config-core.js

@@ -0,0 +1,55 @@
+import { DEFAULT_CURSOR_MODEL } from './cursor-executor.js';
+import { DEFAULT_DAG_MODELS } from './model-routing.js';
+export const TASK_COMPLEXITY_TO_DAG = {
+    small: 'LOW',
+    medium: 'MED',
+    large: 'HIGH',
+};
+export function resolveCursorModel(overrides = {}, cursorConfig) {
+    return overrides.taskModel ?? cursorConfig?.defaultModel ?? DEFAULT_CURSOR_MODEL;
+}
+export function resolveCursorModelForTaskConfig(taskConfig, cursorConfig) {
+    if (taskConfig.cursorModel?.trim()) {
+        return taskConfig.cursorModel.trim();
+    }
+    const dagLevel = TASK_COMPLEXITY_TO_DAG[taskConfig.complexity ?? 'medium'];
+    return DEFAULT_DAG_MODELS[dagLevel] ?? resolveCursorModel({}, cursorConfig);
+}
+export function resolveTaskExecutor(taskConfig, override) {
+    if (override)
+        return override;
+    return taskConfig.executor ?? 'pi';
+}
+export function resolveCursorExecutorConfig(manifest) {
+    const config = manifest.executors?.cursor;
+    if (config?.enabled === false)
+        return undefined;
+    return config;
+}
+export function assertCursorExecutorAvailable(manifest) {
+    const config = resolveCursorExecutorConfig(manifest);
+    if (!config) {
+        throw new Error('cursor executor is not registered in harness.json executors.cursor');
+    }
+    return config;
+}
+export function validateCursorTaskPreflight(taskConfig) {
+    if (taskConfig.executor !== 'cursor')
+        return;
+    const allowed = taskConfig.allowedPaths ?? [];
+    if (allowed.length === 0) {
+        // Read-only analysis tasks may omit allowedPaths; write tasks must declare scope explicitly.
+        return;
+    }
+}
+export function assertCursorWriteTaskScope(taskConfig, changedPaths) {
+    if (taskConfig.executor !== 'cursor')
+        return;
+    if ((taskConfig.allowedPaths ?? []).length > 0)
+        return;
+    const codeChanges = changedPaths.filter((filePath) => !filePath.startsWith('.harness/tasks/'));
+    if (codeChanges.length > 0) {
+        throw new Error('cursor write task refused: allowedPaths is empty but git diff contains code changes. ' +
+            'Declare allowedPaths explicitly or keep the task read-only.');
+    }
+}

package/dist/executors/config.js

@@ -0,0 +1,2 @@
+export * from "./config-core.js";
+export * from "./model-routing.js";

package/dist/executors/cursor-artifacts.js

@@ -0,0 +1,33 @@
+const MODIFY_LOG_MARKERS = ['修改摘要', '修改文件', '验证', '风险'];
+const VERIFY_RESULT_MARKERS = ['命令', 'exit', 'pass', 'fail', '未运行'];
+export function validateCursorModifyLog(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return ['修改记录.md is empty'];
+    if (!trimmed.includes('# 修改记录'))
+        return ['修改记录.md missing heading: # 修改记录'];
+    const missing = MODIFY_LOG_MARKERS.filter((marker) => !trimmed.includes(marker));
+    return missing.map((marker) => `修改记录.md missing section marker: ${marker}`);
+}
+export function validateCursorVerifyResult(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return ['验证结果.md is empty'];
+    if (!trimmed.includes('# 验证结果'))
+        return ['验证结果.md missing heading: # 验证结果'];
+    const hasCommandMarker = VERIFY_RESULT_MARKERS.some((marker) => trimmed.toLowerCase().includes(marker.toLowerCase()));
+    if (!hasCommandMarker) {
+        return ['验证结果.md missing verification command / exit / pass-fail evidence'];
+    }
+    return [];
+}
+export function validateCursorArtifacts(modifyLog, verifyResult) {
+    return [
+        ...validateCursorModifyLog(modifyLog),
+        ...validateCursorVerifyResult(verifyResult),
+    ];
+}
+export function isEmptyArtifactTemplate(content, templateMarker) {
+    const trimmed = content.trim();
+    return trimmed.includes(templateMarker) && trimmed.split('\n').filter((line) => line.trim().length > 0).length <= 3;
+}

package/dist/executors/cursor-execution-log.js

@@ -0,0 +1,81 @@
+import { access, appendFile, mkdir } from 'node:fs/promises';
+import path from 'node:path';
+import { buildCursorPrompt, buildRedactedExecutorRecord, } from './cursor-executor.js';
+import { appendExecutorRecord } from '../shared/logger.js';
+export function resolveDelegateExecutionMode(executor) {
+    if (executor === 'pi')
+        return 'pi-worktree';
+    if (executor === 'cursor')
+        return 'direct';
+    return undefined;
+}
+export function buildCursorExecutionLogRecord(input) {
+    const base = buildRedactedExecutorRecord({
+        executor: 'cursor',
+        model: input.model,
+        durationMs: input.result.durationMs,
+        failureCategory: input.result.failureCategory,
+        ok: input.result.ok,
+        status: input.result.status,
+        prompt: input.prompt,
+        result: input.result,
+        apiKey: input.apiKey,
+    });
+    return {
+        ...base,
+        channel: input.context.channel,
+        executionMode: input.context.executionMode,
+        cwd: input.context.cwd,
+        taskId: input.context.taskId,
+        dagRunId: input.context.dagRunId,
+        dagNodeId: input.context.dagNodeId,
+        recordedAt: new Date().toISOString(),
+    };
+}
+export async function persistCursorExecutionLog(logsDir, record, fileName = 'executor.jsonl') {
+    await mkdir(logsDir, { recursive: true });
+    await appendFile(path.join(logsDir, fileName), `${JSON.stringify(record)}\n`, 'utf-8');
+}
+/** Append a unified record to `<taskDir>/logs/executor.jsonl`. */
+export async function appendCursorExecutionLog(taskDir, record) {
+    await appendExecutorRecord(taskDir, record);
+}
+export async function persistCursorToolExecution(cwd, input) {
+    try {
+        await access(path.join(cwd, '.harness'));
+    }
+    catch {
+        return;
+    }
+    const cacheDir = path.join(cwd, '.harness', 'cache');
+    const record = buildCursorExecutionLogRecord({
+        context: { channel: 'tool', cwd },
+        model: input.model,
+        prompt: buildCursorPrompt(input.task),
+        result: input.result,
+        apiKey: input.apiKey,
+    });
+    await persistCursorExecutionLog(cacheDir, record, 'cursor-executions.jsonl');
+}
+export function formatCursorFailureMessage(category) {
+    switch (category) {
+        case 'missing-api-key':
+            return 'CURSOR_API_KEY is not set.';
+        case 'auth':
+            return 'Cursor API authentication failed.';
+        case 'network':
+            return 'Cursor API network error.';
+        case 'timeout':
+            return 'Cursor execution timed out.';
+        case 'invalid-output':
+            return 'Cursor output or artifacts are invalid.';
+        case 'path-violation':
+            return 'Cursor task violated path boundaries.';
+        case 'nonzero-exit':
+            return 'Cursor agent did not complete successfully.';
+        case 'success':
+            return 'OK';
+        default:
+            return 'Cursor execution failed.';
+    }
+}

package/dist/executors/cursor-executor-artifacts.js

@@ -0,0 +1,135 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { redactPromptForLog, truncateOutput, } from "./cursor-executor.js";
+import { formatCursorFailureMessage, } from "./cursor-execution-log.js";
+const SUMMARY_STDOUT_MAX = 4_000;
+const SUMMARY_STDERR_MAX = 2_000;
+export function buildPromptRedactedMarkdown(prompt) {
+    const redacted = redactPromptForLog(prompt);
+    return [
+        "# Cursor prompt (redacted)",
+        "",
+        `- ${redacted}`,
+        "",
+        "Full prompt text is not stored. See `logs/executor.jsonl` for the same hash reference.",
+        "",
+    ].join("\n");
+}
+export function buildCursorRecoverySteps(input) {
+    const taskId = input.taskId ?? "<task-id>";
+    const session = input.sessionName ?? `task-${taskId}`;
+    const lines = ["## Recovery steps", ""];
+    if (input.failureCategory) {
+        lines.push(`- **Failure**: ${formatCursorFailureMessage(input.failureCategory)} (\`${input.failureCategory}\`)`);
+        lines.push("");
+    }
+    if (input.channel === "delegate") {
+        lines.push("### Retry in-process (direct SDK)");
+        lines.push("```bash");
+        lines.push("cd .");
+        lines.push(`npm run dev -- delegate ${taskId} --executor cursor --auto-run`);
+        lines.push("```");
+        if (input.worktreePath) {
+            lines.push("");
+            lines.push(`- Worktree: \`${input.worktreePath}\``);
+        }
+        lines.push("");
+        lines.push("### Promote evidence");
+        lines.push("```bash");
+        lines.push(`npm run dev -- promote-run ${taskId} --run-id <run-id>`);
+        lines.push(`npm run dev -- closeout task ${taskId}`);
+        lines.push("```");
+        lines.push("");
+        lines.push("### After closeout");
+        lines.push("```bash");
+        lines.push(`npm run dev -- harvest ${taskId}`);
+        lines.push("```");
+    }
+    else if (input.channel === "dag") {
+        lines.push("### Re-run DAG node");
+        lines.push("- Fix upstream outputs or prompts in the DAG JSON, then re-run `run-dag` with a new `--run-id`.");
+        lines.push("- Inspect `executor.jsonl` and per-node `result.summary.md` under `.harness/dag-runs/completed/<run-id>/` (or `active/<run-id>/` while the run is still in progress).");
+    }
+    else {
+        lines.push("### Pi cursor tool");
+        lines.push("- Retry with a clearer `task` and correct `cwd`.");
+        lines.push("- Check `.harness/cache/cursor-executions.jsonl` when cwd contains `.harness`.");
+    }
+    if (input.failureCategory === "missing-api-key") {
+        lines.push("");
+        lines.push("- Export `CURSOR_API_KEY` before retrying.");
+    }
+    return lines;
+}
+function formatTokenUsage(result) {
+    const rows = [];
+    if (result.tokensUsed !== undefined) {
+        rows.push(`| tokensUsed | ${result.tokensUsed} |`);
+    }
+    const usage = result.details?.usage;
+    if (typeof usage?.inputTokens === "number") {
+        rows.push(`| inputTokens | ${usage.inputTokens} |`);
+    }
+    if (typeof usage?.outputTokens === "number") {
+        rows.push(`| outputTokens | ${usage.outputTokens} |`);
+    }
+    if (typeof usage?.totalTokens === "number" &&
+        result.tokensUsed === undefined) {
+        rows.push(`| totalTokens | ${usage.totalTokens} |`);
+    }
+    return rows;
+}
+export function buildResultSummaryMarkdown(input) {
+    const stdout = truncateOutput(input.result.stdout, SUMMARY_STDOUT_MAX);
+    const stderr = truncateOutput(input.result.stderr || "", SUMMARY_STDERR_MAX);
+    const recovery = input.recoveryLines ??
+        buildCursorRecoverySteps({
+            channel: input.context.channel,
+            taskId: input.context.taskId,
+            sessionName: input.context.taskId
+                ? `task-${input.context.taskId}`
+                : undefined,
+            worktreePath: input.context.cwd,
+            failureCategory: input.result.ok
+                ? undefined
+                : input.result.failureCategory,
+        });
+    const meta = [
+        "# Cursor execution summary",
+        "",
+        "## Run metadata",
+        "",
+        `| Field | Value |`,
+        `|-------|-------|`,
+        `| channel | ${input.context.channel} |`,
+    ];
+    if (input.context.executionMode)
+        meta.push(`| executionMode | ${input.context.executionMode} |`);
+    if (input.context.taskId)
+        meta.push(`| taskId | ${input.context.taskId} |`);
+    if (input.context.dagRunId)
+        meta.push(`| dagRunId | ${input.context.dagRunId} |`);
+    if (input.context.dagNodeId)
+        meta.push(`| dagNodeId | ${input.context.dagNodeId} |`);
+    meta.push(`| cwd | ${input.context.cwd} |`, `| model | ${input.model} |`, `| ok | ${input.result.ok} |`, `| status | ${input.result.status} |`, `| failureCategory | ${input.result.failureCategory} |`, `| durationMs | ${input.result.durationMs} |`, ...formatTokenUsage(input.result), "", "## Prompt reference", "", `- ${redactPromptForLog(input.prompt)}`, "", "## Output", "");
+    if (stdout.text.trim()) {
+        meta.push("### stdout", "", "```text", stdout.text, "```", "");
+        if (stdout.truncated)
+            meta.push("_(stdout truncated)_", "");
+    }
+    if (stderr.text.trim()) {
+        meta.push("### stderr", "", "```text", stderr.text, "```", "");
+        if (stderr.truncated)
+            meta.push("_(stderr truncated)_", "");
+    }
+    meta.push(...recovery, "");
+    return meta.join("\n");
+}
+export async function writeCursorExecutorArtifacts(artifactsDir, input) {
+    await mkdir(artifactsDir, { recursive: true });
+    const promptPath = path.join(artifactsDir, "prompt.redacted.md");
+    const summaryPath = path.join(artifactsDir, "result.summary.md");
+    await writeFile(promptPath, buildPromptRedactedMarkdown(input.prompt), "utf-8");
+    await writeFile(summaryPath, buildResultSummaryMarkdown(input), "utf-8");
+    return { promptPath, summaryPath };
+}