@tea-agent/loop-agent 0.1.0 → 0.2.0

package/dist/workflows/dag/scheduler.js

@@ -0,0 +1,84 @@
+import { isPauseOnHumanDecisionGate } from "./decision-envelope.js";
+export function isConditionSkippedReason(reason) {
+    return Boolean(reason?.startsWith("condition "));
+}
+function shouldSkipNode(node, task, nodes) {
+    if (!node || node.status !== "PENDING")
+        return false;
+    return task.depends_on.some((depId) => {
+        const dep = nodes[depId];
+        return !dep || dep.status === "ERROR" || dep.status === "SKIPPED";
+    });
+}
+function conditionSkippedByAncestor(task, nodes) {
+    return task.depends_on.some((depId) => isConditionSkippedReason(nodes[depId]?.skippedReason));
+}
+async function mapConcurrent(items, limit, fn) {
+    const executing = new Set();
+    for (const item of items) {
+        const job = fn(item).finally(() => executing.delete(job));
+        executing.add(job);
+        if (executing.size >= limit) {
+            await Promise.race(executing);
+        }
+    }
+    await Promise.all(executing);
+}
+export async function executeDagRanksOnce(input) {
+    let pausedByNodeId;
+    for (const rank of input.ranks) {
+        const runnable = rank.filter((id) => {
+            const node = input.state.nodes[id];
+            const task = input.tasksById.get(id);
+            if (!node || node.status !== "PENDING")
+                return false;
+            return !shouldSkipNode(node, task, input.state.nodes);
+        });
+        const blocked = rank.filter((id) => {
+            const node = input.state.nodes[id];
+            const task = input.tasksById.get(id);
+            return (node?.status === "PENDING" &&
+                shouldSkipNode(node, task, input.state.nodes));
+        });
+        for (const id of blocked) {
+            const node = input.state.nodes[id];
+            node.status = "SKIPPED";
+            node.skippedReason = conditionSkippedByAncestor(input.tasksById.get(id), input.state.nodes)
+                ? "condition ancestor branch not selected"
+                : "upstream dependency failed or was skipped";
+        }
+        if (blocked.length > 0) {
+            await input.persistState();
+        }
+        const pauseGateRunnable = runnable.filter((id) => {
+            const task = input.tasksById.get(id);
+            return isPauseOnHumanDecisionGate(task);
+        });
+        const regularRunnable = runnable.filter((id) => !pauseGateRunnable.includes(id));
+        const rankCursorNodeIds = runnable.filter((id) => input.tasksById.get(id)?.executor === "cursor");
+        const executeNode = input.createExecuteNodeForRank(rankCursorNodeIds);
+        for (const nodeId of pauseGateRunnable) {
+            await input.executeScheduledNode(nodeId, executeNode, (id, pausedAt, pauseReason) => {
+                pausedByNodeId = id;
+                input.state.pausedAt = pausedAt;
+                input.state.pausedByNodeId = id;
+                input.state.pauseReason = pauseReason;
+            });
+            if (pausedByNodeId)
+                break;
+        }
+        if (pausedByNodeId)
+            break;
+        await mapConcurrent(regularRunnable, input.maxConcurrent, async (nodeId) => {
+            await input.executeScheduledNode(nodeId, executeNode, (id, pausedAt, pauseReason) => {
+                pausedByNodeId = id;
+                input.state.pausedAt = pausedAt;
+                input.state.pausedByNodeId = id;
+                input.state.pauseReason = pauseReason;
+            });
+        });
+        if (pausedByNodeId)
+            break;
+    }
+    return pausedByNodeId;
+}

package/dist/workflows/dag/upstream-artifacts.js

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
-import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { MAX_UPSTREAM_CHARS } from "./prompt.js";
+import { writeDagNodeTextArtifact, writeRelocatedDagNodeRecord, } from "../../infrastructure/harness/artifact-store.js";
 import { rewritePathPrefix } from "../../shared/path-refs.js";
+import { MAX_UPSTREAM_CHARS } from "./prompt.js";
 function sha256Text(text) {
     return createHash("sha256").update(text).digest("hex");
 }
@@ -11,10 +11,7 @@ export async function persistLongNodeOutputArtifacts(input) {
     const nodeRecordPath = path.join(input.runDir, `${input.nodeId}.json`);
     const meta = { nodeRecordPath };
     if (input.stdout && input.stdout.length > previewChars) {
-        const nodeDir = path.join(input.runDir, input.nodeId);
-        await mkdir(nodeDir, { recursive: true });
-        const stdoutPath = path.join(nodeDir, "stdout.md");
-        await writeFile(stdoutPath, input.stdout, "utf-8");
+        const stdoutPath = await writeDagNodeTextArtifact(input.runDir, input.nodeId, "stdout.md", input.stdout);
         meta.stdoutArtifactPath = stdoutPath;
         meta.stdoutChars = input.stdout.length;
         meta.stdoutSha256 = sha256Text(input.stdout);
@@ -23,10 +20,7 @@ export async function persistLongNodeOutputArtifacts(input) {
     if (assistant &&
         assistant !== input.stdout &&
         assistant.length > previewChars) {
-        const nodeDir = path.join(input.runDir, input.nodeId);
-        await mkdir(nodeDir, { recursive: true });
-        const assistantPath = path.join(nodeDir, "assistant.md");
-        await writeFile(assistantPath, assistant, "utf-8");
+        const assistantPath = await writeDagNodeTextArtifact(input.runDir, input.nodeId, "assistant.md", assistant);
         meta.assistantArtifactPath = assistantPath;
         meta.assistantChars = assistant.length;
         meta.assistantSha256 = sha256Text(assistant);
@@ -39,25 +33,33 @@ export function relocateNodeArtifactPaths(node, oldRunDir, newRunDir) {
     const rewrite = (value) => {
         if (!value)
             return value;
-        const rewritten = rewritePathPrefix(value, oldRunDir, newRunDir);
-        if (rewritten !== value)
-            return rewritten;
-        if (value === oldRunDir || value.startsWith(`${oldRunDir}${path.sep}`)) {
-            return path.join(newRunDir, path.relative(oldRunDir, value));
-        }
-        return value;
+        return rewritePathPrefix(value, oldRunDir, newRunDir);
     };
     node.stdoutArtifactPath = rewrite(node.stdoutArtifactPath);
     node.assistantArtifactPath = rewrite(node.assistantArtifactPath);
     node.nodeRecordPath = rewrite(node.nodeRecordPath);
 }
+export function relocateConvergenceArtifactPaths(convergence, oldRunDir, newRunDir) {
+    if (oldRunDir === newRunDir)
+        return;
+    const relocate = (value) => value ? rewritePathPrefix(value, oldRunDir, newRunDir) : value;
+    for (const pass of convergence.passHistory) {
+        for (const ref of pass.artifactRefs) {
+            ref.nodeRecordPath = relocate(ref.nodeRecordPath);
+            ref.stdoutArtifactPath = relocate(ref.stdoutArtifactPath);
+            ref.assistantArtifactPath = relocate(ref.assistantArtifactPath);
+            ref.preservedNodeRecordPath = relocate(ref.preservedNodeRecordPath);
+            ref.preservedNodeDir = relocate(ref.preservedNodeDir);
+        }
+    }
+}
 export async function relocateRunArtifactPaths(input) {
     const { runDir, oldRunDir, nodes } = input;
     if (oldRunDir === runDir)
         return;
     for (const [nodeId, node] of Object.entries(nodes)) {
         relocateNodeArtifactPaths(node, oldRunDir, runDir);
-        await writeFile(path.join(runDir, `${nodeId}.json`), `${JSON.stringify(node, null, 2)}\n`, "utf-8");
+        await writeRelocatedDagNodeRecord(runDir, nodeId, node);
     }
 }
 export function formatStdoutPreview(stdout, maxChars) {

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

@@ -0,0 +1,191 @@
+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/actions/dag-action.js

@@ -0,0 +1,130 @@
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { writeLoopDagRecord } from "../../../infrastructure/harness/loop-action-store.js";
+import { getLoopPaths } from "../paths.js";
+import { appendLoopRound } from "../rounds.js";
+import { rewriteLoopContext } from "../context.js";
+import { readLoopRounds } from "../rounds.js";
+import { asRecord, dagFailureCategory, firstReportRun, loopDecisionForDagRun, loopResultForDagRun, relativeRef, stringField, } from "./shared.js";
+let defaultDagCommandRunner;
+export function configureLoopDagDefaultRunner(runner) {
+    defaultDagCommandRunner = runner;
+}
+function resolveDefaultRunner(repoRoot) {
+    if (!defaultDagCommandRunner) {
+        throw new Error("Loop DAG action default runner is not configured");
+    }
+    return (command, args) => defaultDagCommandRunner(repoRoot, command, args);
+}
+export async function runLoopDagAction(repoRoot, taskId, options = {}) {
+    const mode = options.mode ?? "review";
+    const cwd = options.cwd ? path.resolve(repoRoot, options.cwd) : repoRoot;
+    const rounds = await readLoopRounds(repoRoot, taskId);
+    const round = rounds.length + 1;
+    const paths = getLoopPaths(repoRoot, taskId);
+    const dagEvidenceDir = path.join(paths.loopDir, "dag");
+    await mkdir(dagEvidenceDir, { recursive: true });
+    const dagPath = options.dagPath
+        ? path.resolve(repoRoot, options.dagPath)
+        : path.join(dagEvidenceDir, `round-${round}.dag.json`);
+    const runner = options.runner ?? resolveDefaultRunner(repoRoot);
+    let generated = {};
+    if (!options.dagPath) {
+        generated = asRecord(await runner("dag-run-task", [
+            taskId,
+            "--profile",
+            "auto",
+            "--strict-models",
+            "--output",
+            dagPath,
+            "--cwd",
+            cwd,
+        ]), "dag run-task");
+    }
+    await runner("dag-validate", [
+        "--dag",
+        dagPath,
+        "--strict-models",
+        "--strict-governance",
+    ]);
+    let runId = "";
+    let runStatus = "not-run";
+    let runLifecycle = "not-run";
+    let runRef = "";
+    let reportRef = "";
+    let failureCategory = "";
+    let decision = "continue";
+    let result = "dag generated and strict-governance validated";
+    let lesson = "DAG review packet is ready; inspect writeSet, gates, and expected verification before execution.";
+    let completedCriteria = ["dag generated and strict-governance validated"];
+    if (mode === "execute") {
+        const runArgs = ["--dag", dagPath, "--cwd", cwd];
+        if (options.runId)
+            runArgs.push("--run-id", options.runId);
+        if (options.maxConcurrent !== undefined) {
+            runArgs.push("--max-concurrent", String(options.maxConcurrent));
+        }
+        if (options.noCursor)
+            runArgs.push("--no-cursor");
+        const runSummary = asRecord(await runner("run-dag", runArgs), "run-dag");
+        runId = stringField(runSummary, "runId", "run-dag");
+        const report = await runner("dag-report", [
+            "--run-id",
+            runId,
+            "--json",
+            "--lifecycle",
+            "all",
+        ]);
+        const run = firstReportRun(report);
+        runStatus = stringField(run, "status", "dag report run");
+        runLifecycle = stringField(run, "lifecycle", "dag report run");
+        runRef = relativeRef(repoRoot, stringField(run, "runDir", "dag report run"));
+        failureCategory = dagFailureCategory(run);
+        decision = loopDecisionForDagRun(run);
+        result = loopResultForDagRun(run);
+        lesson =
+            decision === "pause"
+                ? "DAG run paused for human approval; use DAG decision commands before resuming."
+                : "DAG run facts recorded; inspect dag report and follow with shell verification or review.";
+        completedCriteria = ["dag round action executed"];
+    }
+    const recordPath = path.join(dagEvidenceDir, `round-${round}.json`);
+    reportRef = relativeRef(repoRoot, recordPath);
+    const record = {
+        schemaVersion: 1,
+        taskId,
+        round,
+        action: "dag",
+        mode,
+        ok: mode === "review" || runStatus === "finished",
+        dagPath: relativeRef(repoRoot, dagPath),
+        strictValidateOk: true,
+        runId,
+        runStatus,
+        runLifecycle,
+        runRef,
+        reportRef,
+        reviewPacket: generated.reviewPacket,
+        failureCategory,
+        expectedNextVerification: decision === "pause"
+            ? "approve or reject paused DAG run, then resume or replan"
+            : "run shell verification or review DAG report before completion",
+        recordedAt: new Date().toISOString(),
+    };
+    await writeLoopDagRecord(repoRoot, taskId, round, record);
+    await appendLoopRound(repoRoot, taskId, {
+        action: "dag",
+        refs: [runRef, record.dagPath, reportRef].filter(Boolean),
+        result,
+        verification: mode === "review"
+            ? "dag generated and validated with --strict-models --strict-governance"
+            : `dag report status=${runStatus}, lifecycle=${runLifecycle}`,
+        lesson,
+        next: record.expectedNextVerification,
+        decision,
+        failureCategory,
+        completedCriteria,
+    });
+    await rewriteLoopContext(repoRoot, taskId);
+    return record;
+}