@tea-agent/loop-agent 0.26.1 → 0.26.3

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

@@ -10,7 +10,7 @@ import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
 import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, } from "./retry-policy.js";
-import { REVIEW_VERDICT_OUTPUT_PROTOCOL } from "./output-protocol.js";
+import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
 import { buildAuthoritySurfaceAuditNode, buildAuthoritySurfaceGateNode, resolveAuthoritySurfaceAudit, } from "./authority-surface.js";
@@ -890,7 +890,9 @@ function chooseFrontendVerifyCommands(input) {
     if (input.parsedCommands.length > 0) {
         return { commands: input.parsedCommands, commandSource: "inline" };
     }
-    if (input.adapterCommands && input.adapterCommands.length > 0) {
+    if (input.allowAdapter !== false &&
+        input.adapterCommands &&
+        input.adapterCommands.length > 0) {
         return { commands: input.adapterCommands, commandSource: "adapter" };
     }
     return { commandSource: "inline" };
@@ -1252,7 +1254,19 @@ export function extractTaskScopedRequirementIds(requirementMarkdown, ...fallback
         if (fromSection.length > 0)
             return fromSection;
     }
-    return extractExplicitRequirementIds(requirementMarkdown, ...fallbackMarkdown);
+    const explicit = extractExplicitRequirementIds(requirementMarkdown, ...fallbackMarkdown);
+    if (explicit.length > 0)
+        return explicit;
+    // Requirements frequently use a numbered acceptance list instead of
+    // writing AC-* identifiers. Give that list a deterministic canonical
+    // namespace so model-generated AC-1 references bind to the same source
+    // facts instead of failing as unknown requirements at the prewrite gate.
+    const acceptanceSection = requirementMarkdown.match(/(?:^|\n)##\s*(?:验收标准|Acceptance Criteria)\s*\n([\s\S]*?)(?=\n##\s+|\n#\s+|$)/i)?.[1] ?? "";
+    const numbered = [...acceptanceSection.matchAll(/(?:^|\n)\s*(\d+)[.、)]\s+/g)]
+        .map((match) => Number(match[1]))
+        .filter((value, index, values) => Number.isFinite(value) && values.indexOf(value) === index)
+        .sort((a, b) => a - b);
+    return numbered.map((value) => `AC-${value}`);
 }
 function buildDagSourceBinding(sources) {
     const sourceEntries = [
@@ -2146,7 +2160,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
-        "frontend-implementation DAGs must complete deterministic static verification and behavior verification before final review.",
+        "frontend-implementation DAGs must complete deterministic static verification before final review. Behavior verification is also required when the task declares a behavior entrypoint or the implementation contract contains a non-static verification target; static-only contracts must map every target to the declared static entrypoint.",
         "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
@@ -2171,6 +2185,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...explicitFrontendVerifyCommands.behaviorCommands,
     ].map(verifyCommandKey));
     const adapterVerifyCommands = (sources.verifyCommands?.final ?? []).filter((command) => !explicitCommandKeys.has(verifyCommandKey(command)));
+    const hasDeclaredFrontendVerification = explicitFrontendVerifyCommands.staticCommands.length > 0 ||
+        explicitFrontendVerifyCommands.behaviorCommands.length > 0 ||
+        parsedFrontendVerifyCommands.staticCommands.length > 0 ||
+        parsedFrontendVerifyCommands.behaviorCommands.length > 0;
     const staticVerifyCommands = chooseFrontendVerifyCommands({
         explicitCommands: explicitFrontendVerifyCommands.staticCommands,
         parsedCommands: parsedFrontendVerifyCommands.staticCommands,
@@ -2185,6 +2203,9 @@ async function buildFrontendHybridDagFromTask(sources) {
         explicitCommands: explicitFrontendVerifyCommands.behaviorCommands,
         parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
         adapterCommands: adapterVerifyCommands,
+        // A declared task verifier owns this task's verification boundary. A
+        // static-only task must not inherit unrelated root-level test commands.
+        allowAdapter: !hasDeclaredFrontendVerification,
     });
     const staticShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
@@ -2199,8 +2220,13 @@ async function buildFrontendHybridDagFromTask(sources) {
     const behaviorShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: hasDeclaredFrontendVerification
+            ? []
+            : behaviorFallbackCommands,
     });
+    const effectiveBehaviorFallbackCommands = hasDeclaredFrontendVerification
+        ? []
+        : behaviorFallbackCommands;
     const staticVerifyEvidence = buildVerifyEvidence({
         phase: "intermediate",
         quota: strategy.intermediateQuota ?? "full",
@@ -2226,7 +2252,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         quota: "full",
         commandSource: behaviorVerifyCommands.commandSource,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: effectiveBehaviorFallbackCommands,
         commandTexts: behaviorShellCommands,
         finalFullRequired: true,
         commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
@@ -2287,10 +2313,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown scout report covering frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, and risks. No file writes.",
+                outputContract: "Markdown scout report with a required TARGET_SURFACE section covering frontend stack, routes, components, styling system, existing design conventions, state/data flow, test entry points, reuse opportunities, and risks. No file writes.",
                 subtask_prompt: [
                     "Inspect frontend code, routing, components, styles, package scripts, and tests.",
                     "Return code and design observations, existing reuse opportunities, and verification entry points.",
+                    "Begin with a TARGET_SURFACE section containing exactly these labels: entrypoint, routeOrMount, implementationPaths, testPaths, dataSource, allowedPathConflicts. Use repository-relative POSIX paths. implementationPaths and testPaths must name the existing files/directories that actually own the requested behavior; allowedPathConflicts must list every discovered path not covered by task allowedPaths, or [] when none exists.",
                     "Derive all file paths from this target workspace. Do not assume the project uses src/, test/, React, or the loop-agent repository layout.",
                     "Read-only: do not modify repository files.",
                     sourceContext,
@@ -2314,6 +2341,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Select the Mock / API strategy inside the plan and structured contract. Carry endpoint/fixture mapping, explicit activation, production-default-off rule, verification commands, and Real Integration Gap into both outputs.",
                     "Include ordered steps, target files, UI state handling, styling/component strategy, interaction notes, Mock/API strategy, dependency policy, deterministic verification entrypoints, and residual risks. Use only the fixed entrypoints below; implementation may add tests behind them but cannot replace them.",
                     "Every target file and verification target must be selected from the current target workspace and task scope. Do not reuse paths or symbols from examples, prior tasks, or loop-agent itself; if the project uses app/, packages/, spec/, __tests__, or another layout, preserve that layout.",
+                    "Consume the Scout TARGET_SURFACE evidence before selecting files. Preserve the discovered existing entrypoint and data source. If implementationPaths or testPaths are outside task allowedPaths, record a blocking scope conflict; do not substitute a new page or silently broaden the writeSet.",
                     "End with exactly one fenced json object conforming to frontend-implementation-contract-v1 so small topology can materialize the contract without plan-revision.",
                     "Each requirement must state its user-observable or logic-observable expectedOutcome. Each interaction must state its trigger and expectedBehavior. IDs plus file paths are not sufficient behavior semantics.",
                     requirementCoverageInstruction,
@@ -2338,7 +2366,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 subtask_prompt: [
                     "Audit the frontend plan before implementation.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
+                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
@@ -2641,11 +2669,14 @@ async function buildFrontendHybridDagFromTask(sources) {
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
                 skills: FRONTEND_REVIEW_SKILLS,
-                outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision, followed by Findings, Verification Assessment, UX Assessment, and Residual Risks. No file writes.",
+                outputContract: 'Structured JSON review verdict only: {"schemaVersion":1,"verdict":"pass|request-revision","findings":[...],"verificationAssessment":"...","uxAssessment":"...","residualRisks":[...]}. No file writes.',
+                outputProtocol: REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL,
                 subtask_prompt: [
                     "Review the frontend implementation and verification evidence.",
-                    "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Any Critical or Important finding must force VERDICT: request-revision.",
+                    "Return exactly one final JSON object in this response. Do not repeat it, do not emit a second revision, do not wrap it in Markdown, and do not include prose outside the JSON.",
+                    'Required fields: schemaVersion: 1; verdict: "pass" or "request-revision"; findings: array of objects with severity ("Critical" | "Important" | "Minor" | "Info"), optional file, optional positive integer line, issue, and optional requiredChange.',
+                    'verdict "request-revision" requires at least one finding. verdict "pass" is invalid if any finding severity is Critical or Important.',
+                    'Any Critical or Important finding must force verdict "request-revision".',
                     "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, effective initial-or-post-repair verification trace, repair assessment, and the run-owned actual diff (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Treat lint status exactly as passed | baseline-debt | failed | unavailable. baseline-debt may continue only with intact evidence and zero diagnostics on writer-changed files; report the tolerated debt count and never rewrite it as lint passed. Typecheck, build, and test still require successful final exits.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
@@ -2665,15 +2696,16 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writePolicy: "read-only",
                 allowedPaths: readOnlyPaths,
                 forbiddenPaths,
-                outputContract: "Deterministic frontend review verdict gate: exit 0 only when frontend-review-pi emits VERDICT: pass.",
-                subtask_prompt: "Deterministic gate: block downstream closeout unless frontend-review-pi emitted VERDICT: pass.",
+                outputContract: 'Deterministic frontend review verdict gate: exit 0 only when frontend-review-pi emits JSON verdict "pass".',
+                subtask_prompt: 'Deterministic gate: block downstream closeout unless frontend-review-pi emitted JSON verdict "pass".',
                 shell: {
                     commands: [],
                     verdictGate: {
                         fromNodeId: "frontend-review-pi",
-                        accept: ["VERDICT: pass"],
+                        accept: ["pass"],
+                        routingAccept: ["request-revision"],
                         label: "frontend review",
-                        lineMode: "first-verdict-line",
+                        source: "json-review-verdict",
                     },
                     cwd: ".",
                     timeoutMs: 60000,
@@ -3577,13 +3609,50 @@ async function buildBackendTestHybridDag(sources) {
             "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", "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.", "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.");
+    const collectionAssess = shellNode("assess-backend-pytest-collection-shell", [generatePytest.id], "markdown-collection-assess", "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.", "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.", [], 120000);
+    const repairPytest = {
+        id: "repair-backend-pytest-collection-pi",
+        depends_on: [collectionAssess.id],
+        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: Array.from(new Set([...ro, "testcase/**"])),
+        forbiddenPaths: Array.from(new Set([
+            ...forbidden,
+            "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.",
+            "Fix 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.",
+            "Preserve 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.",
+            "Do not read task source/** or reinterpret requirements. Do not modify Markdown, conftest, pytest config, production code or dependencies.",
+            "Do 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.",
+            "Do not execute pytest; the deterministic effective collection gate owns the final collection attempt.",
+        ].join("\n\n"),
+    };
+    const collectionEffective = shellNode("effective-backend-pytest-collection-gate-shell", [collectionAssess.id, repairPytest.id], "markdown-collection-effective", "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.", "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.", [], 120000);
+    collectionEffective.dependsPolicy = "all-or-condition-skip";
+    const traceability = shellNode("backend-test-traceability-gate-shell", [collectionEffective.id], "markdown-traceability", "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.", "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.");
     const manifest = shellNode("backend-test-case-manifest-shell", [traceability.id], "markdown-manifest", "Materialize the canonical Backend Test Case Manifest only from contracts/backend-test-case-coverage-facts.json and contracts/backend-test-markdown-pytest-correspondence-facts.json. Validate schema, task binding, input hashes and freshness; never re-read source semantics, re-analyze Coverage Matrix, rescan pytest symbols or recompute a second set of metrics. Missing/stale/conflicting facts produce partial/unavailable diagnostics rather than fabricated zeros.", "Run-owned contracts/backend-test-case-manifest.json with materializationStatus, sourceFactsIssues, validated coverageScope, coverageSummary, ruleCoverageSummary and correspondenceSummary; this is the single machine input for L-5 and closeout.");
     const pytestCommand = [
         'mkdir -p "${HARNESS_DAG_RUN_DIR}/reports"',
         'echo "pytest targets are resolved at runtime from final Markdown 自动化映射"',
     ].join("; ");
-    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [manifest.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. 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.", "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.", [pytestCommand], 300000);
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [manifest.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. 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.", "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.", [pytestCommand], 300000);
     if (execute.shell) {
         execute.shell.envAllowlist = collectBackendTestShellEnvAllowlist(sources);
     }
@@ -3607,10 +3676,10 @@ async function buildBackendTestHybridDag(sources) {
             ? "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."
             : "Final Markdown report and L-5 conclusion in assistant output; the deterministic L-5 dashboard at reports/backend-test-l5-dashboard.html is the authoritative visualization and must be linked; no JSON or writes.",
         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.",
+            "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.",
             "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.",
-            "The 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.",
-            "Always 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.",
+            "The 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.",
+            "Always 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.",
             "Include 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.",
             "Never 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.",
             canWriteReport
@@ -3628,11 +3697,11 @@ async function buildBackendTestHybridDag(sources) {
         globalConstraints: [
             ...taskConfig.hardConstraints,
             ...STANDARD_GLOBAL_CONSTRAINTS,
-            "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: {
             ...BACKEND_TEST_DEFAULTS,
@@ -3646,6 +3715,9 @@ async function buildBackendTestHybridDag(sources) {
             reviewCases,
             validateCases,
             generatePytest,
+            collectionAssess,
+            repairPytest,
+            collectionEffective,
             traceability,
             manifest,
             execute,
@@ -5286,11 +5358,13 @@ function buildReviewNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Plain Markdown whose first non-empty line is VERDICT: pass or VERDICT: request-revision; Critical/Important findings force request-revision. No file writes.",
-        outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
+        outputContract: 'Structured JSON review verdict only: {"schemaVersion":1,"verdict":"pass|request-revision","findings":[...]}; Critical/Important findings force request-revision. No file writes.',
+        outputProtocol: REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL,
         subtask_prompt: [
             "Review upstream implementation and verification evidence.",
-            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
+            "Return exactly one final JSON object in this response. Do not repeat it, do not emit a second revision, do not wrap it in Markdown, and do not include prose outside the JSON.",
+            'Required fields: schemaVersion: 1; verdict: "pass" or "request-revision"; findings: array of objects with severity ("Critical" | "Important" | "Minor" | "Info"), optional file, optional positive integer line, issue, and optional requiredChange.',
+            'verdict "request-revision" requires at least one finding. verdict "pass" is invalid if any finding severity is Critical or Important.',
             "List Critical/Important findings when present; any Critical/Important finding must force request-revision. Read-only: do not modify files.",
             [
                 "Three-way source fidelity check (required):",
@@ -5319,15 +5393,16 @@ function buildReviewVerdictRecoveryNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Plain Markdown whose first non-empty line is exactly VERDICT: pass or VERDICT: request-revision, followed by the original review findings without substantive changes. No file writes.",
-        outputProtocol: REVIEW_VERDICT_OUTPUT_PROTOCOL,
+        outputContract: 'Structured JSON review verdict only, preserving the original review conclusion/findings without substantive changes. No file writes.',
+        outputProtocol: REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL,
         subtask_prompt: [
             "Normalize the output format of review-pi; this is the single read-only format-recovery attempt for the review verdict protocol.",
-            "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-            "If review-pi already contains a valid VERDICT line, preserve that verdict exactly and keep the original findings.",
-            "If it omitted or malformed the VERDICT line but states an unambiguous request-revision conclusion, emit VERDICT: request-revision and preserve the findings.",
-            "Do not invent VERDICT: pass from natural-language phrases such as 通过、PASS、✅, or general approval prose.",
-            "If the upstream conclusion is ambiguous or cannot be preserved safely, emit VERDICT: request-revision and report the format ambiguity.",
+            "Return only one JSON object. Do not wrap it in Markdown and do not include prose outside the JSON.",
+            'Required fields: schemaVersion: 1; verdict: "pass" or "request-revision"; findings: array of objects with severity ("Critical" | "Important" | "Minor" | "Info"), optional file, optional positive integer line, issue, and optional requiredChange.',
+            "If review-pi already contains valid JSON, preserve its verdict exactly and keep the original findings.",
+            'If it omitted or malformed JSON but states an unambiguous request-revision conclusion, emit verdict "request-revision" and preserve the findings.',
+            'Do not invent verdict "pass" from natural-language phrases such as 通过, PASS, or general approval prose.',
+            'If the upstream conclusion is ambiguous or cannot be preserved safely, emit verdict "request-revision" and report the format ambiguity as a finding.',
             "Do not re-review code, expand task allowedPaths, or edit files.",
             buildSourceContextBlock(sources),
         ].join("\n\n"),
@@ -5343,15 +5418,16 @@ function buildReviewGateNode(sources) {
         writePolicy: "read-only",
         allowedPaths: commonReadOnlyPaths(sources),
         forbiddenPaths: commonForbiddenPaths(sources),
-        outputContract: "Deterministic review verdict gate: exit 0 only when review-verdict-recovery-pi first VERDICT line is pass.",
-        subtask_prompt: "Deterministic gate: block downstream closeout unless review-verdict-recovery-pi emitted VERDICT: pass.",
+        outputContract: 'Deterministic review verdict gate: exit 0 only when review-verdict-recovery-pi emits JSON verdict "pass".',
+        subtask_prompt: 'Deterministic gate: block downstream closeout unless review-verdict-recovery-pi emitted JSON verdict "pass".',
         shell: {
             commands: [],
             verdictGate: {
                 fromNodeId: "review-verdict-recovery-pi",
-                accept: ["VERDICT: pass"],
+                accept: ["pass"],
+                routingAccept: ["request-revision"],
                 label: "review",
-                lineMode: "first-verdict-line",
+                source: "json-review-verdict",
             },
             cwd: ".",
             timeoutMs: 60000,
@@ -5920,8 +5996,8 @@ function buildSupervisedHybridDag(standard, sources) {
             buildReviewGateNode(sources),
             buildDecisionNode(sources),
             cloneTask(closeout, {
-                depends_on: ["decision-pi"],
-                failureAwareDependsOn: ["decision-pi"],
+                depends_on: ["decision-pi", "review-gate-shell"],
+                failureAwareDependsOn: ["decision-pi", "review-gate-shell"],
             }),
         ],
     };

package/dist/workflows/dag/output-protocol.js

@@ -3,22 +3,54 @@ import { normalizeVerdictCandidateLine } from "./dynamic-runtime/shared.js";
 /**
  * Machine-readable output protocol for safe read-only Pi nodes.
  *
- * Phase 1 only supports first-line-enum (e.g. VERDICT lines). Structured JSON
- * continues to use existing structured-required / deterministic gates.
  */
-export const dagOutputProtocolSchema = z
+const firstLineEnumOutputProtocolSchema = z
     .object({
     type: z.literal("first-line-enum"),
     validLines: z.array(z.string().min(1)).min(1),
     retryOnInvalid: z.boolean().default(true),
 })
     .strict();
+const jsonReviewVerdictOutputProtocolSchema = z
+    .object({
+    type: z.literal("json-review-verdict"),
+    retryOnInvalid: z.boolean().default(true),
+})
+    .strict();
+export const dagOutputProtocolSchema = z.discriminatedUnion("type", [
+    firstLineEnumOutputProtocolSchema,
+    jsonReviewVerdictOutputProtocolSchema,
+]);
 /** Reviewer VERDICT protocol used by reviewed/supervised DAGs. */
 export const REVIEW_VERDICT_OUTPUT_PROTOCOL = {
     type: "first-line-enum",
     validLines: ["VERDICT: pass", "VERDICT: request-revision"],
     retryOnInvalid: true,
 };
+/** Structured reviewer verdict protocol used when deterministic gates parse JSON. */
+export const REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL = {
+    type: "json-review-verdict",
+    retryOnInvalid: true,
+};
+const reviewFindingSchema = z
+    .object({
+    severity: z.enum(["Critical", "Important", "Minor", "Info"]),
+    file: z.string().min(1).optional(),
+    line: z.number().int().positive().optional(),
+    issue: z.string().min(1),
+    requiredChange: z.string().min(1).optional(),
+})
+    .strict();
+const reviewJsonVerdictSchema = z
+    .object({
+    schemaVersion: z.literal(1),
+    verdict: z.enum(["pass", "request-revision"]),
+    findings: z.array(reviewFindingSchema),
+    verificationAssessment: z.string().min(1).optional(),
+    uxAssessment: z.string().min(1).optional(),
+    residualRisks: z.array(z.string().min(1)).optional(),
+})
+    .strict();
 /**
  * Extract the first non-empty line from assistant/stdout text.
  */
@@ -30,12 +62,136 @@ export function firstNonEmptyLine(text) {
     }
     return undefined;
 }
+function extractSingleJsonObjectText(text) {
+    const trimmed = String(text).trim();
+    if (!trimmed)
+        return { ok: false, reason: "missing JSON output" };
+    const extractBalancedObject = (source) => {
+        for (let start = 0; start < source.length; start += 1) {
+            if (source[start] !== "{")
+                continue;
+            let depth = 0;
+            let inString = false;
+            let escaped = false;
+            for (let index = start; index < source.length; index += 1) {
+                const char = source[index];
+                if (inString) {
+                    if (escaped)
+                        escaped = false;
+                    else if (char === "\\")
+                        escaped = true;
+                    else if (char === '"')
+                        inString = false;
+                    continue;
+                }
+                if (char === '"')
+                    inString = true;
+                else if (char === "{")
+                    depth += 1;
+                else if (char === "}" && --depth === 0) {
+                    const candidate = source.slice(start, index + 1);
+                    try {
+                        const parsed = JSON.parse(candidate);
+                        if (parsed && typeof parsed === "object" && !Array.isArray(parsed))
+                            return candidate;
+                    }
+                    catch {
+                        // Continue scanning for the next complete object.
+                    }
+                    break;
+                }
+            }
+        }
+        return undefined;
+    };
+    const direct = extractBalancedObject(trimmed);
+    if (direct)
+        return { ok: true, jsonText: direct };
+    const fencedMatches = Array.from(trimmed.matchAll(/```(?:json)?\s*([\s\S]*?)\s*```/gi));
+    if (fencedMatches.length === 1) {
+        const jsonText = fencedMatches[0][1].trim();
+        const fencedObject = extractBalancedObject(jsonText);
+        if (fencedObject)
+            return { ok: true, jsonText: fencedObject };
+        return {
+            ok: false,
+            reason: "single fenced block is not a JSON object",
+        };
+    }
+    if (fencedMatches.length > 1) {
+        return {
+            ok: false,
+            reason: "multiple fenced JSON candidates found; expected exactly one JSON object",
+        };
+    }
+    return {
+        ok: false,
+        reason: "output is not a single JSON object; expected only JSON with no Markdown or prose",
+    };
+}
+function validateJsonReviewVerdict(text) {
+    const extracted = extractSingleJsonObjectText(text);
+    if (!extracted.ok) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: extracted.reason,
+            firstNonEmptyLine: firstNonEmptyLine(text),
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(extracted.jsonText);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
+            firstNonEmptyLine: firstNonEmptyLine(text),
+        };
+    }
+    const checked = reviewJsonVerdictSchema.safeParse(parsed);
+    if (!checked.success) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: `JSON review verdict schema violation: ${checked.error.issues
+                .map((issue) => `${issue.path.join(".") || "<root>"} ${issue.message}`)
+                .join("; ")}`,
+            firstNonEmptyLine: firstNonEmptyLine(text),
+        };
+    }
+    const blockingFindings = checked.data.findings.filter((finding) => finding.severity === "Critical" || finding.severity === "Important");
+    if (checked.data.verdict === "pass" && blockingFindings.length > 0) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: "JSON review verdict cannot be pass when Critical or Important findings are present",
+            firstNonEmptyLine: firstNonEmptyLine(text),
+        };
+    }
+    if (checked.data.verdict === "request-revision" &&
+        checked.data.findings.length === 0) {
+        return {
+            ok: false,
+            failureCategory: "protocol-invalid",
+            reason: "JSON review verdict request-revision requires at least one finding",
+            firstNonEmptyLine: firstNonEmptyLine(text),
+        };
+    }
+    return { ok: true, verdict: checked.data.verdict };
+}
 /**
  * Validate node output against an explicit outputProtocol.
  * Pure function — does not mutate run facts.
  */
 export function validateOutputProtocol(protocol, text) {
-    if (protocol.type !== "first-line-enum") {
+    if (protocol.type === "json-review-verdict") {
+        return validateJsonReviewVerdict(text);
+    }
+    const validLines = "validLines" in protocol ? protocol.validLines : undefined;
+    if (!validLines) {
         return {
             ok: false,
             failureCategory: "protocol-invalid",
@@ -64,6 +220,17 @@ export function validateOutputProtocol(protocol, text) {
  * Correction instruction appended on protocol-invalid retry attempts.
  */
 export function buildProtocolRetryInstruction(protocol, reason) {
+    if (protocol.type === "json-review-verdict") {
+        return [
+            "<retry_instruction>",
+            "Previous attempt violated the structured review output protocol:",
+            reason,
+            "Return ONLY a JSON object, with no Markdown fence and no surrounding prose.",
+            'Required schema: {"schemaVersion":1,"verdict":"pass|request-revision","findings":[{"severity":"Critical|Important|Minor|Info","file":"optional path","line":1,"issue":"required","requiredChange":"optional"}],"verificationAssessment":"optional","uxAssessment":"optional","residualRisks":["optional"]}.',
+            'Rules: verdict "request-revision" requires at least one finding; verdict "pass" is invalid if any finding severity is Critical or Important.',
+            "</retry_instruction>",
+        ].join("\n");
+    }
     const expected = protocol.validLines
         .map((line) => JSON.stringify(line))
         .join(" or ");
@@ -102,9 +269,15 @@ export function buildProtocolRetryInstruction(protocol, reason) {
  * output, and structured protocols are never loosely tolerated.
  */
 export function normalizeReviewVerdictAfterRetries(protocol, text) {
-    const isReviewVerdictProtocol = protocol.type === REVIEW_VERDICT_OUTPUT_PROTOCOL.type &&
-        Array.from(protocol.validLines).every((line, index) => line === REVIEW_VERDICT_OUTPUT_PROTOCOL.validLines[index]) &&
-        protocol.validLines.length ===
+    if (protocol.type !== "first-line-enum") {
+        return {
+            ok: false,
+            reason: "deterministic verdict normalization only applies to the canonical review verdict protocol",
+        };
+    }
+    const validLines = protocol.validLines;
+    const isReviewVerdictProtocol = Array.from(validLines).every((line, index) => line === REVIEW_VERDICT_OUTPUT_PROTOCOL.validLines[index]) &&
+        validLines.length ===
             REVIEW_VERDICT_OUTPUT_PROTOCOL.validLines.length;
     if (!isReviewVerdictProtocol) {
         return {