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

package/dist/workflows/dag/lifecycle.js

@@ -1,5 +1,6 @@
 import { access, mkdir, readFile, readdir, rename, } from "node:fs/promises";
 import path from "node:path";
+import { hostname as localHostname } from "node:os";
 import { writeJsonAtomic, } from "../../infrastructure/harness/atomic-write.js";
 import { parseDagSpec } from "./types.js";
 import { normalizeDagFailureCategory, } from "./failure-category.js";
@@ -161,10 +162,98 @@ export async function humanApprovalArtifactExists(runDir, nodeId) {
         return false;
     }
 }
+export function assessDagRunLiveness(input) {
+    if (input.state.status !== "running")
+        return { status: "unknown" };
+    const runner = input.state.runner;
+    if (!runner)
+        return { status: "unknown" };
+    if (runner.hostname !== (input.hostname ?? localHostname()))
+        return { status: "unknown-host" };
+    const isAlive = input.isProcessAlive ?? ((pid) => {
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    });
+    if (!isAlive(runner.pid))
+        return { status: "orphaned", runnerAlive: false };
+    const heartbeatMs = Date.parse(runner.heartbeatAt);
+    const nowMs = (input.now ?? new Date()).getTime();
+    if (!Number.isNaN(heartbeatMs) && nowMs - heartbeatMs > (input.staleThresholdMs ?? 90_000)) {
+        return { status: "stale", runnerAlive: true };
+    }
+    const activeNode = Object.values(input.state.nodes).find((node) => node.status === "RUNNING");
+    const nodeActivityMs = Date.parse(activeNode?.lastActivityAt ?? activeNode?.startedAt ?? "");
+    if (!Number.isNaN(nodeActivityMs) && nowMs - nodeActivityMs > (input.nodeQuietThresholdMs ?? 300_000)) {
+        return { status: "node-quiet", runnerAlive: true };
+    }
+    return { status: "active", runnerAlive: true };
+}
+export function deriveDagRunEffectiveStatus(input) {
+    if (input.state.status === "superseded")
+        return "superseded";
+    if (input.state.status === "abandoned")
+        return "abandoned";
+    if (input.lifecycle === "paused")
+        return "paused";
+    if (input.lifecycle === "completed") {
+        return input.state.status === "finished" ? "finished" : "failed";
+    }
+    if (input.state.status === "pending")
+        return "pending";
+    if (isTerminalDagRunStatus(input.state.status)) {
+        return input.state.status === "finished" ? "finished" : "failed";
+    }
+    if (input.liveness === "orphaned" || input.liveness === "stale")
+        return "interrupted";
+    if (input.liveness === "node-quiet")
+        return "running-quiet";
+    if (input.liveness === "unknown-host")
+        return "remote-unknown";
+    if (input.liveness === "active")
+        return "running";
+    return "unknown";
+}
+export function assessDagRunRecoveryEligibility(input) {
+    const reasons = [];
+    const canResume = input.lifecycle === "active"
+        && input.state.status === "running"
+        && Boolean(input.state.humanDecisionNodeId)
+        && Boolean(input.hasHumanApproval);
+    if (!canResume)
+        reasons.push("standard-resume-preconditions-not-met");
+    let canReconcile = true;
+    if (input.lifecycle === "completed" || isTerminalDagRunStatus(input.state.status)) {
+        canReconcile = false;
+        reasons.push("run-already-terminal");
+    }
+    if (input.lifecycle === "active"
+        && ["active", "node-quiet", "stale", "unknown-host", "unknown"].includes(input.liveness)) {
+        canReconcile = false;
+        reasons.push("runner-not-proven-dead-or-stopped");
+    }
+    if (input.lifecycle === "paused" && input.state.status !== "paused") {
+        reasons.push("lifecycle-status-mismatch");
+    }
+    if (!input.state.runner)
+        reasons.push("missing-runner-metadata");
+    return {
+        canResume,
+        canReconcile,
+        allowedActions: canReconcile ? ["supersede", "abandon"] : [],
+        reasons: [...new Set(reasons)],
+    };
+}
 export const TERMINAL_RUN_STATUSES = new Set([
     "finished",
     "failed",
     "partial_failed",
+    "superseded",
+    "abandoned",
 ]);
 export function isTerminalDagRunStatus(status) {
     return TERMINAL_RUN_STATUSES.has(status);
@@ -248,6 +337,31 @@ export async function detectDagRunHealthIssues(input) {
             advisoryAction: "Use dag doctor; approve/reject/resume may fail until lifecycle facts are consistent.",
         });
     }
+    const liveness = assessDagRunLiveness({ state });
+    if (liveness.status === "orphaned") {
+        issues.push({
+            code: "runner-process-missing",
+            severity: "error",
+            message: `Runner PID ${state.runner?.pid} is not alive on host ${state.runner?.hostname}`,
+            advisoryAction: "Treat this run as orphaned; inspect artifacts and start a new run instead of resuming it.",
+        });
+    }
+    else if (liveness.status === "stale") {
+        issues.push({
+            code: "runner-heartbeat-stale",
+            severity: "warning",
+            message: `Runner heartbeat is stale since ${state.runner?.heartbeatAt}`,
+            advisoryAction: "Inspect node artifacts and process liveness before stopping or retrying.",
+        });
+    }
+    else if (liveness.status === "node-quiet") {
+        issues.push({
+            code: "node-activity-quiet",
+            severity: "warning",
+            message: "Runner heartbeat is fresh but the current RUNNING node has produced no state activity for more than 5 minutes",
+            advisoryAction: "Inspect the node session events and executor logs before deciding whether to wait or abort.",
+        });
+    }
     if (lifecycle === "active" &&
         state.status === "running" &&
         state.humanDecisionNodeId) {
@@ -340,6 +454,14 @@ export async function buildDagOperatorRunSummary(entry) {
             pendingNodes: [],
             finishedNodes: [],
             healthIssues,
+            effectiveStatus: entry.lifecycle === "paused" ? "paused" : "unknown",
+            stateConsistent: false,
+            recoveryEligibility: {
+                canResume: false,
+                canReconcile: false,
+                allowedActions: [],
+                reasons: ["missing-state-json"],
+            },
             nextRecommendedAction: deriveOperatorNextAction({
                 lifecycle: entry.lifecycle,
                 state: {
@@ -363,9 +485,22 @@ export async function buildDagOperatorRunSummary(entry) {
         runDir: entry.runDir,
         state,
     });
+    const liveness = assessDagRunLiveness({ state });
     const hasHumanApproval = state.humanDecisionNodeId
         ? await humanApprovalArtifactExists(entry.runDir, state.humanDecisionNodeId)
         : false;
+    const effectiveStatus = deriveDagRunEffectiveStatus({
+        lifecycle: entry.lifecycle,
+        state,
+        liveness: liveness.status,
+    });
+    const stateConsistent = !healthIssues.some((issue) => ["lifecycle-status-mismatch", "non-terminal-in-completed"].includes(issue.code));
+    const recoveryEligibility = assessDagRunRecoveryEligibility({
+        lifecycle: entry.lifecycle,
+        state,
+        liveness: liveness.status,
+        hasHumanApproval,
+    });
     return {
         runId: state.runId,
         title: state.title,
@@ -380,6 +515,10 @@ export async function buildDagOperatorRunSummary(entry) {
         pendingNodes: listPendingNodeIds(state),
         finishedNodes: listFinishedNodeIds(state),
         healthIssues,
+        liveness: liveness.status,
+        effectiveStatus,
+        stateConsistent,
+        recoveryEligibility,
         nextRecommendedAction: deriveOperatorNextAction({
             lifecycle: entry.lifecycle,
             state,
@@ -552,6 +691,13 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         "",
         `- run id: ${runId}`,
         `- lifecycle: ${located.lifecycle}`,
+        `- effective status: ${summary.effectiveStatus}`,
+        `- raw status: ${summary.status}`,
+        `- state consistent: ${summary.stateConsistent ? "yes" : "no"}`,
+        `- liveness: ${summary.liveness ?? "unknown"}`,
+        `- can resume: ${summary.recoveryEligibility.canResume ? "yes" : "no"}`,
+        `- can reconcile: ${summary.recoveryEligibility.canReconcile ? "yes" : "no"}`,
+        `- health issues: ${summary.healthIssues.length > 0 ? summary.healthIssues.map((issue) => `${issue.code}: ${issue.message}`).join("; ") : "none"}`,
         `- failed node: ${failure.nodeId ?? "-"}`,
         `- raw failure: ${rawFailureCategory ?? "-"}`,
         `- normalized category: ${normalizedCategory}`,

package/dist/workflows/dag/node-execution.js

@@ -3,6 +3,7 @@ import { recordDecisionEnvelopeForNode, shouldPauseOnHumanEscalation, writeHuman
 import { writeNodeRecord, writeNodeSkillArtifacts } from "./run-store.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
+import { assertSkillSnapshotCoversSpec, buildNodePromptFromSnapshot, isDagSkillSnapshotIntegrityError, readSkillSnapshot, } from "./skill-snapshot.js";
 import { resolveDagSkillInstructions, skillInstructionMetadata, } from "./skill-instructions.js";
 import { resolveDagNodeSkills } from "./skills.js";
 import { parseRepairArtifactFromText, validateRepairArtifactScope, } from "./repair-artifact.js";
@@ -17,7 +18,7 @@ export function buildNodePrompt(spec, task, upstream) {
 }
 export async function buildNodePromptWithResolvedSkillInstructions(spec, task, upstream, cwd) {
     const skillNames = resolveDagNodeSkills(spec, task);
-    const resolvedSkillInstructions = task.executor === "cursor" || task.executor === "pi"
+    const resolvedSkillInstructions = task.executor === "pi"
         ? await resolveDagSkillInstructions(skillNames, {
             cwd,
             includeLearnedPatterns: task.role === "implementer",
@@ -55,7 +56,7 @@ function assertRepairArtifactVerdictMatchesSupervisor(input) {
 }
 function findRepairTaskForGate(input) {
     return Array.from(input.tasksById.values()).find((candidate) => candidate.depends_on.includes(input.gateTask.id) &&
-        candidate.id === "repair-cursor");
+        candidate.id === "repair-pi");
 }
 function parseSupervisorRepairArtifact(node) {
     const text = `${node?.assistantText ?? ""}\n${node?.stdout ?? ""}`;
@@ -111,17 +112,54 @@ export async function executeDagNode(input) {
     const { nodeId, tasksById, state, spec, cwd, runDir, executeNode } = input;
     const task = tasksById.get(nodeId);
     const node = state.nodes[nodeId];
+    const failSkillSnapshot = async (error) => {
+        const failedAt = new Date().toISOString();
+        node.startedAt ??= failedAt;
+        node.status = "ERROR";
+        node.stderr = error instanceof Error ? error.message : String(error);
+        node.failureCategory = "skill-snapshot-integrity";
+        node.finishedAt = failedAt;
+        node.lastActivityAt = node.finishedAt;
+        node.durationMs = Math.max(0, Date.now() - new Date(node.startedAt).getTime());
+        state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
+        await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);
+        await input.persistState();
+        await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
+    };
+    const isDynamicTask = Boolean(task.dynamicExpansion
+        || task.dynamicReduction
+        || task.dynamicCondition
+        || task.dynamicLoopUntil);
+    let snapshotPrompt;
+    if (state.skillSnapshotRef) {
+        try {
+            const skillSnapshot = await readSkillSnapshot(runDir, state.skillSnapshotRef, {
+                expectedRunId: state.runId,
+            });
+            assertSkillSnapshotCoversSpec(skillSnapshot, spec, state);
+            if (!isDynamicTask) {
+                snapshotPrompt = buildNodePromptFromSnapshot({
+                    spec,
+                    task,
+                    upstream: state.nodes,
+                    snapshot: skillSnapshot,
+                });
+            }
+        }
+        catch (error) {
+            await failSkillSnapshot(error);
+            return;
+        }
+    }
     node.status = "RUNNING";
     node.startedAt = new Date().toISOString();
+    node.lastActivityAt = node.startedAt;
     if (task.shell?.verifyEvidence) {
         node.verifyEvidence = task.shell.verifyEvidence;
     }
     await input.persistState();
     await notifyNodeObserver(input.observer, "onNodeStart", nodeId, state);
-    if (task.dynamicExpansion ||
-        task.dynamicReduction ||
-        task.dynamicCondition ||
-        task.dynamicLoopUntil) {
+    if (isDynamicTask) {
         const started = Date.now();
         try {
             const result = await input.executeDynamicNode({
@@ -140,6 +178,7 @@ export async function executeDagNode(input) {
             node.stderr = result.stderr;
             node.failureCategory = result.failureCategory;
             node.finishedAt = new Date().toISOString();
+            node.lastActivityAt = node.finishedAt;
             node.status = result.ok ? "FINISHED" : "ERROR";
         }
         catch (error) {
@@ -163,7 +202,24 @@ export async function executeDagNode(input) {
         await notifyNodeObserver(input.observer, "onNodeFinish", nodeId, state);
         return;
     }
-    const { prompt, resolvedSkills } = await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd);
+    let prompt;
+    let resolvedSkills;
+    try {
+        if (snapshotPrompt) {
+            prompt = snapshotPrompt.prompt;
+            resolvedSkills = snapshotPrompt.resolvedSkills;
+        }
+        else {
+            ({ prompt, resolvedSkills } =
+                await buildNodePromptWithResolvedSkillInstructions(spec, task, state.nodes, cwd));
+        }
+    }
+    catch (error) {
+        if (!isDagSkillSnapshotIntegrityError(error))
+            throw error;
+        await failSkillSnapshot(error);
+        return;
+    }
     node.resolvedSkills = resolvedSkills;
     await writeNodeSkillArtifacts(runDir, nodeId, resolvedSkills);
     const model = resolveModelForTask(task, spec.executorModels);
@@ -202,6 +258,7 @@ export async function executeDagNode(input) {
             await notifyNodeObserver(input.observer, "onNodeOutput", nodeId, state, outputChunk);
         }
         node.finishedAt = new Date().toISOString();
+        node.lastActivityAt = node.finishedAt;
         node.status = result.ok ? "FINISHED" : "ERROR";
         if (result.ok) {
             const decisionRecord = await recordDecisionEnvelopeForNode({

package/dist/workflows/dag/prompt.js

@@ -1,3 +1,4 @@
+import { DEFAULT_DAG_OUTPUT_LANGUAGE, } from "./types.js";
 import { formatStdoutPreview, formatUpstreamArtifactPointerMap, } from "./upstream-artifacts.js";
 export const MAX_UPSTREAM_CHARS = 2_000;
 /** Shared bullets for DAG authoring templates, docs, and planner-node envelopes. */
@@ -41,6 +42,20 @@ function formatResolvedSkillInstructions(instructions) {
         .map((instruction) => instruction.promptText)
         .join("\n\n---\n\n");
 }
+export function formatOutputLanguageBlock(language = DEFAULT_DAG_OUTPUT_LANGUAGE) {
+    if (language === "en") {
+        return [
+            "Write prose, analysis, reports, summaries, and documentation in English.",
+            "Keep code, commands, paths, identifiers, JSON keys, exact protocol tokens, verdict lines, and output-contract literals unchanged.",
+            "If the node task explicitly requires another language, follow the explicit task requirement.",
+        ].join("\n");
+    }
+    return [
+        "使用简体中文撰写说明、分析、报告、总结和文档正文。",
+        "代码、命令、路径、标识符、JSON 字段、精确协议 token、VERDICT 行以及 output contract 中要求的字面量保持原样，不要翻译。",
+        "如果当前节点任务明确要求其他语言，以节点的明确要求为准。",
+    ].join("\n");
+}
 export function buildUpstreamContext(task, upstream, maxChars = MAX_UPSTREAM_CHARS) {
     const sections = [];
     for (const depId of task.depends_on) {
@@ -91,6 +106,7 @@ export function buildDagNodePromptEnvelope(input) {
         `<dag_objective>\n${objective}\n</dag_objective>`,
         `<success_criteria>\n${successCriteria}\n</success_criteria>`,
         `<global_constraints>\n${globalConstraints}\n</global_constraints>`,
+        `<output_language>\n${formatOutputLanguageBlock(spec.outputLanguage)}\n</output_language>`,
         [
             "<node_contract>",
             `Role: ${role}`,

package/dist/workflows/dag/report.js

@@ -20,6 +20,8 @@ const dagRunStatusSchema = z.enum([
     "partial_failed",
     "failed",
     "paused",
+    "superseded",
+    "abandoned",
 ]);
 const dagRecoveryActionSchema = z.enum(DAG_RECOVERY_ACTIONS);
 const dagProductLineFailureCategorySchema = z.enum(dagProductLineFailureCategoryValues);