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

package/dist/workflows/dag/runner.js

@@ -1,18 +1,20 @@
 import { readdir, readFile } from "node:fs/promises";
+import { hostname } from "node:os";
 import path from "node:path";
 import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/runtime.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
 import { moveToCompletedRunDir, moveToPausedRunDir, prepareActiveRunDir, writeRunSpec, writeRunState, } from "./run-store.js";
 import { createDagNodeExecutor } from "./executor-registry.js";
-import { executeDagCursorNode } from "../../executors/dag-cursor-executor.js";
+import { executeDagPiNode } from "../../executors/dag-pi-executor.js";
 import { assertValidDagSpec } from "./validate.js";
 import { normalizeDagPromptSources } from "./prompt-source.js";
 import { relocateConvergenceArtifactPaths, relocateRunArtifactPaths, } from "./upstream-artifacts.js";
+import { createSkillSnapshot, prepareSkillSnapshotForContinuation, writeSkillSnapshot, } from "./skill-snapshot.js";
 import { buildNodePrompt, buildNodePromptWithResolvedSkillInstructions, executeDagNode, } from "./node-execution.js";
 import { runConvergencePassController, shouldEnableDagConvergence, } from "./convergence/controller.js";
 import { executeDagRanksOnce, isConditionSkippedReason, } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
-import { parseDagSpec, } from "./types.js";
+import { parseDagSpec, resolveModelForTask, } from "./types.js";
 import { executeDynamicCondition } from "./dynamic-runtime/condition.js";
 import { executeDynamicLoopUntil } from "./dynamic-runtime/loop-until.js";
 import { executeDynamicMapExpansion } from "./dynamic-runtime/map.js";
@@ -109,6 +111,9 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             status: "PENDING",
             executor: task.executor,
             complexity: task.complexity,
+            ...(resolveModelForTask(task, spec.executorModels)
+                ? { model: resolveModelForTask(task, spec.executorModels) }
+                : {}),
         };
     }
     return {
@@ -117,6 +122,12 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
         runId,
         cwd: opts.cwd,
         startedAt: new Date().toISOString(),
+        runner: {
+            pid: process.pid,
+            hostname: hostname(),
+            startedAt: new Date().toISOString(),
+            heartbeatAt: new Date().toISOString(),
+        },
         status: opts.initOnly || opts.dryRun ? "pending" : "running",
         ranks,
         nodes,
@@ -152,6 +163,19 @@ export async function runDag(spec, opts) {
     const runDir = activeRunDir;
     await prepareActiveRunDir(runDir);
     await writeRunSpec(runDir, spec);
+    // Resolve and snapshot all skill profiles before any node executes.
+    try {
+        const snapshot = await createSkillSnapshot({
+            runId: state.runId,
+            spec,
+            cwd: opts.cwd,
+            mode: "run-start",
+        });
+        state.skillSnapshotRef = await writeSkillSnapshot(runDir, snapshot);
+    }
+    catch (error) {
+        throw new Error(`failed to create run-start skill snapshot: ${error instanceof Error ? error.message : String(error)}`);
+    }
     await writeRunState(runDir, state);
     await notifyRunObserver(opts.observer, "onRunStart", state);
     if (opts.dryRun || opts.initOnly) {
@@ -180,7 +204,6 @@ export async function runDag(spec, opts) {
         });
     }
     finally {
-        await stopCursorWorkerIfRunning();
     }
 }
 export async function resumeDagRun(opts) {
@@ -211,8 +234,34 @@ export async function resumeDagRun(opts) {
     catch {
         throw new Error(`dag run ${opts.runId} is missing human-approval.json for node ${decisionNodeId}`);
     }
+    // Validate or backfill before mutating runner/status for this resume attempt.
+    try {
+        const prepared = await prepareSkillSnapshotForContinuation({
+            runDir,
+            runId: state.runId,
+            spec,
+            state,
+            cwd: state.cwd,
+            ref: state.skillSnapshotRef,
+        });
+        if (prepared.backfilled) {
+            console.warn(`[dag resume] warning: run ${state.runId} has no skill snapshot ref; creating a legacy-resume-backfill that freezes remaining nodes only`);
+            state.skillSnapshotRef = prepared.ref;
+            await writeRunState(runDir, state);
+        }
+    }
+    catch (error) {
+        throw new Error(`skill snapshot validation failed on resume: ${error instanceof Error ? error.message : String(error)}`);
+    }
     const maxConcurrent = Math.max(1, opts.maxConcurrent ?? 4);
     state.status = "running";
+    const resumedAt = new Date().toISOString();
+    state.runner = {
+        pid: process.pid,
+        hostname: hostname(),
+        startedAt: resumedAt,
+        heartbeatAt: resumedAt,
+    };
     const activeRunDir = getDagRunDir(opts.cwd, "active", state.runId);
     const completedRunDir = getDagRunDir(opts.cwd, "completed", state.runId);
     const pausedRunDir = getDagRunDir(opts.cwd, "paused", state.runId);
@@ -232,7 +281,6 @@ export async function resumeDagRun(opts) {
         });
     }
     finally {
-        await stopCursorWorkerIfRunning();
     }
 }
 async function executeDagCheckpoint(input) {
@@ -243,124 +291,136 @@ async function executeDagCheckpoint(input) {
         stateWriteQueue = stateWriteQueue.then(() => writeRunState(runDir, state, options));
         await stateWriteQueue;
     };
-    const tasksById = new Map(spec.tasks.map((task) => [task.id, task]));
-    const baseExecuteNode = input.executeNode ??
-        createDagNodeExecutor({
-            runDir,
-            runId: state.runId,
-            spec,
-        });
-    const executeDynamicNode = async (dynamicInput) => {
-        const { task } = dynamicInput;
-        if (task.dynamicExpansion) {
-            return executeDynamicMapExpansion({
-                ...dynamicInput,
-                expansion: task.dynamicExpansion,
-                executeDynamicNode,
+    const heartbeatTimer = setInterval(() => {
+        if (!state.runner)
+            return;
+        state.runner.heartbeatAt = new Date().toISOString();
+        void persistState().catch(() => { });
+    }, 15_000);
+    heartbeatTimer.unref();
+    try {
+        const tasksById = new Map(spec.tasks.map((task) => [task.id, task]));
+        const baseExecuteNode = input.executeNode ??
+            createDagNodeExecutor({
+                runDir,
+                runId: state.runId,
+                spec,
             });
-        }
-        if (task.dynamicCondition) {
-            return executeDynamicCondition({
+        const executeDynamicNode = async (dynamicInput) => {
+            const { task } = dynamicInput;
+            if (task.dynamicExpansion) {
+                return executeDynamicMapExpansion({
+                    ...dynamicInput,
+                    expansion: task.dynamicExpansion,
+                    executeDynamicNode,
+                });
+            }
+            if (task.dynamicCondition) {
+                return executeDynamicCondition({
+                    task,
+                    condition: task.dynamicCondition,
+                    tasksById: dynamicInput.tasksById,
+                    state: dynamicInput.state,
+                });
+            }
+            if (task.dynamicLoopUntil) {
+                return executeDynamicLoopUntil({
+                    ...dynamicInput,
+                    loop: task.dynamicLoopUntil,
+                    executeDynamicNode,
+                });
+            }
+            return executeDynamicReduction({
                 task,
-                condition: task.dynamicCondition,
-                tasksById: dynamicInput.tasksById,
+                reduction: task.dynamicReduction,
                 state: dynamicInput.state,
+                runDir: dynamicInput.runDir,
             });
-        }
-        if (task.dynamicLoopUntil) {
-            return executeDynamicLoopUntil({
-                ...dynamicInput,
-                loop: task.dynamicLoopUntil,
-                executeDynamicNode,
-            });
-        }
-        return executeDynamicReduction({
-            task,
-            reduction: task.dynamicReduction,
-            state: dynamicInput.state,
-            runDir: dynamicInput.runDir,
-        });
-    };
-    let pausedByNodeId;
-    while (true) {
-        pausedByNodeId = await executeDagRanksOnce({
-            state,
-            ranks,
-            tasksById,
-            maxConcurrent,
-            persistState,
-            createExecuteNodeForRank: (rankCursorNodeIds) => buildRankAwareExecuteNode({
-                baseExecuteNode,
-                customExecuteNode: input.executeNode,
-                rankCursorNodeIds,
-                tasksById,
-                meta: { runDir, runId: state.runId, spec },
-            }),
-            executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
-                nodeId,
-                tasksById,
+        };
+        let pausedByNodeId;
+        while (true) {
+            pausedByNodeId = await executeDagRanksOnce({
                 state,
+                ranks,
+                tasksById,
+                maxConcurrent,
+                persistState,
+                createExecuteNodeForRank: (rankWriterNodeIds) => buildRankAwareExecuteNode({
+                    baseExecuteNode,
+                    customExecuteNode: input.executeNode,
+                    rankWriterNodeIds,
+                    tasksById,
+                    meta: { runDir, runId: state.runId, spec },
+                }),
+                executeScheduledNode: (nodeId, executeNode, onPause) => executeDagNode({
+                    nodeId,
+                    tasksById,
+                    state,
+                    spec,
+                    cwd,
+                    runDir,
+                    executeNode,
+                    executeDynamicNode,
+                    observer: input.observer,
+                    persistState,
+                    onPause,
+                }),
+            });
+            if (pausedByNodeId) {
+                break;
+            }
+            const convergenceDecision = await runConvergencePassController({
                 spec,
-                cwd,
+                state,
+                tasksById,
                 runDir,
-                executeNode,
-                executeDynamicNode,
-                observer: input.observer,
+                cwd,
                 persistState,
-                onPause,
-            }),
-        });
-        if (pausedByNodeId) {
+            });
+            if (convergenceDecision.pausedByNodeId) {
+                pausedByNodeId = convergenceDecision.pausedByNodeId;
+                break;
+            }
+            if (convergenceDecision.retry) {
+                continue;
+            }
             break;
         }
-        const convergenceDecision = await runConvergencePassController({
-            spec,
-            state,
-            tasksById,
+        state.finishedAt = new Date().toISOString();
+        const runDirBeforeTransfer = runDir;
+        if (pausedByNodeId) {
+            state.status = "paused";
+            await persistState();
+            await notifyRunObserver(input.observer, "onRunFinish", state);
+            runDir = await moveToPausedRunDir(runDir, pausedRunDir);
+        }
+        else {
+            finalizeTerminalRunStatus(state, spec.tasks.length);
+            await persistState();
+            await notifyRunObserver(input.observer, "onRunFinish", state);
+            runDir = await moveToCompletedRunDir(runDir, completedRunDir);
+        }
+        await relocateRunArtifactPaths({
             runDir,
-            cwd,
-            persistState,
+            oldRunDir: runDirBeforeTransfer,
+            nodes: state.nodes,
         });
-        if (convergenceDecision.pausedByNodeId) {
-            pausedByNodeId = convergenceDecision.pausedByNodeId;
-            break;
-        }
-        if (convergenceDecision.retry) {
-            continue;
+        if (state.convergence) {
+            relocateConvergenceArtifactPaths(state.convergence, runDirBeforeTransfer, runDir);
         }
-        break;
+        await persistState({ allowCompletedFactsWrite: true });
+        return {
+            title: spec.title,
+            runId: state.runId,
+            status: state.status,
+            ranks,
+            nodes: state.nodes,
+            runDir,
+        };
     }
-    state.finishedAt = new Date().toISOString();
-    const runDirBeforeTransfer = runDir;
-    if (pausedByNodeId) {
-        state.status = "paused";
-        await persistState();
-        await notifyRunObserver(input.observer, "onRunFinish", state);
-        runDir = await moveToPausedRunDir(runDir, pausedRunDir);
+    finally {
+        clearInterval(heartbeatTimer);
     }
-    else {
-        finalizeTerminalRunStatus(state, spec.tasks.length);
-        await persistState();
-        await notifyRunObserver(input.observer, "onRunFinish", state);
-        runDir = await moveToCompletedRunDir(runDir, completedRunDir);
-    }
-    await relocateRunArtifactPaths({
-        runDir,
-        oldRunDir: runDirBeforeTransfer,
-        nodes: state.nodes,
-    });
-    if (state.convergence) {
-        relocateConvergenceArtifactPaths(state.convergence, runDirBeforeTransfer, runDir);
-    }
-    await persistState({ allowCompletedFactsWrite: true });
-    return {
-        title: spec.title,
-        runId: state.runId,
-        status: state.status,
-        ranks,
-        nodes: state.nodes,
-        runDir,
-    };
 }
 async function notifyRunObserver(observer, event, state) {
     try {
@@ -384,16 +444,10 @@ function finalizeTerminalRunStatus(state, taskCount) {
         state.status = "failed";
     }
 }
-async function stopCursorWorkerIfRunning() {
-    const { isCursorWorkerRunning, stopCursorWorker } = await import("../../executors/cursor-worker-client.js");
-    if (isCursorWorkerRunning()) {
-        await stopCursorWorker();
-    }
-}
-function concurrentSiblingWriteSetsForNode(rankCursorNodeIds, nodeId, tasksById) {
-    if (rankCursorNodeIds.length <= 1)
+function concurrentSiblingWriteSetsForNode(rankWriterNodeIds, nodeId, tasksById) {
+    if (rankWriterNodeIds.length <= 1)
         return [];
-    return rankCursorNodeIds
+    return rankWriterNodeIds
         .filter((id) => id !== nodeId)
         .map((id) => tasksById.get(id)?.writeSet ?? [])
         .filter((writeSet) => writeSet.length > 0);
@@ -403,13 +457,16 @@ function buildRankAwareExecuteNode(input) {
         return input.baseExecuteNode;
     }
     return async (nodeInput) => {
-        if (nodeInput.task.executor !== "cursor" || !nodeInput.model) {
+        const isPiWriter = nodeInput.task.executor === "pi" &&
+            nodeInput.task.toolProfile === "write" &&
+            Boolean(nodeInput.model);
+        if (!isPiWriter) {
             return input.baseExecuteNode(nodeInput);
         }
         const siblingWriteSets = nodeInput.task.writePolicy === "exclusive"
-            ? concurrentSiblingWriteSetsForNode(input.rankCursorNodeIds, nodeInput.task.id, input.tasksById)
+            ? concurrentSiblingWriteSetsForNode(input.rankWriterNodeIds, nodeInput.task.id, input.tasksById)
             : [];
-        return executeDagCursorNode({ ...nodeInput, model: nodeInput.model }, {
+        return executeDagPiNode({ ...nodeInput, model: nodeInput.model }, {
             ...input.meta,
             concurrentSiblingWriteSets: siblingWriteSets.length > 0 ? siblingWriteSets : undefined,
             writeGuardAttribution: siblingWriteSets.length > 0 ? "best-effort" : "per-node",

package/dist/workflows/dag/scheduler.js

@@ -55,8 +55,13 @@ export async function executeDagRanksOnce(input) {
             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);
+        const rankWriterNodeIds = runnable.filter((id) => {
+            const task = input.tasksById.get(id);
+            return (task?.executor === "pi" &&
+                task.toolProfile === "write" &&
+                task.writePolicy === "exclusive");
+        });
+        const executeNode = input.createExecuteNodeForRank(rankWriterNodeIds);
         for (const nodeId of pauseGateRunnable) {
             await input.executeScheduledNode(nodeId, executeNode, (id, pausedAt, pauseReason) => {
                 pausedByNodeId = id;