@tea-agent/loop-agent 0.39.0-beta.11 → 0.39.0-beta.13

package/dist/workflows/dag/frontend-implementation-contract.js

@@ -1124,11 +1124,40 @@ function deriveFrontendVerificationCoverage(value, canonicalBinding) {
                 ])];
             const evidenceGap = asRecord(requirement.evidenceGap);
             const hasProof = provenRequirementIds.has(requirementId);
+            // A committed evidenceGap with a blank description means "no gap":
+            // small-output models emit the slot defensively with description
+            // "" and the strict gap schema (description min 1 char) would
+            // fail the whole compile. Strip the incoming slot first and only
+            // re-add it when usable — the requirement either has proof (no
+            // gap needed) or receives the derived blocking gap below.
+            const evidenceGapDescription = asString(evidenceGap?.description).trim();
+            const hasUsableEvidenceGap = evidenceGap !== undefined && evidenceGapDescription !== "";
+            // Source fidelity bindings are deterministic ledger data, not
+            // model-authored content: when the plan requirement carries no
+            // binding (r6 — the contract input block degraded, the model
+            // correctly refused to invent ids), inject the ledger binding
+            // for the requirement id. The strict schema fails a ledger-bound
+            // contract on any requirement without sourceFragmentIds.
+            const declaredSourceFragmentIds = Array.isArray(requirement.sourceFragmentIds)
+                ? requirement.sourceFragmentIds
+                : undefined;
+            const ledgerBoundFragmentIds = Array.isArray(canonicalBinding.requirementToFragments?.[requirementId])
+                ? canonicalBinding.requirementToFragments[requirementId]
+                : undefined;
+            const sourceFragmentIds = declaredSourceFragmentIds && declaredSourceFragmentIds.length > 0
+                ? declaredSourceFragmentIds
+                : ledgerBoundFragmentIds;
+            const { evidenceGap: _incomingGap, sourceFragmentIds: _incomingFragmentIds, ...requirementWithoutGap } = requirement;
+            void _incomingGap;
+            void _incomingFragmentIds;
             return {
-                ...requirement,
+                ...requirementWithoutGap,
+                ...(sourceFragmentIds ? { sourceFragmentIds } : {}),
                 ...(verificationTargetIds.length > 0 ? { verificationTargetIds } : {}),
                 ...(hasProof
-                    ? (evidenceGap ? { evidenceGap: { ...evidenceGap, blocking: false } } : {})
+                    ? (hasUsableEvidenceGap
+                        ? { evidenceGap: { ...evidenceGap, blocking: false } }
+                        : {})
                     : {
                         evidenceGap: {
                             requirementId,
@@ -1140,10 +1169,16 @@ function deriveFrontendVerificationCoverage(value, canonicalBinding) {
         })
         : record.requirements;
     const modelEvidenceGaps = Array.isArray(record.evidenceGaps)
-        ? record.evidenceGaps.map((item) => {
+        ? record.evidenceGaps
+            .map((item) => {
             const gap = asRecord(item);
             if (!gap)
                 return item;
+            // Blank-description gaps are meaningless statements that would
+            // fail the strict gap schema; drop them like the embedded
+            // per-requirement empty slots.
+            if (asString(gap.description).trim() === "")
+                return undefined;
             const requirementId = canonicalizeRequirementId(asString(gap.requirementId));
             // Model gaps are advisory. Blocking status is reconstructed below
             // from the source binding and executable verification targets.
@@ -1156,6 +1191,7 @@ function deriveFrontendVerificationCoverage(value, canonicalBinding) {
                 blocking: false,
             };
         })
+            .filter((item) => item !== undefined)
         : [];
     const derivedBlockingGaps = canonicalBinding.requirementIds
         .filter((requirementId) => !provenRequirementIds.has(requirementId))
@@ -1820,6 +1856,35 @@ export async function analyzeFrontendImplementationContract(input) {
     const result = frontendImplementationContractSchema.safeParse(candidate);
     if (!result.success)
         fail("retryable-invalid", `invalid-output: ${result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`, candidateJsonSha256);
+    // targets.files is runtime-owned (the skeleton derives it from the task
+    // writeSet, a glob the model must not edit). Narrow it AFTER the full
+    // schema validation — never before, so model-authored unsafe/absolute
+    // declarations are still rejected — to every CONCRETE path the validated
+    // contract references (requirement implementationTargets,
+    // verification-target files, Mock endpoint fixture/consumer paths). The
+    // prewrite containment semantics keep covering everything the contract
+    // references because every narrowed entry already matched the declared
+    // patterns during validation. Satisfies frozen requirements like "deliver
+    // exactly these files" without asking the model to edit a protected
+    // field (r10/r11 design-review findings).
+    const referencedConcretePaths = [
+        ...new Set([
+            ...result.data.requirements.flatMap((requirement) => requirement.implementationTargets),
+            // Mock endpoint paths stay in the set: the zod refine validated
+            // them against the declared targets.files patterns, so the
+            // narrowing must keep covering them. Verification-target files
+            // deliberately do NOT join: they are test artifacts, not
+            // deliverables, and pulling them in would change which gate
+            // fires for an out-of-writeSet VT (AC-3a semantics).
+            ...(result.data.mockApi?.endpoints ?? []).flatMap((endpoint) => [endpoint.fixture, endpoint.consumer].filter((value) => typeof value === "string" && value.length > 0)),
+        ].filter((value) => value.length > 0)),
+    ].sort();
+    if (referencedConcretePaths.length > 0) {
+        result.data.targets = {
+            ...result.data.targets,
+            files: referencedConcretePaths,
+        };
+    }
     const blockingGaps = [
         ...(result.data.evidenceGaps ?? []),
         ...result.data.requirements.flatMap((item) => item.evidenceGap ? [item.evidenceGap] : []),
@@ -2038,6 +2103,55 @@ function assertVerificationSymbolShapes(contract) {
         }
     }
 }
+/**
+ * Thrown by analyzeFrontendPlanPatchCandidate when the design-policy
+ * pre-checks report findings. Carries the structured findings so callers
+ * (finalize_plan receipt) can synthesize fix suggestions instead of making
+ * the model re-derive them from prose.
+ */
+export class PlanPolicyPrecheckFailure extends Error {
+    findings;
+    constructor(message, findings) {
+        super(message);
+        this.name = "PlanPolicyPrecheckFailure";
+        this.findings = findings;
+    }
+}
+/**
+ * Shared tail of the plan patch validation: analyze the merged contract and
+ * front-load the plan-attributable design-policy checks. Throws the same
+ * errors the node self-check throws (FrontendContractFailure for schema
+ * failures, Error for policy findings) so every caller — the node validator
+ * and the finalize_plan receipt — surfaces identical diagnostics.
+ */
+export async function analyzeFrontendPlanPatchCandidate(input) {
+    const analysis = await analyzeFrontendImplementationContract(input);
+    // Front-load the verification-symbol shape check so fabricated symbols
+    // are fixed by the plan retry ladder in-node instead of failing the
+    // verify trace gate at the end of the run.
+    assertVerificationSymbolShapes(analysis.canonical);
+    // Front-load the plan-attributable design-policy checks so the §5.1
+    // retry ladder can fix these facts in-node with diagnostics instead of
+    // the run terminating at the policy shell. The policy shell remains the
+    // final authority and re-runs the identical checks on committed facts.
+    const policyPreFindings = [
+        ...checkUiDesignCoverage(analysis.canonical),
+        ...checkUiStateAttribution(analysis.canonical),
+        ...checkDependencies(analysis.canonical, await deriveAllowedDependenciesFromRun(input.runDir)),
+        ...checkTargetPaths(analysis.canonical, await deriveWriteSetFromRun(input.runDir)),
+    ];
+    if (policyPreFindings.length > 0) {
+        const message = `frontend plan policy pre-check failed (fix these plan facts, then re-commit and finalize): ${policyPreFindings
+            .map((finding) => `${finding.code}: ${finding.message}`)
+            .join("; ")}`;
+        throw new PlanPolicyPrecheckFailure(message, policyPreFindings.map((finding) => ({
+            code: finding.code,
+            message: finding.message,
+            ...(finding.path ? { path: finding.path } : {}),
+        })));
+    }
+    return analysis;
+}
 export async function validateFrontendPlanPatchNodeOutput(input) {
     const nodeId = input.nodeId ?? "frontend-plan-pi";
     const attempt = input.attempt ?? 1;
@@ -2089,29 +2203,11 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             runDir: input.runDir,
             contract: merged,
         });
-        const analysis = await analyzeFrontendImplementationContract({
+        const analysis = await analyzeFrontendPlanPatchCandidate({
             runDir: input.runDir,
             rawContractText: serializeDeterministicJson(merged),
             sourceBinding: input.sourceBinding,
         });
-        // Front-load the verification-symbol shape check so fabricated symbols
-        // are fixed by the plan retry ladder in-node instead of failing the
-        // verify trace gate at the end of the run.
-        assertVerificationSymbolShapes(analysis.canonical);
-        // Front-load the plan-attributable design-policy checks so the §5.1
-        // retry ladder can fix these facts in-node with diagnostics instead of
-        // the run terminating at the policy shell. The policy shell remains the
-        // final authority and re-runs the identical checks on committed facts.
-        const policyPreFindings = [
-            ...checkUiDesignCoverage(analysis.canonical),
-            ...checkUiStateAttribution(analysis.canonical),
-            ...checkDependencies(analysis.canonical, await deriveAllowedDependenciesFromRun(input.runDir)),
-            ...checkTargetPaths(analysis.canonical, await deriveWriteSetFromRun(input.runDir)),
-        ];
-        if (policyPreFindings.length > 0)
-            throw new Error(`frontend plan policy pre-check failed (fix these plan facts, then re-commit and finalize): ${policyPreFindings
-                .map((finding) => `${finding.code}: ${finding.message}`)
-                .join("; ")}`);
         const normalizedArtifact = await writeDeterministicJsonArtifact(input.runDir, path.posix.join(candidateDir, `attempt-${attempt}.normalized.json`), analysis.canonical);
         await writeReport({
             classification: "accepted-normalized",

package/dist/workflows/dag/frontend-shadow-dual-write.js

@@ -607,7 +607,7 @@ export function readCompleteScoutTargetSurface(records) {
     if (!namedPaths.some((candidate) => freshPaths.has(candidate)))
         return {
             ok: false,
-            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path",
+            reason: "frontend scout target surface lacks fresh runtime evidence for a named target path; record_target_surface enriches every declared entrypoint/implementation/test path against the real workspace, so at least one named path must exist on disk (an existing directory counts; a file to be created later cannot count)",
         };
     return { ok: true, surface };
 }

package/dist/workflows/dag/frontend-writer-admission.js

@@ -78,6 +78,19 @@ export const frontendWriterAdmissionResultV1Schema = z
         path: z.string().optional(),
     })
         .strict()),
+    // r12 policy change: a request_design_changes verdict no longer blocks
+    // writer admission. The verdict and its findings ride along as
+    // advisory context for the implement node; blocking is owned by the
+    // deterministic gates (prewrite, write guard) and the final code
+    // review.
+    designReviewAdvisory: z
+        .object({
+        verdict: z.enum(["approve_design", "request_design_changes"]),
+        restartPhase: z.string().min(1).optional(),
+        findingCount: z.number().int().nonnegative(),
+    })
+        .strict()
+        .optional(),
     failureSource: frontendAdmissionFailureSourceSchema.optional(),
 })
     .strict();

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

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { access, readdir, readFile, realpath } from "node:fs/promises";
 import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 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";
@@ -2563,9 +2564,10 @@ async function resolveFrontendOpenspecGateConfig(sources) {
 const frontendComponentConformanceInstruction = [
     "## Component Selection conformance (uiComponentChoices; hard rule)",
     "每个 UI 用途必须在契约的 uiComponentChoices[] 中声明组件选型：{ purpose, component, decision, specReference, rationale }。",
+    "purpose is the stable coverage key：它应精确匹配 interaction.name 或 uiState.name；职责语义由对应 interaction.expectedBehavior / uiState.expectedBehavior 与 rationale 表达。不得仅因 purpose 与 interaction 或 component 标识符相同而判缺陷。",
     "- decision=specified：前端规范（候选组件/主题桶 + 任务源显式引用）已定义该用途组件 → 必须使用该组件，并给精确 specReference { path, section, line }（path 必须是 openspec/ai_workspace 受支持规范路径）。",
     "- decision=reuse-existing：仅当该组件/惯例**确实已存在于仓库当前代码**（如复用现有 ActiveRunBadge 的 oc- class 惯例）→ specReference 可为 null，rationale 必须指明复用的具体现有组件/文件与依据。",
-    "- decision=new：任务源/PRD 要求**新增**该组件（仓库当前不存在该组件文件）→ decision 必须为 new，不得标 reuse-existing；调用 record_component_choice 时传 sourceRequirementIds（关联的 frozen requirement ID），runtime 会从 source-fidelity ledger 物化精确的任务源 PRD { path, section, line }。不要读取 PRD 或手填/猜测 specReference；rationale 说明新增纯展示组件、复用既有 CSS 命名与主题变量约定。",
+    "- decision=new：任务源/PRD 要求**新增**该组件（仓库当前不存在该组件文件）→ decision 必须为 new，不得标 reuse-existing；调用 record_component_choice 时传 sourceRequirementIds（关联的 frozen requirement ID）与 plan checklist 列出的 sourceFragmentId，runtime 校验其隶属关系并物化精确的任务源 PRD { path, section, line }。不要读取 PRD 或手填/猜测 specReference；rationale 说明新增纯展示组件、复用既有 CSS 命名与主题变量约定。",
     "不得静默替换规范组件或自创组件而无偏差声明；spec 已定义该用途组件时不得改选其它组件。",
     "prewrite gate 确定性交叉校验：仅 decision=specified 的 specReference 必须是候选 OpenSpec 路径、在 typed decision ledger 中声明且有成功 read 事件；decision=new 的 PRD 引用走任务源可追溯性审查，不得按 OpenSpec 候选拒绝。候选桶非空且契约有 UI 可见工作而 uiComponentChoices 缺失/空 → component-choices-missing。",
 ].join("\n");
@@ -2764,6 +2766,37 @@ function resolveFrontendShapeCapsuleGenerationInput(sources) {
     }
     return explicit ?? autoloaded;
 }
+/** Standard frontend DAG template (docs/templates/frontend-implementation-dag.json).
+ * It is the topology source of truth: node set, execution order, and depends_on
+ * come from the template; the runtime generator assembles each node's full
+ * configuration (budgets, retry, skeleton, skills, dynamic prompt sections).
+ * Resolution order: repoRoot copy (dev workspace) → bundled package copy. */
+export async function loadFrontendDagTemplate(repoRoot) {
+    const candidates = [];
+    if (repoRoot) {
+        candidates.push(path.join(repoRoot, "docs", "templates", "frontend-implementation-dag.json"));
+    }
+    candidates.push(fileURLToPath(new URL("../../../docs/templates/frontend-implementation-dag.json", import.meta.url)));
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse(await readFile(candidate, "utf8"));
+            if (!Array.isArray(parsed.tasks))
+                continue;
+            const tasks = parsed.tasks.filter((item) => typeof item === "object" &&
+                item !== null &&
+                typeof item.id === "string" &&
+                Array.isArray(item.depends_on) &&
+                typeof item.executor === "string");
+            if (tasks.length === 0)
+                continue;
+            return { tasks };
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
 async function buildFrontendHybridDagFromTask(sources) {
     const { taskConfig } = sources;
     const mockCapability = sources.frontendMockCapability ?? {
@@ -3112,6 +3145,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 skills: FRONTEND_IMPLEMENTATION_SKILLS,
                 outputContract: "Typed requirement facts plus a concise Markdown contract. Submit through the incremental typed tools record_requirement / record_constraint / record_evidence_expectation / record_handoff_intent / record_open_question / record_split_proposal / record_openspec_selection, then call finalize_contract exactly once. Requirements use stable REQ/BR/AC identifiers with source spans and a disposition (explicit | repository-resolvable | assumption | blocking); each requirement registers evidence expectations across static/behavior/Mock/real-integration (required | optional | not-applicable), and UI-visible or interactive requirements register a non-blocking frontend-test handoff intent. End finalize_contract with a single contract disposition of ready | ready-with-assumptions | blocked. Cover scope, non-goals, acceptance criteria, UI states, target runtime environment, risks, and verification expectations; do not fix target files, components, or implementation methods as requirements. When OpenSpec candidates exist, classify only the ones you actually use: call record_openspec_selection once per required/relevant path; never enumerate irrelevant candidates (unmentioned defaults to irrelevant) and never emit a fenced selection JSON. No file writes.",
                 subtask_prompt: [
+                    "OUTPUT BUDGET DISCIPLINE (hard requirement, extreme-environment safe): the provider output window is small — NEVER attempt to emit the whole contract in one response; a single large JSON dump will be truncated and rejected. Incremental submission through the typed tools is the ONLY supported output mode. Start submitting with the FIRST tool call: after each read, call record_requirement for the requirements you have already confirmed, one or a few per call. Every tool-call round MUST make progress by submitting at least one record_* fact. Do not re-read the same source file that is already materialized in this session; read each file at most once.",
                     "Read task source and produce a concise frontend implementation contract as typed requirement facts plus narrative Markdown.",
                     "Assign each requirement the SAME id as the ledger canonical requirement it covers (sourceBinding.requirementIds, e.g. AC-001) — do NOT invent new REQ/BR prefixed ids for canonical requirements: the compiled contract must match the ledger canonical requirement ids exactly or schema validation rejects it (unknown requirement id). Requirements use the canonical id with a source span (task-source section or repository file:line). Label each requirement's disposition as explicit | repository-resolvable | assumption | blocking; a blocking requirement must name its owner (human-decision or external-state) and evidence refs.",
                     "Source fidelity ledger: when the DAG sourceBinding carries a requirement→fragment mapping (requirementToFragments, e.g. REQ-SRC-* ids from the managed ledger), each record_requirement MUST declare the fragments that requirement is bound to: set sourceFragmentIds to the mapped fragment ids (the authoritative provenance evidence the design policy verifies). sourceRefs (fragment→path display refs) are optional — declare them only when you have the exact path from the materialized source; otherwise omit them rather than inventing paths. Declare exactly what the ledger binds — do not invent ids, do not omit them, and do not re-derive them from prose. A requirement that the ledger binds but the contract omits (or fabricates) fails writer admission.",
@@ -3267,6 +3301,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Request design changes 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 design changes 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.",
                     "Component selection conformance is a hard blocking condition: request_design_changes when the frontend spec (component/theme/rule.components bucket) already defines a component for a purpose but the plan selects another or self-invents one without a declared deviation; when uiComponentChoices is missing/empty for UI-visible work while the frozen component/theme bucket is non-empty; when a decision=specified specReference.path is missing a ledger OpenSpec reference or successful read event; or when a decision=new component lacks a traceable task-source/PRD specReference. A PRD reference for decision=new is not an OpenSpec citation and must not be rejected merely for lacking an OpenSpec read event.",
+                    "For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name. Responsibility is expressed by the matched expectedBehavior plus rationale; you must not reject it merely for matching an interaction or component identifier.",
                     "You must NOT make authoritative assertions about the execution result of frozen verification commands (typecheck/test/build/lint/etc.). Predicting that a command will necessarily pass or fail, or declaring an acceptance criterion unreachable on that basis, is out of your authority: command results are deterministically established by frontend-verify-shell. Any concern about verification feasibility must be recorded only as a non-blocking verification concern in findings (severity must not be Critical, and it must never be the sole fatal basis for request_design_changes). Only semantic design defects (component selection, state flow, interaction contract, or conflicts with the specification) may be Critical. A pure command-will-fail prediction must not be classified as contract-requirement-gap.",
                     "Read-only: do not modify repository files.",
                     "LARGE-FILE AUDIT (avoid full reads): style/theme audit files can be large (e.g. styles.css is often hundreds of KB). Prefer grep to locate the exact rules/variables you must verify (e.g. grep the oc- class, is-* modifier, or --oc- theme variables with their line numbers), then read only the narrow line range when surrounding context is needed. Do not read a large style/test file in full — a single full read can exhaust the read budget and fail the attempt.",
@@ -3432,6 +3467,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "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).",
                     "The contract embedded in frontend-review-context.json is the effective plan materialized by frontend-design-policy-shell. Do not re-open task sources, OpenSpec, AI workspace, design-review, writer summary, or verification node prose. Inspect only the canonical review context, its bound diff, and diff-referenced files when semantic review requires source code.",
+                    "For uiComponentChoices, purpose is the stable coverage key and must match interaction.name or uiState.name. Responsibility is expressed by the matched expectedBehavior plus rationale; you must not reject it merely for matching an interaction or component identifier.",
                     "Treat a commented-out real request, default-enabled Mock, production entrypoint importing test mocks, API/fixture contract drift, unauthorized Mock dependency/path, or missing behavior evidence for the selected strategy as at least Important. 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 verify that the real request remains the default and the Real Integration Gap is preserved.",
                     "Inspect the frontend-verify-shell evidence in the review context directly, including the production/default-real-path static check, and require Mock activation to be off for that check.",
                     "Distinguish Mock-backed evidence from real API integration evidence and preserve the Real Integration Gap when the backend was not exercised.",
@@ -3461,6 +3497,34 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
         ],
     };
+    // The static DAG template is the topology source of truth: the generated
+    // chain must match the template's node set and order, and the template's
+    // depends_on must be a subset of the generated one (the runtime may add
+    // dependencies, e.g. Mock-required planning depending on the contract
+    // node's Mock facts). The template's own tasks carry simplified placeholder
+    // configs; the generated node definitions (budgets, retry, skeleton,
+    // skills, prompts) and any runtime-added dependencies win.
+    const frontendTemplate = await loadFrontendDagTemplate(sources.repoRoot);
+    if (frontendTemplate) {
+        const byId = new Map(spec.tasks.map((task) => [task.id, task]));
+        const templateIds = frontendTemplate.tasks.map((task) => task.id);
+        const missing = templateIds.filter((id) => !byId.has(id));
+        if (missing.length > 0) {
+            throw new Error(`frontend DAG template topology drift: generated chain is missing template node(s): ${missing.join(", ")}`);
+        }
+        for (const templateTask of frontendTemplate.tasks) {
+            const generated = byId.get(templateTask.id);
+            const generatedDeps = new Set(generated.depends_on);
+            const templateOnly = templateTask.depends_on.filter((dep) => !generatedDeps.has(dep));
+            if (templateOnly.length > 0) {
+                throw new Error(`frontend DAG template topology drift: generated node ${templateTask.id} is missing template dependency ${templateOnly.join(", ")}`);
+            }
+        }
+        const templateSet = new Set(templateIds);
+        const ordered = templateIds.map((id) => byId.get(id));
+        const extra = spec.tasks.filter((task) => !templateSet.has(task.id));
+        spec.tasks = [...ordered, ...extra];
+    }
     if (frontendTaskShape.shape === "split-required") {
         spec.tasks = pruneFrontendTasksForSplitRequired(spec.tasks);
     }
@@ -4649,7 +4713,7 @@ async function buildBackendTestHybridDag(sources) {
             "Coverage priority is strict inside the declared scope: P0 product requirements/task hard constraints always remain in scope; P1 exhaustively supplements documented operations, fields, business rules, statuses and errors only for Affected Operations; P2 adds bounded protocol robustness only when it is relevant to the change and does not invent product behavior. Coverage percentages describe the declared affected scope, never whole-API completeness unless every operation is explicitly listed. Conflicts or undefined expectations must stay visible as GAP/CONFLICT with precise source pointers, never guessed.",
             "For uniqueness/lifecycle rules cover absent, active-existing, deleted-existing, create-delete-recreate, restore-then-recreate and documented scope/case-normalization states. For every enum cover every valid value plus bounded invalid equivalence classes (unknown, case variant, whitespace, empty, null/missing and wrong types as applicable). For every length/number rule cover min-1, min, nominal, max and max+1. For format rules cover each allowed class separately plus a valid mixed value, and representative forbidden classes including uppercase, internal/leading/trailing whitespace, tab/newline, unsupported punctuation, slash, emoji or control characters when the source contract supports that expectation.",
             "Mandatory module index: include a `## Module Index` table in the plan artifact that lists every planned module as a canonical relative link of the exact form `[label](./<stem>.md)` plus a `testcase/md/<stem>.md` path cell, so a downstream deterministic manifest can parse the module list. Group by stable business resource/domain, not by CRUD operation: one resource's list/detail/create/update/delete cases belong in one module such as `resource_notes`; split only when a single module would exceed the per-child 16K output protocol, keep the total module count at the smallest safe value, and never exceed 8 modules. Name each module file with a stable lowercase business stem such as `health` or `resource_notes`. Pure hexadecimal/hash-like opaque stems such as `a401606` or `deadbeef` are forbidden. Do not use priority-only stems `p0`, `p1` or `p2`; Priority belongs only in the Coverage Matrix and never defines module files. Do not use Case-ID-like module filenames such as `BE-HEALTH.md` or `BE-NOTES.md`. The relative link target MUST equal the on-disk filename stem the sharded writer will create. 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.",
-            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots writes `each-value` plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
+            "Scenario Partitions (query/filter axes): for every affected GET/list operation, declare one row per enum or classification axis used for filtering (query/path parameters such as type/status/category). Add a mandatory machine-readable `## Scenario Partitions` section after the Coverage Matrix using exactly `| Partition ID | Operation | Axis | Domain | Required Slots | Expected by Slot | Bind Rule |` with the separator row. Partition ID is a stable `SP-<OPERATION>-<AXIS>` token; Domain must copy the legal values verbatim from the bound OpenAPI enum or requirement sentence (never guess), using bare semicolon-separated identifier values inside the single table cell (for example `ACTIVE; ARCHIVED`, with no Markdown backticks or prose); Required Slots must contain `each-value` and exactly one `not-in-set`, plus `omitted` only when the parameter is optional; Expected by Slot states the documented expectation per slot kind (`domain-value`, `default-behavior`, `empty-result`/`excluded-result` when documented, or `GAP` when the source does not document the complement expectation — never invent 空列表/400). POST/PUT body field-validation enums stay in the Coverage Matrix as `TP-<FIELD>-ENUM-*` and MUST NOT get a Scenario Partition row. Do not create partitions for axes without a documented legal-value domain. Only GET/list query or path parameters whose bound source documents a finite enum or classification set may become a Scenario Partition. Do not create partitions for free-form strings, primary keys, required-or-optional-only parameters, or boundary/format-only axes. If an axis has no finite legal-value domain, do not declare a Partition row and do not invent NOT-IN-SET cases. Cross-axis combinations stay as ONE nominal Case; never declare a cross-axis cartesian partition.",
             "Before finalizing README, calculate the predicted collected-item count as `sum(max(1, number of variant Test Points in each Case))`. If the task declares an item budget, the prediction must not exceed it. Reduce excess only by removing duplicate execution and converting same-request checkpoints to assertions; never drop required rules, boundaries, enums, operation-specific inputs, or business states. Record the prediction in README. Use only environment-supported fixtures/targets/isolation, record evidence gaps in Chinese, and do not emit JSON, pytest, or execute commands.",
             ...(sharedSetupPrompt ? [sharedSetupPrompt] : []),
             intake.boundedSourceContext,
@@ -4944,7 +5008,7 @@ async function buildBackendTestHybridDag(sources) {
         writerOutcomePolicy: { type: "implementation-outcome-v1", requireChangedFiles: true },
         outputContract: "First non-empty line is IMPLEMENTATION_OUTCOME: changed|blocked, followed by a concise repair summary. This node runs only for REPAIRABLE initial facts, so already-satisfied is invalid and a successful outcome requires a non-empty bounded diff. 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. Treat any upstream line such as `Repair paths: testcase/test_x.py` as complete authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
+            "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. The direct upstream JSON includes authoritative `repairPaths` and bounded `repairFindings`; treat both as the complete mandatory checklist without searching for a run directory or report file. Treat any upstream line such as `Repair paths: testcase/test_x.py` as equivalent authoritative repairPaths evidence. Directly read and edit that testcase path; do not search for separate root-level `contracts/**`, guess a DAG run directory, or require another report artifact. If the read tool successfully returns the testcase file, the path exists—continue the bounded repair and never later claim that file is absent.",
             "Initial status REPAIRABLE means at least one listed finding remains: `already-satisfied` is forbidden, and you must produce a non-empty bounded diff on repairPaths before returning `IMPLEMENTATION_OUTCOME: changed`. Fix only readiness-proven generated testcase-local defects on initial facts repairPaths: create exact safe missing mapped test_*.py paths, repair syntax/import/symbol/decorator/parameterization, close generated fixture dependencies/plugin registration, and repair initial Markdown-to-pytest correspondence findings. Use this deterministic repair map instead of reading analyzer implementation: findings about `Case-ID`, `Assertion-Test-Points`, or `Cross-Cutting-Test-Points` are fixed by editing the declared primary symbol docstring metadata lines; variant binding findings are fixed in the literal direct `pytest.param(..., id=\"TP-...\")` row; primary-symbol cardinality/name findings are fixed in the function name or duplicate primary symbols; script mismatch is fixed only on the authoritative assessment repairPaths; payload findings are fixed in request payload construction. Do not read controller `src/**` or inspect JS/TS analyzer code. Do not search for `testcase/**/README.md`. Never invent a business pytest symbol for evidence-only Markdown Cases that declare `脚本/primary symbol=无` with empty variants. For fixture defects inspect both provider and importer listed by repairPaths; fix ScopeMismatch by aligning fixture scopes or inlining request-scoped values so module fixtures never depend on function fixtures; when a shared fixture depends on sibling fixtures, register the whole provider module through an exact pytest_plugins declaration rather than importing only the outer fixture. Do not create unrelated pytest scripts.",
             "This is the single pytest incremental synchronization round. The `Findings` in `reports/backend-test-pytest-collection-initial.md` are the mandatory repair checklist: resolve every repairable listed finding on every authoritative `Repair paths` file before considering any other advisory evidence, and never substitute an unrelated scenario-param cleanup for a listed correspondence/collection defect. For every assessment-listed path, compare the effective Markdown Case/Test Points/test data and its `Payload Contract`/`Payload Required Paths`/`Payload Allowed Paths`/`Payload Enum` labels with the generated module. Incrementally add or repair only missing symbols, params, assertions and payload builders. Repair every assessment-listed missing nested path, unexpected key and enum mismatch; preserve exact DTO keys, nested shapes, enum/boundary literals, operation transport and business preconditions; remove guessed replacement keys only when the effective Markdown proves the exact contract. Keep path/query/header identifiers and scenario-control metadata separate from DTO patches and JSON bodies; an `id` used for a path target must be passed to the request path/helper, never inserted into a body patch unless `id` is explicitly listed in Payload Allowed Paths. Flatten every variant into a literal direct `pytest.param(..., id=\"TP-...\")` row; replace `_post_case`/`_put_case` or other parameter-row factories because correspondence and scenario readiness require the actual row values and IDs to be statically visible. Also repair helper call sites to match their defined return signatures; do not tuple-unpack a helper that returns one scalar value.",
             "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.",