@tea-agent/loop-agent 0.24.0 → 0.24.1

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

@@ -7,6 +7,7 @@ import { z } from "zod";
 import { writeDagRunJsonArtifact } from "../../infrastructure/harness/artifact-store.js";
 import { findPackageRoot } from "../../shared/package-metadata.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { resolveDagTaskSourcePath } from "../../task/dag-source-paths.js";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
 /**
  * Load the canonical frontend-implementation-contract-v1 JSON Schema from the
@@ -133,7 +134,7 @@ export const frontendImplementationContractSchema = z
         verificationTargetIds: z.array(z.string().min(1)).optional(),
         notApplicableReason: z.string().min(1).optional(),
     })
-        .strict()).min(1),
+        .strict()),
     interactions: z.array(z
         .object({
         name: z.string().min(1),
@@ -300,17 +301,11 @@ export const frontendImplementationContractSchema = z
 });
 export async function assertFrontendSourceBindingFresh(input) {
     for (const source of input.binding.sources) {
-        // DAG source bindings are task-relative (for example source/需求.md),
-        // while older bindings may already contain the repository-relative
-        // .harness/tasks/<taskId>/ prefix. Resolve both forms before hashing.
-        const taskDir = path.resolve(input.workspaceRoot, ".harness", "tasks", input.binding.taskId);
-        const absolute = source.path.startsWith(".harness/")
-            ? path.resolve(input.workspaceRoot, source.path)
-            : path.resolve(taskDir, source.path);
-        const relative = path.relative(input.workspaceRoot, absolute);
-        if (relative.startsWith("..") || path.isAbsolute(relative)) {
-            throw new Error(`frontend source binding escapes workspace: ${source.path}`);
-        }
+        const absolute = resolveDagTaskSourcePath({
+            workspaceRoot: input.workspaceRoot,
+            taskId: input.binding.taskId,
+            sourcePath: source.path,
+        });
         let content;
         try {
             content = await readFile(absolute);
@@ -425,12 +420,23 @@ export function coerceFrontendImplementationContractInput(value, canonicalBindin
             uiStates: Array.isArray(rawRecord.uiStates)
                 ? rawRecord.uiStates.map((item) => {
                     const state = asRecord(item);
-                    if (!state ||
-                        state.applicable === false ||
-                        (state.notApplicableReason !== "" && state.notApplicableReason !== null))
+                    if (!state)
                         return item;
-                    const { notApplicableReason: _emptyReason, ...withoutEmptyReason } = state;
-                    return withoutEmptyReason;
+                    if (state.applicable === true &&
+                        (state.notApplicableReason === null ||
+                            (typeof state.notApplicableReason === "string" &&
+                                state.notApplicableReason.trim() === ""))) {
+                        const { notApplicableReason: _emptyReason, ...withoutEmptyReason } = state;
+                        return withoutEmptyReason;
+                    }
+                    if (state.applicable === false &&
+                        (state.expectedBehavior === null ||
+                            (typeof state.expectedBehavior === "string" &&
+                                state.expectedBehavior.trim() === ""))) {
+                        const { expectedBehavior: _emptyBehavior, ...withoutEmptyBehavior } = state;
+                        return withoutEmptyBehavior;
+                    }
+                    return item;
                 })
                 : rawRecord.uiStates,
         }

package/dist/workflows/dag/frontend-project-capability.js

@@ -1,316 +1 @@
-/**
- * Generation-time frontend project capability discovery (M5/M6).
- * Strong evidence only: package.json deps, config files, source imports.
- * Lockfile-only or directory-name-only must NOT activate adapters.
- */
-import { readFile, readdir, stat } from "node:fs/promises";
-import path from "node:path";
-import { OPENSPEC_SPEC_DIRS, OPENSPEC_SPEC_EXT_RE } from "../../shared/openspec-spec.js";
-async function exists(filePath) {
-    try {
-        await stat(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function readJson(filePath) {
-    try {
-        return JSON.parse(await readFile(filePath, "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-function allDeps(pkg) {
-    return {
-        ...(pkg.dependencies ?? {}),
-        ...(pkg.devDependencies ?? {}),
-        ...(pkg.peerDependencies ?? {}),
-    };
-}
-function hasDep(deps, name) {
-    return Object.hasOwn(deps, name);
-}
-async function listOpenspec(repoRoot) {
-    const out = [];
-    for (const specDir of OPENSPEC_SPEC_DIRS) {
-        const root = path.join(repoRoot, specDir);
-        if (!(await exists(root)))
-            continue;
-        await walk(root, 0);
-    }
-    return out.slice(0, 40);
-    async function walk(dir, depth) {
-        if (depth > 4)
-            return;
-        let entries = [];
-        try {
-            entries = await readdir(dir);
-        }
-        catch {
-            return;
-        }
-        for (const name of entries) {
-            const full = path.join(dir, name);
-            try {
-                const info = await stat(full);
-                if (info.isDirectory())
-                    await walk(full, depth + 1);
-                else if (OPENSPEC_SPEC_EXT_RE.test(name)) {
-                    out.push(path.relative(repoRoot, full).replace(/\\/g, "/"));
-                }
-            }
-            catch {
-                // skip
-            }
-        }
-    }
-}
-export function buildAdapterGuidance(capability) {
-    const lines = [
-        "## Frontend project capability (generation-time)",
-        `Framework: ${capability.framework}${capability.frameworkVersion ? `@${capability.frameworkVersion}` : ""}`,
-        `Evidence: ${capability.evidencePaths.join(", ") || "(none)"}`,
-        "Rules: openspec specs and task sources outrank adapter tips; do not invent APIs for unknown versions; lockfile-only is not enough.",
-    ];
-    if (capability.framework === "react") {
-        lines.push("React adapter: prefer function components + hooks; reuse existing Testing Library / Vitest patterns; do not introduce new state libs without authorization.");
-    }
-    else if (capability.framework === "next") {
-        lines.push("Next.js adapter: respect App vs Pages router from evidence; keep server/client boundaries explicit; avoid guessing cache/navigation APIs across major versions.");
-    }
-    else if (capability.framework === "vue") {
-        lines.push("Vue adapter: prefer Composition API if project already uses it; reuse Pinia/Vue Router/Vue Query only when evidenced; Vitest + Vue Test Utils when present.");
-    }
-    else {
-        lines.push("Unknown framework: use generic frontend-implementation skill only; do not assume React/Vue/Next APIs.");
-    }
-    if (capability.a11y.status === "present") {
-        lines.push(`A11y tools present: ${capability.a11y.tools.join(", ")}. Report static/component-level evidence only; Browser a11y remains not-run.`);
-    }
-    else {
-        lines.push("A11y tools: absent/unknown — mark a11y checks unavailable/not-run; do not install tools.");
-    }
-    if (capability.designEvidence.normativePaths.length) {
-        lines.push(`Normative design paths: ${capability.designEvidence.normativePaths.slice(0, 8).join(", ")}`);
-    }
-    return lines.join("\n");
-}
-/**
- * Discover frontend project capability from repo root.
- * Strong evidence: package.json direct deps + config/bootstrap files.
- */
-export async function discoverFrontendProjectCapability(repoRoot) {
-    const evidencePaths = [];
-    const reasons = [];
-    const pkgPath = path.join(repoRoot, "package.json");
-    const pkgRaw = await readJson(pkgPath);
-    if (!pkgRaw || typeof pkgRaw !== "object") {
-        const openspec = await listOpenspec(repoRoot);
-        const base = {
-            schemaVersion: 1,
-            framework: "unknown",
-            state: [],
-            dataFetching: [],
-            componentLibrary: [],
-            style: [],
-            testRunner: [],
-            mock: [],
-            a11y: { status: "unknown", tools: [], evidencePaths: [] },
-            evidencePaths: openspec.slice(0, 5),
-            reasons: ["package.json missing or unreadable"],
-            designEvidence: {
-                normativePaths: openspec,
-                advisoryPaths: [],
-                conflicts: [],
-            },
-        };
-        if (openspec.length) {
-            base.reasons.push(`openspec spec files discovered: ${openspec.slice(0, 5).join(", ")}`);
-        }
-        return { ...base, adapterGuidance: buildAdapterGuidance(base) };
-    }
-    evidencePaths.push("package.json");
-    const deps = allDeps(pkgRaw);
-    // Lockfile alone does not activate
-    for (const lock of ["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]) {
-        if (await exists(path.join(repoRoot, lock))) {
-            reasons.push(`${lock} present but not used as sole activation evidence`);
-        }
-    }
-    let framework = "unknown";
-    let frameworkVersion;
-    const configHits = [];
-    const nextConfig = ["next.config.js", "next.config.mjs", "next.config.ts"];
-    for (const name of nextConfig) {
-        if (await exists(path.join(repoRoot, name))) {
-            configHits.push(name);
-            evidencePaths.push(name);
-        }
-    }
-    if (hasDep(deps, "next") && configHits.some((c) => c.startsWith("next"))) {
-        framework = "next";
-        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
-        reasons.push("next dependency + next.config*");
-    }
-    else if (hasDep(deps, "next") && configHits.length === 0) {
-        // dep without config: still weak if only transitive — require direct dep
-        framework = "next";
-        frameworkVersion = deps.next?.replace(/^[^\d]*/, "");
-        reasons.push("next direct dependency (config not found)");
-        evidencePaths.push("package.json#dependencies.next");
-    }
-    if (framework === "unknown") {
-        const vueConfig = ["vite.config.ts", "vite.config.js", "vue.config.js"];
-        let vueCfg = false;
-        for (const name of vueConfig) {
-            if (await exists(path.join(repoRoot, name))) {
-                vueCfg = true;
-                evidencePaths.push(name);
-            }
-        }
-        if (hasDep(deps, "vue") && (vueCfg || hasDep(deps, "nuxt"))) {
-            framework = "vue";
-            frameworkVersion = deps.vue?.replace(/^[^\d]*/, "");
-            reasons.push("vue direct dependency + config/tooling");
-        }
-    }
-    if (framework === "unknown" && hasDep(deps, "react")) {
-        // Need config or jsx tooling — not lockfile-only
-        const reactCfg = (await exists(path.join(repoRoot, "vite.config.ts"))) ||
-            (await exists(path.join(repoRoot, "vite.config.js"))) ||
-            (await exists(path.join(repoRoot, "webpack.config.js"))) ||
-            hasDep(deps, "react-scripts") ||
-            hasDep(deps, "vite");
-        if (reactCfg) {
-            framework = "react";
-            frameworkVersion = deps.react?.replace(/^[^\d]*/, "");
-            reasons.push("react direct dependency + bundler/tooling evidence");
-            evidencePaths.push("package.json#dependencies.react");
-        }
-        else {
-            reasons.push("react listed but no strong config/bundler evidence — framework=unknown");
-        }
-    }
-    const state = [];
-    for (const lib of [
-        "redux",
-        "@reduxjs/toolkit",
-        "zustand",
-        "jotai",
-        "recoil",
-        "pinia",
-        "vuex",
-    ]) {
-        if (hasDep(deps, lib))
-            state.push(lib);
-    }
-    const dataFetching = [];
-    for (const lib of [
-        "@tanstack/react-query",
-        "swr",
-        "axios",
-        "@tanstack/vue-query",
-        "ofetch",
-    ]) {
-        if (hasDep(deps, lib))
-            dataFetching.push(lib);
-    }
-    const componentLibrary = [];
-    for (const lib of [
-        "antd",
-        "@mui/material",
-        "element-plus",
-        "vuetify",
-        "@chakra-ui/react",
-    ]) {
-        if (hasDep(deps, lib))
-            componentLibrary.push(lib);
-    }
-    const style = [];
-    for (const lib of [
-        "tailwindcss",
-        "sass",
-        "less",
-        "styled-components",
-        "@emotion/react",
-    ]) {
-        if (hasDep(deps, lib))
-            style.push(lib);
-    }
-    const testRunner = [];
-    for (const lib of [
-        "vitest",
-        "jest",
-        "@testing-library/react",
-        "@testing-library/vue",
-        "@playwright/test",
-    ]) {
-        if (hasDep(deps, lib))
-            testRunner.push(lib);
-    }
-    const mock = [];
-    for (const lib of ["msw", "nock", "miragejs"]) {
-        if (hasDep(deps, lib))
-            mock.push(lib);
-    }
-    const a11yTools = [];
-    const a11yEvidence = [];
-    for (const lib of [
-        "eslint-plugin-jsx-a11y",
-        "@axe-core/react",
-        "jest-axe",
-        "vitest-axe",
-        "axe-core",
-    ]) {
-        if (hasDep(deps, lib)) {
-            a11yTools.push(lib);
-            a11yEvidence.push(`package.json#${lib}`);
-        }
-    }
-    const a11y = {
-        status: (a11yTools.length > 0 ? "present" : "absent"),
-        tools: a11yTools,
-        evidencePaths: a11yEvidence,
-    };
-    let router;
-    if (hasDep(deps, "react-router-dom") || hasDep(deps, "react-router")) {
-        router = "react-router";
-    }
-    if (framework === "next")
-        router = router ?? "next-router";
-    if (hasDep(deps, "vue-router"))
-        router = "vue-router";
-    const openspec = await listOpenspec(repoRoot);
-    const designEvidence = {
-        normativePaths: openspec,
-        advisoryPaths: [],
-        conflicts: [],
-    };
-    if (openspec.length)
-        evidencePaths.push(...openspec.slice(0, 5));
-    const base = {
-        schemaVersion: 1,
-        framework,
-        frameworkVersion,
-        router,
-        state,
-        dataFetching,
-        componentLibrary,
-        style,
-        testRunner,
-        mock,
-        a11y,
-        packageManager: (await exists(path.join(repoRoot, "pnpm-lock.yaml")))
-            ? "pnpm"
-            : (await exists(path.join(repoRoot, "yarn.lock")))
-                ? "yarn"
-                : "npm",
-        evidencePaths: [...new Set(evidencePaths)],
-        reasons,
-        designEvidence,
-    };
-    return { ...base, adapterGuidance: buildAdapterGuidance(base) };
-}
+export * from "../../task/frontend-project-capability.js";

package/dist/workflows/dag/frontend-worktree-diff.js

@@ -33,7 +33,10 @@ function splitLines(text) {
         .filter(Boolean);
 }
 function statusPaths(status) {
-    return splitLines(status)
+    return status
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .filter((line) => line.length >= 4)
         .map((line) => line.slice(3).split(" -> ").at(-1) ?? "")
         .filter(Boolean)
         .sort();

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

@@ -29,6 +29,7 @@ import { buildFrontendCaseEvidenceValidateShellSnippet, buildFrontendTestOutcome
 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";
+import { serializeDagTaskSourcePath } from "../../task/dag-source-paths.js";
 const REQUIREMENT_FILE = "需求.md";
 const CONSTRAINT_FILE = "执行约束.md";
 const REFERENCE_DIRECTORY = "references";
@@ -1062,8 +1063,12 @@ function deriveFrontendBehaviorPaths(taskConfig) {
         return explicitTestPaths;
     return taskConfig.allowedPaths;
 }
-function toTaskRelativeSourcePath(sources, absolutePath) {
-    return path.relative(sources.taskDir, absolutePath).replaceAll(path.sep, "/");
+function toDagSourcePath(sources, absolutePath) {
+    return serializeDagTaskSourcePath({
+        repoRoot: sources.repoRoot,
+        taskDir: sources.taskDir,
+        absolutePath,
+    });
 }
 function extractExplicitRequirementIds(...markdownInputs) {
     const ids = [];
@@ -1124,7 +1129,7 @@ function buildDagSourceBinding(sources) {
         taskId: sources.taskId,
         sources: sourceEntries.map((source) => ({
             kind: source.kind,
-            path: toTaskRelativeSourcePath(sources, source.path),
+            path: toDagSourcePath(sources, source.path),
             sha256: createHash("sha256")
                 .update(source.markdown, "utf8")
                 .digest("hex"),
@@ -1149,13 +1154,13 @@ function buildBackendTestAnalysisSourceBindingContract(sources) {
     };
 }
 function buildSourceContextBlock(sources) {
-    const requirementRef = toTaskRelativeSourcePath(sources, sources.requirementPath);
+    const requirementRef = toDagSourcePath(sources, sources.requirementPath);
     const requirementExcerpt = excerptMarkdown(sources.requirementMarkdown, {
         sourceRef: requirementRef,
     });
     const parts = ["## Task source: 需求.md", requirementExcerpt.text];
     if (sources.constraintMarkdown) {
-        const constraintRef = toTaskRelativeSourcePath(sources, sources.constraintPath);
+        const constraintRef = toDagSourcePath(sources, sources.constraintPath);
         const constraintExcerpt = excerptMarkdown(sources.constraintMarkdown, {
             sourceRef: constraintRef,
         });
@@ -1165,7 +1170,7 @@ function buildSourceContextBlock(sources) {
         const relativePath = path
             .relative(path.join(sources.taskDir, "source"), reference.path)
             .replaceAll(path.sep, "/");
-        const referenceRef = toTaskRelativeSourcePath(sources, reference.path);
+        const referenceRef = toDagSourcePath(sources, reference.path);
         const referenceExcerpt = excerptMarkdown(reference.markdown, {
             sourceRef: referenceRef,
         });
@@ -1289,7 +1294,7 @@ export async function loadTaskHybridSources(repoRoot, taskId) {
     };
     return sources;
 }
-async function prepareFrontendMockSources(sources) {
+async function prepareFrontendMockSources(sources, discoveredProjectCapability) {
     const repoRoot = sources.repoRoot ?? process.cwd();
     const capability = await discoverFrontendMockCapability(repoRoot, sources.taskConfig);
     const sourceMockVerifyCommands = extractFrontendMockVerifyCommandsFromMarkdown({
@@ -1302,7 +1307,8 @@ async function prepareFrontendMockSources(sources) {
             capability.verifyCommands.push(command);
         }
     }
-    const projectCapability = await discoverFrontendProjectCapability(repoRoot);
+    const projectCapability = discoveredProjectCapability ??
+        (await discoverFrontendProjectCapability(repoRoot));
     const frontendRisk = classifyFrontendRisk({
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
@@ -1936,6 +1942,8 @@ async function buildFrontendHybridDagFromTask(sources) {
             "## Critical rules",
             "- verificationTargets is a TOP-LEVEL required array",
             "- uiStates items use name/applicable/expectedBehavior/implementationTargets/verificationTargetIds/notApplicableReason",
+            "- Use uiStates: [] for frontend logic changes with no user-visible UI state. Do not invent UI states.",
+            "- For applicable=true, provide non-empty expectedBehavior plus non-empty implementationTargets and verificationTargetIds. For applicable=false, provide non-empty notApplicableReason and omit expectedBehavior instead of emitting an empty string.",
             "- mockApi.productionDefaultOff must always be true (including strategy: not-needed)",
             "- All implementation files, verification files, symbols, and commands must be discovered from the current target workspace and current task. Never copy paths, symbols, or commands from the loop-agent repository, an example task, or prior run output.",
             "- Use relative POSIX paths rooted at the target workspace. Do not assume a particular src/test directory layout; preserve the target project's actual app/, packages/, spec/, __tests__, or other layout.",
@@ -2299,11 +2307,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     ...(lintShellCommands.length > 0
                         ? ["frontend-lint-baseline-shell"]
                         : []),
-                    "frontend-plan-revision-pi",
-                    "frontend-final-design-review-pi",
-                    "frontend-plan-pi",
                 ],
-                dependsPolicy: "all-or-condition-skip",
                 role: "implementer",
                 executor: "pi",
                 toolProfile: "write",
@@ -2316,6 +2320,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 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.",
                 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.",
                     "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.",
@@ -2323,8 +2328,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "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.",
                     "Do not write root artifacts/** unless explicitly included in writeSet. Do not claim Browser/visual verification.",
                     writerDeliveryContract(taskConfig),
-                    sourceContext,
-                    mockContextBlock,
                 ]
                     .filter((value) => Boolean(value))
                     .join("\n\n"),
@@ -2379,11 +2382,10 @@ async function buildFrontendHybridDagFromTask(sources) {
                 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.",
+                    "The repair assessment and canonical implementation contract are complete inputs for this phase. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, or design-review prose, and do not repeat repository-wide discovery.",
                     "Do not change lint/type/test config, do not add .skip/.only, do not comment out real requests, do not default-enable Mock, do not add dependencies.",
                     "Do not re-plan requirements or expand allowed paths. Browser/visual remain not-run.",
                     writerDeliveryContract(taskConfig),
-                    sourceContext,
-                    mockContextBlock,
                 ]
                     .filter((value) => Boolean(value))
                     .join("\n\n"),
@@ -2449,19 +2451,7 @@ async function buildFrontendHybridDagFromTask(sources) {
             },
             {
                 id: "frontend-review-pi",
-                depends_on: [
-                    "frontend-review-context-shell",
-                    "frontend-reverify-shell",
-                    "frontend-repair-pi",
-                    "frontend-verify-assess-shell",
-                    implementId,
-                    "frontend-prewrite-gate-shell",
-                    "frontend-plan-pi",
-                    "frontend-design-review-pi",
-                    "frontend-plan-revision-pi",
-                    "frontend-final-design-review-pi",
-                ],
-                dependsPolicy: "all-or-condition-skip",
+                depends_on: ["frontend-review-context-shell"],
                 role: "reviewer",
                 executor: "pi",
                 complexity: "HIGH",
@@ -2477,13 +2467,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read contracts/frontend-review-context.json from frontend-review-context-shell. It binds the validated implementation contract, frontend lint assessment when lint is configured, effective initial-or-post-repair verification trace, repair assessment, and the run-owned actual diff (contracts/frontend-worktree-diff.json + artifacts/diff_patch.patch). Do not claim actual diff is missing when those artifacts exist; do not invent a diff from the implementation summary alone. Trace proves command/file/symbol binding only—not semantic correctness.",
                     "Treat lint status exactly as passed | baseline-debt | failed | unavailable. baseline-debt may continue only with intact evidence and zero diagnostics on writer-changed files; report the tolerated debt count and never rewrite it as lint passed. Typecheck, build, and test still require successful final exits.",
                     "Flag .skip/.only, deleted or weakened tests, unauthorized config changes, Mock-only evidence claimed as real integration, and Browser/visual claims (always not-run in this workflow).",
-                    "Use the direct contract and the effective plan/design branch: original plan plus initial pass when revision was skipped, or revised plan plus final design review when revision ran. Do not infer them from the implementation summary.",
+                    "The contract embedded in frontend-review-context.json is the effective reviewed plan materialized by the prewrite gate. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, 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.",
                     "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-assess-shell or selected frontend-reverify-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.",
                     "Review implementation quality, behavior/state coverage, verification evidence, and maintainability. Read-only: do not modify files.",
-                    sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2512,15 +2500,9 @@ async function buildFrontendHybridDagFromTask(sources) {
             {
                 id: "frontend-closeout-pi",
                 depends_on: [
-                    "frontend-review-gate-shell",
-                    "frontend-review-pi",
                     "frontend-review-context-shell",
-                    "frontend-reverify-shell",
-                    "frontend-repair-pi",
-                    "frontend-verify-assess-shell",
-                    "frontend-prewrite-gate-shell",
+                    "frontend-review-gate-shell",
                 ],
-                dependsPolicy: "all-or-condition-skip",
                 role: "closeout",
                 executor: "pi",
                 complexity: "MED",
@@ -2533,12 +2515,11 @@ async function buildFrontendHybridDagFromTask(sources) {
                 outputContract: "Markdown closeout summary with Changes, Mock Decision / Strategy / Files / Verification / Production Boundary, Verification Evidence, Review Result, Frontend Status, Real Integration Status, Known Risks, and Follow-up. No file writes.",
                 subtask_prompt: [
                     "Return a frontend closeout summary covering Mock decision/strategy/files/verification/production boundary, changes, verification evidence, review result, known risks, and follow-up.",
+                    "Use only the canonical frontend-review-context.json plus the final frontend review gate verdict. Do not re-open task sources, OpenSpec, AI workspace, plan/revision, design-review, writer, repair, or verification prose, and do not perform new repository research during closeout.",
                     "Include a coverage matrix for each requirement id, applicable UI state, and verification target/check with status passed|failed|not-run|blocked|unavailable. Report lint separately as passed|baseline-debt|failed|unavailable; baseline-debt is explicit debt, not passed. Always state Browser accessibility verification: not-run and Visual regression: not-run. Use contracts/frontend-review-context.json and the effective frontend-verify-assess-shell or frontend-reverify-shell facts; do not invent Browser evidence from component tests.",
                     `When only Mock-backed evidence passed, state exactly Frontend status: mock-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task to create/run after backend readiness. This follow-up is not auto-created or auto-executed. Never describe Mock evidence as real API integration.`,
                     `When Mock was skipped in auto mode and no real API evidence passed, state exactly Frontend status: locally-validated and Real integration: pending, summarize the Real Integration Gap, and name ${taskConfig.taskId}-real-api-integration-verify as the explicit follow-up task when backend readiness matters.`,
                     "Read-only: do not modify code, docs, artifacts, or .harness/dag-runs/.",
-                    sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
         ],
@@ -4940,11 +4921,22 @@ function assertNoGovernanceFlagOnDisallowedTemplate(spec, template) {
     }
 }
 export async function buildHybridDagFromTask(sources, options = {}) {
+    const routingProjectCapability = sources.taskConfig.taskKind === "standard" &&
+        (options.template === undefined || options.template === "standard-dag") &&
+        sources.repoRoot
+        ? await discoverFrontendProjectCapability(sources.repoRoot)
+        : sources.frontendProjectCapability;
     const selection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,
+        frontendProject: routingProjectCapability
+            ? {
+                framework: routingProjectCapability.framework,
+                evidencePaths: routingProjectCapability.evidencePaths,
+            }
+            : undefined,
         requestedTemplate: options.template,
     });
     return buildHybridDagForTemplate(sources, selection.template);
@@ -5566,17 +5558,27 @@ 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")
+        ? await discoverFrontendProjectCapability(sources.repoRoot ?? process.cwd())
+        : sources.frontendProjectCapability;
     const templateSelection = resolveTaskDagTemplateSelection({
         taskKind: sources.taskConfig.taskKind,
         title: sources.taskConfig.title,
         requirementMarkdown: sources.requirementMarkdown,
         allowedPaths: sources.taskConfig.allowedPaths,
+        frontendProject: routingProjectCapability
+            ? {
+                framework: routingProjectCapability.framework,
+                evidencePaths: routingProjectCapability.evidencePaths,
+            }
+            : undefined,
         requestedTemplate: options.template,
     });
     const template = templateSelection.template;
     assertTaskAllowedPathsPreflight(sources.taskConfig);
     const preparedSources = template === "frontend-implementation"
-        ? await prepareFrontendMockSources(sources)
+        ? await prepareFrontendMockSources(sources, routingProjectCapability)
         : sources;
     const spec = await buildHybridDagForTemplate(preparedSources, template);
     if (preparedSources.repoRoot && dagHasWriterExecution(spec)) {