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

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,8 +12,9 @@ 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 { renderFrontendPlanMarkdown } from "./frontend-plan-render.js";
 import { isConfigurationVerificationFile, verificationSymbolMatchesContent, } from "./frontend-verification-trace.js";
 export const frontendNormalizationActionSchema = z.enum([
     "remove-trailing-commas",
@@ -142,6 +143,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 +339,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 +2046,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
@@ -2003,11 +2076,17 @@ export async function validateFrontendPlanPatchNodeOutput(input) {
             sha256: canonicalArtifact.sha256,
             schemaId: FRONTEND_IMPLEMENTATION_CONTRACT_SCHEMA_ID,
         };
+        // Human-readable plan summary appended after the artifact pointer. The
+        // pointer remains the machine authority (path/schema/sha256); the
+        // rendered summary is a deterministic view of the canonical contract so
+        // Console/reviewers can read the plan without opening the JSON. It never
+        // participates in downstream validation.
+        const planSummary = renderFrontendPlanMarkdown(analysis.canonical);
         return {
             ok: true,
             contract: analysis.canonical,
             artifact,
-            normalizedText: formatStructuredArtifactPointer(artifact),
+            normalizedText: `${formatStructuredArtifactPointer(artifact)}\n\n${planSummary}`,
         };
     }
     catch (error) {

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

@@ -0,0 +1,270 @@
+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.
+ *
+ * The design-review analog (`request_design_changes`) reuses the same PRD
+ * rendering and typed-fact channel: a design rejection is a definite finding
+ * (not a protocol/environment error), so it auto-re-enters the next plan round
+ * with the committed design findings instead of terminating the run.
+ */
+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";
+/** Design review node id whose committed typed facts drive the findings PRD. */
+export const FRONTEND_DESIGN_REVIEW_NODE_ID = "frontend-design-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 { runDir: reviewRunDir } = input;
+    const reviewNodeId = input.reviewNodeId ?? FRONTEND_REVIEW_NODE_ID;
+    return readCommittedRequestFactByKind({
+        runDir: reviewRunDir,
+        nodeId: reviewNodeId,
+        factsFile: "review-typed-facts.jsonl",
+        kind: "request_review_changes",
+    });
+}
+/**
+ * Read the committed `request_design_changes` fact from the design review
+ * node's typed event store. Returns undefined when no committed request fact
+ * exists (e.g. approve_design, missing store, or an unreadable store).
+ */
+export async function readCommittedDesignRequestFact(input) {
+    const { runDir: designRunDir } = input;
+    const designNodeId = input.designNodeId ?? FRONTEND_DESIGN_REVIEW_NODE_ID;
+    return readCommittedRequestFactByKind({
+        runDir: designRunDir,
+        nodeId: designNodeId,
+        factsFile: "design-typed-facts.jsonl",
+        kind: "request_design_changes",
+    });
+}
+async function readCommittedRequestFactByKind(input) {
+    let records;
+    try {
+        records = await readTypedEventStoreFromJsonl(path.join(input.runDir, input.nodeId, input.factsFile));
+    }
+    catch {
+        return undefined;
+    }
+    const committed = records.filter((record) => record.phase === "committed");
+    if (committed.length === 0)
+        return undefined;
+    const request = committed.find((record) => record.fact.kind === input.kind);
+    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` / `request_design_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 isDesign = fact.kind === "request_design_changes";
+    const reviewNodeId = input.reviewNodeId ??
+        (isDesign ? FRONTEND_DESIGN_REVIEW_NODE_ID : 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 [
+        `# 修复 ${isDesign ? "设计" : "review"} 发现（${scope.shape}）：${targetSummary}`,
+        "",
+        "## 背景",
+        "",
+        `- parentRunId: \`${parentRunId}\``,
+        `- reviewNodeId: \`${reviewNodeId}\``,
+        `- typedVerdict: \`${fact.kind}\``,
+        `- 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 的 ${isDesign ? "plan → design" : "implement → verify → review"} 链，直到${isDesign ? " design-review 提交 approve_design" : " 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,