@tea-agent/loop-agent 0.20.1 → 0.21.0

package/dist/workflows/dag/init-hybrid.js

@@ -2801,12 +2801,18 @@ function buildBackendTestSemanticReviewNode(sources, options = {}) {
 }
 function collectBackendTestShellEnvAllowlist(sources) {
     const names = new Set();
-    for (const verify of sources.taskConfig.verifyCommands) {
+    const collectAssignments = (text) => {
         const assignmentPattern = /(?:^|[\s;&|])([A-Z_][A-Z0-9_]*)\s*=/g;
-        for (const match of verify.command.matchAll(assignmentPattern)) {
+        for (const match of text.matchAll(assignmentPattern)) {
             if (match[1])
                 names.add(match[1]);
         }
+    };
+    for (const constraint of sources.taskConfig.hardConstraints) {
+        collectAssignments(constraint);
+    }
+    for (const verify of sources.taskConfig.verifyCommands) {
+        collectAssignments(verify.command);
     }
     return [...names].sort();
 }
@@ -3051,7 +3057,7 @@ async function buildBackendTestHybridDag(sources) {
             "Read the upstream environment report. Generate a Markdown-first backend test strategy and cases under testcase/md/**.",
             "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
             "Create testcase/md/README.md as the concise entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in README.",
-            "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>` and uses these Chinese headings: `### 测试目的`, `### 验收标准`, `### 需求依据`, `### 前置条件`, optional `### 测试数据`, `### 操作步骤`, `### 预期结果`, and `### 自动化映射`. API metadata may use a compact table under the case heading. The deterministic validator also accepts legacy English headings, but new output should use this Chinese presentation.",
+            "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. The only sections required by the deterministic validator are `### 前置条件`, `### 操作步骤`, and `### 预期结果` (legacy English aliases remain accepted). Add `测试目的`, `验收标准`, `需求依据`, `测试数据`, and `自动化映射` when useful for human readability; every automatable case should explicitly name its target pytest script under `自动化映射` so traceability can scan only that script.",
             "Place steps and their expected results in a compact readable table when that improves clarity; otherwise keep numbered executable steps and numbered/bulleted independently assertable results. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
             "In `自动化映射`, record the planned script path and pytest function name when known. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
@@ -3065,7 +3071,7 @@ async function buildBackendTestHybridDag(sources) {
         writeSet: ["testcase/md/**"], allowedPaths: ["testcase/md/**"], forbiddenPaths: forbidden,
         outputContract: "Review source fidelity and directly revise only testcase/md/**; return concise Markdown, never JSON.",
         subtask_prompt: [
-            "Independently review generated Markdown cases against each case 需求依据 and environment evidence. Treat the files as human-facing test documentation: require a clear Chinese name and scenario/purpose, compact metadata, readable steps/results, and a concise automation mapping while preserving exact machine IDs and technical literals.",
+            "Independently review generated Markdown cases against the task requirements and environment evidence. Treat the files as human-facing test documentation: require clear preconditions, executable steps and assertable expected results; improve names, purpose, metadata and automation mapping where useful while preserving exact machine IDs and technical literals.",
             "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, and missing script/function mapping where it can be derived.",
             "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, fix mappings/expectations, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations exact. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "Read only precise referenced source paths plus requirement sections needed for uncovered ACs. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
@@ -3073,7 +3079,7 @@ async function buildBackendTestHybridDag(sources) {
             "For each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
         ].join("\n\n"),
     };
-    const validateCases = shellNode("validate-backend-md-cases-shell", [reviewCases.id], "markdown-cases", "Fail closed on missing/duplicate IDs, sections, AC coverage, source references, executable steps, assertable results, placeholders or secret-shaped content.", "Run-owned reports/backend-md-case-validation.md proving final Markdown quality and safety.");
+    const validateCases = shellNode("validate-backend-md-cases-shell", [reviewCases.id], "markdown-cases", "Record advisory findings for missing/duplicate IDs, missing core sections (preconditions, steps, expected results), AC coverage, executable steps, assertable results or placeholders. Do not validate source-reference existence. Keep quality findings advisory, but fail closed after writing the report when secret-shaped values are detected so downstream pytest/report nodes cannot consume them.", "Run-owned reports/backend-md-case-validation.md with PASS/FAIL advisory findings; downstream execution continues.");
     const generatePytest = {
         id: "generate-backend-pytest-pi", depends_on: [validateCases.id], role: "implementer",
         executor: "pi", toolProfile: "write", complexity: "HIGH", writePolicy: "exclusive",
@@ -3081,20 +3087,23 @@ async function buildBackendTestHybridDag(sources) {
         allowedPaths: Array.from(new Set([...ro, "testcase/**"])), forbiddenPaths: forbidden,
         outputContract: "Convert every final automatable Markdown case into pytest assets whose actual test function region contains the exact Case ID, preferably in the function name or docstring; no JSON and no pytest execution.",
         subtask_prompt: [
-            "Convert validated testcase/md/** to pytest using upstream environment and validation evidence plus only bounded pytest config/conftest.",
-            "Ensure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件/测试数据/自动化映射 or their legacy English aliases.",
+            "Convert testcase/md/** to pytest using upstream environment and advisory validation evidence plus only bounded pytest config/conftest. A FAIL advisory report does not authorize inventing missing behavior; use the final Markdown facts that are present.",
+            "Ensure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.",
+            "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.",
+            "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
+            "Before logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.",
             "Do not read source/**, add cases, reassign ACs, modify conftest/config/production code, use skip/xfail, swallow assertions, execute pytest, or emit JSON. For best-effort cleanup, catch only the narrow transport exception actually raised by the selected HTTP client (for example `requests.RequestException` or `urllib.error.URLError`); never use bare `except`, `Exception`, or `BaseException` with `pass`.",
         ].join("\n\n"),
     };
-    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Fail closed only when a real Markdown case heading has no associated pytest test function or class method. Accept exact Case IDs in the function/method name or its decorator/body/docstring region; report multiple mappings and extra automation Case IDs without blocking. Continue to reject skip/xfail or swallowed exceptions.", "Run-owned reports/backend-test-traceability.md proving every real Markdown Case ID is covered by at least one pytest test function.");
+    const traceability = shellNode("backend-test-traceability-gate-shell", [generatePytest.id], "markdown-traceability", "Record advisory findings when a real Markdown case heading has no associated pytest test function or class method in the script explicitly mapped by that Markdown case, or when a mapped HTTP test script lacks request parameters logging, response result logging, recursive redaction or bounded truncation evidence. Accept exact Case IDs in the function/method name or its decorator/body/docstring region. Do not scan unrelated test_*.py files and do not block pytest execution.", "Run-owned reports/backend-test-traceability.md with PASS/FAIL advisory findings for Markdown Case to mapped pytest script/symbol coverage.");
     const pytestCommand = [
         'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
-        'PYTHONUTF8=1 PYTHONIOENCODING=utf-8 PYTHONDONTWRITEBYTECODE=1 python -m pytest testcase/ -v -p no:cacheprovider --junitxml="${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml"',
-        "STATUS=$?", 'printf "%s" "${STATUS}" > "${HARNESS_DAG_RUN_DIR}/reports/backend-test-pytest-exit.txt"',
-        'if { [ "${STATUS}" -eq 0 ] || [ "${STATUS}" -eq 1 ]; } && [ -s "${HARNESS_DAG_RUN_DIR}/reports/backend-test.junit.xml" ]; then exit 0; fi',
-        'exit "${STATUS}"',
+        'echo "pytest targets are resolved at runtime from final Markdown 自动化映射"',
     ].join("; ");
-    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Execute pytest exactly once. Validate JUnit, render the primary self-contained Chinese HTML report from the same JUnit plus final Markdown case metadata without rerun, list every case with name/scenario/script/function/result/duration, and preserve failure summaries plus expandable technical details as facts.", "One pytest execution producing valid JUnit, self-contained HTML and reports/backend-test-facts.md; exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Validate JUnit, then render the primary self-contained Chinese HTML report from the same JUnit plus final Markdown case metadata without rerun. Keep 测试结论, quality status, failure overview, and a polished per-case result card with concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over Markdown-mapped scripts producing valid JUnit with per-case captured output, self-contained HTML and reports/backend-test-facts.md; exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
+    if (execute.shell) {
+        execute.shell.envAllowlist = collectBackendTestShellEnvAllowlist(sources);
+    }
     const canWriteReport = taskAllowsBackendTestReportWrite(sources);
     const report = {
         id: "backend-test-report-and-l5-pi", depends_on: [execute.id], role: "closeout", executor: "pi", complexity: "MED",
@@ -3104,7 +3113,9 @@ async function buildBackendTestHybridDag(sources) {
         forbiddenPaths: forbidden,
         outputContract: canWriteReport ? "Final Markdown report and L-5 conclusion under docs/test-reports/**; no JSON." : "Final Markdown report and L-5 conclusion in assistant output; no JSON or writes.",
         subtask_prompt: [
-            "Generate the final Markdown report from upstream facts and run-owned environment, case-validation, traceability, JUnit and HTML evidence. Do not emit JSON.",
+            "Generate the final Markdown report from upstream facts and run-owned environment, advisory case-validation, advisory traceability, JUnit and HTML evidence. Do not emit JSON.",
+            "Use this exact human-facing section order: 测试结论 → 执行概览 → 质量校验 → 失败分析 → 风险与建议 → 证据与 L-5. Put the decision and key numbers first, use compact tables/bullets, and keep headings concise. Do not paste entire upstream reports, duplicate per-case tables already present in facts, or repeat the same evidence in multiple sections; link to paths/hashes and quote only the findings needed for the conclusion.",
+            "Always state the exact PASS/FAIL status and findings from nodes 4 and 6. Their FAIL status does not block pytest, but it must remain visible as a quality/traceability risk and must never be rewritten as PASS.",
             "Include environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage/stability availability, and L-5 READY/NOT READY.",
             "Never override Shell/JUnit facts. One run cannot prove FlakyTest. Missing coverage/stability is Unavailable. L-5 requires pass=100%, AC=100%, automation>=90%, stability>=95% n>=5, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.",
             canWriteReport ? "Write only under docs/test-reports/**." : "Keep the full report in assistant output.",
@@ -3118,9 +3129,9 @@ async function buildBackendTestHybridDag(sources) {
         successCriteria: extractSuccessCriteria(sources.requirementMarkdown, sources.taskId),
         globalConstraints: [
             ...taskConfig.hardConstraints, ...STANDARD_GLOBAL_CONSTRAINTS,
-            "backend-test-dag uses exactly 8 real top-level tasks and executes pytest exactly once.",
+            "backend-test-dag uses exactly 8 real top-level tasks and executes pytest exactly once over only the safe scripts explicitly mapped by final Markdown cases.",
             "Model nodes produce Markdown and pytest assets, never backend-test business JSON envelopes.",
-            "Environment, Markdown validation, traceability, JUnit, HTML and execution facts are deterministic fail-closed evidence.",
+            "Environment, advisory Markdown validation, advisory traceability, JUnit, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8.",
             "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
             "Functional case IDs use BE-<MODULE>-<NNN>; production code/config, skip/xfail, repair and rerun are forbidden.",
         ],

package/dist/workflows/dag/lifecycle.js

@@ -187,10 +187,38 @@ export function assessDagRunLiveness(input) {
         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)) {
+    if (!activeNode)
+        return { status: "active", runnerAlive: true };
+    // Prefer persisted adaptive projection when present.
+    if (activeNode.livenessStatus === "needs-attention") {
+        return { status: "needs-attention", runnerAlive: true };
+    }
+    if (activeNode.livenessStatus === "suspected-stall"
+        || activeNode.livenessStatus === "probing") {
+        return { status: "suspected-stall", runnerAlive: true };
+    }
+    if (activeNode.livenessStatus === "quiet") {
         return { status: "node-quiet", runnerAlive: true };
     }
+    // Fall back to meaningful progress clocks (never use runner lease as progress).
+    const meaningfulAt = activeNode.lastMeaningfulProgressAt
+        ?? activeNode.lastProviderActivityAt
+        ?? activeNode.lastToolActivityAt
+        ?? activeNode.lastOutputActivityAt
+        ?? activeNode.lastActivityAt
+        ?? activeNode.startedAt;
+    const nodeActivityMs = Date.parse(meaningfulAt ?? "");
+    if (!Number.isNaN(nodeActivityMs)) {
+        const idleMs = nowMs - nodeActivityMs;
+        const stallMs = input.nodeStallThresholdMs ?? 900_000;
+        const quietMs = input.nodeQuietThresholdMs ?? 300_000;
+        if (idleMs > stallMs) {
+            return { status: "suspected-stall", runnerAlive: true };
+        }
+        if (idleMs > quietMs) {
+            return { status: "node-quiet", runnerAlive: true };
+        }
+    }
     return { status: "active", runnerAlive: true };
 }
 export function deriveDagRunEffectiveStatus(input) {
@@ -210,6 +238,10 @@ export function deriveDagRunEffectiveStatus(input) {
     }
     if (input.liveness === "orphaned" || input.liveness === "stale")
         return "interrupted";
+    if (input.liveness === "needs-attention")
+        return "needs-attention";
+    if (input.liveness === "suspected-stall")
+        return "running-suspected-stall";
     if (input.liveness === "node-quiet")
         return "running-quiet";
     if (input.liveness === "unknown-host")
@@ -232,7 +264,15 @@ export function assessDagRunRecoveryEligibility(input) {
         reasons.push("run-already-terminal");
     }
     if (input.lifecycle === "active"
-        && ["active", "node-quiet", "stale", "unknown-host", "unknown"].includes(input.liveness)) {
+        && [
+            "active",
+            "node-quiet",
+            "suspected-stall",
+            "needs-attention",
+            "stale",
+            "unknown-host",
+            "unknown",
+        ].includes(input.liveness)) {
         canReconcile = false;
         reasons.push("runner-not-proven-dead-or-stopped");
     }
@@ -358,10 +398,26 @@ export async function detectDagRunHealthIssues(input) {
         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",
+            message: "Runner heartbeat is fresh but the current RUNNING node has produced no meaningful activity for more than 5 minutes",
             advisoryAction: "Inspect the node session events and executor logs before deciding whether to wait or abort.",
         });
     }
+    else if (liveness.status === "suspected-stall") {
+        issues.push({
+            code: "node-activity-suspected-stall",
+            severity: "warning",
+            message: "Runner heartbeat is fresh but the current RUNNING node has no meaningful Provider/tool/output activity for more than 15 minutes",
+            advisoryAction: "Treat as suspected network/provider stall; only retry read-only nodes after the attempt is proven finished. Writers must fail closed to reconcile.",
+        });
+    }
+    else if (liveness.status === "needs-attention") {
+        issues.push({
+            code: "node-needs-attention",
+            severity: "error",
+            message: "Runner or node process identity cannot be proven healthy, or absolute max wall clock was exceeded",
+            advisoryAction: "Do not forge timed-out/cancelled. Inspect process identity and artifacts; reconcile only when exit is proven.",
+        });
+    }
     if (lifecycle === "active" &&
         state.status === "running" &&
         state.humanDecisionNodeId) {

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

@@ -0,0 +1,250 @@
+import { z } from "zod";
+/**
+ * Adaptive liveness policy for DAG/Pi supervision.
+ *
+ * Four clocks must not be mixed:
+ * - runner lease (synthetic heartbeat) — not meaningful progress
+ * - provider/transport activity
+ * - tool activity
+ * - output / meaningful progress
+ */
+export const DEFAULT_LIVENESS_POLICY = {
+    heartbeatIntervalMs: 15_000,
+    runnerStaleMs: 90_000,
+    quietMs: 300_000,
+    stallProbeMs: 900_000,
+    abortGraceMs: 30_000,
+    /** 4h absolute max wall clock — cannot be renewed by empty heartbeats. */
+    absoluteMaxWallClockMs: 14_400_000,
+};
+export const dagLivenessPolicySchema = z
+    .object({
+    heartbeatIntervalMs: z.number().int().min(1_000).optional(),
+    runnerStaleMs: z.number().int().positive().optional(),
+    quietMs: z.number().int().positive().optional(),
+    stallProbeMs: z.number().int().positive().optional(),
+    abortGraceMs: z.number().int().positive().optional(),
+    absoluteMaxWallClockMs: z.number().int().positive().optional(),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    const resolved = { ...DEFAULT_LIVENESS_POLICY, ...value };
+    if (resolved.runnerStaleMs <= resolved.heartbeatIntervalMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["runnerStaleMs"],
+            message: "runnerStaleMs must be greater than heartbeatIntervalMs",
+        });
+    }
+    if (resolved.stallProbeMs <= resolved.quietMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["stallProbeMs"],
+            message: "stallProbeMs must be greater than quietMs",
+        });
+    }
+    if (resolved.absoluteMaxWallClockMs <= resolved.stallProbeMs) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["absoluteMaxWallClockMs"],
+            message: "absoluteMaxWallClockMs must be greater than stallProbeMs",
+        });
+    }
+})
+    .optional();
+/**
+ * Resolve policy from node/defaults partials. Missing fields use conservative defaults.
+ */
+export function resolveLivenessPolicy(...sources) {
+    const merged = {};
+    for (const source of sources) {
+        if (!source)
+            continue;
+        for (const key of Object.keys(DEFAULT_LIVENESS_POLICY)) {
+            const value = source[key];
+            if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+                merged[key] = Math.trunc(value);
+            }
+        }
+    }
+    return {
+        heartbeatIntervalMs: merged.heartbeatIntervalMs ?? DEFAULT_LIVENESS_POLICY.heartbeatIntervalMs,
+        runnerStaleMs: merged.runnerStaleMs ?? DEFAULT_LIVENESS_POLICY.runnerStaleMs,
+        quietMs: merged.quietMs ?? DEFAULT_LIVENESS_POLICY.quietMs,
+        stallProbeMs: merged.stallProbeMs ?? DEFAULT_LIVENESS_POLICY.stallProbeMs,
+        abortGraceMs: merged.abortGraceMs ?? DEFAULT_LIVENESS_POLICY.abortGraceMs,
+        absoluteMaxWallClockMs: merged.absoluteMaxWallClockMs ??
+            DEFAULT_LIVENESS_POLICY.absoluteMaxWallClockMs,
+    };
+}
+/**
+ * Synthetic timer heartbeats never count as meaningful Pi progress.
+ */
+export function isMeaningfulActivityKind(kind) {
+    return kind === "provider" || kind === "tool" || kind === "output";
+}
+/**
+ * Attempt fence: late activity from a previous attempt must not overwrite the current one.
+ */
+export function shouldAcceptActivity(currentAttempt, activityAttempt) {
+    if (!Number.isInteger(currentAttempt) || currentAttempt < 1)
+        return false;
+    if (!Number.isInteger(activityAttempt) || activityAttempt < 1)
+        return false;
+    return activityAttempt === currentAttempt;
+}
+export function classifySessionEventActivity(event) {
+    if (!event || typeof event !== "object")
+        return "provider";
+    const type = typeof event.type === "string"
+        ? String(event.type)
+        : "";
+    if (type === "tool_start" ||
+        type === "tool_end" ||
+        type === "tool_execution_start" ||
+        type === "tool_execution_end") {
+        return "tool";
+    }
+    if (type === "thinking_delta" || type === "message_update") {
+        // Noise — do not treat as progress when callers filter via shouldPersistSessionEvent.
+        return null;
+    }
+    return "provider";
+}
+function parseMs(value) {
+    if (!value)
+        return NaN;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : NaN;
+}
+function latestMeaningfulActivityMs(snapshot) {
+    const candidates = [
+        parseMs(snapshot.lastMeaningfulProgressAt),
+        parseMs(snapshot.lastProviderActivityAt),
+        parseMs(snapshot.lastToolActivityAt),
+        parseMs(snapshot.lastOutputActivityAt),
+        // Compatibility: lastActivityAt is treated as meaningful when richer clocks absent.
+        parseMs(snapshot.lastActivityAt),
+        parseMs(snapshot.startedAt),
+    ].filter((value) => !Number.isNaN(value));
+    if (candidates.length === 0)
+        return NaN;
+    return Math.max(...candidates);
+}
+/**
+ * Pure node liveness evaluator. No I/O.
+ *
+ * Transitions:
+ * - real provider/tool/output activity → active
+ * - no activity ≥ quietMs and runner lease fresh → quiet
+ * - no activity ≥ stallProbeMs → suspected-stall
+ * - probing flag → probing
+ * - identity mismatch / unprovable survival → needs-attention
+ * - wall clock ≥ absoluteMax → needs-attention (controlled abort path upstream)
+ */
+export function evaluateNodeLiveness(input) {
+    const policy = resolveLivenessPolicy(input.policy);
+    const nowMs = typeof input.now === "number"
+        ? input.now
+        : (input.now ?? new Date()).getTime();
+    const startedMs = parseMs(input.node.startedAt);
+    const wallClockMs = !Number.isNaN(startedMs)
+        ? Math.max(0, nowMs - startedMs)
+        : 0;
+    const exceededAbsoluteMax = wallClockMs >= policy.absoluteMaxWallClockMs;
+    if (input.node.needsAttentionReason || exceededAbsoluteMax) {
+        return {
+            status: "needs-attention",
+            lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+            idleMs: 0,
+            wallClockMs,
+            exceededAbsoluteMax,
+        };
+    }
+    if (input.node.probing) {
+        return {
+            status: "probing",
+            lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+            idleMs: 0,
+            wallClockMs,
+            exceededAbsoluteMax,
+        };
+    }
+    const meaningfulMs = latestMeaningfulActivityMs(input.node);
+    const idleMs = !Number.isNaN(meaningfulMs)
+        ? Math.max(0, nowMs - meaningfulMs)
+        : wallClockMs;
+    const leaseFresh = input.runnerLeaseFresh ??
+        (() => {
+            const heartbeatMs = parseMs(input.runnerHeartbeatAt);
+            if (Number.isNaN(heartbeatMs))
+                return true;
+            return nowMs - heartbeatMs <= policy.runnerStaleMs;
+        })();
+    if (idleMs >= policy.stallProbeMs) {
+        return {
+            status: "suspected-stall",
+            lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+            idleMs,
+            wallClockMs,
+            exceededAbsoluteMax,
+        };
+    }
+    if (idleMs >= policy.quietMs && leaseFresh) {
+        return {
+            status: "quiet",
+            lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+            idleMs,
+            wallClockMs,
+            exceededAbsoluteMax,
+        };
+    }
+    // Active tool presence keeps us from escalating beyond quiet solely on idle output.
+    if ((input.node.activeToolCount ?? 0) > 0 && idleMs < policy.stallProbeMs) {
+        return {
+            status: idleMs >= policy.quietMs ? "quiet" : "active",
+            lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+            idleMs,
+            wallClockMs,
+            exceededAbsoluteMax,
+        };
+    }
+    return {
+        status: "active",
+        lastMeaningfulProgressAt: input.node.lastMeaningfulProgressAt ?? input.node.lastActivityAt,
+        idleMs,
+        wallClockMs,
+        exceededAbsoluteMax,
+    };
+}
+/**
+ * Apply a fenced activity event onto a mutable node snapshot (pure field updates).
+ * Returns whether the write was accepted.
+ */
+export function applyNodeActivity(input) {
+    if (!shouldAcceptActivity(input.currentAttempt, input.activityAttempt)) {
+        return false;
+    }
+    const at = input.at ?? new Date().toISOString();
+    if (input.kind === "lease" || input.kind === "synthetic-heartbeat") {
+        input.node.lastLeaseAt = at;
+        // Never treat synthetic lease as meaningful progress.
+        return true;
+    }
+    if (!isMeaningfulActivityKind(input.kind)) {
+        return false;
+    }
+    if (input.kind === "provider") {
+        input.node.lastProviderActivityAt = at;
+    }
+    else if (input.kind === "tool") {
+        input.node.lastToolActivityAt = at;
+    }
+    else if (input.kind === "output") {
+        input.node.lastOutputActivityAt = at;
+    }
+    input.node.lastMeaningfulProgressAt = at;
+    input.node.lastActivityAt = at;
+    input.node.livenessStatus = "active";
+    return true;
+}

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

@@ -8,6 +8,7 @@ import { resolveContextPolicy } from "./context-policy.js";
 import { buildDagNodePromptEnvelope } from "./prompt.js";
 import { persistLongNodeOutputArtifacts } from "./upstream-artifacts.js";
 import { computeBackoffDelayMs, isRetryablePiFailureCategory, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
+import { applyNodeActivity, evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { buildProtocolRetryInstruction, validateOutputProtocol, } from "./output-protocol.js";
 import { writeDagNodeJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { buildProjectGovernanceContext, readCompletedWriterChangeManifests, writeProjectGovernanceContext, } from "./project-governance-context.js";
@@ -235,6 +236,9 @@ export async function executeDagNode(input) {
     node.status = "RUNNING";
     node.startedAt = new Date().toISOString();
     node.lastActivityAt = node.startedAt;
+    node.lastMeaningfulProgressAt = node.startedAt;
+    node.livenessStatus = "active";
+    node.currentAttempt = 1;
     if (task.shell?.verifyEvidence) {
         node.verifyEvidence = task.shell.verifyEvidence;
     }
@@ -310,12 +314,48 @@ export async function executeDagNode(input) {
     const maxAttempts = retryPolicy?.maxAttempts ?? 1;
     const attempts = [];
     let totalBackoffMs = 0;
+    const livenessPolicy = resolveLivenessPolicy(spec.defaults?.livenessPolicy, task.livenessPolicy);
+    /**
+     * Attempt-fenced, throttled activity sink. Late events from a previous
+     * attempt are no-ops. Persistence is best-effort and never throws to the
+     * executor path.
+     */
+    const ACTIVITY_PERSIST_MIN_INTERVAL_MS = 2_000;
+    let lastActivityPersistMs = 0;
+    const reportActivity = (activity) => {
+        const accepted = applyNodeActivity({
+            node,
+            currentAttempt: node.currentAttempt ?? 1,
+            activityAttempt: activity.attempt,
+            kind: activity.kind,
+            at: activity.at,
+        });
+        if (!accepted)
+            return;
+        const evaluation = evaluateNodeLiveness({
+            node,
+            policy: livenessPolicy,
+            runnerHeartbeatAt: state.runner?.heartbeatAt,
+        });
+        node.livenessStatus = evaluation.status;
+        const nowMs = Date.now();
+        if (nowMs - lastActivityPersistMs < ACTIVITY_PERSIST_MIN_INTERVAL_MS) {
+            return;
+        }
+        lastActivityPersistMs = nowMs;
+        // Canonical mid-call activity lives in active state.json. Queue through the
+        // runner's serialized state writer; per-node records remain terminal/attempt
+        // evidence so a late best-effort write cannot recreate an archived run dir.
+        void input.persistState().catch(() => { });
+    };
     let terminalResult;
     let previousFailureCategory;
     let previousProtocolReason;
     for (let attemptNumber = 1; attemptNumber <= maxAttempts; attemptNumber += 1) {
         const attemptStartedAt = new Date().toISOString();
         const attemptStarted = Date.now();
+        node.currentAttempt = attemptNumber;
+        node.livenessStatus = "active";
         let result;
         try {
             validateRepairArtifactGateBeforeShell({
@@ -328,6 +368,11 @@ export async function executeDagNode(input) {
                 cwd,
                 model,
                 prompt: buildAttemptPrompt(task, prompt, attemptNumber, previousFailureCategory, previousProtocolReason),
+                attempt: attemptNumber,
+                reportActivity,
+                timeoutMs: livenessPolicy.absoluteMaxWallClockMs,
+                stallTimeoutMs: livenessPolicy.stallProbeMs,
+                abortGraceMs: livenessPolicy.abortGraceMs,
             });
         }
         catch (error) {
@@ -405,6 +450,10 @@ export async function executeDagNode(input) {
                 ? result.parsedEvents
                 : sumAttemptMetric(attempts, (attempt) => attempt.parsedEvents);
         node.lastActivityAt = attemptFinishedAt;
+        if (result.failureCategory === "termination-unconfirmed") {
+            node.needsAttentionReason = "attempt-termination-unconfirmed";
+            node.livenessStatus = "needs-attention";
+        }
         if (retryPolicy !== undefined) {
             state.nodes[nodeId].nodeRecordPath = path.join(runDir, `${nodeId}.json`);
             await writeNodeRecord(runDir, nodeId, state.nodes[nodeId]);

package/dist/workflows/dag/runner.js

@@ -8,6 +8,7 @@ import { CANONICAL_TASK_ID_PATTERN, formatLocalCompactDate, } from "../../task/r
 import { assertFrozenBudget, initRunBudgetLedger, preflightBudgetOrBreach, recordFinishedNodeBudget, writeBudgetLedgerArtifacts, } from "./budget-enforcement.js";
 import { getDagRunDir, isTerminalDagRunStatus, locateDagRun, readHumanApprovalArtifact, requireActiveDagRun, } from "./lifecycle.js";
 import { moveToCompletedRunDir, moveToPausedRunDir, prepareActiveRunDir, writeRunSpec, writeRunState, } from "./run-store.js";
+import { evaluateNodeLiveness, resolveLivenessPolicy, } from "./liveness-policy.js";
 import { createDagNodeExecutor } from "./executor-registry.js";
 import { executeDagPiNode } from "../../executors/dag-pi-executor.js";
 import { assertValidDagSpec } from "./validate.js";
@@ -406,12 +407,31 @@ async function executeDagCheckpoint(input) {
         stateWriteQueue = stateWriteQueue.then(() => writeRunState(runDir, state, options));
         await stateWriteQueue;
     };
+    const runnerLivenessPolicy = resolveLivenessPolicy(spec.defaults?.livenessPolicy);
     const heartbeatTimer = setInterval(() => {
         if (!state.runner)
             return;
+        // Runner lease only — never counts as meaningful Pi progress.
         state.runner.heartbeatAt = new Date().toISOString();
+        const tasksByIdForPolicy = new Map(spec.tasks.map((task) => [task.id, task]));
+        for (const node of Object.values(state.nodes)) {
+            if (node.status !== "RUNNING")
+                continue;
+            // Lease clock is separate from meaningful activity.
+            node.lastLeaseAt = state.runner.heartbeatAt;
+            const task = tasksByIdForPolicy.get(node.id);
+            const policy = resolveLivenessPolicy(spec.defaults?.livenessPolicy, task?.livenessPolicy);
+            const evaluation = evaluateNodeLiveness({
+                node,
+                policy,
+                runnerHeartbeatAt: state.runner.heartbeatAt,
+            });
+            node.livenessStatus = evaluation.status;
+            // Intentionally do NOT refresh lastActivityAt / lastMeaningfulProgressAt
+            // from the runner lease timer.
+        }
         void persistState().catch(() => { });
-    }, 15_000);
+    }, runnerLivenessPolicy.heartbeatIntervalMs);
     heartbeatTimer.unref();
     try {
         const tasksById = new Map(spec.tasks.map((task) => [task.id, task]));

package/dist/workflows/dag/types.js

@@ -2,6 +2,7 @@ import { z } from "zod";
 import { campaignBudgetSchema, } from "../../application/evaluation/budget.js";
 import { assertDagPromptSourceRule } from "./prompt-source.js";
 import { dagRetryPolicySchema } from "./retry-policy.js";
+import { dagLivenessPolicySchema, } from "./liveness-policy.js";
 import { dagOutputProtocolSchema } from "./output-protocol.js";
 export const dagComplexitySchema = z.enum(["HIGH", "MED", "LOW"]);
 export const dagNodeExecutorSchema = z.enum(["pi", "shell", "static"]);
@@ -194,6 +195,8 @@ export const dagDefaultsSchema = z
     contextPolicyId: contextPolicyIdSchema.optional(),
     skills: z.array(z.string()).optional(),
     writePolicy: dagWritePolicySchema.optional(),
+    /** Adaptive liveness thresholds for Pi node supervision. */
+    livenessPolicy: dagLivenessPolicySchema,
 })
     .optional();
 export const dagNodeStatusSchema = z.enum([
@@ -400,6 +403,8 @@ export const dagTaskSchema = z.object({
     forbiddenPaths: z.array(z.string()).optional().default([]),
     decisionGate: dagDecisionGateSchema.optional(),
     retryPolicy: dagRetryPolicySchema.optional(),
+    /** Optional per-node adaptive liveness override (merged over defaults). */
+    livenessPolicy: dagLivenessPolicySchema,
     dynamicExpansion: dagDynamicExpansionSchema.optional(),
     dynamicReduction: dagDynamicReductionSchema.optional(),
     dynamicCondition: dagDynamicConditionSchema.optional(),