@tea-agent/loop-agent 0.36.0 → 0.36.1

package/dist/workflows/dag/runner.js

@@ -8,6 +8,7 @@ import { readCandidateRecord } from "../../infrastructure/evaluation/candidate-s
 import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/runtime.js";
 import { assertFrozenBudget, initRunBudgetLedger, preflightBudgetOrBreach, recordFinishedNodeBudget, writeBudgetLedgerArtifacts, } from "./budget-enforcement.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readDagRunSpec, readDagRunState, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
+import { markInterruptNeedsReconcile, mergeAbortSignals, readInterruptRequest, runnerIdentityFromState, settleDagInterrupt, startInterruptWatcher, } from "./interrupt-request.js";
 import { moveToCompletedRunDir, moveToPausedRunDir, prepareRunDir, writeRunSpec, writeRunState, } from "./run-store.js";
 import { evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { createDagNodeExecutor } from "./executor-registry.js";
@@ -450,6 +451,18 @@ async function executeDagCheckpoint(input) {
         void persistState().catch(() => { });
     }, runnerLivenessPolicy.heartbeatIntervalMs);
     heartbeatTimer.unref();
+    await persistState();
+    const interruptController = new AbortController();
+    const expectedRunnerIdentity = runnerIdentityFromState(state);
+    const interruptWatcher = expectedRunnerIdentity
+        ? startInterruptWatcher({
+            runDir,
+            runId: state.runId,
+            expectedRunnerIdentity,
+            controller: interruptController,
+        })
+        : undefined;
+    const abortSignal = mergeAbortSignals(input.abortSignal, interruptController.signal);
     // Graceful terminal persistence: an outer SIGTERM/SIGINT (operator hard
     // timeout, supervision layer, or shell wall-clock) must not leave the run
     // orphaned in RUNNING with a dead heartbeat. Persist a terminal failed
@@ -549,7 +562,7 @@ async function executeDagCheckpoint(input) {
                 meta: { runDir, runId: state.runId, spec },
             }),
             executeScheduledNode: async (nodeId, executeNode, onPause) => {
-                if (input.abortSignal?.aborted)
+                if (abortSignal?.aborted)
                     return;
                 if (isHardBudgetBreached(state.budgetLedger))
                     return;
@@ -616,6 +629,7 @@ async function executeDagCheckpoint(input) {
             // still producing a truthful failure handoff for max-passes/non-retry.
             pausedByNodeId = await executeRanks(terminalCloseoutRanks);
         }
+        interruptWatcher?.stop();
         // Stop heartbeats before terminal archive. A late heartbeat writing
         // state.json under completed/ trips the completed-facts write guard and
         // makes run-dag exit non-zero after every node already finished.
@@ -626,12 +640,24 @@ async function executeDagCheckpoint(input) {
         await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
         if (pausedByNodeId) {
             state.status = "paused";
+            await finalizeRunOwnedInterrupt({
+                runDir,
+                state,
+                paused: true,
+                interruptAborted: interruptController.signal.aborted,
+            });
             await persistState();
             await notifyRunObserver(input.observer, "onRunFinish", state);
             runDir = await moveToPausedRunDir(runDir, pausedRunDir);
         }
         else {
             const { recoveryPending } = await finalizeTerminalRunStatus(state, spec.tasks.length, runDir, cwd);
+            await finalizeRunOwnedInterrupt({
+                runDir,
+                state,
+                paused: false,
+                interruptAborted: interruptController.signal.aborted,
+            });
             await persistState();
             if (recoveryPending) {
                 // Recovery coordinator (phase 3c AC-2/AC-3): materialize the reserved
@@ -664,7 +690,7 @@ async function executeDagCheckpoint(input) {
                         maxConcurrent,
                         executeNode: input.executeNode,
                         observer: input.observer,
-                        abortSignal: input.abortSignal,
+                        abortSignal,
                     });
                 }
             }
@@ -701,10 +727,51 @@ async function executeDagCheckpoint(input) {
     }
     finally {
         clearInterval(heartbeatTimer);
+        interruptWatcher?.stop();
         process.removeListener("SIGTERM", onSigTerm);
         process.removeListener("SIGINT", onSigInt);
     }
 }
+async function finalizeRunOwnedInterrupt(input) {
+    const request = await readInterruptRequest(input.runDir);
+    if (!request)
+        return;
+    if (request.status === "settled" || request.status === "needs-reconcile") {
+        return;
+    }
+    const hasUnconfirmed = Object.values(input.state.nodes).some((node) => node.failureCategory === "termination-unconfirmed");
+    if (hasUnconfirmed || input.paused) {
+        await markInterruptNeedsReconcile({
+            runDir: input.runDir,
+            outcome: hasUnconfirmed
+                ? "termination-unconfirmed"
+                : "paused-before-settle",
+        });
+        return;
+    }
+    if (input.interruptAborted &&
+        request.status === "acknowledged" &&
+        (input.state.status === "failed" ||
+            input.state.status === "partial_failed" ||
+            input.state.failureCategory === "controller-interrupted")) {
+        await settleDagInterrupt({
+            runDir: input.runDir,
+            outcome: "controller-interrupted",
+        });
+        return;
+    }
+    if (request.status === "requested") {
+        await markInterruptNeedsReconcile({
+            runDir: input.runDir,
+            outcome: "runner-did-not-acknowledge",
+        });
+        return;
+    }
+    await markInterruptNeedsReconcile({
+        runDir: input.runDir,
+        outcome: "run-exited-before-interrupt-settled",
+    });
+}
 async function notifyRunObserver(observer, event, state) {
     try {
         await observer?.[event]?.(state);
@@ -859,8 +926,9 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
     // mechanical partial_failed just because prewrite FINISHED while the writer
     // was SKIPPED. Fail closed on retryable-invalid/blocked before aggregation.
     let recoveryPending = false;
+    const skipFrontendRecovery = state.failureCategory === "controller-interrupted";
     const hasFrontendWriter = Object.keys(state.nodes).some((id) => FRONTEND_WRITER_NODE_IDS.includes(id));
-    if (hasFrontendWriter) {
+    if (hasFrontendWriter && !skipFrontendRecovery) {
         const admission = await readFrontendPrewriteResult(runDir);
         if (admission.ok) {
             if (admission.result.classification === "blocked") {
@@ -888,7 +956,7 @@ export async function finalizeTerminalRunStatus(state, taskCount, runDir, cwd) {
     // for frontend-implementation writers with a remaining root continuation, and
     // only when the rollback journal (captured before the provider call) restores
     // cleanly; otherwise the run stays failed with auto-recovery-blocked.
-    if (hasFrontendWriter && !recoveryPending) {
+    if (hasFrontendWriter && !recoveryPending && !skipFrontendRecovery) {
         const writerNodeId = FRONTEND_WRITER_NODE_IDS.find((id) => {
             const node = state.nodes[id];
             return (node &&

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.36.0",
+  "version": "0.36.1",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",

package/skills/loop-agent/references/command-reference.md

@@ -321,6 +321,7 @@ loop-agent dag report [--run-id <run-id>] [--lifecycle active|paused|completed|a
 loop-agent dag reconcile-run --run-id <run-id>            # 只读检查 effectiveStatus 与恢复/收口资格
 loop-agent dag reconcile-run --run-id <run-id> --action supersede --reason "..." # 显式保留证据并标记为任务已另行完成
 loop-agent dag reconcile-run --run-id <run-id> --action abandon --reason "..."   # 显式保留证据并收口为已放弃
+loop-agent dag request-interrupt --run-id <run-id> --request-id <id> --target-operation-id <id> --reason-code <code> --reason <detail> [--json]  # 协作中止：写入 interrupt.json（identity CAS）；需配 --expected-runner-pid/--expected-runner-hostname 校验 runner 身份
 loop-agent dag rerun --run-id <run-id> --from-node <node-id> --plan [--json]  # 从节点重跑资格预检（不执行）
 loop-agent dag rerun --run-id <run-id> --from-node <node-id> --plan-hash <sha256> --request-id <key> --reason "..." [--json]  # 安全子图 continuation
 loop-agent dag rerun-task --run-id <run-id> --reason "..." --request-id <key> [--profile auto] [--task-id <id>] [--json]  # standalone 完整任务重跑