@tea-agent/loop-agent 0.24.11-beta.0 → 0.25.1

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

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
-import { access, readdir, readFile, realpath, writeFile, } from "node:fs/promises";
+import { access, readdir, readFile, realpath, } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
-import os from "node:os";
 import path from "node:path";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
 import { assertValidDagSpec } from "./validate.js";
 import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1, DAG_RUNTIME_CONTRACT_SCHEMA_VERSION, DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
+import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
@@ -25,7 +26,7 @@ import { normalizeTaskRequirementText, resolveTaskDagTemplateSelection, } from "
 import { BACKEND_TEST_EXECUTION_DEFAULT_TEST_ROOT, buildBackendTestExecutionPreflightShellSnippet, } from "./backend-test-execution-contract.js";
 import { buildBackendTestOutcomeGateShellSnippet } from "./backend-test-result-contract.js";
 import { buildBackendTestIntakeContext } from "./backend-test-intake-context.js";
-import { buildFrontendCaseEvidenceValidateShellSnippet, buildFrontendTestOutcomeGateShellSnippet, } from "./frontend-test-result-contract.js";
+import { buildFrontendTestOutcomeGateShellSnippet } from "./frontend-test-result-contract.js";
 import { classifyFrontendRisk, } from "./frontend-risk.js";
 import { discoverFrontendProjectCapability, } from "./frontend-project-capability.js";
 import { FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID, loadFrontendImplementationContractJsonSchema, } from "./frontend-implementation-contract.js";
@@ -90,6 +91,7 @@ const FRONTEND_SKILLS_BY_ROLE = {
     closeout: [],
 };
 const FRONTEND_IMPLEMENTATION_SKILLS = ["frontend-implementation"];
+const FRONTEND_BOUNDED_IMPLEMENT_SKILLS = ["frontend-bounded-implement"];
 const FRONTEND_DESIGN_REVIEW_SKILLS = ["frontend-design-review"];
 const FRONTEND_REVIEW_SKILLS = ["frontend-review"];
 const FRONTEND_VERIFICATION_SKILLS = ["frontend-verification"];
@@ -758,6 +760,56 @@ function buildVerifyShellCommands(input) {
     const repoRoot = input.repoRoot;
     return input.commands.map((command) => verifyCommandToShell(repoRoot, command));
 }
+function toDagMavenVerificationPlan(plan, shellCommands) {
+    const shellCommandDigests = shellCommands?.map((command) => createHash("sha256").update(command).digest("hex")) ?? plan.shellCommandDigests;
+    return {
+        schemaVersion: plan.schemaVersion,
+        plannerVersion: plan.plannerVersion,
+        fingerprint: plan.fingerprint,
+        inputDigest: plan.inputDigest,
+        targets: plan.targets,
+        commandDigests: plan.commandDigests,
+        plannedCommands: plan.plannedCommands,
+        ...(plan.workspaceManifest
+            ? { workspaceManifest: plan.workspaceManifest }
+            : {}),
+        ...(shellCommandDigests && shellCommandDigests.length > 0
+            ? { shellCommandDigests }
+            : {}),
+    };
+}
+/**
+ * Apply task-scope Maven verification planning before shell serialization.
+ * Non-Maven command sets are returned unchanged (REQ-MVN-007).
+ */
+function applyMavenVerificationPlanning(input) {
+    if (!input.repoRoot || !input.commands || input.commands.length === 0) {
+        return { commands: input.commands };
+    }
+    const implement = resolveImplementPaths(input.taskConfig);
+    const planned = planMavenVerification({
+        repoRoot: input.repoRoot,
+        commands: input.commands,
+        scope: {
+            allowedPaths: input.taskConfig.allowedPaths ?? [],
+            writeSet: implement.writeSet,
+            sourcePaths: input.taskConfig.sourceFiles ?? [],
+        },
+    });
+    if (!planned.plan) {
+        return { commands: planned.commands };
+    }
+    // Freeze shell command digests against the serialized shell form used at runtime.
+    const shellCommands = buildVerifyShellCommands({
+        repoRoot: input.repoRoot,
+        commands: planned.commands,
+        fallbackCommands: [],
+    });
+    return {
+        commands: planned.commands,
+        mavenVerificationPlan: toDagMavenVerificationPlan(planned.plan, shellCommands),
+    };
+}
 function markdownVerifyCommand(repoRoot, command) {
     const args = command.split(/\s+/).filter(Boolean);
     if (args.length === 0 ||
@@ -871,7 +923,101 @@ function buildExplicitFrontendVerifyCommands(taskConfig, repoRoot) {
     return { staticCommands, behaviorCommands };
 }
 function verifyCommandKey(command) {
-    return `${command.cwd}\0${command.args.join("\0")}`;
+    const normalizedArgs = normalizeVerifyCommandArgs(command.args);
+    const normalizedCwd = path.resolve(command.cwd).replace(/\\/g, "/");
+    const cwdKey = process.platform === "win32"
+        ? normalizedCwd.toLowerCase()
+        : normalizedCwd;
+    const envKey = Object.entries(command.env ?? {})
+        .filter((entry) => entry[1] !== undefined)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\0");
+    return [cwdKey, normalizedArgs.join("\0"), envKey, command.timeoutMs ?? ""]
+        .join("\u0001");
+}
+function normalizeVerifyCommandArgs(args) {
+    if (args.length === 3 &&
+        /^(?:bash|sh)(?:\.exe)?$/i.test(path.basename(args[0])) &&
+        args[1] === "-lc") {
+        const parsed = tokenizeSimpleShellCommand(args[2]);
+        if (parsed)
+            return normalizeVerifyCommandArgs(parsed);
+    }
+    return args.map((arg, index) => {
+        const normalized = arg.replace(/\\/g, "/");
+        return index === 0 && process.platform === "win32"
+            ? normalized.toLowerCase()
+            : normalized;
+    });
+}
+function tokenizeSimpleShellCommand(command) {
+    const tokens = [];
+    let token = "";
+    let quote = null;
+    let escaping = false;
+    let tokenStarted = false;
+    for (const char of command.trim()) {
+        if (escaping) {
+            token += char;
+            escaping = false;
+            tokenStarted = true;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaping = true;
+            tokenStarted = true;
+            continue;
+        }
+        if (quote) {
+            if (quote === '"' && (char === "$" || char === "`"))
+                return undefined;
+            if (char === quote)
+                quote = null;
+            else
+                token += char;
+            tokenStarted = true;
+            continue;
+        }
+        if (char === "'" || char === '"') {
+            quote = char;
+            tokenStarted = true;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (tokenStarted)
+                tokens.push(token);
+            token = "";
+            tokenStarted = false;
+            continue;
+        }
+        if (/[;&|<>`\r\n]/.test(char) || char === "$" || char === "(") {
+            return undefined;
+        }
+        token += char;
+        tokenStarted = true;
+    }
+    if (escaping || quote)
+        return undefined;
+    if (tokenStarted)
+        tokens.push(token);
+    return tokens.length > 0 ? tokens : undefined;
+}
+function isFullSuiteVerifyCommand(command) {
+    const args = normalizeVerifyCommandArgs(command.args);
+    let index = 0;
+    while (/^[A-Za-z_][A-Za-z0-9_]*=/.test(args[index] ?? ""))
+        index += 1;
+    const executable = path.basename(args[index] ?? "").toLowerCase().replace(/\.(?:exe|cmd)$/, "");
+    const rest = args.slice(index + 1);
+    if (["npm", "pnpm", "yarn", "bun"].includes(executable)) {
+        return ((rest.length === 1 && rest[0] === "test") ||
+            (rest.length === 2 && rest[0] === "run" && rest[1] === "test"));
+    }
+    if (["bash", "sh"].includes(executable) && rest.length === 1) {
+        return /(?:^|\/)scripts\/ci\.sh$/i.test(rest[0].replace(/\\/g, "/"));
+    }
+    return rest.length === 0 && /(?:^|\/)scripts\/ci\.sh$/i.test((args[index] ?? "").replace(/\\/g, "/"));
 }
 function resolveDagVerifyStrategy(taskConfig, defaultIntermediateQuotaWhenFull = "full") {
     const explicitIntermediateQuota = taskConfig.dagVerifyStrategy?.intermediateQuota;
@@ -1339,7 +1485,7 @@ function mergeFinalVerifyCommands(repoRoot, taskConfig, adapterCommands) {
     }));
     const seen = new Set();
     return [...taskCommands, ...adapterCommands].filter((command) => {
-        const key = `${command.cwd}\0${command.args.join("\0")}`;
+        const key = verifyCommandKey(command);
         if (seen.has(key))
             return false;
         seen.add(key);
@@ -1355,9 +1501,14 @@ export function buildStandardHybridDagFromTask(sources) {
     const implementComplexity = resolveWriterComplexity(taskConfig);
     const implementId = implementationNodeId();
     const finalVerifyCommands = sources.verifyCommands?.final ?? [];
-    const verifyShellCommands = buildVerifyShellCommands({
+    const plannedFinal = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
         commands: finalVerifyCommands,
+        taskConfig,
+    });
+    const verifyShellCommands = buildVerifyShellCommands({
+        repoRoot: sources.repoRoot,
+        commands: plannedFinal.commands,
         fallbackCommands: [],
     });
     const verifyShellTask = verifyShellCommands.length > 0
@@ -1381,13 +1532,16 @@ export function buildStandardHybridDagFromTask(sources) {
                         phase: "final",
                         quota: "full",
                         commandSource: "adapter",
-                        commands: finalVerifyCommands,
+                        commands: plannedFinal.commands,
                         fallbackCommands: [],
                         finalFullRequired: true,
                         commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
                     }),
                     cwd: ".",
                     timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+                    ...(plannedFinal.mavenVerificationPlan
+                        ? { mavenVerificationPlan: plannedFinal.mavenVerificationPlan }
+                        : {}),
                 },
             },
         ]
@@ -1782,9 +1936,8 @@ function resolveFrontendMockContextBlock(sources) {
     }
     if (mode === "not-required") {
         parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
-        if ((sources.taskConfig.frontendMock?.policy ?? "auto") === "auto" &&
-            (capability.status === "absent" || capability.status === "ambiguous")) {
-            parts.push("Auto mode may skip Mock when no project Mock capability is confirmed. Do not block solely for missing Mock; keep the real request path as default and record any unproved backend behavior as Real Integration Gap.");
+        if (frontendMockStrategyMustBeNotNeeded(sources)) {
+            parts.push('Auto mode has no confirmed project Mock capability. The structured contract must set mockApi.strategy to "not-needed". Do not add Mock files or dependencies; keep the real request path as default and record any unproved backend behavior as Real Integration Gap.');
         }
     }
     if (mode === "blocked") {
@@ -1792,6 +1945,12 @@ function resolveFrontendMockContextBlock(sources) {
     }
     return parts.join("\n");
 }
+function frontendMockStrategyMustBeNotNeeded(sources) {
+    const capabilityStatus = sources.frontendMockCapability?.status;
+    return ((sources.taskConfig.frontendMock?.policy ?? "auto") === "auto" &&
+        (sources.frontendMockMode ?? "not-required") === "not-required" &&
+        (capabilityStatus === "absent" || capabilityStatus === "ambiguous"));
+}
 function resolveFrontendCapabilityContextBlock(sources) {
     const risk = sources.frontendRisk;
     const capability = sources.frontendProjectCapability;
@@ -2146,6 +2305,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "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.",
                     "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,
                     "Read-only: do not modify code, docs, artifacts, or repository files.",
                     fixedVerificationContext,
@@ -2200,6 +2360,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Do not turn MOCK_STRATEGY: blocked into an implementable strategy without new repository or contract evidence that resolves every blocker.",
                     "Read-only: do not modify code, docs, artifacts, or repository files. This node revises the plan only.",
                     "End the response with exactly one fenced json object conforming to frontend-implementation-contract-v1. Bind it to the supplied task sources; map every requirement and applicable UI state to concrete implementation and verification targets or an explicit blocking evidence gap. Do not include secrets or unsafe paths.",
+                    "Preserve each requirement expectedOutcome and each interaction trigger/expectedBehavior in the revised contract; do not reduce behavior semantics to IDs and paths.",
                     sourceContext,
                     frontendContractSchemaBlock,
                 ].join("\n\n"),
@@ -2259,7 +2420,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                         reviewFromNodeId: "frontend-final-design-review-pi",
                         reviewFallbackFromNodeIds: ["frontend-design-review-pi"],
                         requiredRequirementIds: requirementIds,
-                        allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled"
+                        allowedMockStrategies: taskConfig.frontendMock?.policy === "disabled" ||
+                            frontendMockStrategyMustBeNotNeeded(frontendSources)
                             ? ["not-needed"]
                             : taskConfig.frontendMock?.policy === "required"
                                 ? ["native", "browser-intercept", "request-adapter"]
@@ -2316,13 +2478,17 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writeSet: implementPaths.writeSet,
                 allowedPaths: implementPaths.allowedPaths,
                 forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
+                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                },
+                outputContract: "First non-empty line: IMPLEMENTATION_OUTCOME: changed | already-satisfied | blocked. Then a Markdown delivery summary with Contract Ref (path/schema/hash), Changed Files, Requirements Implemented, UI States, Tests Changed, Verification Attempts, Deviations, and Residual Risks. Follow fixed stages: contract confirm → tests → component/state → API/Mock → focused checks → diff cleanup.",
                 subtask_prompt: [
                     "Implement against the validated run-owned Frontend Implementation Contract from frontend-prewrite-gate-shell (path/schema/hash). Do not rebuild the contract from Markdown alone.",
                     "The canonical contract already contains the approved requirement, target-file, UI-state, verification, design, and Mock/API decisions. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat broad repository research. Inspect only contract target files and directly related local code needed to implement them.",
                     "Execute in fixed stages and report each in the delivery summary: (1) Contract confirm, (2) Tests sync, (3) Component/UI state implementation, (4) API/Mock wiring per contract.mockApi, (5) Focused checks behind frozen entrypoints only, (6) Diff cleanup.",
-                    "Map every requirement id and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
+                    "Map every requirement id, expectedOutcome, interaction trigger/expectedBehavior, and applicable UI state from the contract to concrete files. Do not invent shell verification commands; only frozen static/behavior entrypoints will run.",
+                    "Begin implementation after the contract and its target files are confirmed. Do not spend the turn collecting optional context. If the canonical contract lacks behavior needed to edit safely, return IMPLEMENTATION_OUTCOME: blocked instead of reopening broad discovery.",
                     "Implement only the approved Mock strategy carried by the validated contract. Preserve the real request path as the default, require explicit test/dev activation, and never comment out or replace the real request with inline data.",
                     "frontend-prewrite-gate-shell confirmed the effective plan/review, requirement coverage, Mock policy, and contract. Stay within writeSet and preserve unrelated files.",
                     "For native, browser-intercept, or request-adapter, implement contract-aligned fixtures/states and a dev/test-only activation boundary in this same writer. For not-needed, do not add Mock files or a framework and state the positive reason.",
@@ -2377,8 +2543,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 writeSet: implementPaths.writeSet,
                 allowedPaths: implementPaths.allowedPaths,
                 forbiddenPaths,
-                skills: FRONTEND_IMPLEMENTATION_SKILLS,
-                outputContract: "Repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
+                skills: FRONTEND_BOUNDED_IMPLEMENT_SKILLS,
+                writerOutcomePolicy: {
+                    type: "implementation-outcome-v1",
+                },
+                outputContract: "First non-empty line: IMPLEMENTATION_OUTCOME: changed | already-satisfied | blocked. Then a repair summary for an eligible repairable assessment. Must not expand writeSet, re-interpret requirements, skip tests, or enable Mock by default.",
                 subtask_prompt: [
                     "Read contracts/frontend-repair-assessment.json and the validated frontend implementation contract.",
                     "This node runs only for eligible=true. Apply the smallest fix for the classified repairable failure inside the original implement writeSet only.",
@@ -3302,8 +3471,9 @@ async function buildBackendTestHybridDag(sources) {
             "Write human-readable content in Simplified Chinese by default. Keep English only for machine-readable IDs and technical literals such as Case/AC/REQ/BR IDs, HTTP methods, paths, field names, enum values, commands, filenames, code symbols and exact source citations.",
             "Create testcase/md/README.md as the concise entry page: test objective, target/environment, isolation/cleanup, module summary and a linked case index table with Case ID, Chinese case name, scenario type, endpoint and expected status/result. Avoid repeating every case body in README.",
             "Write each module as readable case cards. Every case starts with `## BE-<MODULE>-<NNN>｜<中文用例名称>`. The only sections required by the deterministic validator are `### 前置条件`, `### 操作步骤`, and `### 预期结果` (legacy English aliases remain accepted). Add `测试目的`, `验收标准`, `需求依据`, `测试数据`, and `自动化映射` when useful for human readability; every automatable case should explicitly name its target pytest script under `自动化映射` so traceability can scan only that script.",
+            "Name each module file with a stable lowercase business stem such as `testcase/md/health.md` or `testcase/md/resource_notes.md`. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. For every automatable case, `自动化映射` must name exactly `testcase/test_<module>.py`, where <module> is that Markdown filename without `.md`, lowercased, with non-alphanumeric characters replaced by underscores. Example: `testcase/md/health.md` → `testcase/test_health.py`; `testcase/md/resource_notes.md` → `testcase/test_resource_notes.py`. Never invent a different pytest path in Markdown than the module stem implies.",
             "Place steps and their expected results in a compact readable table when that improves clarity; otherwise keep numbered executable steps and numbered/bulleted independently assertable results. Every result must name the observable HTTP status, response field/value, state transition or membership condition, never vague wording such as ‘符合预期’.",
-            "In `自动化映射`, record the planned script path and pytest function name when known. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
+            "In `自动化映射`, record the planned script path and pytest function name when known, and keep the script path identical to the module one-to-one path above. Put implementation-only restrictions in a concise `<details>` block rather than dominating the main case flow. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and copy `path` exactly into Markdown Source References. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
             "Read only precise indexed references needed for AC/API/field/rule evidence; references remain authoritative over derived text.",
@@ -3316,8 +3486,8 @@ async function buildBackendTestHybridDag(sources) {
         outputContract: "Review source fidelity and directly revise only testcase/md/**; return concise Markdown, never JSON.",
         subtask_prompt: [
             "Independently review generated Markdown cases against the task requirements and environment evidence. Treat the files as human-facing test documentation: require clear preconditions, executable steps and assertable expected results; improve names, purpose, metadata and automation mapping where useful while preserving exact machine IDs and technical literals.",
-            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, and missing script/function mapping where it can be derived.",
-            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, fix mappings/expectations, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations exact. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
+            "Check AC completeness/meaning, endpoint, fields/shape, status/error codes, rules, states, documented boundaries/auth, positive/negative coverage, executable steps and assertable results. Reject avoidable English prose, duplicated bilingual wording, repeated boilerplate, oversized unstructured sections, vague results such as ‘符合预期’, Case-ID-like module filenames (for example `BE-HEALTH.md`), and missing or drifted script/function mapping where it can be derived.",
+            "Correct testcase/md/** directly: add documented omissions, remove unsupported cases, rename module files to stable lowercase stems when needed, fix automation mappings so each case points at `testcase/test_<module>.py` derived from that module filename, merge duplicates, improve navigation/tables/Chinese wording, or record gaps in Chinese. Keep Case IDs, AC/REQ/BR IDs, HTTP methods, paths, fields, enum values, filenames, code symbols and source citations exact. The validator accepts Chinese and legacy English section aliases; retain or converge to the Chinese human-readable headings without losing structure.",
             "Read only precise referenced source paths plus requirement sections needed for uncovered ACs. Do not scan the repository, modify source/**, generate pytest, execute tests, or emit JSON.",
             intake.boundedSourceContext, "## Authoritative reference index", JSON.stringify(intake.referenceIndex, null, 2),
             "For each index entry, use `readPath` for Pi read-tool calls and keep `path` as the exact Markdown Source References citation. Bound files under .harness/tasks/<taskId>/source/** are read-only inputs: reading them is allowed even though writing .harness/** is forbidden. Never resolve `path` relative to the repository root, search for substitutes, or fall back to docs/** when a bound read fails.",
@@ -3333,7 +3503,7 @@ async function buildBackendTestHybridDag(sources) {
         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.",
             "Ensure every final Markdown Case ID appears in at least one real pytest test function or pytest test class method region, preferably as `test_BE_<MODULE>_<NNN>_<description>` and in that function/method docstring. Module-level functions and class-based pytest methods are both supported. Multiple test functions may cover one Case ID; assertions come only from 预期结果/Expected Results and setup comes only from 前置条件 plus any optional 测试数据/自动化映射 or their legacy English aliases.",
-            "Name 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`, and `testcase/md/order-api.md` maps to `testcase/test_order_api.py`. 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.",
+            "Name 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.",
             "Generate a reusable HTTP logging helper (or equivalent client wrapper) and call it for every interface request. The request log must include method, URL/path, and request parameters (query plus JSON/body/payload summary). The response log must include status code and response result (JSON/text/body summary), and both records must be visible in pytest stdout/stderr without changing assertions.",
             "Compare timestamps and other semantically equivalent protocol values by parsed meaning, not byte-for-byte serialization. In particular, normalize valid ISO-8601 instants before equality/order assertions so differences such as omitted trailing fractional seconds do not create TestBug failures; preserve exact-string assertions only when the Markdown explicitly requires representation equality.",
             "Before logging, recursively redact sensitive keys and header values including authorization, proxy-authorization, cookie, set-cookie, token, password, secret, api key and credentials. Never print full Authorization/Cookie values. Apply bounded truncation to serialized request and response bodies (with an explicit truncation marker) so large payloads cannot flood pytest or report artifacts.",
@@ -3345,7 +3515,7 @@ async function buildBackendTestHybridDag(sources) {
         '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", [traceability.id], "markdown-execute-html", "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. Validate JUnit, then render the primary self-contained Chinese HTML report from the same JUnit plus final Markdown case metadata without rerun. Keep 测试结论, quality status, failure overview, and a polished per-case result card with concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over Markdown-mapped scripts producing valid JUnit with per-case captured output, self-contained reports/backend-test.html and reports/backend-test.md, plus internal reports/backend-test-facts.md evidence; exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
+    const execute = shellNode("execute-backend-pytest-and-html-report-shell", [traceability.id], "markdown-execute-html", "Resolve the final Markdown Automation Notes/自动化映射 to a unique, safe set of testcase/**/test_*.py targets and execute only those scripts exactly once. 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 测试结论, quality status, failure overview, and a polished per-case result card with concise scenario, automation test name, result, duration, and redacted bounded HTTP request parameters/response results for both passed and failed cases. Do not render a technical/execution evidence section in HTML; retain auditable paths and hashes in facts.", "One scoped pytest execution over Markdown-mapped scripts producing 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);
     }
@@ -3356,13 +3526,14 @@ async function buildBackendTestHybridDag(sources) {
             ? { toolProfile: "write", writePolicy: "exclusive", writeSet: ["docs/test-reports/**"], allowedPaths: ["docs/test-reports/**"] }
             : { writePolicy: "read-only", allowedPaths: ro }),
         forbiddenPaths: forbidden,
-        outputContract: canWriteReport ? "Final Markdown report and L-5 conclusion under docs/test-reports/**; no JSON." : "Final Markdown report and L-5 conclusion in assistant output; no JSON or writes.",
+        outputContract: canWriteReport ? "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 from upstream facts and run-owned environment, advisory case-validation, advisory traceability, JUnit and HTML evidence. Do not emit JSON.",
+            "Generate the final Markdown report from upstream facts and run-owned environment, advisory case-validation, advisory traceability, pytest-html and HTML evidence. Do not emit JSON.",
             "Use this exact human-facing section order: 测试结论 → 执行概览 → 质量校验 → 失败分析 → 风险与建议 → 证据与 L-5. Put the decision and key numbers first, use compact tables/bullets, and keep headings concise. Do not paste entire upstream reports, duplicate per-case tables already present in facts, or repeat the same evidence in multiple sections; link to paths/hashes and quote only the findings needed for the conclusion.",
+            "The L-5 metrics and visualization are already produced deterministically by node 7 at reports/backend-test-l5-dashboard.html (rendered from computeL5ReportMetrics). Link to that dashboard as the authoritative L-5 view; do not recompute pass/AC/automation/coverage numbers or re-render an HTML dashboard yourself. Quote its L-5 decision verbatim.",
             "Always state the exact PASS/FAIL status and findings from nodes 4 and 6. Their FAIL status does not block pytest, but it must remain visible as a quality/traceability risk and must never be rewritten as PASS.",
             "Include environment, case quality/review, automation mapping, exact pytest facts, failure classification/analysis, risks, regression recommendations, evidence paths/hashes, coverage availability, and L-5 READY/NOT READY.",
-            "Never override Shell/JUnit facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.",
+            "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 ? "Write only under docs/test-reports/**." : "Keep the full report in assistant output.",
         ].join("\n\n"),
     };
@@ -3376,7 +3547,7 @@ async function buildBackendTestHybridDag(sources) {
             ...taskConfig.hardConstraints, ...STANDARD_GLOBAL_CONSTRAINTS,
             "backend-test-dag uses exactly 8 real top-level tasks and executes pytest exactly once over only the safe scripts explicitly mapped by final Markdown cases.",
             "Model nodes produce Markdown and pytest assets, never backend-test business JSON envelopes.",
-            "Environment, advisory Markdown validation, advisory traceability, JUnit, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8.",
+            "Environment, advisory Markdown validation, advisory traceability, pytest-html, HTML and execution facts are deterministic evidence. Nodes 4 and 6 record findings without blocking nodes 5, 7 or 8.",
             "Only Markdown case generation/review may read source facts; pytest generation must not read source/**.",
             "Functional case IDs use BE-<MODULE>-<NNN>; production code/config, skip/xfail, repair and rerun are forbidden.",
         ],
@@ -3503,8 +3674,6 @@ function buildFrontendTestHybridDag(sources) {
             "process.stdout.write(JSON.stringify({cases:manifest.cases}));",
         ].join("")),
     ].join(" ");
-    // Heal malformed/missing case evidence to blocked; only unsafe evidenceDir hard-fails.
-    const evidenceValidation = buildFrontendCaseEvidenceValidateShellSnippet();
     const frontendTestOutcomeGate = buildFrontendTestOutcomeGateShellSnippet();
     const frontendCaseQualityAdvisory = [
         "node -e",
@@ -3752,9 +3921,9 @@ function buildFrontendTestHybridDag(sources) {
         writeSet: [`${evidenceRoot}/**`],
         allowedPaths: ["testcase/frontend/cases/**", `${evidenceRoot}/**`],
         forbiddenPaths: forbidden,
-        outputContract: "Deterministic evidence gate: heal missing/malformed case-result to blocked(invalid-evidence-shape); hard-fail only on unsafe evidenceDir. Does not block retrospect.",
-        subtask_prompt: "Validate frontend case evidence before result materialization. Prefer healing bad shapes to blocked so pipeline can still produce a report; only path-escape failures abort the node.",
-        shell: { commands: [evidenceValidation], cwd: ".", timeoutMs: 120000 },
+        outputContract: "Deterministic evidence gate: missing/malformed evidence is advisory; only unsafe evidenceDir or evidence paths hard-fail. Does not block retrospect.",
+        subtask_prompt: "Validate frontend case evidence before result materialization. Keep missing or malformed evidence as advisory findings; only path-escape failures abort the node.",
+        shell: { commands: [], frontendTestEvidenceValidation: {}, cwd: ".", timeoutMs: 120000 },
     }, {
         id: "materialize-frontend-test-result-shell",
         depends_on: ["validate-frontend-case-evidence-shell"],
@@ -5304,9 +5473,15 @@ function buildSoftVerifyNode(sources) {
     const implementId = implementationNodeId();
     const strategy = resolveDagVerifyStrategy(sources.taskConfig, "1");
     const fallbackCommands = ["npm run typecheck"];
+    const focusedIntermediate = sources.verifyCommands?.intermediate.filter((command) => !isFullSuiteVerifyCommand(command));
+    const plannedIntermediate = applyMavenVerificationPlanning({
+        repoRoot: sources.repoRoot,
+        commands: focusedIntermediate,
+        taskConfig: sources.taskConfig,
+    });
     const commands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
-        commands: sources.verifyCommands?.intermediate,
+        commands: plannedIntermediate.commands,
         fallbackCommands,
     });
     return {
@@ -5326,12 +5501,16 @@ function buildSoftVerifyNode(sources) {
                 phase: "intermediate",
                 quota: strategy.intermediateQuota ?? "full",
                 commandSource: sources.verifyCommands ? "adapter" : "inline",
-                commands: sources.verifyCommands?.intermediate,
+                commands: plannedIntermediate.commands,
                 fallbackCommands,
+                commandTexts: commands,
                 commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
             }),
             cwd: ".",
             timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+            ...(plannedIntermediate.mavenVerificationPlan
+                ? { mavenVerificationPlan: plannedIntermediate.mavenVerificationPlan }
+                : {}),
         },
     };
 }
@@ -5423,9 +5602,14 @@ function buildHardVerifyNode(sources) {
     const fallbackCommands = [
         "HARNESS_ALLOW_ACTIVE_DAG_RUNS=1 bash scripts/check-repo.sh",
     ];
-    const commands = buildVerifyShellCommands({
+    const plannedFinal = applyMavenVerificationPlanning({
         repoRoot: sources.repoRoot,
         commands: sources.verifyCommands?.final,
+        taskConfig: sources.taskConfig,
+    });
+    const commands = buildVerifyShellCommands({
+        repoRoot: sources.repoRoot,
+        commands: plannedFinal.commands,
         fallbackCommands,
     });
     return {
@@ -5445,13 +5629,17 @@ function buildHardVerifyNode(sources) {
                 phase: "final",
                 quota: "full",
                 commandSource: sources.verifyCommands ? "adapter" : "inline",
-                commands: sources.verifyCommands?.final,
+                commands: plannedFinal.commands,
                 fallbackCommands,
+                commandTexts: commands,
                 finalFullRequired: true,
                 commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
             }),
             cwd: ".",
             timeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
+            ...(plannedFinal.mavenVerificationPlan
+                ? { mavenVerificationPlan: plannedFinal.mavenVerificationPlan }
+                : {}),
         },
     };
 }
@@ -5553,9 +5741,6 @@ function buildSupervisedHybridDag(standard, sources) {
     assertValidDagSpec(spec);
     return spec;
 }
-export function defaultHybridDagOutputPath(taskId) {
-    return path.join(os.tmpdir(), `${taskId}-hybrid-dag.json`);
-}
 export async function writeHybridDagDraft(sources, outputPath, options = {}) {
     const routingProjectCapability = sources.taskConfig.taskKind === "standard" &&
         (options.template === undefined || options.template === "standard-dag")
@@ -5586,7 +5771,7 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
             taskId: preparedSources.taskId,
         });
     }
-    await writeFile(outputPath, `${JSON.stringify(spec, null, 2)}\n`, "utf-8");
+    await writeJsonAtomic(outputPath, spec, { repoRoot: sources.repoRoot });
     return {
         taskId: sources.taskId,
         outputPath,
@@ -5599,7 +5784,7 @@ export async function writeHybridDagDraft(sources, outputPath, options = {}) {
 export async function initHybridDagFromTask(repoRoot, taskId, options = {}) {
     const sources = await loadTaskHybridSources(repoRoot, taskId);
     assertTaskAllowedPathsPreflight(sources.taskConfig);
-    const outputPath = options.outputPath ?? defaultHybridDagOutputPath(taskId);
+    const outputPath = options.outputPath ?? getTaskPaths(repoRoot, taskId).dagDraftPath;
     return writeHybridDagDraft(sources, outputPath, {
         template: options.template,
     });

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

@@ -593,8 +593,9 @@ export async function executeDagNode(input) {
             node.structuredArtifactSha256 = createHash("sha256").update(bytes).digest("hex");
             node.structuredArtifactSchemaId = task.shell.jsonArtifactGate.schemaId;
         }
-        else if (task.shell?.backendTestPipeline === "classification-result-context") {
-            // The current 15-node single-run pipeline materializes the canonical
+        else if (task.shell?.backendTestPipeline === "classification-result-context" ||
+            task.shell?.backendTestPipeline === "markdown-execute-html") {
+            // Legacy 15-node and Markdown-first 8-node pipelines materialize
             // contracts/backend-test-result.json without jsonArtifactGate. Bind it
             // so Outcome adapters project kind=backend-test-result for Ready Planner.
             const artifactPath = path.join(runDir, "contracts", "backend-test-result.json");

package/dist/workflows/dag/reconcile-run.js

@@ -91,6 +91,21 @@ export async function executeDagReconcileRun(repoRoot, rawArgs) {
             continue;
         node.status = "ERROR";
         node.finishedAt = reconciledAt;
+        const elapsedNodeMs = elapsedDurationMs(node.startedAt, reconciledAt);
+        if (elapsedNodeMs !== undefined) {
+            node.durationMs = Math.max(node.durationMs ?? 0, elapsedNodeMs);
+        }
+        const attemptsNewestFirst = node.attempts?.slice().reverse() ?? [];
+        const currentAttempt = attemptsNewestFirst.find((attempt) => attempt.attempt === node.currentAttempt &&
+            attempt.finishedAt === undefined) ?? attemptsNewestFirst.find((attempt) => attempt.finishedAt === undefined);
+        if (currentAttempt && currentAttempt.finishedAt === undefined) {
+            currentAttempt.finishedAt = reconciledAt;
+            const elapsedAttemptMs = elapsedDurationMs(currentAttempt.startedAt, reconciledAt);
+            if (elapsedAttemptMs !== undefined) {
+                currentAttempt.durationMs = Math.max(currentAttempt.durationMs ?? 0, elapsedAttemptMs);
+            }
+            currentAttempt.failureCategory = `operator-${parsed.action}`;
+        }
         node.failureCategory = `operator-${parsed.action}`;
     }
     state.status = parsed.action === "supersede" ? "superseded" : "abandoned";
@@ -119,3 +134,12 @@ export async function executeDagReconcileRun(repoRoot, rawArgs) {
         runDir,
     };
 }
+function elapsedDurationMs(startedAt, finishedAt) {
+    if (!startedAt)
+        return undefined;
+    const started = Date.parse(startedAt);
+    const finished = Date.parse(finishedAt);
+    if (!Number.isFinite(started) || !Number.isFinite(finished))
+        return undefined;
+    return Math.max(0, finished - started);
+}