@tea-agent/loop-agent 0.24.10 → 0.25.0

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

@@ -5,6 +5,7 @@ import os from "node:os";
 import path from "node:path";
 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";
@@ -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.",
@@ -3346,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. 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 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, and a deterministic self-contained reports/backend-test-l5-dashboard.html (machine-computed L-5 metrics, no JSON); exit 0/1 with valid evidence continues.", [pytestCommand], 300000);
     if (execute.shell) {
         execute.shell.envAllowlist = collectBackendTestShellEnvAllowlist(sources);
     }
@@ -3357,10 +3526,11 @@ 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, 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/pytest-html facts. L-5 requires pass=100%, AC=100%, automation>=90%, line>=80%, branch>=70%, skipped=0 and no blocking Critical risk.",
@@ -5303,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 {
@@ -5325,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 }
+                : {}),
         },
     };
 }
@@ -5422,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 {
@@ -5444,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 }
+                : {}),
         },
     };
 }

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);
+}

package/dist/workflows/dag/types.js

@@ -281,6 +281,36 @@ export const dagBackendTestPipelineSchema = z.enum([
     "markdown-execute-html",
 ]);
 export const dagFrontendTestEvidenceValidationSchema = z.object({}).strict();
+export const dagMavenWorkspaceManifestSchema = z.object({
+    files: z.array(z.object({
+        path: z.string(),
+        size: z.number(),
+        mtimeMs: z.number(),
+    })),
+    directories: z.array(z.object({
+        path: z.string(),
+        entryNames: z.array(z.string()),
+    })),
+});
+export const dagMavenVerificationPlanSchema = z.object({
+    schemaVersion: z.number().int().positive(),
+    plannerVersion: z.string().min(1),
+    fingerprint: z.string().min(1),
+    inputDigest: z.string().min(1),
+    targets: z.array(z.object({
+        pomPath: z.string().min(1),
+        artifactId: z.string().min(1),
+        reactorRootPomPath: z.string().min(1).optional(),
+        moduleCoordinate: z.string().min(1).optional(),
+    })),
+    commandDigests: z.array(z.string()),
+    plannedCommands: z.array(z.object({
+        label: z.string(),
+        args: z.array(z.string()),
+    })),
+    workspaceManifest: dagMavenWorkspaceManifestSchema.optional(),
+    shellCommandDigests: z.array(z.string()).optional(),
+});
 export const dagShellConfigSchema = z.object({
     commands: z.array(z.string()).default([]),
     preset: dagShellPresetSchema.optional(),
@@ -303,6 +333,8 @@ export const dagShellConfigSchema = z.object({
     envAllowlist: z.array(z.string()).optional(),
     timeoutMs: z.number().optional(),
     cwd: z.string().optional(),
+    /** Frozen Maven verification plan; shell executor re-checks fingerprint before running. */
+    mavenVerificationPlan: dagMavenVerificationPlanSchema.optional(),
 });
 export const dagStaticConfigSchema = z.object({
     resultMarkdown: z.string().min(1),
@@ -410,6 +442,11 @@ export const dagDecisionGateSchema = z.object({
     schemaVersion: z.literal(1).optional(),
     mode: dagDecisionGateModeSchema.optional().default("record-only"),
 });
+export const dagWriterOutcomePolicySchema = z
+    .object({
+    type: z.literal("implementation-outcome-v1"),
+})
+    .strict();
 export const dagConvergenceSpecSchema = z
     .object({
     enabled: z.boolean().optional().default(false),
@@ -467,6 +504,13 @@ export const dagTaskSchema = z.object({
      * on safe read-only Pi nodes before the node becomes ERROR.
      */
     outputProtocol: dagOutputProtocolSchema.optional(),
+    /**
+     * Fail-closed outcome/diff consistency contract for bounded Pi writers.
+     * The writer must begin with IMPLEMENTATION_OUTCOME: changed,
+     * already-satisfied, or blocked; the executor checks it against the
+     * run-attributed diff.
+     */
+    writerOutcomePolicy: dagWriterOutcomePolicySchema.optional(),
     /**
      * Explicit opt-in for the deterministic project governance context resolver
      * (AGENTS.md chain + referenced code standards). Only tasks that set this

package/dist/workflows/dag/validate.js

@@ -604,6 +604,21 @@ function validateOutputProtocolTaskConfig(task, issues) {
         });
     }
 }
+function validateWriterOutcomePolicyTaskConfig(task, issues) {
+    if (task.writerOutcomePolicy === undefined)
+        return;
+    const isBoundedPiWriter = task.executor === "pi" &&
+        task.toolProfile === "write" &&
+        task.role === "implementer" &&
+        task.writePolicy === "exclusive" &&
+        (task.writeSet?.length ?? 0) > 0;
+    if (!isBoundedPiWriter) {
+        issues.push({
+            type: "invalid-writer-outcome-policy",
+            message: `task ${task.id} declares writerOutcomePolicy but is not a bounded exclusive Pi implementer writer`,
+        });
+    }
+}
 function validateDecisionGateTaskConfig(task, issues) {
     if (!task.decisionGate?.enabled) {
         return;
@@ -758,6 +773,7 @@ export function validateDagSpec(spec) {
         validateDecisionGateTaskConfig(task, issues);
         validateRetryPolicyTaskConfig(task, issues);
         validateOutputProtocolTaskConfig(task, issues);
+        validateWriterOutcomePolicyTaskConfig(task, issues);
         validateProjectGovernanceTaskConfig(task, spec, issues);
         validateFailureAwareDependsOn(task, spec, issues);
     }

package/docs/architecture/dag-execution.md

@@ -128,7 +128,7 @@ decision envelope 中的 **model verdict**（`decision` / `riskLevel` 等解析
 
 - **pause → approve → resume**：`dag approve` 在 paused run 写 `human-approval.json`，将状态改回 `running` 并把目录迁回 `active/`；随后 `resumeDagRun`（`runner.ts`）要求 active lifecycle + approval artifact，并用 `prepareSkillSnapshotForContinuation` 复用 run-owned snapshot。
 - **completed 写入**：只有 runner 在终态 `persistState({ allowCompletedFactsWrite: true })`（`runner.ts`）才能写 completed 目录；该 flag 经 `completed-facts-guard.ts` 校验。
-- **显式 recovery mutation**：`dag reconcile-run`（`src/commands/dag-reconcile-run.ts`，命令层）默认仅检查；只有给出 `--action supersede|abandon` + reason，且 liveness 证明 runner 已停止时，才在原 lifecycle 写 reconciliation/state 并迁移到 `completed/`。它不是修改既有 completed history 的通用入口。Observe / status / doctor 始终只读。
+- **显式 recovery mutation**：`dag reconcile-run`（`src/commands/dag-reconcile-run.ts`，命令层）默认仅检查；只有给出 `--action supersede|abandon` + reason，且 liveness 证明 runner 已停止时，才在原 lifecycle 写 reconciliation/state 并迁移到 `completed/`。仍为 `RUNNING` 的节点保持失败语义，但以 `reconciledAt - startedAt` 补齐节点和当前 attempt 的耗时，原始状态继续冻结在 `reconciliation.json`。它不是修改既有 completed history 的通用入口。Observe / status / doctor 始终只读。
 - **status 枚举**：`DagRunState.status`；`TERMINAL_RUN_STATUSES` 判终态；`isTerminalDagRunStatus` 工具函数。
 
 ## convergence（可选、supervised）
@@ -142,6 +142,10 @@ decision envelope 中的 **model verdict**（`decision` / `riskLevel` 等解析
 
 完成声明的权威是 shell command 的新鲜 exit code 与归档输出。验证命令执行在 `src/executors/shell-executor.ts`，环境与 preset helper 在 `src/executors/shell-verification.ts`；DAG authoring 写入的 `task.shell.verifyEvidence` 元数据由 `src/workflows/dag/node-execution.ts` 复制到 `node.verifyEvidence`。model verdict、Observe 或报告都不能替代这些 shell facts。
 
+supervised 的 `soft-verify-shell` 只运行聚焦命令，明确排除无参数的 `npm test`、`npm run test` 与 `scripts/ci.sh` 等 full-suite 入口；`hard-verify-shell` 保留一次完整 final 集合。task 与 adapter 命令合并时会解包可证明安全的单命令 `bash -lc` wrapper，并以规范化 cwd、argv、env、timeout 做语义去重；`verifyEvidence.commandCount/commandLabels/commandTexts` 必须对应去重后实际执行的命令。
+
+Pi SDK 正常路径继续在内存中传递 system prompt；只有 CLI fallback / `cli-only` 才通过权限收紧的系统临时文件传给 `--append-system-prompt`，归档命令只保存占位符。transport 解析并记录真实 temp root，持有 prompt 文件句柄，并冻结 temp root、随机私有目录、固定文件名三层 identity；收口时先用句柄清空正文，三层 identity 均匹配才精确 `unlink` 文件并非递归 `rmdir` 空目录。未知 sibling、symlink/junction 或 identity 漂移都会拒绝扩大删除范围。shell 与 Pi 子进程以独立进程组启动；超时在 Windows 使用 tree termination、在 POSIX 对进程组发信号，防止 npm/Vitest/tsx 后代在节点结束后继续持有 IPC 或临时文件。
+
 ## Dynamic Workflow
 
 Dynamic Workflow 是 DAG runtime 上方的逻辑编排/编译层，**不**重写 runner：

package/docs/architecture/runtime-boundaries.md

@@ -18,6 +18,9 @@ Application layer (src/application/，逐步引入)
 Workflow runtime (src/workflows/)
   └─ DAG / Dynamic / Loop 核心执行规则；不应依赖 commands
 
+Verification planners (src/verification/)
+  └─ 生成期/执行期验证规划（如 Maven workspace 静态图与冻结计划）；纯库模块，不跑 CLI
+
 Executors (src/executors/)
   └─ Pi / Shell / Static 等受治理外部工具适配；不应依赖 commands 或 CLI formatting
 
@@ -66,11 +69,18 @@ Governance (scripts/check-*.sh, src/governance/)
 - **允许依赖**：`src/executors/**`、`src/task/**`、`src/records/**`、`src/shared/**`、application use-case（目标态）。
 - **禁止**：`import` 来自 `src/commands/**`（见下方过渡例外）。
 
+### Verification planners
+
+- **位置**：`src/verification/**`（当前含 `src/verification/maven/**`）
+- **职责**：在 DAG 生成阶段与 `verify-shell` 执行前，对任务作用域驱动的验证命令做静态规划与冻结计划复核（例如 Maven Workspace Graph、`-f/-pl/-am` 重写、`.harness/cache/` 图缓存、`verification-plan-stale`）。
+- **允许依赖**：`src/adapters/types`（`VerifyCommand`）、Node 标准库；由 `src/workflows/dag/**` 与 `src/executors/shell-executor.ts` 调用。
+- **禁止**：执行 Maven/npm 等外部 goal 做发现；依赖 `src/commands/**` 或 CLI；把独立 POM 拼成伪 reactor；按 first-match/深度/字典序/启动 cwd 选择目标。
+
 ### Executors
 
 - **位置**：`src/executors/**`
 - **职责**：封装 Pi SDK、shell 执行、static 输出与 write guard。受治理 Agent runtime 只有 Pi。
-- **允许依赖**：`src/shared/**`、外部 SDK（不含 `@cursor/sdk`）。
+- **允许依赖**：`src/shared/**`、`src/verification/**`（执行前计划复核）、外部 SDK（不含 `@cursor/sdk`）。
 - **禁止**：依赖 `src/commands/**`、CLI 输出格式，或 import `src/sidecars/**` / `@cursor/sdk`。
 
 ### Sidecars

package/docs/architecture/worker-and-feature.md

@@ -83,6 +83,19 @@ controller identity 与 DAG skill snapshot 是两个不同冻结层（前者跨
 - Delivery / Closeout：clean Delivery HEAD 上生成 canonical QA/最终验证证据、Delivery Package、Acceptance Coverage、PR 草稿；Closeout 默认预览，显式 `--apply --owner` 才原子写回。
 - 权威证据：`CHANGELOG.md [0.10.0]`、`docs/reports/feature/2026-07-12-m2-completion-audit.md`。
 
+### Final Verification 权威（ADR 0007）
+
+| 入口 | 职责 |
+| --- | --- |
+| `agent-worker feature verify-final` | **唯一** canonical writer：Feature Verification Bundle、`qa-pass.json`、`final-verification.json` |
+| `agent-worker feature advance` | 编排 verify-final → delivery → closeout preview[/apply]（ADR 0007 运维入口） |
+| `agent-worker feature doctor` | 只读诊断证据/Pool/dirty worktree；建议下一步命令 |
+| Feature Packet `FINAL-VERIFY-*`（若保留） | 可选 **local smoke recipe**（样本 `verify:final` / reports）；Task Done ≠ Final Verification Record |
+| `feature delivery` | 重验 verify-final 证据；省略路径时默认 `.harness/task-pool/evidence/<featureId>/{qa-pass,final-verification}.json` |
+| `feature closeout` | 只认 Delivery manifest + Final Verification Record 链 |
+
+禁止把 packet Task 的 smoke 报告或 agent-dag `verify-pi` 结论当作 Delivery 放行条件。
+
 ### Inspect（Observe 只读 read model）
 
 - 模块：`src/worker/observe/`、`src/worker/observability/{read-model,event-store}.ts`。

package/docs/init-surface.manifest.json

@@ -74,6 +74,7 @@
     "skills/frontend-implementation/references/node-contracts.md",
     "skills/frontend-implementation/references/design-spec.md",
     "skills/frontend-implementation/references/code-standards.md",
+    "skills/frontend-bounded-implement/SKILL.md",
     "skills/frontend-design-review/SKILL.md",
     "skills/frontend-design-review/references/review-checklist.md",
     "skills/frontend-review/SKILL.md",
@@ -151,6 +152,7 @@
     ".agents/skills/frontend-implementation/references/node-contracts.md",
     ".agents/skills/frontend-implementation/references/design-spec.md",
     ".agents/skills/frontend-implementation/references/code-standards.md",
+    ".agents/skills/frontend-bounded-implement/SKILL.md",
     ".agents/skills/frontend-design-review/SKILL.md",
     ".agents/skills/frontend-design-review/references/review-checklist.md",
     ".agents/skills/frontend-review/SKILL.md",
@@ -229,6 +231,7 @@
     ".agents/skills/frontend-implementation/references/node-contracts.md": "copied",
     ".agents/skills/frontend-implementation/references/design-spec.md": "copied",
     ".agents/skills/frontend-implementation/references/code-standards.md": "copied",
+    ".agents/skills/frontend-bounded-implement/SKILL.md": "copied",
     ".agents/skills/frontend-design-review/SKILL.md": "copied",
     ".agents/skills/frontend-design-review/references/review-checklist.md": "copied",
     ".agents/skills/frontend-review/SKILL.md": "copied",