@tea-agent/loop-agent 0.26.1 → 0.26.3

package/dist/workflows/dag/runner.js

@@ -20,7 +20,7 @@ import { relocateConvergenceArtifactPaths, relocateRunArtifactPaths, } from "./u
 import { createSkillSnapshot, prepareSkillSnapshotForContinuation, writeSkillSnapshot, } from "./skill-snapshot.js";
 import { captureWorkspaceCheckpoint, WORKSPACE_CHECKPOINT_START_REL, WORKSPACE_CHECKPOINT_TERMINAL_REL, writeWorkspaceCheckpoint, } from "./workspace-checkpoint.js";
 import { buildNodePrompt, buildNodePromptWithResolvedSkillInstructions, executeDagNode, } from "./node-execution.js";
-import { runConvergencePassController, shouldEnableDagConvergence, } from "./convergence/controller.js";
+import { runConvergencePassController, } from "./convergence/controller.js";
 import { executeDagRanksOnce, isConditionSkippedReason } from "./scheduler.js";
 import { topoSortToRanks } from "./topo.js";
 import { parseDagSpec, resolveModelForTask, } from "./types.js";
@@ -142,11 +142,11 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
         ranks,
         nodes,
         ...(spec.evaluation ? { evaluation: { ...spec.evaluation } } : {}),
-        ...(shouldEnableDagConvergence(spec)
+        ...(spec.convergence
             ? {
                 convergence: {
-                    enabled: true,
-                    maxPasses: Math.max(1, spec.convergence?.maxPasses ?? 3),
+                    enabled: spec.convergence.enabled === true,
+                    maxPasses: Math.max(1, spec.convergence.maxPasses ?? 3),
                     currentPass: 1,
                     passHistory: [],
                 },
@@ -186,7 +186,7 @@ export async function runDag(spec, opts) {
     // Candidate identity is validated before run-id allocation or directory creation.
     await assertEvaluationBindingPreflight(opts.cwd, spec.evaluation);
     // Phase 0.5: new writer execution requires DagSpec v4 + live taskContractBinding match.
-    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent } = await import("./task-contract-binding.js");
+    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent, } = await import("./task-contract-binding.js");
     assertDagSpecAllowsNewWriterExecution(spec);
     await assertTaskContractBindingConsistent({ repoRoot: opts.cwd, spec });
     const runningIdentity = resolveRunningControllerIdentity();
@@ -323,7 +323,7 @@ export async function resumeDagRun(opts) {
     assertFrozenEvaluationBinding(spec, state);
     assertFrozenBudget(spec.budget, state.budget, state.runId);
     // Phase 0.5: refuse resume of pre-v4 writer DAGs; revalidate live binding.
-    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent } = await import("./task-contract-binding.js");
+    const { assertDagSpecAllowsNewWriterExecution, assertTaskContractBindingConsistent, } = await import("./task-contract-binding.js");
     assertDagSpecAllowsNewWriterExecution(spec);
     await assertTaskContractBindingConsistent({ repoRoot: opts.cwd, spec });
     // Runtime contract + controller identity must be re-verified before executing
@@ -472,52 +472,63 @@ async function executeDagCheckpoint(input) {
                 runDir: dynamicInput.runDir,
             });
         };
-        let pausedByNodeId;
-        while (true) {
-            pausedByNodeId = await executeDagRanksOnce({
-                state,
-                ranks,
+        const deferTerminalCloseout = state.convergence !== undefined && tasksById.has("closeout-pi");
+        const convergenceRanks = deferTerminalCloseout
+            ? ranks
+                .map((rank) => rank.filter((nodeId) => nodeId !== "closeout-pi"))
+                .filter((rank) => rank.length > 0)
+            : ranks;
+        const terminalCloseoutRanks = deferTerminalCloseout
+            ? ranks
+                .map((rank) => rank.filter((nodeId) => nodeId === "closeout-pi"))
+                .filter((rank) => rank.length > 0)
+            : [];
+        const executeRanks = (selectedRanks) => executeDagRanksOnce({
+            state,
+            ranks: selectedRanks,
+            tasksById,
+            maxConcurrent,
+            persistState,
+            createExecuteNodeForRank: (rankWriterNodeIds) => buildRankAwareExecuteNode({
+                baseExecuteNode,
+                customExecuteNode: input.executeNode,
+                rankWriterNodeIds,
                 tasksById,
-                maxConcurrent,
-                persistState,
-                createExecuteNodeForRank: (rankWriterNodeIds) => buildRankAwareExecuteNode({
-                    baseExecuteNode,
-                    customExecuteNode: input.executeNode,
-                    rankWriterNodeIds,
+                meta: { runDir, runId: state.runId, spec },
+            }),
+            executeScheduledNode: async (nodeId, executeNode, onPause) => {
+                if (isHardBudgetBreached(state.budgetLedger))
+                    return;
+                const preBreach = preflightBudgetOrBreach(state);
+                if (preBreach && isHardBudgetBreached(state.budgetLedger)) {
+                    await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
+                    await persistState();
+                    return;
+                }
+                await executeDagNode({
+                    nodeId,
                     tasksById,
-                    meta: { runDir, runId: state.runId, spec },
-                }),
-                executeScheduledNode: async (nodeId, executeNode, onPause) => {
-                    if (isHardBudgetBreached(state.budgetLedger))
-                        return;
-                    const preBreach = preflightBudgetOrBreach(state);
-                    if (preBreach && isHardBudgetBreached(state.budgetLedger)) {
-                        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
-                        await persistState();
-                        return;
-                    }
-                    await executeDagNode({
-                        nodeId,
-                        tasksById,
-                        state,
-                        spec,
-                        cwd,
-                        runDir,
-                        executeNode,
-                        executeDynamicNode,
-                        observer: input.observer,
-                        persistState,
-                        onPause,
-                    });
-                    const node = state.nodes[nodeId];
-                    if (node &&
-                        (node.status === "FINISHED" || node.status === "ERROR")) {
-                        recordFinishedNodeBudget(state, node);
-                        await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
-                        await persistState();
-                    }
-                },
-            });
+                    state,
+                    spec,
+                    cwd,
+                    runDir,
+                    executeNode,
+                    executeDynamicNode,
+                    observer: input.observer,
+                    persistState,
+                    onPause,
+                });
+                const node = state.nodes[nodeId];
+                if (node && (node.status === "FINISHED" || node.status === "ERROR")) {
+                    recordFinishedNodeBudget(state, node);
+                    await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
+                    await persistState();
+                }
+            },
+        });
+        let pausedByNodeId;
+        while (true) {
+            pausedByNodeId = await executeRanks(convergenceRanks);
             if (pausedByNodeId) {
                 break;
             }
@@ -541,6 +552,16 @@ async function executeDagCheckpoint(input) {
             }
             break;
         }
+        if (!pausedByNodeId &&
+            terminalCloseoutRanks.length > 0 &&
+            state.convergence?.terminalReason &&
+            !isHardBudgetBreached(state.budgetLedger)) {
+            // Convergence closeout is a terminal phase, not an ordinary descendant
+            // rank. Running it only after the controller records terminalReason avoids
+            // stale success handoffs on intermediate request-revision passes while
+            // still producing a truthful failure handoff for max-passes/non-retry.
+            pausedByNodeId = await executeRanks(terminalCloseoutRanks);
+        }
         // 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.
@@ -599,11 +620,79 @@ async function notifyRunObserver(observer, event, state) {
         // Observers are derived views; they must not affect canonical DAG execution.
     }
 }
+const SUCCESSFUL_CONVERGENCE_TERMINAL_REASONS = new Set([
+    "review-pass",
+    "hard-verify-pass",
+]);
+/**
+ * Intermediate soft-verify failures may be excluded from terminal error
+ * aggregation only when repair + final hard verify succeeded and, when a review
+ * gate is present, convergence ended in review-pass. Historical node status is
+ * never rewritten.
+ */
+function collectSupersededIntermediateFailures(state) {
+    const supersededIds = new Set();
+    const supersededFailures = [];
+    const soft = state.nodes["soft-verify-shell"];
+    if (!soft || soft.status !== "ERROR") {
+        return { supersededIds, supersededFailures };
+    }
+    const repair = state.nodes["repair-pi"];
+    const hard = state.nodes["hard-verify-shell"];
+    if (repair?.status !== "FINISHED" || hard?.status !== "FINISHED") {
+        return { supersededIds, supersededFailures };
+    }
+    const observesReview = Boolean(state.nodes["review-gate-shell"]);
+    const terminalReason = state.convergence?.terminalReason;
+    if (observesReview) {
+        if (terminalReason !== "review-pass") {
+            return { supersededIds, supersededFailures };
+        }
+    }
+    else if (terminalReason && terminalReason !== "hard-verify-pass") {
+        return { supersededIds, supersededFailures };
+    }
+    // Evidence: at least one successful repair pass after soft failure, with hard verify finished in terminal state.
+    const hasRepairEvidence = !state.convergence?.enabled ||
+        state.convergence.passHistory.some((pass) => pass.reason === "hard-verify-failed" ||
+            pass.reason === "review-request-revision" ||
+            pass.status === "retrying") ||
+        repair.status === "FINISHED";
+    if (!hasRepairEvidence) {
+        return { supersededIds, supersededFailures };
+    }
+    supersededIds.add("soft-verify-shell");
+    supersededFailures.push({
+        nodeId: "soft-verify-shell",
+        preservedStatus: "ERROR",
+        supersededBy: ["repair-pi", "hard-verify-shell"],
+        pass: state.convergence?.currentPass,
+        reason: "intermediate-soft-verify-covered-by-repair-and-final-hard",
+    });
+    return { supersededIds, supersededFailures };
+}
+function isSuccessfulConvergenceTerminal(state) {
+    const reason = state.convergence?.terminalReason;
+    if (!reason)
+        return true;
+    return SUCCESSFUL_CONVERGENCE_TERMINAL_REASONS.has(reason);
+}
 function finalizeTerminalRunStatus(state, taskCount) {
     const finishedCount = Object.values(state.nodes).filter((n) => n.status === "FINISHED").length;
-    const errorCount = Object.values(state.nodes).filter((n) => n.status === "ERROR").length;
+    const { supersededIds, supersededFailures } = collectSupersededIntermediateFailures(state);
+    if (state.convergence && supersededFailures.length > 0) {
+        state.convergence.supersededFailures = supersededFailures;
+    }
+    // Prefer map keys: DagNodeRecord may not always mirror the map key on `.id`.
+    const effectiveErrorCount = Object.entries(state.nodes).filter(([nodeId, n]) => n.status === "ERROR" && !supersededIds.has(nodeId)).length;
+    const supersededErrorCount = Object.entries(state.nodes).filter(([nodeId, n]) => n.status === "ERROR" && supersededIds.has(nodeId)).length;
     const conditionSkippedCount = Object.values(state.nodes).filter((n) => n.status === "SKIPPED" && isConditionSkippedReason(n.skippedReason)).length;
-    if (errorCount === 0 && finishedCount + conditionSkippedCount === taskCount) {
+    const successTerminal = isSuccessfulConvergenceTerminal(state);
+    // Superseded intermediate ERRORs remain ERROR in history but count as settled
+    // for terminal aggregation only (they do not inflate effectiveErrorCount).
+    if (effectiveErrorCount === 0 &&
+        successTerminal &&
+        finishedCount + conditionSkippedCount + supersededErrorCount === taskCount) {
         state.status = "finished";
     }
     else if (finishedCount > 0) {

package/dist/workflows/dag/types.js

@@ -79,6 +79,8 @@ export const dagVerdictGateSchema = z.object({
         .regex(/^[a-z][a-z0-9-]*$/, "fallbackFromNodeIds must be kebab-case"))
         .optional(),
     accept: z.array(z.string().min(1)).min(1),
+    routingAccept: z.array(z.string().min(1)).optional(),
+    source: z.enum(["verdict-line", "json-review-verdict"]).optional(),
     lineMode: z.enum(["first-non-empty", "first-verdict-line"]).optional(),
     label: z.string().min(1).optional(),
 });
@@ -161,7 +163,7 @@ export const dagFrontendVerificationBundleSchema = z
     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),
+    behaviorCommands: z.array(z.string()).default([]),
     mockEvidence: dagShellVerifyEvidenceSchema.optional(),
     lintEvidence: dagShellVerifyEvidenceSchema.optional(),
     staticEvidence: dagShellVerifyEvidenceSchema,
@@ -311,6 +313,8 @@ export const dagBackendTestPipelineSchema = z.enum([
     "classification-result-context",
     "markdown-environment",
     "markdown-cases",
+    "markdown-collection-assess",
+    "markdown-collection-effective",
     "markdown-traceability",
     "markdown-execute-html",
     "markdown-manifest",

package/dist/workflows/dag/validate.js

@@ -235,7 +235,8 @@ function validateRepairArtifactGateConfig(task, spec, issues) {
         candidate.role === "reviewer" &&
         !candidate.decisionGate?.enabled &&
         candidate.writePolicy === "read-only" &&
-        (candidate.outputContract?.includes("VERDICT:") ?? false) &&
+        ((candidate.outputContract?.includes("VERDICT:") ?? false) ||
+            candidate.outputProtocol?.type === "json-review-verdict") &&
         // Format recovery / write-set format-repair nodes also emit VERDICT but
         // are not the primary content review after hard verification.
         !/(?:-format-repair-pi|-verdict-recovery-pi)$/.test(candidate.id));
@@ -243,7 +244,7 @@ function validateRepairArtifactGateConfig(task, spec, issues) {
         issues.push({
             type: "invalid-repair-artifact-gate-config",
             message: reviewCandidates.length === 0
-                ? `task ${task.id} hard verification node "${hardVerify.id}" must reach one read-only Pi reviewer with a VERDICT output contract`
+                ? `task ${task.id} hard verification node "${hardVerify.id}" must reach one read-only Pi reviewer with a VERDICT or JSON review output contract`
                 : `task ${task.id} hard verification node "${hardVerify.id}" has multiple Pi reviewer nodes (${reviewCandidates.map((candidate) => candidate.id).join(", ")})`,
         });
     }

package/docs/templates/backend-test-dag.json

@@ -28,11 +28,11 @@
     "Root artifacts/ is reserved for explicit exclusive write nodes, not read-only scout/reviewer output",
     "exclusive implementer nodes must use narrow, concrete writeSet paths; never keep ** or repo root",
     "Replace REPLACE/WITH/NARROW/IMPLEMENT/PATHS/** with concrete paths before executing the implementation writer",
-    "backend-test-dag uses exactly 9 real top-level tasks and executes pytest exactly once over only the safe scripts explicitly mapped by final Markdown cases.",
+    "backend-test-dag uses exactly 12 real top-level tasks. Pytest collection runs once on the green path and at most twice only when one bounded pre-execution repair is eligible; business pytest test bodies execute exactly once over safe scripts explicitly mapped by final Markdown cases.",
     "Model nodes produce Markdown and pytest assets, never backend-test business JSON envelopes.",
-    "Environment, advisory Markdown validation/coverage, advisory traceability/correspondence, canonical manifest, pytest-html, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8; node 7 partial/unavailable does not block node 8.",
+    "Environment, advisory Markdown validation/coverage, collection initial/effective facts, advisory traceability/correspondence, canonical manifest, pytest-html, HTML and execution facts are deterministic evidence. Node 4 quality findings stay advisory; nodes 6/8 form the fail-closed collection authorization; node 9 traceability findings stay advisory; node 10 partial/unavailable manifest does not block node 11 when effective collection remains fresh.",
     "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
-    "Functional case IDs use canonical BE-<MODULE>-<NNN> with exactly three digits and no alphabetic suffix. Every Test Point has exactly one variant/assertion/cross-cutting binding; only variant bindings create pytest parameter items. Production code/config, skip/xfail, repair and rerun are forbidden."
+    "Functional case IDs use canonical BE-<MODULE>-<NNN> with exactly three digits and no alphabetic suffix. Every Test Point has exactly one variant/assertion/cross-cutting binding; only variant bindings create pytest parameter items. Production code/config, skip/xfail, execution-result repair and business pytest rerun are forbidden; the only repair is one pre-execution collection-proven generated-test asset repair."
   ],
   "defaults": {
     "executor": "pi",
@@ -206,7 +206,7 @@
       "subtask_prompt": "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.\n\nEnsure every final Markdown Case ID appears in exactly one primary pytest test function or pytest test class method region, using the exact `primary symbol` declared by Markdown. The symbol must start with `test_BE_<MODULE>_<NNN>_` so every parameterized collected item remains associated with its Case. Module-level functions and class-based pytest methods are both supported. Only `变体测试点` may use stable `pytest.param(..., id=\"TP-...\")` IDs, and every atomic variant ID must appear exactly once with a genuine input/state/outcome change. Use `pytest.param(..., id=...)` for every row; do not use decorator-level `ids=[...]`, generated suffixes, or IDs that extend/shorten the exact Markdown TP. Do not parameterize `场景断言测试点` or `横切证据测试点`; execute all assertion checkpoints within the same business journey/item and use shared helpers for cross-cutting evidence. The primary symbol docstring must contain exact metadata lines `Case-ID: BE-...`, `Assertion-Test-Points: TP-...;TP-...` and `Cross-Cutting-Test-Points: TP-...;TP-...` (use `none` when empty). No Test Point may be invented, renamed, omitted or bound in two modes. The generated pytest collection shape must equal the Markdown prediction `sum(max(1, variant count per Case))`; keep it at or below the task's explicit budget by removing duplicate execution, never by collapsing multiple parameter rows under a coarse family TP. Assertions come only from 预期结果 and setup comes only from 前置条件/测试数据/自动化映射.\n\nName each generated pytest file so it corresponds one-to-one with its source Markdown module file: for each `testcase/md/<module>.md` (excluding README.md), emit exactly one `testcase/test_<module>.py`. The <module> stem is the Markdown filename without the `.md` extension, lowercased and with non-alphanumeric characters replaced by underscores. For example, `testcase/md/resource_notes.md` maps to `testcase/test_resource_notes.py`, `testcase/md/health.md` maps to `testcase/test_health.py`, `testcase/md/BE-HEALTH.md` maps to `testcase/test_be_health.py`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. If Markdown automation mapping names a different path than this module stem path, still write the module stem path and do not invent prefixes such as `test_be_*` unless the module filename itself normalizes to that stem. Never merge multiple Markdown modules into one pytest file, never split one module across several files, and never invent pytest filenames unrelated to the Markdown modules.\n\nGenerate 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.\n\nHTTP response header names are case-insensitive. If the helper stores a lower-case normalized header map, every Content-Type or other header assertion must query the lower-case key (for example `content-type`) or use an explicitly case-insensitive accessor; never call a case-sensitive plain dict with `Content-Type` when the stored key is lower-case. Preserve the actual media-type assertion rather than dropping it.\n\nCompare 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.\n\nBefore 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.\n\nDo 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`."
     },
     {
-      "id": "backend-test-traceability-gate-shell",
+      "id": "assess-backend-pytest-collection-shell",
       "depends_on": [
         "generate-backend-pytest-pi"
       ],
@@ -223,8 +223,100 @@
         ".harness/dag-runs/**",
         "artifacts/**"
       ],
-      "outputContract": "Run-owned reports/backend-test-traceability.md, reports/backend-test-markdown-pytest-correspondence.md and contracts/backend-test-markdown-pytest-correspondence-facts.json with PASS/FAIL/UNAVAILABLE correspondence facts.",
-      "subtask_prompt": "Deterministically scan only Markdown-mapped pytest scripts. Keep the existing traceability/logging checks and produce a bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol correspondence analysis. Map variant Test Points from stable parameter IDs, assertion Test Points from the primary symbol docstring, and cross-cutting Test Points from the primary symbol evidence binding. Report 1:1, 1:0, 1:N, 0:1, script/primary-symbol mismatch, missing Case ID, missing variant parameter IDs, missing assertion/cross-cutting bindings, duplicate modes and extra bindings. Human and machine evidence must come from the same facts. Findings are advisory and never block pytest.",
+      "outputContract": "Run-owned reports/backend-test-pytest-collection-initial.md and contracts/backend-test-pytest-collection-initial.json with bounded diagnostics, asset hashes, collected item IDs and deterministic repair eligibility.",
+      "subtask_prompt": "Run pytest collection only over final Markdown-mapped scripts before any business test body execution. Materialize hash-bound PASS/REPAIRABLE/BLOCKED facts. Only generated testcase-local syntax/import inconsistencies are repairable; dependency, plugin, production-module, environment, safety and unknown failures remain blocked.",
+      "shell": {
+        "commands": [],
+        "backendTestPipeline": "markdown-collection-assess",
+        "cwd": ".",
+        "timeoutMs": 120000
+      }
+    },
+    {
+      "id": "repair-backend-pytest-collection-pi",
+      "depends_on": [
+        "assess-backend-pytest-collection-shell"
+      ],
+      "runIf": "$.nodes['assess-backend-pytest-collection-shell'].json.repairEligible == true",
+      "role": "implementer",
+      "executor": "pi",
+      "toolProfile": "write",
+      "complexity": "HIGH",
+      "writePolicy": "exclusive",
+      "writeSet": [
+        "testcase/**/test_*.py",
+        "testcase/**/helpers/**",
+        "testcase/**/factories/**"
+      ],
+      "allowedPaths": [
+        "testcase/**",
+        "docs/test-reports/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        ".harness/dag-runs/**",
+        "artifacts/**",
+        "testcase/md/**",
+        "conftest.py",
+        "pytest.ini",
+        "pyproject.toml",
+        "setup.cfg"
+      ],
+      "writerOutcomePolicy": {
+        "type": "implementation-outcome-v1"
+      },
+      "outputContract": "First non-empty line is IMPLEMENTATION_OUTCOME: changed|already-satisfied|blocked, followed by a concise repair summary. Modify only generated pytest scripts/helpers/factories and preserve every Markdown Case, Test Point, primary symbol and assertion meaning.",
+      "subtask_prompt": "Repair the generated backend pytest asset as one bounded program using the direct upstream collection assessment. This is the only repair attempt and happens before any business test body execution.\n\nFix only collection-proven generated testcase-local syntax, module path, missing symbol, circular import, fixture-name, decorator or parameterization inconsistencies. Inspect all affected importers and providers so the repair is cross-file consistent.\n\nPreserve final testcase/md/** semantics, every Case ID, Rule/Test Point binding, primary symbol, parameter ID, expected status/body/schema assertion, HTTP logging, redaction and truncation behavior.\n\nDo not read task source/** or reinterpret requirements. Do not modify Markdown, conftest, pytest config, production code or dependencies.\n\nDo not add skip/skipif/xfail, remove tests, reduce collected items, loosen assertions, swallow exceptions, use try/except ImportError fallback, mutate sys.path/PYTHONPATH, or replace the real API with mocks.\n\nDo not execute pytest; the deterministic effective collection gate owns the final collection attempt."
+    },
+    {
+      "id": "effective-backend-pytest-collection-gate-shell",
+      "depends_on": [
+        "assess-backend-pytest-collection-shell",
+        "repair-backend-pytest-collection-pi"
+      ],
+      "role": "verifier",
+      "executor": "shell",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/**",
+        "docs/test-reports/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        ".harness/dag-runs/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Run-owned reports/backend-test-pytest-collection-effective.md and contracts/backend-test-pytest-collection-effective.json proving the exact final assets are collectable; initial PASS is reused, repair path records attempt=1.",
+      "subtask_prompt": "If initial collection passed, verify unchanged asset hashes and reuse it without another collection. If the single repair ran, collect the final mapped scripts once and fail closed unless it passes. BLOCKED initial facts, repair failure, final collection failure or hash drift must prevent business pytest execution.",
+      "shell": {
+        "commands": [],
+        "backendTestPipeline": "markdown-collection-effective",
+        "cwd": ".",
+        "timeoutMs": 120000
+      },
+      "dependsPolicy": "all-or-condition-skip"
+    },
+    {
+      "id": "backend-test-traceability-gate-shell",
+      "depends_on": [
+        "effective-backend-pytest-collection-gate-shell"
+      ],
+      "role": "verifier",
+      "executor": "shell",
+      "complexity": "LOW",
+      "writePolicy": "read-only",
+      "allowedPaths": [
+        "testcase/**",
+        "docs/test-reports/**"
+      ],
+      "forbiddenPaths": [
+        ".harness/**",
+        ".harness/dag-runs/**",
+        "artifacts/**"
+      ],
+      "outputContract": "Run-owned reports/backend-test-traceability.md, reports/backend-test-markdown-pytest-correspondence.md and contracts/backend-test-markdown-pytest-correspondence-facts.json with PASS/FAIL/UNAVAILABLE correspondence facts bound after effective collection.",
+      "subtask_prompt": "Deterministically scan only Markdown-mapped pytest scripts after the effective hash-bound collection gate. Keep the existing traceability/logging checks and produce a bidirectional Markdown module/Case/Test Point ↔ pytest file/primary symbol correspondence analysis. Map variant Test Points from stable parameter IDs, assertion Test Points from the primary symbol docstring, and cross-cutting Test Points from the primary symbol evidence binding. Report 1:1, 1:0, 1:N, 0:1, script/primary-symbol mismatch, missing Case ID, missing variant parameter IDs, missing assertion/cross-cutting bindings, duplicate modes and extra bindings. Human and machine evidence must come from the same facts. Findings are advisory and never block pytest.",
       "shell": {
         "commands": [],
         "backendTestPipeline": "markdown-traceability",
@@ -278,7 +370,7 @@
         "artifacts/**"
       ],
       "outputContract": "One scoped pytest execution over Markdown-mapped scripts producing a valid pytest-html report with per-case captured output, self-contained reports/backend-test.html, reports/backend-test.md, reports/backend-test-facts.md, a deterministic self-contained reports/backend-test-l5-dashboard.html (machine-computed L-5 metrics, no JSON), and an optional contracts/code-coverage-v1.json when jacocoCoverage is configured (JaCoCo TCP dump → jacoco.xml → parsed; failure-safe); exit 0/1 with valid evidence continues.",
-      "subtask_prompt": "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Prefer the deterministic module one-to-one path when a mapped script is missing but the module stem file exists. Generate a native pytest-html self-contained report, then render the primary self-contained Chinese HTML report from the same pytest-html plus final Markdown case metadata without rerun. Keep 测试结论 and quality status; make node 4 Markdown validation + case coverage and node 6 traceability + Markdown-to-pytest correspondence expandable to their full escaped details; show each failure overview item with its original pytest message plus deterministic evidence-based reason analysis; list failure/error case cards before the remaining cases while preserving stable order. Each polished per-case result card includes 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.",
+      "subtask_prompt": "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Prefer the deterministic module one-to-one path when a mapped script is missing but the module stem file exists. Generate a native pytest-html self-contained report, then render the primary self-contained Chinese HTML report from the same pytest-html plus final Markdown case metadata without rerun. Keep 测试结论 and quality status; make node 4 Markdown validation + case coverage and node 9 traceability + Markdown-to-pytest correspondence expandable to their full escaped details; show each failure overview item with its original pytest message plus deterministic evidence-based reason analysis; list failure/error case cards before the remaining cases while preserving stable order. Each polished per-case result card includes 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.",
       "shell": {
         "commands": [
           "mkdir -p \"${HARNESS_DAG_RUN_DIR}/reports\"; echo \"pytest targets are resolved at runtime from final Markdown 自动化映射\""
@@ -311,7 +403,7 @@
         "artifacts/**"
       ],
       "outputContract": "Final Markdown report and L-5 conclusion under docs/test-reports/**; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked, not re-rendered; no JSON.",
-      "subtask_prompt": "Generate the final Markdown report only from authoritative run-owned artifacts. Read node 1 reports/backend-test-environment.md; node 4 backend-md-case-validation.md and backend-test-case-coverage-analysis.md; node 6 backend-test-traceability.md and backend-test-markdown-pytest-correspondence.md; node 7 contracts/backend-test-case-manifest.json; and node 8 backend-test-result.json, backend-test-facts.md, pytest-html/HTML and L-5 dashboard. Do not use node 2/3/5 assistant prose as facts. Do not emit JSON.\n\nUse 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.\n\nThe L-5 metrics and visualization are produced deterministically by node 8 at reports/backend-test-l5-dashboard.html. Link to that dashboard as the authoritative L-5 view. Pytest execution facts come from node 8; coverage/correspondence numbers and materializationStatus come from node 7; detailed coverage findings come from node 4; detailed mapping findings come from node 6. Never recompute these values. If machine manifest and human reports disagree, report evidence inconsistency rather than silently choosing.\n\nAlways state the exact Coverage Scope classification, policy, affected operations, regression floor, completeness claim, PASS/FAIL/UNAVAILABLE status and findings from node 4 case validation + coverage, plus node 6 traceability + correspondence. Affected-scope or affected-operations-full coverage must never be described as whole-API completeness unless every operation is explicitly listed. Their FAIL status does not block pytest, but it must remain visible and must never be rewritten as PASS.\n\nInclude environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage availability, and L-5 READY/NOT READY. Distinguish Markdown Case count, primary pytest symbol count, collected pytest item count, variant/assertion/cross-cutting Test Point counts and execution amplification; never describe pytest item count as the number of business scenarios.\n\nNever override Shell/pytest-html facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.\n\nWrite only under docs/test-reports/**."
+      "subtask_prompt": "Generate the final Markdown report only from authoritative run-owned artifacts. Read node 1 reports/backend-test-environment.md; node 4 backend-md-case-validation.md and backend-test-case-coverage-analysis.md; nodes 6/8 backend-test-pytest-collection initial/effective reports and facts; node 9 backend-test-traceability.md and backend-test-markdown-pytest-correspondence.md; node 10 contracts/backend-test-case-manifest.json; and node 11 backend-test-result.json, backend-test-facts.md, pytest-html/HTML and L-5 dashboard. Do not use node 2/3/5 assistant prose as facts. Do not emit JSON.\n\nUse 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.\n\nThe L-5 metrics and visualization are produced deterministically by node 11 at reports/backend-test-l5-dashboard.html. Link to that dashboard as the authoritative L-5 view. Pytest execution facts come from node 11; coverage/correspondence numbers and materializationStatus come from node 10; collection authorization comes from nodes 6/8; detailed coverage findings come from node 4; detailed mapping findings come from node 9. Never recompute these values. If machine manifest and human reports disagree, report evidence inconsistency rather than silently choosing.\n\nAlways state the exact Coverage Scope classification, policy, affected operations, regression floor, completeness claim, PASS/FAIL/UNAVAILABLE status and findings from node 4 case validation + coverage, plus node 9 traceability + correspondence. Affected-scope or affected-operations-full coverage must never be described as whole-API completeness unless every operation is explicitly listed. Their FAIL status does not block pytest, but it must remain visible and must never be rewritten as PASS.\n\nInclude environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage availability, and L-5 READY/NOT READY. Distinguish Markdown Case count, primary pytest symbol count, collected pytest item count, variant/assertion/cross-cutting Test Point counts and execution amplification; never describe pytest item count as the number of business scenarios.\n\nNever override Shell/pytest-html facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.\n\nWrite only under docs/test-reports/**."
     }
   ],
   "sourceBinding": {

package/package.json

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

package/skills/loop-agent/references/hybrid-dag.md

@@ -20,7 +20,7 @@
 
 > Backend-test Markdown-first：先由确定性环境 Shell 检查 clean env 中 Python/pytest、常见配置、conftest/fixture、test root、server entry 和 HTML renderer，失败时不消耗模型调用。随后 Pi 生成中文 README 索引与模块用例卡片并独立 Review `testcase/md/**`。第 4 节点只把前置条件、操作步骤、预期结果作为必选章节，并检查 Case ID、业务 AC、步骤/预期和占位措辞；不校验需求来源引用有效性或 Markdown sensitive-shaped 内容。pytest writer 为每次真实接口调用记录脱敏、有界的请求 method/URL/参数摘要和响应 status/body 摘要。第 6 节点只扫描每条 Case 明确映射的 pytest 脚本，同时支持模块级函数和 pytest class 方法，并把缺少请求/响应日志、递归脱敏或有界截断证据记录为 advisory。第 4/6 节点均写 PASS/FAIL findings 而不阻断后续；pytest 仍只运行一次，生成 JUnit，并把 Markdown 名称/场景/脚本映射与同一 JUnit 合成为按测试概览、质量校验、失败概览、用例执行明细和技术证据组织的中文 self-contained HTML 与 Markdown facts。最终 Pi 按固定简洁结构汇总 advisory 状态、执行事实和 L-5 结论。active 流程不要求模型生成 backend-test 业务 JSON。
 
-显式专用 `taskKind` 保持兼容并优先于任务源分类。`backend-test` 选择固定 **8 个真实顶层节点**的 Markdown-first DAG：环境硬门、Markdown cases、独立 Review/修订、第 4 节点 advisory Markdown 校验、pytest 转换、第 6 节点 scoped advisory traceability、单次 pytest + JUnit/HTML/facts、最终 Markdown 报告与 L-5。历史 JSON contract/materializer 可继续读取旧 DAG，但新 runtime/template 不再生成模型业务 JSON。`knowledge-sync` 与 `knowledge-graph-bootstrap` 继续通过各自显式 taskKind 选择知识回写/图谱开荒 DAG。治理等级仍由 `minimal|standard|reviewed|supervised` 推断。
+显式专用 `taskKind` 保持兼容并优先于任务源分类。`backend-test` 选择固定 **12 个真实顶层节点**的 Markdown-first DAG：环境硬门、Markdown cases、独立 Review/修订、第 4 节点 advisory Markdown 校验、pytest 转换、initial collection assessment、仅 `REPAIRABLE` 时最多一次 generated-test repair、hash-bound effective collection、scoped traceability、facts-only manifest、单次业务 pytest + pytest-html/HTML/facts、最终 Markdown 报告与 L-5。绿色路径 collection 一次，repair 路径两次，但测试体始终只执行一次；依赖/plugin/生产模块/环境/安全/未知 collection error 不得 repair，assertion/API failure不触发 repair 或 rerun。历史 JSON contract/materializer 可继续读取旧 DAG，但新 runtime/template 不再生成模型业务 JSON。`knowledge-sync` 与 `knowledge-graph-bootstrap` 继续通过各自显式 taskKind 选择知识回写/图谱开荒 DAG。治理等级仍由 `minimal|standard|reviewed|supervised` 推断。
 
 ### DAG workflow 层级