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

package/skills/loop-agent/references/pi-subagent-assisted-mode.md

@@ -62,20 +62,23 @@ pi -p --no-session --no-context-files --no-skills --tools subagent "Reply with e
 
 **Agents**（`.pi/agents/`）
 
-| Agent | Role | Model |
-|-------|------|-------|
-| `loop-agent-scout` | Read-only recon：code、tests、docs、governance | `cursor/composer-2.5` |
-| `loop-agent-planner` | Implementation planning：最小可执行 plan | `cursor/composer-2.5` |
-| `loop-agent-reviewer` | Strict review：scope drift、verification gap、contract break | `cursor/composer-2.5` |
-| `loop-agent-worker` | General execution：bounded implementation 与 fix | `cursor/composer-2.5` |
+| Agent | Role | 对应阶段 |
+|-------|------|----------|
+| `loop-agent-scout` | 只读侦察：code、tests、docs、governance | Scout |
+| `loop-agent-planner` | 最小可执行计划；强调验证与回退 | Plan |
+| `loop-agent-reviewer` | 严格审查：范围漂移、验证缺口、契约破坏 | Verify / Review |
+| `loop-agent-worker` | 有界实现与修补 | Implement |
 
-**Prompt Templates**（`.pi/prompts/`）：输入 `/loop-agent-*` 调用
+另有通用 agents：`scout` / `planner` / `worker` / `reviewer`（中文提示，可被通用 prompt 模板调用）。模型以各 agent frontmatter 为准（当前仓库默认对齐 `harness.json` 的 Pi executor）。
+
+**Prompt Templates**（`.pi/prompts/`）：输入 `/loop-agent-*` 或通用模板名调用
 
 | Template | Flow |
 |----------|------|
-| `loop-agent-scout-and-plan` | scout → planner chain |
-| `loop-agent-analyze-wide` | 3 parallel scouts → analysis |
-| `loop-agent-review-only` | 独立 review plan/implementation/verification |
-| `loop-agent-implement-and-review` | worker → reviewer → worker loop |
+| `loop-agent-scout-and-plan` | parallel scout → planner |
+| `loop-agent-analyze-wide` | 3 parallel scouts → 结构化分析 |
+| `loop-agent-review-only` | 独立审查计划/实现/验证 |
+| `loop-agent-implement-and-review` | worker → reviewer → worker |
+| `scout-and-plan` / `implement` / `implement-and-review` | 通用 chain（调用 `scout`/`planner`/`worker`/`reviewer`） |
 
 传 `agentScope: "both"` + `confirmProjectAgents: false` 以访问 repo-local agents。

package/skills/using-git-worktrees/SKILL.md

@@ -0,0 +1,215 @@
+---
+name: using-git-worktrees
+description: Use when starting feature work that needs isolation from current workspace or before executing implementation plans - ensures an isolated workspace exists via native tools or git worktree fallback
+---
+
+# Using Git Worktrees
+
+## Overview
+
+Ensure work happens in an isolated workspace. Prefer your platform's native worktree tools. Fall back to manual git worktrees only when no native tool is available.
+
+**Core principle:** Detect existing isolation first. Then use native tools. Then fall back to git. Never fight the harness.
+
+**Announce at start:** "I'm using the using-git-worktrees skill to set up an isolated workspace."
+
+## Step 0: Detect Existing Isolation
+
+**Before creating anything, check if you are already in an isolated workspace.**
+
+```bash
+GIT_DIR=$(cd "$(git rev-parse --git-dir)" 2>/dev/null && pwd -P)
+GIT_COMMON=$(cd "$(git rev-parse --git-common-dir)" 2>/dev/null && pwd -P)
+BRANCH=$(git branch --show-current)
+```
+
+**Submodule guard:** `GIT_DIR != GIT_COMMON` is also true inside git submodules. Before concluding "already in a worktree," verify you are not in a submodule:
+
+```bash
+# If this returns a path, you're in a submodule, not a worktree — treat as normal repo
+git rev-parse --show-superproject-working-tree 2>/dev/null
+```
+
+**If `GIT_DIR != GIT_COMMON` (and not a submodule):** You are already in a linked worktree. Skip to Step 3 (Project Setup). Do NOT create another worktree.
+
+Report with branch state:
+- On a branch: "Already in isolated workspace at `<path>` on branch `<name>`."
+- Detached HEAD: "Already in isolated workspace at `<path>` (detached HEAD, externally managed). Branch creation needed at finish time."
+
+**If `GIT_DIR == GIT_COMMON` (or in a submodule):** You are in a normal repo checkout.
+
+Has the user already indicated their worktree preference in your instructions? If not, ask for consent before creating a worktree:
+
+> "Would you like me to set up an isolated worktree? It protects your current branch from changes."
+
+Honor any existing declared preference without asking. If the user declines consent, work in place and skip to Step 3.
+
+## Step 1: Create Isolated Workspace
+
+**You have two mechanisms. Try them in this order.**
+
+### 1a. Native Worktree Tools (preferred)
+
+The user has asked for an isolated workspace (Step 0 consent). Do you already have a way to create a worktree? It might be a tool with a name like `EnterWorktree`, `WorktreeCreate`, a `/worktree` command, or a `--worktree` flag. If you do, use it and skip to Step 3.
+
+Native tools handle directory placement, branch creation, and cleanup automatically. Using `git worktree add` when you have a native tool creates phantom state your harness can't see or manage.
+
+Only proceed to Step 1b if you have no native worktree tool available.
+
+### 1b. Git Worktree Fallback
+
+**Only use this if Step 1a does not apply** — you have no native worktree tool available. Create a worktree manually using git.
+
+#### Directory Selection
+
+Follow this priority order. Explicit user preference always beats observed filesystem state.
+
+1. **Check your instructions for a declared worktree directory preference.** If the user has already specified one, use it without asking.
+
+2. **Check for an existing project-local worktree directory:**
+   ```bash
+   ls -d .worktrees 2>/dev/null     # Preferred (hidden)
+   ls -d worktrees 2>/dev/null      # Alternative
+   ```
+   If found, use it. If both exist, `.worktrees` wins.
+
+3. **Check for an existing global directory:**
+   ```bash
+   project=$(basename "$(git rev-parse --show-toplevel)")
+   ls -d ~/.worktrees 2>/dev/null
+   ```
+   If found, use it.
+
+4. **If there is no other guidance available**, default to `.worktrees/` at the project root.
+
+#### Safety Verification (project-local directories only)
+
+**MUST verify directory is ignored before creating worktree:**
+
+```bash
+git check-ignore -q .worktrees 2>/dev/null || git check-ignore -q worktrees 2>/dev/null
+```
+
+**If NOT ignored:** Add to .gitignore, commit the change, then proceed.
+
+**Why critical:** Prevents accidentally committing worktree contents to repository.
+
+Global directories (`~/.worktrees/`) need no verification.
+
+#### Create the Worktree
+
+```bash
+project=$(basename "$(git rev-parse --show-toplevel)")
+
+# Determine path based on chosen location
+# For project-local: path="$LOCATION/$BRANCH_NAME"
+# For global: path="~/.worktrees/$BRANCH_NAME"
+
+git worktree add "$path" -b "$BRANCH_NAME"
+cd "$path"
+```
+
+**Sandbox fallback:** If `git worktree add` fails with a permission error (sandbox denial), tell the user the sandbox blocked worktree creation and you're working in the current directory instead. Then run setup and baseline tests in place.
+
+## Step 3: Project Setup
+
+Auto-detect and run appropriate setup:
+
+```bash
+# Node.js
+if [ -f package.json ]; then npm install; fi
+
+# Rust
+if [ -f Cargo.toml ]; then cargo build; fi
+
+# Python
+if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
+if [ -f pyproject.toml ]; then poetry install; fi
+
+# Go
+if [ -f go.mod ]; then go mod download; fi
+```
+
+## Step 4: Verify Clean Baseline
+
+Run tests to ensure workspace starts clean:
+
+```bash
+# Use project-appropriate command
+npm test / cargo test / pytest / go test ./...
+```
+
+**If tests fail:** Report failures, ask whether to proceed or investigate.
+
+**If tests pass:** Report ready.
+
+### Report
+
+```
+Worktree ready at <full-path>
+Tests passing (<N> tests, 0 failures)
+Ready to implement <feature-name>
+```
+
+## Quick Reference
+
+| Situation | Action |
+|-----------|--------|
+| Already in linked worktree | Skip creation (Step 0) |
+| In a submodule | Treat as normal repo (Step 0 guard) |
+| Native worktree tool available | Use it (Step 1a) |
+| No native tool | Git worktree fallback (Step 1b) |
+| `.worktrees/` exists | Use it (verify ignored) |
+| `worktrees/` exists | Use it (verify ignored) |
+| Both exist | Use `.worktrees/` |
+| Neither exists | Check instruction file, then default `.worktrees/` |
+| Global path exists | Use it (backward compat) |
+| Directory not ignored | Add to .gitignore + commit |
+| Permission error on create | Sandbox fallback, work in place |
+| Tests fail during baseline | Report failures + ask |
+| No package.json/Cargo.toml | Skip dependency install |
+
+## Common Mistakes
+
+### Fighting the harness
+
+- **Problem:** Using `git worktree add` when the platform already provides isolation
+- **Fix:** Step 0 detects existing isolation. Step 1a defers to native tools.
+
+### Skipping detection
+
+- **Problem:** Creating a nested worktree inside an existing one
+- **Fix:** Always run Step 0 before creating anything
+
+### Skipping ignore verification
+
+- **Problem:** Worktree contents get tracked, pollute git status
+- **Fix:** Always use `git check-ignore` before creating project-local worktree
+
+### Assuming directory location
+
+- **Problem:** Creates inconsistency, violates project conventions
+- **Fix:** Follow priority: existing > global legacy > instruction file > default
+
+### Proceeding with failing tests
+
+- **Problem:** Can't distinguish new bugs from pre-existing issues
+- **Fix:** Report failures, get explicit permission to proceed
+
+## Red Flags
+
+**Never:**
+- Create a worktree when Step 0 detects existing isolation
+- Use `git worktree add` when you have a native worktree tool (e.g., `EnterWorktree`). This is the #1 mistake — if you have it, use it.
+- Skip Step 1a by jumping straight to Step 1b's git commands
+- Create worktree without verifying it's ignored (project-local)
+- Skip baseline test verification
+- Proceed with failing tests without asking
+
+**Always:**
+- Run Step 0 detection first
+- Prefer native tools over git fallback
+- Follow directory priority: existing > global legacy > instruction file > default
+- Verify directory is ignored for project-local
+- Auto-detect and run project setup
+- Verify clean test baseline

package/dist/commands/cursor-worker.js

@@ -1,43 +0,0 @@
-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/cursor-worker-entry.js

@@ -1,8 +0,0 @@
-#!/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/cursor-artifacts.js

@@ -1,33 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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

@@ -1,134 +0,0 @@
-import path from "node:path";
-import { writeTextArtifactFile } from "../infrastructure/harness/artifact-store.js";
-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) {
-    const promptPath = path.join(artifactsDir, "prompt.redacted.md");
-    const summaryPath = path.join(artifactsDir, "result.summary.md");
-    await writeTextArtifactFile(promptPath, buildPromptRedactedMarkdown(input.prompt));
-    await writeTextArtifactFile(summaryPath, buildResultSummaryMarkdown(input));
-    return { promptPath, summaryPath };
-}

package/dist/executors/cursor-run.js

@@ -1,115 +0,0 @@
-import { readFile } from 'node:fs/promises';
-import path from 'node:path';
-import { validateCursorArtifacts } from './cursor-artifacts.js';
-import { buildCursorPrompt, executeCursorTask, } from './cursor-executor.js';
-import { writeCursorExecutorArtifacts } from './cursor-executor-artifacts.js';
-import { appendCursorExecutionLog, buildCursorExecutionLogRecord, } from './cursor-execution-log.js';
-import { assertCursorExecutorAvailable, resolveCursorExecutorConfig, resolveCursorModelForTaskConfig, } from './config-core.js';
-import { appendWorkflowLog } from '../shared/logger.js';
-import { getTaskDir, getTaskPaths, loadTaskConfig } from '../task/runtime.js';
-export async function runCursorDelegatedTask(repoRoot, taskId, manifest, options = {}) {
-    const taskConfig = await loadTaskConfig(repoRoot, taskId);
-    if (taskConfig.executor !== 'cursor') {
-        throw new Error(`runCursorDelegatedTask requires executor=cursor, got "${taskConfig.executor ?? 'pi'}"`);
-    }
-    assertCursorExecutorAvailable(manifest);
-    const cursorConfig = resolveCursorExecutorConfig(manifest);
-    const taskDir = getTaskDir(repoRoot, taskId);
-    const userTask = await buildCursorTaskDescription(repoRoot, taskId);
-    const model = resolveCursorModelForTaskConfig(taskConfig, cursorConfig);
-    await appendWorkflowLog(taskDir, `cursor executor start model=${model}`);
-    const result = await executeCursorTask({
-        task: userTask,
-        cwd: repoRoot,
-        model,
-        timeoutMs: taskConfig.timeoutMs,
-        runHook: options.runHook,
-    });
-    const prompt = buildCursorPrompt(userTask);
-    const executionContext = {
-        channel: 'delegate',
-        cwd: repoRoot,
-        executionMode: options.executionMode ?? 'direct',
-        taskId,
-    };
-    await appendCursorExecutionLog(taskDir, buildCursorExecutionLogRecord({
-        context: executionContext,
-        model,
-        prompt,
-        result,
-    }));
-    await writeCursorExecutorArtifacts(path.join(taskDir, 'logs'), {
-        prompt,
-        model,
-        context: executionContext,
-        result,
-    });
-    const artifactIssues = await validateCursorTaskArtifacts(repoRoot, taskId);
-    if (!result.ok) {
-        await appendWorkflowLog(taskDir, `cursor executor failed category=${result.failureCategory}`);
-        return result;
-    }
-    if (artifactIssues.length > 0) {
-        await appendWorkflowLog(taskDir, `cursor artifact validation failed: ${artifactIssues.join('; ')}`);
-        return {
-            ...result,
-            ok: false,
-            status: 'failed',
-            failureCategory: 'invalid-output',
-            stderr: artifactIssues.join('\n'),
-            details: {
-                ...(result.details ?? {}),
-                artifactIssues,
-            },
-        };
-    }
-    const postRun = options.postRun ?? 'none';
-    if (postRun === 'verify') {
-        const message = 'Cursor direct run no longer runs legacy sequential verify; use DAG verification, promote-run, or closeout.';
-        await appendWorkflowLog(taskDir, `cursor post-run verify rejected: ${message}`);
-        return {
-            ...result,
-            ok: false,
-            status: 'failed',
-            failureCategory: 'nonzero-exit',
-            stderr: message,
-            details: {
-                ...(result.details ?? {}),
-                postRunFailed: true,
-            },
-        };
-    }
-    await appendWorkflowLog(taskDir, 'cursor executor completed; one-shot evidence only');
-    return result;
-}
-async function buildCursorTaskDescription(repoRoot, taskId) {
-    const paths = getTaskPaths(repoRoot, taskId);
-    const taskConfig = await loadTaskConfig(repoRoot, taskId);
-    const requirement = await readFile(path.join(paths.sourceDir, '需求.md'), 'utf-8');
-    const constraints = await readFile(path.join(paths.sourceDir, '执行约束.md'), 'utf-8');
-    return [
-        `# Task ${taskId}`,
-        '',
-        '## 需求.md',
-        requirement.trim(),
-        '',
-        '## 执行约束.md',
-        constraints.trim(),
-        '',
-        '## Path boundaries',
-        `- allowedPaths: ${(taskConfig.allowedPaths ?? []).join(', ') || '(read-only; no code writes outside .harness/tasks/)'}`,
-        `- forbiddenPaths: ${(taskConfig.forbiddenPaths ?? []).join(', ') || '(none)'}`,
-        '',
-        '## Required artifacts',
-        '- artifacts/修改记录.md must include 修改摘要 / 修改文件 / 验证 / 风险',
-        '- artifacts/验证结果.md must include commands, exit code, pass/fail',
-    ].join('\n');
-}
-async function validateCursorTaskArtifacts(repoRoot, taskId) {
-    const paths = getTaskPaths(repoRoot, taskId);
-    const modifyLogPath = path.join(paths.taskDir, 'artifacts', '修改记录.md');
-    const verifyResultPath = path.join(paths.taskDir, 'artifacts', '验证结果.md');
-    const modifyLog = await readFile(modifyLogPath, 'utf-8');
-    const verifyResult = await readFile(verifyResultPath, 'utf-8');
-    return validateCursorArtifacts(modifyLog, verifyResult);
-}