@tea-agent/loop-agent 0.10.0 → 0.12.0

package/dist/governance/exec-plans.js

@@ -0,0 +1,545 @@
+import { access, mkdir, readFile, readdir, rm, stat, writeFile, } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { loadHarnessManifest } from "./harness.js";
+const README_BASENAME = "README.md";
+/**
+ * Plan ids must be safe file stems. We reject anything that could escape the
+ * exec-plans directory, masquerade as the README, or carry path separators.
+ */
+export function assertSafePlanId(planId) {
+    if (typeof planId !== "string" ||
+        planId.length === 0 ||
+        planId === README_BASENAME ||
+        planId === "README" ||
+        path.isAbsolute(planId) ||
+        planId.includes("/") ||
+        planId.includes("\\") ||
+        planId.includes("..") ||
+        planId.includes(path.sep) ||
+        planId.includes("\0")) {
+        throw new Error(`invalid plan id: ${JSON.stringify(planId)}; must be a safe file stem without path separators, '..', or 'README'`);
+    }
+    // Also block Windows-reserved/odd characters that would break filesystems.
+    if (/[<>:"|?*]/.test(planId)) {
+        throw new Error(`invalid plan id: ${JSON.stringify(planId)}; contains forbidden filesystem characters`);
+    }
+}
+export async function resolveExecPlanPaths(repoRoot) {
+    const manifest = await loadHarnessManifest(repoRoot);
+    const execPlansDir = path.join(repoRoot, manifest.artifacts.execPlansDir ??
+        path.join(manifest.governanceRoot, "exec-plans"));
+    return {
+        execPlansDir,
+        activeDir: path.join(execPlansDir, "active"),
+        completedDir: path.join(execPlansDir, "completed"),
+        activeIndex: path.join(execPlansDir, "active", README_BASENAME),
+        completedIndex: path.join(execPlansDir, "completed", README_BASENAME),
+        localTemplatePath: path.join(repoRoot, manifest.governanceRoot, "templates", "exec-plan.md"),
+    };
+}
+async function exists(targetPath) {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureDir(targetPath) {
+    await mkdir(targetPath, { recursive: true });
+}
+/**
+ * Resolve a plan file path, guaranteeing it lands inside the given directory.
+ * This is defense-in-depth on top of {@link assertSafePlanId}: even if a caller
+ * bypasses validation, the resolved path is confined to the exec-plans dir.
+ */
+function resolveConfinedPlanPath(dir, planId) {
+    assertSafePlanId(planId);
+    const base = path.basename(planId);
+    const resolved = path.resolve(dir, `${base}.md`);
+    const relative = path.relative(dir, resolved);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new Error(`invalid plan id: ${JSON.stringify(planId)}; escapes directory ${dir}`);
+    }
+    return resolved;
+}
+function extractTitle(content) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match?.[1]?.trim() ?? null;
+}
+function extractStatusLine(content) {
+    const match = content.match(/^##\s*状态\s*\n\s*\n([^\n]+)/m);
+    return match?.[1]?.trim() ?? null;
+}
+function normalizeStatus(statusLine) {
+    if (!statusLine)
+        return "unknown";
+    const value = statusLine.replace(/^-\s*/, "").trim().toLowerCase();
+    if (value.startsWith("active"))
+        return "active";
+    if (value.startsWith("completed"))
+        return "completed";
+    if (value.startsWith("blocked"))
+        return "blocked";
+    if (value.startsWith("draft"))
+        return "draft";
+    return "unknown";
+}
+/**
+ * Build the active exec-plan body. The status line uses the `- active` form so
+ * `check` and the shell checker can both parse it deterministically.
+ */
+export function renderActiveExecPlan(title, templateContent) {
+    const safeTitle = title.trim();
+    if (!safeTitle) {
+        throw new Error("plan create requires a non-empty title");
+    }
+    let rendered = templateContent.replace(/^#\s+.*$/m, `# ${safeTitle}`);
+    rendered = rendered.replace(/^## 标题[^\n]*\r?\n(?:\r?\n)?/m, "");
+    if (/^##\s*状态\s*\n\s*\n[^\n]+/m.test(rendered)) {
+        rendered = rendered.replace(/^##\s*状态\s*\n\s*\n[^\n]+/m, "## 状态\n\n- active");
+    }
+    else {
+        rendered = `${rendered.trimEnd()}\n\n## 状态\n\n- active\n`;
+    }
+    return `${rendered.trimEnd()}\n`;
+}
+async function loadExecPlanTemplate(paths) {
+    if (await exists(paths.localTemplatePath)) {
+        return readFile(paths.localTemplatePath, "utf-8");
+    }
+    const packageRoot = await findPackageRoot();
+    const bundledTemplatePath = path.join(packageRoot, "docs", "templates", "exec-plan.md");
+    if (!(await exists(bundledTemplatePath))) {
+        throw new Error(`exec-plan template not found: ${paths.localTemplatePath} or ${bundledTemplatePath}`);
+    }
+    return readFile(bundledTemplatePath, "utf-8");
+}
+async function findPackageRoot() {
+    let current = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        if (await exists(path.join(current, "package.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error("cannot locate loop-agent package root for exec-plan template");
+        }
+        current = parent;
+    }
+}
+function applyCompletedStatus(content) {
+    const replaced = content.replace(/^##\s*状态\s*\n\s*\n([^\n]+)/m, (_whole, line) => {
+        const next = line
+            .replace(/^-\s*active\b/i, "- completed")
+            .replace(/^active\b/i, "completed");
+        return `## 状态\n\n${next}`;
+    });
+    if (/^##\s*状态\s*\n\s*\n[^\n]+/m.test(replaced)) {
+        return replaced;
+    }
+    return `${replaced.trimEnd()}\n\n## 状态\n\n- completed\n`;
+}
+function appendCompletionSummary(content, summary) {
+    const trimmed = summary.trim();
+    const block = [
+        "## 完成摘要",
+        "",
+        `- ${trimmed}`,
+        "",
+    ].join("\n");
+    if (/^##\s*完成摘要\b/m.test(content)) {
+        return content.replace(/^##\s*完成摘要\b.*(?=\n##\s|\n*$)/s, block.trimEnd());
+    }
+    return `${content.trimEnd()}\n\n${block}`;
+}
+async function listPlanFiles(dir) {
+    if (!(await exists(dir)))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true });
+    return entries
+        .filter((entry) => entry.isFile() &&
+        entry.name.endsWith(".md") &&
+        entry.name !== README_BASENAME)
+        .map((entry) => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+async function readPlanStatus(filePath) {
+    const content = await readFile(filePath, "utf-8");
+    return normalizeStatus(extractStatusLine(content));
+}
+function localIndexReference(rawReference) {
+    const normalized = rawReference
+        .trim()
+        .replace(/^<|>$/g, "")
+        .split(/[?#]/, 1)[0]
+        .replaceAll("\\", "/");
+    if (!normalized.endsWith(".md") || normalized.includes("/"))
+        return null;
+    return normalized;
+}
+function extractIndexReferences(indexContent) {
+    const references = new Set();
+    for (const line of indexContent.split(/\r?\n/)) {
+        // Match markdown links [text](file.md) and backtick-quoted `file.md`.
+        // This mirrors scripts/check-exec-plan-index-sync.sh, which keys on
+        // `(${base})` and `` `base` ``. Bare mentions are intentionally NOT
+        // treated as references to avoid false positives from partial matches.
+        const linkMatches = [...line.matchAll(/\[[^\]]*\]\(([^)]+\.md)\)/g)];
+        for (const match of linkMatches) {
+            const reference = match[1] ? localIndexReference(match[1]) : null;
+            if (reference)
+                references.add(reference);
+        }
+        const backtickMatches = [...line.matchAll(/`([^`]+\.md)`/g)];
+        for (const match of backtickMatches) {
+            const reference = match[1] ? localIndexReference(match[1]) : null;
+            if (reference)
+                references.add(reference);
+        }
+    }
+    return references;
+}
+/**
+ * Check that exec-plan directories and indexes are mutually consistent.
+ *
+ * Empty repos (no plan files, consistent indexes) are always OK; this only
+ * fails closed on real drift so default DAG flow remains unblocked.
+ */
+export async function checkExecPlanIndex(repoRoot, options = {}) {
+    const paths = await resolveExecPlanPaths(repoRoot);
+    const activeFiles = await listPlanFiles(paths.activeDir);
+    const completedFiles = await listPlanFiles(paths.completedDir);
+    const issues = [];
+    const activeIndexContent = (await exists(paths.activeIndex))
+        ? await readFile(paths.activeIndex, "utf-8")
+        : "";
+    const completedIndexContent = (await exists(paths.completedIndex))
+        ? await readFile(paths.completedIndex, "utf-8")
+        : "";
+    const activeIndexRefs = extractIndexReferences(activeIndexContent);
+    const completedIndexRefs = extractIndexReferences(completedIndexContent);
+    for (const file of activeFiles) {
+        const status = await readPlanStatus(path.join(paths.activeDir, file));
+        if (!activeIndexRefs.has(file)) {
+            issues.push({
+                kind: "missing-from-index",
+                status: "active",
+                file,
+                message: `active exec-plan 文件 ${file} 未在 active/README.md 索引中登记`,
+            });
+        }
+        if (status === "completed") {
+            issues.push({
+                kind: "status-directory-mismatch",
+                status,
+                file,
+                message: `exec-plan ${file} 的状态为 completed，但仍位于 active 目录`,
+            });
+        }
+    }
+    for (const file of completedFiles) {
+        const status = await readPlanStatus(path.join(paths.completedDir, file));
+        if (!completedIndexRefs.has(file)) {
+            issues.push({
+                kind: "missing-from-index",
+                status: "completed",
+                file,
+                message: `completed exec-plan 文件 ${file} 未在 completed/README.md 索引中登记`,
+            });
+        }
+        if (status === "active") {
+            issues.push({
+                kind: "status-directory-mismatch",
+                status,
+                file,
+                message: `exec-plan ${file} 的状态为 active，但仍位于 completed 目录`,
+            });
+        }
+    }
+    for (const ref of activeIndexRefs) {
+        if (ref === README_BASENAME)
+            continue;
+        if (!activeFiles.includes(ref)) {
+            issues.push({
+                kind: "stale-index-entry",
+                status: "active",
+                file: ref,
+                message: `active/README.md 引用了不存在的文件 ${ref}`,
+            });
+        }
+    }
+    for (const ref of completedIndexRefs) {
+        if (ref === README_BASENAME)
+            continue;
+        if (!completedFiles.includes(ref)) {
+            issues.push({
+                kind: "stale-index-entry",
+                status: "completed",
+                file: ref,
+                message: `completed/README.md 引用了不存在的文件 ${ref}`,
+            });
+        }
+    }
+    const duplicates = activeFiles.filter((file) => completedFiles.includes(file));
+    for (const file of duplicates) {
+        issues.push({
+            kind: "duplicate-plan-id",
+            file,
+            message: `exec-plan ${file} 同时出现在 active 和 completed 目录`,
+        });
+    }
+    const ok = issues.length === 0;
+    if (options.strict && !ok) {
+        throw new Error(`exec-plan index check failed (${issues.length} issue(s)): ${issues
+            .map((issue) => issue.message)
+            .join("; ")}`);
+    }
+    return {
+        ok,
+        issues,
+        activeFiles,
+        completedFiles,
+    };
+}
+/**
+ * Assert that the exec-plan index is consistent. Used by `dag run-task`
+ * preflight so drift fails fast before expensive DAG nodes run.
+ */
+export async function assertExecPlanIndexConsistent(repoRoot) {
+    const result = await checkExecPlanIndex(repoRoot, { strict: true });
+    void result;
+}
+function ensureActiveIndexEntry(indexContent, planId, title) {
+    const file = `${planId}.md`;
+    const safeTitle = title.trim() || planId;
+    const marker = `- [\`${file}\`](${file}) — ${safeTitle}`;
+    if (indexContent.includes(`(${file})`)) {
+        return indexContent;
+    }
+    const lines = indexContent.split(/\r?\n/);
+    const insertIndex = findInsertionPointForActiveEntry(lines);
+    const next = [...lines.slice(0, insertIndex), marker, ...lines.slice(insertIndex)];
+    return collapseBlankRuns(next).join("\n").replace(/\s+$/g, "") + "\n";
+}
+function findInsertionPointForActiveEntry(lines) {
+    // Insert before the first line that looks like a narrative / archive
+    // trailing section (blank-line separated context), or at the end.
+    for (let i = 0; i < lines.length; i += 1) {
+        const line = lines[i];
+        if (/^[-*]\s+已归档/.test(line))
+            return i;
+        if (/^[-*]\s+`[^`]+\.md`/.test(line)) {
+            // skip existing plan entries
+            continue;
+        }
+        if (/^[-*]\s+/.test(line) && i > 0) {
+            // A non-plan bullet (e.g. "已归档：...") starts the trailing context.
+            return i;
+        }
+    }
+    return lines.length;
+}
+function ensureCompletedIndexEntry(indexContent, planId) {
+    const file = `${planId}.md`;
+    const marker = `- [\`${file}\`](${file})`;
+    if (indexContent.includes(`(${file})`)) {
+        return indexContent;
+    }
+    return `${indexContent.trimEnd()}\n\n${marker}\n`;
+}
+function removeIndexEntries(indexContent, file) {
+    const lines = indexContent.split(/\r?\n/);
+    const filtered = lines.filter((line) => {
+        const linkMatch = line.match(/\[[^\]]*\]\(([^)]+)\)/);
+        if (linkMatch && path.basename(linkMatch[1]) === file)
+            return false;
+        if (line.includes(`\`${file}\``))
+            return false;
+        return true;
+    });
+    return collapseBlankRuns(filtered).join("\n").replace(/\s+$/g, "") + "\n";
+}
+function collapseBlankRuns(lines) {
+    const result = [];
+    let prevBlank = false;
+    for (const line of lines) {
+        const isBlank = line.trim() === "";
+        if (isBlank && prevBlank)
+            continue;
+        result.push(line);
+        prevBlank = isBlank;
+    }
+    while (result.length > 0 && result[result.length - 1].trim() === "") {
+        result.pop();
+    }
+    return result;
+}
+/**
+ * Create an active exec-plan file and register it in the active index.
+ * Fails if the plan id already exists in active or completed.
+ */
+export async function createExecPlan(repoRoot, planId, title) {
+    assertSafePlanId(planId);
+    const paths = await resolveExecPlanPaths(repoRoot);
+    const activePlanPath = resolveConfinedPlanPath(paths.activeDir, planId);
+    const completedPlanPath = resolveConfinedPlanPath(paths.completedDir, planId);
+    if (await exists(activePlanPath)) {
+        throw new Error(`exec-plan ${planId} already exists in active directory`);
+    }
+    if (await exists(completedPlanPath)) {
+        throw new Error(`exec-plan ${planId} already exists in completed directory`);
+    }
+    const activeIndexExisted = await exists(paths.activeIndex);
+    const activeIndexWasFile = activeIndexExisted
+        ? (await stat(paths.activeIndex)).isFile()
+        : false;
+    const activeIndexOriginal = activeIndexWasFile
+        ? await readFile(paths.activeIndex, "utf-8")
+        : null;
+    const body = renderActiveExecPlan(title, await loadExecPlanTemplate(paths));
+    try {
+        await ensureDir(paths.activeDir);
+        await writeFile(activePlanPath, body, "utf-8");
+        await ensureIndexFile(paths.activeIndex, "# 进行中的执行计划\n\n");
+        const activeIndexContent = await readFile(paths.activeIndex, "utf-8");
+        const nextIndex = ensureActiveIndexEntry(activeIndexContent, planId, extractTitle(body) ?? planId);
+        if (nextIndex !== activeIndexContent) {
+            await writeFile(paths.activeIndex, nextIndex, "utf-8");
+        }
+    }
+    catch (error) {
+        await rollbackCreation({
+            activePlanPath,
+            activeIndexPath: paths.activeIndex,
+            activeIndexExisted,
+            activeIndexOriginal,
+        });
+        throw error;
+    }
+    return {
+        planId,
+        status: "active",
+        planPath: activePlanPath,
+        indexPath: paths.activeIndex,
+    };
+}
+async function rollbackCreation(context) {
+    if (await exists(context.activePlanPath)) {
+        await rm(context.activePlanPath, { force: true }).catch(() => undefined);
+    }
+    if (context.activeIndexExisted) {
+        if (context.activeIndexOriginal !== null) {
+            await writeFile(context.activeIndexPath, context.activeIndexOriginal, "utf-8").catch(() => undefined);
+        }
+        return;
+    }
+    if (await exists(context.activeIndexPath)) {
+        await rm(context.activeIndexPath, { force: true }).catch(() => undefined);
+    }
+}
+async function ensureIndexFile(indexPath, bootstrapContent) {
+    if (await exists(indexPath))
+        return;
+    await mkdir(path.dirname(indexPath), { recursive: true });
+    await writeFile(indexPath, bootstrapContent, "utf-8");
+}
+/**
+ * Move an active exec-plan to completed, set status to completed, append the
+ * summary, and sync both indexes. Rollback restores touched files on failure.
+ */
+export async function completeExecPlan(repoRoot, planId, options) {
+    assertSafePlanId(planId);
+    const summary = options.summary?.trim();
+    if (!summary) {
+        throw new Error("plan complete requires a non-empty --summary describing what was delivered");
+    }
+    const paths = await resolveExecPlanPaths(repoRoot);
+    const activePlanPath = resolveConfinedPlanPath(paths.activeDir, planId);
+    const completedPlanPath = resolveConfinedPlanPath(paths.completedDir, planId);
+    if (!(await exists(activePlanPath))) {
+        throw new Error(`exec-plan ${planId} not found in active directory`);
+    }
+    if (await exists(completedPlanPath)) {
+        throw new Error(`exec-plan ${planId} already exists in completed directory`);
+    }
+    // Snapshot everything we will mutate so a mid-flight failure can roll back.
+    const activePlanOriginal = await readFile(activePlanPath, "utf-8");
+    const activeIndexExisted = await exists(paths.activeIndex);
+    const activeIndexOriginal = activeIndexExisted
+        ? await readFile(paths.activeIndex, "utf-8")
+        : null;
+    const completedIndexExisted = await exists(paths.completedIndex);
+    const completedIndexOriginal = completedIndexExisted
+        ? await readFile(paths.completedIndex, "utf-8")
+        : null;
+    const file = `${planId}.md`;
+    const completedBody = appendCompletionSummary(applyCompletedStatus(activePlanOriginal), summary);
+    try {
+        await ensureDir(paths.completedDir);
+        await writeFile(completedPlanPath, completedBody, "utf-8");
+        await ensureIndexFile(paths.completedIndex, "# 已完成的执行计划\n\n");
+        const completedIndexContent = await readFile(paths.completedIndex, "utf-8");
+        const nextCompletedIndex = ensureCompletedIndexEntry(completedIndexContent, planId);
+        if (nextCompletedIndex !== completedIndexContent) {
+            await writeFile(paths.completedIndex, nextCompletedIndex, "utf-8");
+        }
+        await rm(activePlanPath, { force: true });
+        if (activeIndexExisted) {
+            const nextActiveIndex = removeIndexEntries(activeIndexOriginal ?? "", file);
+            if (nextActiveIndex !== activeIndexOriginal) {
+                await writeFile(paths.activeIndex, nextActiveIndex, "utf-8");
+            }
+        }
+    }
+    catch (error) {
+        await rollbackCompletion({
+            activePlanPath,
+            activePlanOriginal,
+            completedPlanPath,
+            activeIndexPath: paths.activeIndex,
+            activeIndexExisted,
+            activeIndexOriginal,
+            completedIndexPath: paths.completedIndex,
+            completedIndexExisted,
+            completedIndexOriginal,
+        });
+        throw error;
+    }
+    return {
+        planId,
+        status: "completed",
+        fromPath: activePlanPath,
+        toPath: completedPlanPath,
+        activeIndex: paths.activeIndex,
+        completedIndex: paths.completedIndex,
+    };
+}
+async function rollbackCompletion(context) {
+    try {
+        await writeFile(context.activePlanPath, context.activePlanOriginal, "utf-8");
+    }
+    catch {
+        // Best-effort restore; original error must still propagate.
+    }
+    if (await exists(context.completedPlanPath)) {
+        await rm(context.completedPlanPath, { force: true });
+    }
+    await restoreOrRemoveIndex(context.activeIndexPath, context.activeIndexExisted, context.activeIndexOriginal);
+    await restoreOrRemoveIndex(context.completedIndexPath, context.completedIndexExisted, context.completedIndexOriginal);
+}
+async function restoreOrRemoveIndex(indexPath, existed, original) {
+    if (existed && original !== null) {
+        try {
+            await writeFile(indexPath, original, "utf-8");
+        }
+        catch {
+            // best-effort
+        }
+        return;
+    }
+    if (await exists(indexPath)) {
+        await rm(indexPath, { force: true });
+    }
+}

package/dist/governance/manifest-types.js

@@ -16,7 +16,8 @@ export const complexityRouteSchema = z.object({
 export const worktreeManifestConfigSchema = z.object({
     rootRelativePath: z.string().optional().default(".worktrees"),
 });
-export const taskExecutorSchema = z.enum(["pi", "cursor"]);
+export const taskExecutorSchema = z.enum(["pi"]);
+export const CURSOR_TASK_EXECUTOR_REMOVED_ERROR = 'task executor "cursor" is no longer supported; governed runtime is Pi-only';
 export const executorManifestSchema = z.object({
     description: z.string().optional(),
     enabled: z.boolean().optional(),
@@ -41,6 +42,7 @@ export const workflowPolicyDagTemplateSchema = z.enum([
     "standard-dag",
     "review-gated-dag",
     "supervised-implementation",
+    "frontend-implementation",
 ]);
 export const workflowPolicyOutputLanguageSchema = z.enum(["zh-CN", "en"]);
 export const workflowPolicySchema = z
@@ -92,7 +94,9 @@ export const workflowPolicySchema = z
 })
     .optional()
     .default({});
-export const harnessManifestSchema = z.object({
+export const CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR = 'harness executors.cursor is no longer supported; remove it and use executors.pi only (Cursor is available only via cursor-prompt sidecar)';
+export const harnessManifestSchema = z
+    .object({
     version: z.number(),
     project: z.string(),
     adapter: z.string().optional(),
@@ -138,4 +142,22 @@ export const harnessManifestSchema = z.object({
         .record(z.string(), executorManifestSchema)
         .optional()
         .default({}),
+})
+    .superRefine((manifest, ctx) => {
+    const executors = manifest.executors ?? {};
+    if ("cursor" in executors) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: CURSOR_HARNESS_EXECUTOR_REMOVED_ERROR,
+            path: ["executors", "cursor"],
+        });
+    }
+    const entrypoints = manifest.entrypoints ?? {};
+    if ("cursorExecutorUsage" in entrypoints) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: 'entrypoints.cursorExecutorUsage is no longer supported; remove it (Cursor is cursor-prompt sidecar only)',
+            path: ["entrypoints", "cursorExecutorUsage"],
+        });
+    }
 });

package/dist/infrastructure/harness/loop-action-store.js

@@ -9,9 +9,6 @@ function loopActionWriteOptions(repoRoot) {
 export async function writeLoopShellVerifyRecord(repoRoot, taskId, round, record) {
     await writeJsonAtomic(loopActionFile(repoRoot, taskId, "verification", `round-${round}.json`), record, loopActionWriteOptions(repoRoot));
 }
-export async function writeLoopCursorFixRecord(repoRoot, taskId, round, record) {
-    await writeJsonAtomic(loopActionFile(repoRoot, taskId, "reviews", `round-${round}-cursor-fix.json`), record, loopActionWriteOptions(repoRoot));
-}
 export async function writeLoopDagRecord(repoRoot, taskId, round, record) {
     await writeJsonAtomic(loopActionFile(repoRoot, taskId, "dag", `round-${round}.json`), record, loopActionWriteOptions(repoRoot));
 }

package/dist/records/harvest.js

@@ -1,12 +1,10 @@
-import { readFile, stat } from 'node:fs/promises';
+import { stat } from 'node:fs/promises';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { loadHarnessManifest } from '../governance/harness.js';
 import { resolveWorktreePath } from '../task/worktree.js';
 import { getTaskPaths, getTaskStatus, loadTaskConfig } from '../task/runtime.js';
 import { validateDiffPathGuard, listDiffPaths } from '../governance/path-guard.js';
-import { validateCursorArtifacts } from '../executors/cursor-artifacts.js';
-import { checkTaskHandoff } from '../governance/checks.js';
 import { archiveTaskDirFromWorktree } from '../task/worktree-cleanup.js';
 export { copyDir } from '../shared/copy-dir.js';
 /**
@@ -154,8 +152,7 @@ async function runHarvestGates(repoRoot, taskId, taskRoot, baseBranch, branch) {
     catch {
         return;
     }
-    const shouldRunPathGuard = taskConfig.executor === 'cursor'
-        || (taskConfig.allowedPaths ?? []).length > 0
+    const shouldRunPathGuard = (taskConfig.allowedPaths ?? []).length > 0
         || (taskConfig.forbiddenPaths ?? []).length > 0;
     if (shouldRunPathGuard) {
         const changedPaths = await listDiffPaths(repoRoot, baseBranch, branch);
@@ -165,24 +162,6 @@ async function runHarvestGates(repoRoot, taskId, taskRoot, baseBranch, branch) {
                 'Worktree preserved for manual review.');
         }
     }
-    if (taskConfig.executor !== 'cursor') {
-        return;
-    }
-    const paths = getTaskPaths(taskRoot, taskId);
-    const modifyLog = await readFile(path.join(paths.taskDir, 'artifacts', '修改记录.md'), 'utf-8');
-    const verifyResult = await readFile(path.join(paths.taskDir, 'artifacts', '验证结果.md'), 'utf-8');
-    const artifactIssues = validateCursorArtifacts(modifyLog, verifyResult);
-    if (artifactIssues.length > 0) {
-        throw new Error(`harvest artifact validation failed for cursor task "${taskId}": ${artifactIssues.join('; ')}. ` +
-            'Worktree preserved for manual review.');
-    }
-    const handoff = await checkTaskHandoff(taskRoot, taskId);
-    const taskHandoff = handoff.tasks.find((task) => task.taskId === taskId);
-    const blockingIssues = (taskHandoff?.issues ?? []).filter((issue) => issue.severity === 'error');
-    if (blockingIssues.length > 0) {
-        throw new Error(`harvest handoff check failed for task "${taskId}": ${blockingIssues.map((issue) => issue.message).join('; ')}. ` +
-            'Worktree preserved for manual review.');
-    }
 }
 // ---------------------------------------------------------------------------
 // Helpers

package/dist/records/one-shot-runs.js

@@ -1,6 +1,6 @@
 import { access, readdir, readFile } from 'node:fs/promises';
 import path from 'node:path';
-import { truncateOutput } from '../executors/cursor-executor.js';
+import { truncateOutput } from '../shared/output-truncation.js';
 import { createOneShotActiveRunDir, ensureOneShotRunDirs, finalizeLegacyRunLogToCompleted, transferOneShotRunToCompleted, transferOneShotRunToFailed, writeOneShotActiveLogAtPath, writeOneShotRunMarkdown, writeOneShotRunMeta, } from '../infrastructure/harness/one-shot-run-store.js';
 /** Maximum chars for result summary in the run log. */
 export const RUN_LOG_RESULT_MAX = 4_000;