@tea-agent/loop-agent 0.20.1 → 0.22.0

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

@@ -1,7 +1,9 @@
 import { z } from "zod";
+import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
 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"]);
@@ -24,6 +26,7 @@ export const dagShellVerifyEvidenceSchema = z.object({
     commandSource: z.enum(["adapter", "inline"]),
     commandCount: z.number().int().nonnegative(),
     commandLabels: z.array(z.string()).default([]),
+    commandTexts: z.array(z.string()).default([]),
     finalFullRequired: z.boolean().optional(),
 });
 export const dagRepairArtifactGateSchema = z.object({
@@ -127,22 +130,80 @@ export const dagFrontendPrewriteGateSchema = z.object({
     allowedMockStrategies: z.array(z.enum(["native", "browser-intercept", "request-adapter", "not-needed"])).min(1),
     artifactName: z.string().regex(/^[a-z0-9][a-z0-9._-]*\.json$/),
     outputDir: z.string().regex(/^[a-z0-9][a-z0-9._-]*$/),
+    requireSourceFreshness: z.literal(true),
+    implementationWriteSet: z.array(z.string().min(1)).min(1).optional(),
     openspecCandidatePaths: z
-        .array(z.string().regex(/^openspec\/.+/, "openspec candidate must be repo-relative"))
+        .array(z.string().refine((candidate) => !candidate.includes("\\") &&
+        isOpenspecSpecFilePath(candidate), "openspec candidate must be a repo-relative supported file under openspec/schemas/ or openspec/project-specs/"))
         .default([]),
 });
+export const dagFrontendLintBaselineSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    lintCommands: z.array(z.string().min(1)).min(1),
+    lintEvidence: dagShellVerifyEvidenceSchema,
+})
+    .strict();
 export const dagFrontendVerificationBundleSchema = z.object({
     schemaVersion: z.literal(1),
     mockCommands: z.array(z.string()).default([]),
+    lintCommands: z.array(z.string().min(1)).optional(),
     staticCommands: z.array(z.string()).min(1),
     behaviorCommands: z.array(z.string()).min(1),
     mockEvidence: dagShellVerifyEvidenceSchema.optional(),
+    lintEvidence: dagShellVerifyEvidenceSchema.optional(),
     staticEvidence: dagShellVerifyEvidenceSchema,
     behaviorEvidence: dagShellVerifyEvidenceSchema,
+    lintBaselineNodeId: dagFrontendNodeIdSchema.optional(),
+    writerNodeIds: z.array(dagFrontendNodeIdSchema).optional(),
     mode: z.enum(["initial", "repair"]),
+}).superRefine((bundle, context) => {
+    const groups = [
+        ["mock", bundle.mockCommands, bundle.mockEvidence],
+        ["lint", bundle.lintCommands ?? [], bundle.lintEvidence],
+        ["static", bundle.staticCommands, bundle.staticEvidence],
+        ["behavior", bundle.behaviorCommands, bundle.behaviorEvidence],
+    ];
+    for (const [name, commands, evidence] of groups) {
+        if ((name === "mock" || name === "lint") && commands.length === 0 && !evidence)
+            continue;
+        if (!evidence) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: [`${name}Evidence`], message: `${name} evidence is required when commands are configured` });
+            continue;
+        }
+        if (evidence.commandCount !== commands.length) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: [`${name}Evidence`, "commandCount"], message: `${name} commandCount must match commands` });
+        }
+        if (evidence.commandLabels.length !== commands.length) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: [`${name}Evidence`, "commandLabels"], message: `${name} commandLabels must match commands` });
+        }
+        if (evidence.commandTexts.length !== commands.length || evidence.commandTexts.some((command, index) => command !== commands[index])) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: [`${name}Evidence`, "commandTexts"], message: `${name} commandTexts must exactly match commands` });
+        }
+        if (new Set(evidence.commandLabels).size !== evidence.commandLabels.length || evidence.commandLabels.some((label) => !label.trim())) {
+            context.addIssue({ code: z.ZodIssueCode.custom, path: [`${name}Evidence`, "commandLabels"], message: `${name} commandLabels must be non-empty and unique` });
+        }
+    }
+    if ((bundle.lintCommands?.length ?? 0) > 0) {
+        if (!bundle.lintBaselineNodeId) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["lintBaselineNodeId"],
+                message: "lintBaselineNodeId is required when lintCommands are present",
+            });
+        }
+        if (!bundle.writerNodeIds || bundle.writerNodeIds.length === 0) {
+            context.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["writerNodeIds"],
+                message: "writerNodeIds are required when lintCommands are present",
+            });
+        }
+    }
 });
 export const dagFrontendReviewContextSchema = z.object({
     schemaVersion: z.literal(1),
+    requireBaseline: z.literal(true),
 });
 export const ENV_VAR_NAME_PATTERN = /^[A-Z_][A-Z0-9_]*$/;
 export const dagVersionSchema = z
@@ -194,6 +255,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([
@@ -223,6 +286,7 @@ export const dagShellConfigSchema = z.object({
     requirementCoverageGate: dagRequirementCoverageGateSchema.optional(),
     jsonArtifactGate: dagJsonArtifactGateSchema.optional(),
     frontendPrewriteGate: dagFrontendPrewriteGateSchema.optional(),
+    frontendLintBaseline: dagFrontendLintBaselineSchema.optional(),
     frontendVerificationBundle: dagFrontendVerificationBundleSchema.optional(),
     frontendReviewContext: dagFrontendReviewContextSchema.optional(),
     backendTestPipeline: dagBackendTestPipelineSchema.optional(),
@@ -400,6 +464,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(),

package/docs/README.md

@@ -52,17 +52,14 @@
 完整索引与归档策略见 `design/README.md`。下列为当前高频活入口：
 
 - `design/backend-test-workflow.md` — backend-test Markdown-first 8 节点流程、单次 pytest、run-owned artifacts 与 L-5
-- `design/frontend-mock-data-workflow.md` — 前端 Mock 节点、触发条件、规范证据与失败路由
-- `design/frontend-implementation-workflow.md` — 前端实现 / 评审 / 验证工作流
+- `design/frontend-implementation-workflow.md` — 前端实现 / 评审 / 验证工作流（含 Mock/API 策略、capability seed、verification bundle）
 - `design/dag-source-binding-and-recovery.md` — 新生成 DAG 的任务源绑定与中断恢复
 - `design/agent-worker-fullstack-workflow-integration.md` — workflow routing、Task Outcome、artifact-aware Ready、`fullstack-v1` 与 Verification Bundle
 - `design/fullstack-end-to-end-delivery-optimization-roadmap.md` — 全栈端到端优化收敛路线图（release train / Delivery / Final Verification）
-- `design/2026-07-22-console-observe-unified-operator-surface.md` — Observe 深度融合进 Console（Wave 1–3 已实现，目标 0.18.0）
-- `design/2026-07-23-operator-task-rerun-and-node-retry.md` — Operator 自动节点重试、从节点重跑、standalone 完整任务重跑与 Worker Task 重排队（**Wave 1–2 已落地**；Wave 3–4 仍分波；优先解决 LLM/provider 不稳定；Inspect 只读 / Operate mutation）
-- `design/local-operator-console-from-pi-web.md` — Operator Console 设计输入；MVP 已随 `0.17.0`–`0.17.2` 发布；统一 surface 见上条
+- `design/local-operator-console-from-pi-web.md` — Operator Console 设计输入；MVP 已随 `0.17.0`–`0.17.2` 发布；统一 surface 设计已归档（见下）
 - `design/taskspec-to-loop-agent-mapping.md` — TaskSpec → loop-agent task 兼容契约（文档镜像；runtime 真源在代码）
 
-已实现且仅作历史说明的设计见 `design/archive/`（例如 `design/archive/2026-07-14-loop-agent-self-update-notifier.md`）。
+已实现且仅作历史说明的设计见 `design/archive/`（例如 `design/archive/2026-07-14-loop-agent-self-update-notifier.md`、`design/archive/2026-07-22-console-observe-unified-operator-surface.md`、`design/archive/2026-07-23-operator-task-rerun-and-node-retry.md`、`design/archive/frontend-mock-data-workflow.md`）。
 
 ## 进行中 / 近期完成
 
@@ -76,6 +73,8 @@
 
 完整 completed 列表与主题速览见 `exec-plans/completed/README.md`。近期高频归档：
 
+- `exec-plans/completed/2026-07-24-backend-test-request-response-logs-report-format.md` — pytest 请求/响应脱敏日志与第 7/8 节点报告版式；真实 `my-webapp` Campaign R04 8/8、17 passed
+- `exec-plans/completed/2026-07-23-backend-test-advisory-gates.md` — 第 4/6 节点改为非阻断 advisory：用例只强制前置条件/步骤/预期，第 6 节点只扫描 Markdown 映射脚本；真实 `my-webapp` Campaign R02 8/8、10 passed
 - `exec-plans/completed/2026-07-23-backend-test-human-readable-artifacts.md` — 中文 README/用例卡片、class-based pytest traceability 与逐条 self-contained HTML 报告；真实 `my-webapp` Campaign Round 04 8/8、16 passed
 - `exec-plans/completed/2026-07-22-backend-markdown-gate-fix.md` — backend-test Markdown gate、traceability、中文生成与真实 Campaign 收口
 - `exec-plans/completed/2026-07-22-backend-test-markdown-first-8-node.md` — backend-test Markdown-first 8 节点

package/docs/architecture/dag-execution.md

@@ -101,6 +101,17 @@ snapshot 与 controller identity 是两个不同冻结层，详见 `runtime-boun
 
 decision envelope 中的 **model verdict**（`decision` / `riskLevel` 等解析自文本）是 `advisoryOnly: true` 派生视图，**不**是完成权威（`facts-and-state.md`）。
 
+## 自适应 liveness（节点活动 vs runner lease）
+
+实现见 `src/workflows/dag/liveness-policy.ts` 与设计文档 `docs/design/dag-adaptive-liveness-and-supervision.md`。
+
+- **runner lease**（`runner.heartbeatAt`，约 15s）只证明 runner 进程事件循环；**不是** Pi meaningful progress。
+- **真实活动**：SDK provider/tool event 与 CLI stdout|stderr 刷新 provider/tool/output；attempt-fenced，旧 attempt 晚到事件 no-op。SDK noisy delta 只续租 transport watchdog，不刷新 meaningful progress。
+- **节点投影** `livenessStatus`：`active | quiet | suspected-stall | probing | needs-attention`。
+- **absolute max** 默认 4h wall clock（不可被空心跳续期）；历史 30 分钟不再是活跃 Pi 节点硬杀边界。
+- `assessDagRunLiveness` 在 lease 新鲜但无 meaningful activity 时返回 `node-quiet` / `suspected-stall` / `needs-attention`；doctor codes 含 `node-activity-quiet`、`node-activity-suspected-stall`、`node-needs-attention`。
+- Observe/read-model 仅为 derived/advisory。
+
 ## 生命周期：active / paused / completed
 
 `src/workflows/dag/lifecycle.ts` 定义三个目录：

package/docs/architecture/facts-and-state.md

@@ -23,6 +23,7 @@
 - **Task Pool 是 Worker 专用可选根**：只有使用 `agent-worker` 产品线时才存在；唯一根 `.harness/task-pool/`。
 - **Task Pool state identity（ADR 0004）**：canonical 键为 `{ featureId, taskId }`（`TaskPoolTaskRef`），不是裸 `taskId`。
 - **Observe snapshot 不是事实源**：`buildGlobalSnapshot` 投影失败返回安全错误摘要而非全零健康，不改变执行成败。
+- **节点 liveness 投影是保守 canonical 字段**：`lastProviderActivityAt` / `lastToolActivityAt` / `lastOutputActivityAt` / `lastMeaningfulProgressAt` / `livenessStatus` 由 runner/executor 写入 active run facts；runner lease heartbeat **不得**刷新 meaningful progress。Observe badge（quiet/suspected-stall/needs-attention/needs-reconcile）仍是 derived。
 
 ### Task Pool state 布局与迁移