@tea-agent/loop-agent 0.10.0 → 0.11.0

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

@@ -1,87 +0,0 @@
-import path from "node:path";
-import { ensureDagNodeArtifactDir } from "../infrastructure/harness/artifact-store.js";
-import { executeCursorTask } from "./cursor-executor.js";
-import { writeCursorExecutorArtifacts } from "./cursor-executor-artifacts.js";
-import { buildCursorExecutionLogRecord, persistCursorExecutionLog, } from "./cursor-execution-log.js";
-import { readGitStatusPorcelain, runPostRunWriteGuard, } from "./shell-write-guard.js";
-export async function executeDagCursorNode(input, meta) {
-    const started = Date.now();
-    let beforeStatus;
-    try {
-        beforeStatus = await readGitStatusPorcelain(input.cwd);
-    }
-    catch {
-        // Non-git cwd: skip write guard (documented limitation).
-        beforeStatus = undefined;
-    }
-    const artifactDir = await ensureDagNodeArtifactDir(meta.runDir, input.task.id);
-    const result = await executeCursorTask({
-        task: input.prompt,
-        cwd: input.cwd,
-        model: input.model,
-        useWorker: true,
-        artifactDir,
-    });
-    const executionContext = {
-        channel: "dag",
-        cwd: input.cwd,
-        dagRunId: meta.runId,
-        dagNodeId: input.task.id,
-    };
-    await persistCursorExecutionLog(meta.runDir, buildCursorExecutionLogRecord({
-        context: executionContext,
-        model: input.model,
-        prompt: input.prompt,
-        result,
-    }));
-    await writeCursorExecutorArtifacts(path.join(meta.runDir, input.task.id), {
-        prompt: input.prompt,
-        model: input.model,
-        context: executionContext,
-        result,
-    });
-    let writeGuardOk = true;
-    let writeGuardViolations = [];
-    if (beforeStatus !== undefined) {
-        try {
-            const guard = await runPostRunWriteGuard({
-                rootCwd: input.cwd,
-                beforeStatus,
-                writePolicy: input.task.writePolicy,
-                writeSet: input.task.writeSet,
-                allowedPaths: input.task.allowedPaths,
-                forbiddenPaths: input.task.forbiddenPaths,
-                concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
-            });
-            writeGuardOk = guard.ok;
-            writeGuardViolations = guard.violations;
-        }
-        catch {
-            writeGuardOk = false;
-            writeGuardViolations = ["write guard failed: git status unavailable"];
-        }
-    }
-    const ok = result.ok && writeGuardOk;
-    const stderrParts = [result.stderr];
-    if (!writeGuardOk) {
-        stderrParts.push(`write guard failed: ${writeGuardViolations.join(", ")}`);
-        if (meta.writeGuardAttribution === "best-effort") {
-            stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
-        }
-    }
-    const executionResult = {
-        ok,
-        stdout: result.stdout,
-        stderr: stderrParts.filter(Boolean).join("\n\n"),
-        failureCategory: !result.ok
-            ? result.failureCategory
-            : !writeGuardOk
-                ? "write-guard"
-                : result.failureCategory,
-        durationMs: result.durationMs ?? Date.now() - started,
-    };
-    if (result.tokensUsed !== undefined) {
-        executionResult.tokensUsed = result.tokensUsed;
-    }
-    return executionResult;
-}

package/dist/workflows/loop/actions/cursor-fix.js

@@ -1,191 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { DEFAULT_CURSOR_MODEL, DEFAULT_CURSOR_TIMEOUT_MS, executeCursorTask, } from "../../../executors/cursor-executor.js";
-import { pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "../../../executors/shell-write-guard.js";
-import { computeRunDir, persistCursorRunLog } from "../../../records/one-shot-runs.js";
-import { writeLoopCursorFixRecord } from "../../../infrastructure/harness/loop-action-store.js";
-import { loadTaskConfig } from "../../../task/runtime.js";
-import { getLoopPaths } from "../paths.js";
-import { appendLoopRound } from "../rounds.js";
-import { rewriteLoopContext } from "../context.js";
-import { readLoopRounds } from "../rounds.js";
-import { validateLoopCursorFixPolicy } from "../policy/cursor-fix-policy.js";
-import { filterLoopOwnedChangedPaths, hasDagRound, relativeRef } from "./shared.js";
-import { readLatestPiReviewRecord } from "./pi-review.js";
-function extractChangedPaths(result) {
-    const raw = result.details?.changedPaths;
-    if (!Array.isArray(raw))
-        return undefined;
-    return raw.filter((value) => typeof value === "string");
-}
-export async function buildLoopCursorFixPrompt(repoRoot, taskId) {
-    const paths = getLoopPaths(repoRoot, taskId);
-    const [objective, context] = await Promise.all([
-        readFile(paths.objectivePath, "utf-8"),
-        readFile(paths.contextPath, "utf-8"),
-    ]);
-    const config = await loadTaskConfig(repoRoot, taskId);
-    const rounds = await readLoopRounds(repoRoot, taskId);
-    const latestReview = await readLatestPiReviewRecord(repoRoot, taskId);
-    validateLoopCursorFixPolicy({
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        complexity: config.complexity,
-        dagFallbackReason: config.dagFallbackReason ?? "",
-        hasDagRound: hasDagRound(rounds),
-    });
-    return [
-        `Task id: ${taskId}`,
-        "Exact objective: implement the next bounded fix described by the loop context.",
-        "",
-        "Allowed paths:",
-        ...config.allowedPaths.map((entry) => `- ${entry}`),
-        "",
-        "Forbidden paths:",
-        ...(config.forbiddenPaths.length > 0
-            ? config.forbiddenPaths.map((entry) => `- ${entry}`)
-            : ["- none"]),
-        "",
-        "Hard constraints:",
-        "- Preserve unrelated files and user work.",
-        "- Do not touch forbidden paths.",
-        "- Do not mark the loop complete; shell verification or review must follow.",
-        "",
-        "Expected verification:",
-        "- Run the verification commands listed in the task constraints after the fix, or explain why they were not run.",
-        "",
-        "<latest_pi_review>",
-        latestReview
-            ? [
-                `recommendedAction: ${latestReview.structured.recommendedAction}`,
-                `rootCause: ${latestReview.structured.rootCause}`,
-                `fixScope: ${latestReview.structured.fixScope.join(", ")}`,
-                `invariant: ${latestReview.structured.invariant ?? "unknown"}`,
-            ].join("\n")
-            : "No structured Pi review record found.",
-        "</latest_pi_review>",
-        "",
-        "<objective>",
-        objective.trim(),
-        "</objective>",
-        "",
-        "<context>",
-        context.trim(),
-        "</context>",
-    ].join("\n");
-}
-async function defaultCursorFixExecutor(input) {
-    return executeCursorTask({
-        task: input.prompt,
-        cwd: input.cwd,
-        model: input.model,
-        timeoutMs: input.timeoutMs,
-        runDir: input.runDir,
-    });
-}
-export async function runLoopCursorFix(repoRoot, taskId, options = {}) {
-    const config = await loadTaskConfig(repoRoot, taskId);
-    const rounds = await readLoopRounds(repoRoot, taskId);
-    validateLoopCursorFixPolicy({
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        complexity: config.complexity,
-        dagFallbackReason: config.dagFallbackReason ?? "",
-        hasDagRound: hasDagRound(rounds),
-    });
-    const model = options.model ?? config.cursorModel ?? DEFAULT_CURSOR_MODEL;
-    const timeoutMs = options.timeoutMs ?? DEFAULT_CURSOR_TIMEOUT_MS;
-    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
-    const executor = options.executor ?? defaultCursorFixExecutor;
-    const round = rounds.length + 1;
-    const latestReview = await readLatestPiReviewRecord(repoRoot, taskId);
-    const prompt = await buildLoopCursorFixPrompt(repoRoot, taskId);
-    const runDir = (await computeRunDir(repoRoot, `${taskId} cursor-fix r${round}`)) ?? undefined;
-    const beforeStatus = await readGitStatusPorcelain(repoRoot).catch(() => "");
-    const result = await executor({ prompt, cwd, model, timeoutMs, runDir });
-    const explicitChangedPaths = extractChangedPaths(result);
-    let changedPaths = explicitChangedPaths
-        ? filterLoopOwnedChangedPaths(explicitChangedPaths, repoRoot, runDir)
-        : undefined;
-    const guard = explicitChangedPaths
-        ? validateShellWriteGuard({
-            changedPaths: changedPaths ?? [],
-            writePolicy: "exclusive",
-            writeSet: config.allowedPaths,
-            forbiddenPaths: config.forbiddenPaths,
-        })
-        : await (async () => {
-            const afterStatus = await readGitStatusPorcelain(repoRoot).catch(() => "");
-            changedPaths = filterLoopOwnedChangedPaths(pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), snapshotGitStatusPorcelain(afterStatus)), repoRoot, runDir);
-            return validateShellWriteGuard({
-                changedPaths,
-                writePolicy: "exclusive",
-                writeSet: config.allowedPaths,
-                forbiddenPaths: config.forbiddenPaths,
-            });
-        })();
-    const finalResult = guard.ok
-        ? result
-        : {
-            ...result,
-            ok: false,
-            status: "failed",
-            failureCategory: "path-violation",
-            stderr: [
-                result.stderr,
-                `loop cursor-fix path violations: ${guard.violations.join(", ")}`,
-            ]
-                .filter(Boolean)
-                .join("\n"),
-        };
-    const persisted = await persistCursorRunLog(repoRoot, {
-        task: prompt,
-        model,
-        channel: "tool",
-        cwd,
-        result: finalResult,
-        taskId,
-        runDir,
-    });
-    const runRef = persisted?.logPath
-        ? relativeRef(repoRoot, persisted.logPath)
-        : "";
-    const paths = getLoopPaths(repoRoot, taskId);
-    const record = {
-        schemaVersion: 1,
-        taskId,
-        round,
-        action: "cursor-fix",
-        ok: finalResult.ok,
-        model,
-        runRef,
-        allowedPaths: config.allowedPaths,
-        forbiddenPaths: config.forbiddenPaths,
-        changedPaths: changedPaths ?? [],
-        writeGuardViolations: guard.violations,
-        fixScope: latestReview?.structured.fixScope ?? [],
-        rootCause: latestReview?.structured.rootCause ?? "",
-        invariant: latestReview?.structured.invariant ?? "",
-        expectedNextVerification: "loop shell-verify or required task verification commands",
-        recordedAt: new Date().toISOString(),
-    };
-    const recordPath = path.join(paths.reviewDir, `round-${round}-cursor-fix.json`);
-    await writeLoopCursorFixRecord(repoRoot, taskId, round, record);
-    await appendLoopRound(repoRoot, taskId, {
-        action: "cursor-fix",
-        refs: [runRef, relativeRef(repoRoot, recordPath)].filter(Boolean),
-        result: finalResult.ok ? "cursor fix completed" : "cursor fix failed",
-        verification: finalResult.ok
-            ? "cursor-fix completed; shell verification still required"
-            : `cursor-fix failed: ${finalResult.failureCategory}`,
-        lesson: finalResult.ok
-            ? "cursor-fix changed only allowed paths; completion remains gated by verification"
-            : finalResult.stderr || finalResult.stdout || "cursor-fix failed",
-        next: "run shell verification for the cursor fix",
-        decision: "continue",
-        failureCategory: finalResult.ok ? undefined : finalResult.failureCategory,
-        completedCriteria: finalResult.ok ? ["cursor bounded fix action executed"] : [],
-    });
-    await rewriteLoopContext(repoRoot, taskId);
-    return record;
-}

package/dist/workflows/loop/policy/cursor-fix-policy.js

@@ -1,31 +0,0 @@
-import { pathMatchesPattern } from "../../../shared/git-progress.js";
-export function normalizePattern(pattern) {
-    return pattern.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/\*\*$/, "");
-}
-export function patternsOverlap(allowed, forbidden) {
-    const a = normalizePattern(allowed);
-    const f = normalizePattern(forbidden);
-    return (a === f ||
-        a.startsWith(`${f}/`) ||
-        f.startsWith(`${a}/`) ||
-        pathMatchesPattern(a, forbidden) ||
-        pathMatchesPattern(f, allowed));
-}
-export function validateLoopCursorFixPolicy(input) {
-    if (input.allowedPaths.length === 0) {
-        throw new Error("loop cursor-fix requires non-empty task allowedPaths");
-    }
-    for (const allowed of input.allowedPaths) {
-        for (const forbidden of input.forbiddenPaths) {
-            if (patternsOverlap(allowed, forbidden)) {
-                throw new Error(`loop cursor-fix allowed/forbidden paths overlap: ${allowed} vs ${forbidden}`);
-            }
-        }
-    }
-    if (input.complexity !== undefined &&
-        input.complexity !== "small" &&
-        !input.hasDagRound &&
-        !input.dagFallbackReason?.trim()) {
-        throw new Error("loop cursor-fix for medium/large tasks requires a prior loop dag round or task dagFallbackReason");
-    }
-}

package/docs/cursor-executor-usage.md

@@ -1,25 +0,0 @@
-# Cursor Executor 用法
-
-Cursor 用于有界写实现。每个 Cursor 写任务必须显式定义 scope。
-
-## Prompt 必填字段
-
-- task id
-- objective
-- allowed paths
-- forbidden paths
-- constraints
-- expected verification
-- 保留无关变更的指令
-
-## One-Shot Helper
-
-```bash
-loop-agent cursor-prompt \
-  --cwd . \
-  --timeout 1800000 \
-  --model composer-2.5 \
-  "<bounded task prompt>"
-```
-
-Cursor 返回后，主会话必须检查 diff 并运行相关验证命令。