@tea-agent/loop-agent 0.39.0-beta.6 → 0.39.0-beta.7

package/dist/workflows/dag/backend-test-pytest-collection.js

@@ -131,6 +131,23 @@ function normalizeHazardOccurrenceIdentity(line) {
     // Unclosed quote or no out-of-string `#`: do not invent a comment boundary.
     return trimmed;
 }
+/**
+ * Bare `__NNN_*` helper module names imported by a Python source snippet.
+ * Only the head token of an `import`/`from` statement is considered a module
+ * name; dotted submodules (`__551_manager_helpers.x`) collapse to the head.
+ */
+function importedBareHelperModules(source) {
+    const names = [];
+    const seen = new Set();
+    for (const match of normalizeSourceNewlines(source).matchAll(/\b(?:import|from)\s+([A-Za-z0-9_.]+)/g)) {
+        const head = match[1].split(".")[0];
+        if (/^__\d+[A-Za-z0-9_]*$/.test(head) && !seen.has(head)) {
+            seen.add(head);
+            names.push(head);
+        }
+    }
+    return names;
+}
 function listPatternOccurrences(source, patternSource, flags = "") {
     const normalized = normalizeSourceNewlines(source);
     const pattern = new RegExp(patternSource, flags.includes("g") ? flags : `${flags}g`);
@@ -221,6 +238,8 @@ export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScri
     const inputHashes = {};
     const hazardOccurrenceCounts = {};
     const hazardOccurrences = {};
+    const scriptBareImports = {};
+    const mappedScriptSet = new Set(normalizedScripts);
     for (const file of assetFiles) {
         const bytes = await readFile(path.resolve(workspaceRoot, file));
         const source = bytes.toString("utf8");
@@ -228,8 +247,10 @@ export async function buildBackendPytestAssetInventory(workspaceRoot, mappedScri
         const lists = scanRepairHazardOccurrenceLists(source);
         hazardOccurrences[file] = lists;
         hazardOccurrenceCounts[file] = Object.fromEntries(Object.entries(lists).map(([label, identities]) => [label, identities.length]));
+        if (mappedScriptSet.has(file))
+            scriptBareImports[file] = importedBareHelperModules(source);
     }
-    return { mappedScripts: normalizedScripts, assetFiles, inputHashes, hazardOccurrenceCounts, hazardOccurrences };
+    return { mappedScripts: normalizedScripts, assetFiles, inputHashes, hazardOccurrenceCounts, hazardOccurrences, scriptBareImports };
 }
 function bounded(value) {
     const normalized = value.replaceAll(/(Bearer|Basic)\s+[A-Za-z0-9._~+\/-]+/gi, "$1 [REDACTED]");
@@ -308,8 +329,68 @@ function classifyFixtureResolutionFailure(output, layout) {
         repairPaths: paths,
     };
 }
-function classifyCollectionFailure(output) {
+/**
+ * Generated-local bare helper module signatures found in the bound pytest
+ * asset inventory. A file such as `testcase/__551_manager_helpers.py` in the
+ * test root/script dir is generated-local: when collection reports
+ * `No module named '__551_manager_helpers'`, the defect can be precisely
+ * attributed to the generated mapped script instead of a missing third-party
+ * package.
+ */
+function generatedLocalBareHelperNames(inventory) {
+    if (!inventory)
+        return [];
+    const names = [];
+    for (const file of inventory.assetFiles) {
+        const stem = path.posix.basename(file).replace(/\.py$/, "");
+        if (/^__\d+[A-Za-z0-9_]*$/.test(stem))
+            names.push(stem);
+    }
+    return [...new Set(names)];
+}
+function classifyCollectionFailure(output, evidence) {
     const normalized = output.replaceAll("\\", "/");
+    const helperNames = generatedLocalBareHelperNames(evidence?.inventory);
+    const helperByLower = new Map(helperNames.map((name) => [name.toLowerCase(), name]));
+    // A bare `__NNN_...` module import that collection cannot find is only a
+    // candidate generated-local helper signature. REPAIRABLE requires two
+    // deterministic pieces of evidence: (1) a helper asset of the same name in
+    // the bound inventory, and (2) at least one mapped generated script whose
+    // source truly imports that bare module. Without both — or when attribution
+    // is impossible — fail closed as BLOCKED so an un-attributable dependency
+    // error is never widened into a repair. Genuine third-party modules (no
+    // `__NNN_` signature) stay BLOCKED below.
+    const missingModule = /No module named ['\"]([^'\"]+)['\"]/i.exec(normalized)?.[1];
+    if (missingModule && /^__\d+[A-Za-z0-9_]*$/.test(missingModule)) {
+        const helperAsset = helperByLower.get(missingModule.toLowerCase());
+        const inventory = evidence?.inventory;
+        const scriptBareImports = inventory?.scriptBareImports ?? {};
+        const missingLower = missingModule.toLowerCase();
+        const importedByMappedScript = inventory
+            ? inventory.mappedScripts.some((script) => (scriptBareImports[script] ?? []).some((name) => name.toLowerCase() === missingLower))
+            : false;
+        if (helperAsset && importedByMappedScript && inventory) {
+            const repairPaths = [...new Set([
+                    ...(helperAsset
+                        ? inventory.assetFiles.filter((file) => path.posix.basename(file).replace(/\.py$/, "") === helperAsset)
+                        : []),
+                    ...inventory.mappedScripts,
+                ])].sort();
+            return {
+                status: "REPAIRABLE",
+                kind: "missing-generated-local-helper",
+                detail: `generated testcase asset imports missing bare generated-local helper module ${missingModule}; inline the helper or remove the generated shared dependency`,
+                repairPaths,
+            };
+        }
+        return {
+            status: "BLOCKED",
+            kind: "missing-generated-local-helper-without-evidence",
+            detail: helperAsset
+                ? `missing bare generated-local helper module ${missingModule} has a name match but no mapped generated script imports it (no precise generated-local attribution)`
+                : `missing bare __NNN_* module ${missingModule} has no generated-local helper asset in the bound inventory (cannot be precisely attributed)`,
+        };
+    }
     const blockedPatterns = [
         [/No module named ['\"](?!testcase(?:\.|['\"]))/i, "missing-third-party-module"],
         [/pytest(?:_|-)plugin|pluggy|unknown hook|unrecognized arguments/i, "pytest-plugin-or-config"],
@@ -401,7 +482,7 @@ export function assessBackendPytestCollection(input) {
             fixtureStderrExcerpt: bounded(fixtureResolution.stderr),
         });
     }
-    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`);
+    const classification = classifyCollectionFailure(`${input.stdout}\n${input.stderr}`, { layout: input.layout, inventory: input.inventory });
     return backendPytestCollectionFactsSchema.parse({
         schemaId: "backend-test-pytest-collection-v3",
         phase: input.phase,
@@ -412,7 +493,9 @@ export function assessBackendPytestCollection(input) {
         fixtureResolutionAttempted: false,
         fixtureResolutionStatus: "NOT_RUN",
         fixtureResolutionExitCode: null,
-        repairPaths: testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
+        repairPaths: classification.repairPaths && classification.repairPaths.length > 0
+            ? classification.repairPaths
+            : testcasePythonPaths(`${input.stdout}\n${input.stderr}`),
         mappedScripts: input.inventory.mappedScripts,
         existingMappedScripts: input.inventory.mappedScripts,
         missingMappedScripts: [],

package/dist/workflows/dag/backend-test-writer-completeness.js

@@ -385,12 +385,17 @@ export const FORBIDDEN_GENERATED_IMPORT_NAMESPACES = [
     "testcase.helpers",
     "testcase.factories",
 ];
-const FORBIDDEN_GENERATED_IMPORT_PATTERN = /^\s*(?:from\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b|import\s+(testcase_helpers|testcase\.helpers|testcase\.factories)\b)/gm;
+const FORBIDDEN_GENERATED_IMPORT_PATTERN = /^\s*(?:from\s+(testcase_helpers|testcase\.helpers|testcase\.factories|__\d+[A-Za-z0-9_]*)\b|import\s+(testcase_helpers|testcase\.helpers|testcase\.factories|__\d+[A-Za-z0-9_]*)\b)/gm;
 /**
- * Scan Python source for imports from forbidden generated shared namespaces.
- * Anchored at line start with a word boundary so `testcase.helpers_other` or a
- * substring inside a docstring sentence is not falsely flagged. Returns the
- * list of offending namespace module names (deduplicated, order-preserving).
+ * Scan Python source for imports from forbidden generated shared namespaces
+ * or bare generated-local helper modules. Anchored at line start with a word
+ * boundary so `testcase.helpers_other` or a substring inside a docstring is not
+ * falsely flagged. In addition to the `testcase_helpers`/`testcase.helpers`/
+ * `testcase.factories` namespaces, bare `__<digits>...` helper modules (for
+ * example `from __551_manager_helpers import ...` / `import __551_manager_helpers`)
+ * are generated-local shared dependencies: a self-contained pytest child must
+ * inline or remove them rather than depend on a generated shared module.
+ * Returns the list of offending module names (deduplicated, order-preserving).
  */
 export function findForbiddenGeneratedImports(source) {
     const hits = [];

package/dist/workflows/dag/frontend-design-policy.js

@@ -2,6 +2,10 @@ import { deterministicSha256, } from "./frontend-implementation-contract.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 const SHA256_HEX = /^[a-f0-9]{64}$/;
 const NPM_PACKAGE_NAME = /^(?:@[a-zA-Z0-9_.-]+\/)?[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
+/** Max concrete implementation files a single writeSet may carry before the
+ * plan is asked to split. Kept at 15: beyond this, a single implement node's
+ * read/edit loop inflates provider context toward overflow. */
+const MAX_WRITE_SET_FILES = 15;
 function normalizeRelativePath(value) {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -209,7 +213,22 @@ export function checkComponentChoice(contract, componentSpecCandidatePaths) {
  * must fall inside the declared writeSet patterns. */
 export function checkTargetPaths(contract, writeSetPatterns) {
     const findings = [];
+    // No frozen writeSet patterns (legacy / unconfigured run) → nothing to
+    // check; an empty pattern set must not report every file as out of scope.
+    if (writeSetPatterns.length === 0)
+        return findings;
     const matches = (file) => writeSetPatterns.some((pattern) => pathMatchesPattern(file, pattern));
+    // A writeSet this large forces a single implement node to read/edit many
+    // files, inflating the provider context until it overflows (400
+    // request-too-large). Flag it so the plan is asked to split (the contract
+    // node already has record_split_proposal) instead of letting the writer
+    // blow up mid-run.
+    if (contract.targets.files.length > MAX_WRITE_SET_FILES) {
+        findings.push({
+            code: "write-set-too-large",
+            message: `implementation writeSet has ${contract.targets.files.length} files (limit ${MAX_WRITE_SET_FILES}); split the task (record_split_proposal) so no single implement node exceeds the bound`,
+        });
+    }
     for (const file of contract.targets.files) {
         if (!matches(file)) {
             findings.push({

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

@@ -12,7 +12,7 @@ import { readTypedEventStoreFromJsonl } from "./frontend-typed-event-store.js";
 // Cycle-safe value imports: the check functions are hoisted declarations used
 // only at call time, so the contract module and the policy module can depend
 // on each other without module-init ordering issues.
-import { checkDependencies, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
+import { checkDependencies, checkTargetPaths, checkUiDesignCoverage, checkUiStateAttribution, } from "./frontend-design-policy.js";
 import { canonicalContractRel, classifyStructuredContractFailure, formatStructuredArtifactPointer, persistRuntimeSkeleton, } from "./structured-output-repair.js";
 import { isConfigurationVerificationFile, verificationSymbolMatchesContent, } from "./frontend-verification-trace.js";
 export const frontendNormalizationActionSchema = z.enum([
@@ -142,6 +142,35 @@ async function deriveAllowedDependenciesFromRun(runDir) {
     }
     return [...deps];
 }
+/** Read the frozen implementation writeSet patterns from run.json so the plan
+ * validator can front-load checkTargetPaths (write-set-too-large) before the
+ * design-policy shell terminates the run. */
+async function deriveWriteSetFromRun(runDir) {
+    const specPath = path.join(runDir, "run.json");
+    let raw;
+    try {
+        raw = await readFile(specPath, "utf8");
+    }
+    catch {
+        return [];
+    }
+    let spec;
+    try {
+        spec = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    const writeSet = new Set();
+    for (const task of spec.tasks ?? []) {
+        const patterns = task.shell?.frontendDesignPolicy?.implementationWriteSet;
+        if (patterns) {
+            for (const pattern of patterns)
+                writeSet.add(pattern);
+        }
+    }
+    return [...writeSet];
+}
 export const FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID = "frontend-implementation-contract-v1";
 export const FRONTEND_IMPLEMENTATION_CONTRACT_PLAN_PATCH_SCHEMA_ID = "frontend-implementation-contract-plan-patch-v1";
 /**
@@ -309,8 +338,50 @@ function stripNullValuesDeep(value) {
     }
     return value;
 }
+/**
+ * Normalize a model-emitted `uiComponentChoices` where a `new` choice carries a
+ * degenerate empty `specReference` object (`{ path: "", section: "", line:
+ * null }`) instead of the required `null`. The model intent is unambiguous
+ * (new components must not carry a specReference; the empty object is a format
+ * slip, not a real spec hit), so dropping the empty object before validation
+ * avoids a full plan retry on an otherwise-correct emission. A `specReference`
+ * with a non-empty `path` is preserved (it is a genuine `specified` hit).
+ */
+export function normalizeNewComponentSpecReference(value) {
+    if (!Array.isArray(value))
+        return value;
+    return value.map((item) => {
+        if (!item || typeof item !== "object")
+            return item;
+        const record = item;
+        if (record.decision !== "new")
+            return item;
+        const ref = record.specReference;
+        if (!ref || typeof ref !== "object")
+            return item;
+        const refRecord = ref;
+        const path = typeof refRecord.path === "string" ? refRecord.path.trim() : "";
+        if (path.length > 0)
+            return item;
+        // Empty/degenerate specReference on a new choice → absent (null intent).
+        const { specReference: _dropped, ...rest } = record;
+        return rest;
+    });
+}
 export const frontendImplementationContractSchema = z
-    .preprocess(stripNullValuesDeep, z
+    .preprocess((value) => {
+    const record = asRecord(value);
+    if (!record)
+        return stripNullValuesDeep(value);
+    return stripNullValuesDeep({
+        ...record,
+        ...(record.uiComponentChoices !== undefined
+            ? {
+                uiComponentChoices: normalizeNewComponentSpecReference(record.uiComponentChoices),
+            }
+            : {}),
+    });
+}, z
     .object({
     schemaVersion: z.literal(1),
     sourceBinding: z
@@ -1974,6 +2045,7 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             ...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

package/dist/workflows/dag/frontend-review-findings.js

@@ -0,0 +1,238 @@
+import path from "node:path";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { readTypedEventStoreFromJsonl, } from "./frontend-typed-event-store.js";
+/**
+ * Frontend review findings → downstream work (direction A).
+ *
+ * When `frontend-review-pi` commits `request_review_changes`, the implementation
+ * must not silently finish: the run becomes "not passed" (partial_failed +
+ * terminalReason=review-request-changes), and the committed findings are
+ * rendered into a downstream-task PRD draft that a later DAG round can consume
+ * instead of repeating the previous flow. Rendering is deterministic (pure);
+ * only the JSONL read and PRD write are IO.
+ */
+export const FRONTEND_REVIEW_FINDINGS_PRD_REL = "contracts/frontend-review-findings-prd.md";
+/** Review node id whose committed typed facts drive the findings PRD. */
+export const FRONTEND_REVIEW_NODE_ID = "frontend-review-pi";
+/** Deterministic issueCategory → failure owner mapping (A+B AC-009 §4.10). */
+export function classifyReviewIssueCategoryFailureOwner(issueCategory) {
+    switch (issueCategory) {
+        case "implementation-mismatch":
+            return "implementation";
+        case "approved-design-defect":
+            return "plan";
+        case "target-surface-defect":
+            return "scout";
+        case "contract-requirement-gap":
+            return "contract";
+        case "unknown":
+        default:
+            return "unknown";
+    }
+}
+const API_SIGNAL_RE = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i;
+/** Negations for the API signal. CJK "无 API/无接口" has no \b boundary, so
+ * it is matched separately from the ASCII no api/not-needed forms. */
+const API_NEGATION_RE = /(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])|无\s*api|无\s*接口/i;
+const SMALL_SIGNAL_WORDS = [
+    "单文件局部修复",
+    "局部样式",
+    "文案调整",
+    "无远程接口",
+];
+function topLevelDir(p) {
+    const normalized = p.replace(/\\/g, "/");
+    const first = normalized.split("/").filter(Boolean)[0] ?? "";
+    return first;
+}
+/** Collect unique non-empty finding `file` values (sorted, de-duplicated). */
+function findingTargetFiles(fact) {
+    const files = new Set();
+    for (const finding of fact.findings) {
+        if (typeof finding.file === "string" && finding.file.trim()) {
+            files.add(finding.file.trim());
+        }
+    }
+    return [...files].sort();
+}
+/**
+ * Deterministically derive the fix scope for the downstream task. Same fact
+ * always yields the same scope. The shape mirrors `resolveFrontendTaskShape`
+ * signals (concentrated paths, no remote API → micro/small) so that when the
+ * PRD draft is used as the next task's requirement, the frontend DAG generator
+ * routes a small fix to micro/small instead of the full 11-node standard
+ * topology.
+ */
+export function deriveFrontendReviewFixScope(fact) {
+    const targetFiles = findingTargetFiles(fact);
+    const blob = fact.findings
+        .map((f) => `${f.issue} ${f.requiredChange ?? ""} ${f.file ?? ""}`)
+        .join("\n");
+    const hasApiSignal = API_SIGNAL_RE.test(blob) && !API_NEGATION_RE.test(blob);
+    const topDirs = new Set(targetFiles.map(topLevelDir));
+    const concentrated = targetFiles.length > 0 && topDirs.size <= 1 && targetFiles.length <= 4;
+    let shape;
+    let complexity;
+    let reason;
+    if (targetFiles.length === 0) {
+        shape = "standard";
+        complexity = "medium";
+        reason =
+            "findings carry no file references; scope unknown, keep standard topology";
+    }
+    else if (hasApiSignal) {
+        shape = "standard";
+        complexity = "medium";
+        reason = `findings reference a remote API signal; standard topology required (files=${targetFiles.length})`;
+    }
+    else if (concentrated && targetFiles.length <= 1) {
+        shape = "micro";
+        complexity = "trivial";
+        reason = "single-file concentrated fix without remote API";
+    }
+    else if (concentrated) {
+        shape = "small";
+        complexity = "low";
+        reason = `concentrated fix across ${targetFiles.length} file(s) in one top-level directory`;
+    }
+    else {
+        shape = "standard";
+        complexity = "medium";
+        reason = `fix spans ${targetFiles.length} file(s) across ${topDirs.size} top-level directories; standard topology`;
+    }
+    const allowedPaths = [
+        ...new Set([
+            ...targetFiles,
+            ...targetFiles.map((f) => `${topLevelDir(f)}/**`),
+        ]),
+    ].sort();
+    return {
+        shape,
+        complexity,
+        targetFiles,
+        allowedPaths,
+        smallSignals: [...SMALL_SIGNAL_WORDS],
+        hasApiSignal,
+        reason,
+    };
+}
+/**
+ * Read the committed `request_review_changes` fact from the review node's typed
+ * event store. Returns undefined when no committed request fact exists (e.g.
+ * approve_review, missing store, or an unreadable store).
+ */
+export async function readCommittedReviewRequestFact(input) {
+    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    let records;
+    try {
+        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, reviewNodeId, "review-typed-facts.jsonl"));
+    }
+    catch {
+        return undefined;
+    }
+    const committed = records.filter((record) => record.phase === "committed");
+    if (committed.length === 0)
+        return undefined;
+    // A committed approve_review means the review passed; only a committed
+    // request_review_changes carries a "not passed" verdict.
+    const request = committed.find((record) => record.fact.kind === "request_review_changes");
+    if (!request)
+        return undefined;
+    const fact = request.fact;
+    if (typeof fact !== "object" || fact === null)
+        return undefined;
+    return fact;
+}
+function bulletList(items) {
+    if (!items || items.length === 0)
+        return "_(none)_";
+    return items.map((item) => `- ${item}`).join("\n");
+}
+function findingLines(findings) {
+    if (findings.length === 0)
+        return "_(none)_";
+    return findings
+        .map((finding) => {
+        const location = [finding.file, finding.line]
+            .filter((value) => value !== undefined)
+            .join(":");
+        const prefix = location ? `[${location}] ` : "";
+        const requiredChange = finding.requiredChange
+            ? `\n  - requiredChange: ${finding.requiredChange}`
+            : "";
+        return `- ${prefix}${finding.severity}: ${finding.issue}${requiredChange}`;
+    })
+        .join("\n");
+}
+/**
+ * Deterministically render a downstream-task PRD draft from a committed
+ * `request_review_changes` fact. Same fact always renders byte-identical
+ * output; the parent run id and review node id are the only context.
+ */
+export function renderFrontendReviewFindingsPrd(input) {
+    const { parentRunId, fact } = input;
+    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    const restartPhase = classifyReviewIssueCategoryFailureOwner(fact.issueCategory);
+    const scope = deriveFrontendReviewFixScope(fact);
+    const targetSummary = scope.targetFiles.length > 0
+        ? scope.targetFiles.join(", ")
+        : fact.issueCategory;
+    return [
+        `# 修复 review 发现（${scope.shape}）：${targetSummary}`,
+        "",
+        "## 背景",
+        "",
+        `- parentRunId: \`${parentRunId}\``,
+        `- reviewNodeId: \`${reviewNodeId}\``,
+        `- typedVerdict: \`request_review_changes\``,
+        `- issueCategory: \`${fact.issueCategory}\``,
+        `- restartPhase/failureOwner: \`${restartPhase}\``,
+        "",
+        "## 修复范围（供下一轮任务生成路由）",
+        "",
+        `- 建议 shape：\`${scope.shape}\`（micro=7 / small=10 / standard=11 节点）`,
+        `- 建议 complexity：\`${scope.complexity}\``,
+        `- 推导依据：${scope.reason}`,
+        ...(scope.hasApiSignal ? ["- ⚠️ findings 含远程 API/接口信号，走 standard 拓扑"] : []),
+        scope.targetFiles.length > 0
+            ? [`- 目标文件：${scope.targetFiles.map((f) => `\`${f}\``).join(", ")}`]
+            : ["- 目标文件：_(findings 未提供 file 引用，需人工补全)_"],
+        scope.allowedPaths.length > 0
+            ? [`- 建议 allowedPaths：${scope.allowedPaths.map((p) => `\`${p}\``).join(", ")}`]
+            : [],
+        scope.shape === "micro" || scope.shape === "small"
+            ? [`- 范围信号：${scope.smallSignals.join("、")}（供 shape 分类器识别，避免退化为全节点流程）`]
+            : [],
+        "",
+        "## 问题清单",
+        "",
+        findingLines(fact.findings),
+        "",
+        "## 证据引用",
+        "",
+        bulletList(fact.evidenceRefs),
+        "",
+        "## 修复目标",
+        "",
+        `- 按 issueCategory 映射的重启阶段（${restartPhase}）定点修复，不复用上一轮未通过的实现。`,
+        "- 逐条关闭上面「问题清单」中的 findings，并保留上一轮已通过的验证目标继续有效。",
+        "- 完成修复后重新走 frontend DAG 的 implement → verify → review 链，直到 review 提交 approve_review。",
+        "",
+    ].join("\n");
+}
+/** Write the findings PRD draft under the run dir (run-owned artifact). */
+export async function writeFrontendReviewFindingsPrd(input) {
+    const markdown = renderFrontendReviewFindingsPrd(input);
+    const abs = path.join(input.runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL);
+    await mkdir(path.dirname(abs), { recursive: true });
+    await writeFile(abs, markdown, "utf8");
+    return FRONTEND_REVIEW_FINDINGS_PRD_REL;
+}
+export async function readFrontendReviewFindingsPrd(runDir) {
+    try {
+        return await readFile(path.join(runDir, FRONTEND_REVIEW_FINDINGS_PRD_REL), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/workflows/dag/frontend-shape.js

@@ -29,7 +29,7 @@ const SHAPE_ESCALATION_PATTERNS = [
 ];
 const SHAPE_SMALL_PATTERNS = [
     { id: "single-component", re: /single\s+component|单一组件|局部样式|style\s+tweak|css\s+only|文案|copy\s+change/i },
-    { id: "no-remote", re: /no\s+api|无接口|本地状态|local\s+state\s+only|pure\s+ui/i },
+    { id: "no-remote", re: /no\s+api|无\s*api|无\s*接口|本地状态|local\s+state\s+only|pure\s+ui/i },
 ];
 const SHAPE_SPLIT_REQUIRED_PATTERN = /拆分|split\s+(?:requirement|task|需求)|large\s+requirement|大型需求|多步骤需求/i;
 const EXECUTABLE_SHAPE_RANK = {
@@ -77,7 +77,8 @@ function resolveBaselineFrontendTaskShape(input) {
     const spread = pathSpreadScore(paths);
     const concentrated = spread <= 1 && paths.length <= 4;
     const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
+            /无\s*api|无\s*接口/i.test(blob));
     const complexity = (input.complexity ?? "").toLowerCase();
     // split-required wins over everything: it is a termination/escalation
     // signal, not an executable topology.
@@ -258,7 +259,8 @@ export function deriveFrontendRuntimeShapeFacts(input) {
     const escalationSignals = collectEscalationSignals(blob, supervised);
     const paths = input.allowedPaths ?? [];
     const hasApiSignal = /\b(api|fetch|axios|graphql|endpoint|远程|接口)\b/i.test(blob) &&
-        !/\b(no\s+api|无接口|not-needed)\b/i.test(blob);
+        !(/(?:^|[^\w])(?:no\s+api|not-needed)(?:$|[^\w])/i.test(blob) ||
+            /无\s*api|无\s*接口/i.test(blob));
     const requiresFull = escalationSignals.length > 0 || pathSpreadScore(paths) > 1 || hasApiSignal;
     return {
         splitRequired: input.splitRequired,

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

@@ -2257,6 +2257,83 @@ function frontendMockStrategyMustBeNotNeeded(sources) {
             capabilityStatus === "ambiguous" ||
             !hasDeterministicMockVerification));
 }
+/**
+ * 候选规范懒加载：prompt 只内联与任务相关的候选，不全部塞给模型。
+ *
+ * - mandatory（任务源显式声明/引用）始终保留——模型必须知道它们存在。
+ * - scan-strict 候选按「路径段是否命中任务源关键词」过滤：列表页任务只
+ *   带出列表相关组件/页面规范，创建页规范不进 prompt。
+ * - runtime 的选型/read 门禁仍消费完整 openspecCandidatePaths（prewrite
+ *   gate 用全量）；这里只缩小 prompt 体积，不改变门禁语义。未提及的候选
+ *   由 runtime 默认 irrelevant，模型无需枚举。
+ * - 真正读取发生在 plan 侧：模型对 required 选型调用 read 工具，prewrite
+ *   门禁验证 read 事件——按需读取，不预加载正文。
+ */
+export function filterRelevantOpenspecCandidates(input) {
+    const mandatory = new Set(input.mandatoryPaths);
+    const relevant = [];
+    for (const candidate of input.candidates) {
+        if (mandatory.has(candidate)) {
+            relevant.push(candidate);
+            continue;
+        }
+        if (openspecCandidateMatchesSource(candidate, input.sourceMarkdown)) {
+            relevant.push(candidate);
+        }
+    }
+    // 保持候选发现顺序（确定性）；mandatory 与相关候选都按原始顺序出现。
+    return relevant;
+}
+/**
+ * 候选路径是否与任务源相关：从任务源提取文件名/路径 token（去扩展名、
+ * 去连字符/下划线），若候选的路径段包含任一 token 即视为相关。纯字符串
+ * 判定，无 IO；找不到 token 时保守保留（避免漏掉模型可能需要的规范）。
+ */
+function openspecCandidateMatchesSource(candidate, sourceMarkdown) {
+    const sourceTokens = extractOpenspecSourceTokens(sourceMarkdown);
+    if (sourceTokens.size === 0)
+        return true;
+    const candidateLower = candidate.toLowerCase().replace(/\\/g, "/");
+    const candidateSegments = candidateLower.split("/");
+    const candidateBasename = candidateSegments[candidateSegments.length - 1] ?? "";
+    for (const token of sourceTokens) {
+        if (candidateBasename.includes(token) ||
+            candidateLower.includes(`/${token}/`) ||
+            candidateLower.includes(`${token}.`)) {
+            return true;
+        }
+    }
+    return false;
+}
+/** 从任务源 markdown 提取显著 token：反引号代码段、路径、组件/页面名。 */
+function extractOpenspecSourceTokens(markdown) {
+    const tokens = new Set();
+    const push = (raw) => {
+        const cleaned = raw
+            .trim()
+            .replace(/[.*+?^${}()|[\]\\]/g, "")
+            .toLowerCase();
+        if (cleaned.length >= 2 && cleaned.length <= 40)
+            tokens.add(cleaned);
+    };
+    // 反引号内联代码（文件名/组件名）
+    for (const match of markdown.matchAll(/`([^`\n]+)`/g)) {
+        push(match[1] ?? "");
+    }
+    // markdown 链接文本
+    for (const match of markdown.matchAll(/\[([^\]]+)\]\([^)]+\)/g)) {
+        push(match[1] ?? "");
+    }
+    // 路径 token（openspec/ 或 xxx/xxx.md）
+    for (const match of markdown.matchAll(/(?:[A-Za-z0-9_-]+\/)+[A-Za-z0-9_.-]+/g)) {
+        const segments = (match[0] ?? "").split("/");
+        const basename = segments[segments.length - 1] ?? "";
+        push(basename.replace(/\.[a-z0-9]+$/i, ""));
+        for (const segment of segments)
+            push(segment);
+    }
+    return tokens;
+}
 async function resolveFrontendOpenspecGateConfig(sources) {
     const taskConfig = sources.taskConfig;
     const policy = taskConfig.frontendOpenspec?.policy ?? "cited";
@@ -2870,10 +2947,22 @@ async function buildFrontendHybridDagFromTask(sources) {
     const openspecGate = await resolveFrontendOpenspecGateConfig(sources);
     const requiresOpenspecClassification = openspecGate.openspecPolicy === "cited" &&
         openspecGate.openspecCandidatePaths.length > 0;
+    // Prompt 内联的候选只保留与任务相关的子集：mandatory（任务显式声明/
+    // 引用）始终保留；scan-strict 候选按路径段是否命中任务源关键词过滤。
+    // runtime 的选型/read 门禁仍消费完整 openspecCandidatePaths——这里只
+    // 减小 prompt 体积，不改变门禁语义；未提及的候选 runtime 默认 irrelevant。
+    const promptCandidates = filterRelevantOpenspecCandidates({
+        candidates: openspecGate.openspecCandidatePaths,
+        mandatoryPaths: openspecGate.openspecMandatoryPaths,
+        sourceMarkdown: [
+            sources.requirementMarkdown,
+            sources.constraintMarkdown ?? "",
+        ].join("\n"),
+    });
     const openspecSelectionContext = JSON.stringify({
         schemaVersion: 1,
         schemaId: "frontend-openspec-selection-v1",
-        candidates: openspecGate.openspecCandidatePaths,
+        candidates: promptCandidates,
         mandatoryPaths: openspecGate.openspecMandatoryPaths,
     });
     // Generation-frozen component/theme specification bucket (ADR 0016). Derived