@tea-agent/loop-agent 0.36.1-beta.0 → 0.36.2

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

@@ -216,28 +216,18 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             "</retry_instruction>",
         ].join("\n");
     }
-    if (previousFailureCategory !== "output-too-large") {
+    if (task.outputMode !== "structured-required" ||
+        previousFailureCategory !== "output-too-large") {
         return basePrompt;
     }
-    if (task.outputMode === "structured-required") {
-        return [
-            basePrompt,
-            "",
-            "<retry_instruction>",
-            "Previous attempt exceeded the structured output size limit.",
-            "Return only the compact structured artifact required by this node's output contract.",
-            "Do not include explanatory prose, duplicated upstream context, long evidence excerpts, or additional markdown sections.",
-            "If a fenced JSON object is required, output exactly one fenced json block and nothing else.",
-            "</retry_instruction>",
-        ].join("\n");
-    }
     return [
         basePrompt,
         "",
         "<retry_instruction>",
-        "Previous attempt exceeded the output size limit.",
-        "Return a minimal plan: ordered steps, narrow writeSet boundaries, and verification commands.",
-        "Drop verbatim upstream quotes, long evidence excerpts, and repeated context.",
+        "Previous attempt exceeded the structured output size limit.",
+        "Return only the compact structured artifact required by this node's output contract.",
+        "Do not include explanatory prose, duplicated upstream context, long evidence excerpts, or additional markdown sections.",
+        "If a fenced JSON object is required, output exactly one fenced json block and nothing else.",
         "</retry_instruction>",
     ].join("\n");
 }

package/dist/workflows/dag/report.js

@@ -441,7 +441,6 @@ export async function buildDagRunReportEntry(input) {
                 normalizedFailureCategory,
                 nodeId,
                 executor: node.executor,
-                skippedReason: node.skippedReason,
             });
             const followUp = node.status === "ERROR" || node.status === "SKIPPED"
                 ? recommendFollowUpForFailureCategory(node.failureCategory)
@@ -506,7 +505,6 @@ export async function buildDagRunReportEntry(input) {
             normalizedFailureCategory: normalizeDagFailureCategory(pausedNode.failureCategory, pausedNode.status),
             failureCategory: pausedNode.failureCategory,
             nodeId: input.state.pausedByNodeId,
-            skippedReason: pausedNode.skippedReason,
         }
         : firstActionableNode
             ? {
@@ -515,7 +513,6 @@ export async function buildDagRunReportEntry(input) {
                     normalizeDagFailureCategory(firstActionableNode.failureCategory, firstActionableNode.status),
                 failureCategory: firstActionableNode.failureCategory,
                 nodeId: firstActionableNode.nodeId,
-                skippedReason: input.state.nodes[firstActionableNode.nodeId]?.skippedReason,
             }
             : {
                 status: input.state.status,
@@ -532,9 +529,6 @@ export async function buildDagRunReportEntry(input) {
         rawFailureCategory: runRecoverySource.failureCategory,
         normalizedFailureCategory: runRecoverySource.normalizedFailureCategory,
         nodeId: "nodeId" in runRecoverySource ? runRecoverySource.nodeId : undefined,
-        skippedReason: "skippedReason" in runRecoverySource
-            ? runRecoverySource.skippedReason
-            : undefined,
     });
     const runFollowUp = input.state.status === "failed" ||
         input.state.status === "partial_failed"

package/dist/workflows/dag/retry-policy.js

@@ -118,17 +118,6 @@ export const STRUCTURED_REQUIRED_PI_RETRY_POLICY = {
     ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
     retryCategories: [...STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES],
 };
-/**
- * Planner read-only nodes (standard DAG contract-pi / plan-pi) may retry with
- * a compact-output instruction when the model produced an oversized assistant
- * response. Only `output-too-large` is added on top of the default set;
- * report/review and other read-only roles keep the default set so they do not
- * silently learn new output semantics.
- */
-export const PLANNER_OUTPUT_LIMIT_RETRY_POLICY = {
-    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
-    retryCategories: [...DEFAULT_DAG_RETRY_CATEGORIES, STRUCTURED_OUTPUT_RETRY_CATEGORY],
-};
 /**
  * Default retry for reviewer / recovery nodes that declare outputProtocol.
  * Includes protocol-invalid so missing VERDICT lines are corrected in-node.

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/docs/templates/frontend-task-constraints.md

@@ -18,19 +18,13 @@ TODO
 
 ## Mock 约束（数据型任务）
 
-本段决定生成期 `allowedMockStrategies` 与冻结的 Mock 验证命令。只有当生成期**能证明任务确实包含 Mock 且有确定性验证命令**时，DAG 才会放行 `native` / `browser-intercept` / `request-adapter`；否则自动收敛为 `not-needed`，design review 若按项目规范改选 `native`，会在 prewrite 被 `mock-strategy-outside-allowed` 拦截、`implement` 被跳过。
-
-- **何时必须填**：项目规范（`openspec/project-specs/**`、`ai_workspace/**`、mock 规则或类似 DEC-* 决策）要求/建议 Mock；或需求涉及远端接口且后端未就绪。规范要求 Mock 时，优先 `task.json.frontendMock.policy: "required"`。
-- **命令要探索、不要硬编码**：到项目 `package.json` scripts 里找实际存在的 Mock 相关脚本（如 `mock`、`mock:*`、`dev:mock`，或名字含 mock 的脚本），结合既有 service root 的 handler/fixture/bootstrap 启动方式，确定一条**真实存在、确定、可自终止**（启动→断言→退出 0）的验证命令。常驻 dev server 必须包装成自终止脚本（start→assert→stop），否则 verify shell 会超时 fail-closed。
-- **写入 task.json**：把探索到的命令原样写进 `frontendMock.verifyCommands`（`label` 唯一、`command` 与项目脚本一致）。`label` 会进入冻结命令集，implementation contract 的 `verificationTarget.commandLabel` 必须逐字引用它。
-- **命令来源白名单**：只允许项目 `package.json` 已有脚本、Mock capability seed、或本段声明的 `verifyCommands`；plan/design 阶段不能发明 shell 命令。
-- **Mock/API/schema 规范路径**：TODO
-- **既有 Mock service root、handler/fixture/bootstrap**：TODO
-- **既有 browser/e2e interception 或 request adapter/DI seam**：TODO
-- **production 禁用边界**：TODO
-- **真实请求默认路径与 Mock 显式启用方式**：TODO
-- **`task.json.frontendMock.policy`**：`auto | required | disabled`（规范强制 Mock 用 `required`）
-- **被拦截时怎么修**：`mock-strategy-outside-allowed` / `no authorized Mock verification commands` 是**生成期契约问题，不是 plan 问题**——补 `frontendMock.verifyCommands`（或 `policy: "required"` + 命令）后**重新生成 DAG** 再跑，plan-revision 无法修复它。
+- Mock/API/schema 规范路径：TODO
+- 既有 Mock service root、handler/fixture/bootstrap：TODO
+- 既有 browser/e2e interception 或 request adapter/DI seam：TODO
+- 启动、健康检查和专项验证命令：TODO
+- production 禁用边界：TODO
+- 真实请求默认路径与 Mock 显式启用方式：TODO
+- `task.json.frontendMock.policy`：`auto | required | disabled`
 
 ## allowedPaths
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.36.1-beta.0",
+  "version": "0.36.2",
   "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 完整任务重跑