@tea-agent/loop-agent 0.38.0 → 0.39.0-next.2

package/dist/workflows/dag/frontend-prewrite-gate.js

@@ -2,6 +2,7 @@ import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { z } from "zod";
 import { isOpenspecSpecFilePath } from "../../shared/openspec-spec.js";
+import { countExcludedGovernanceSpecFiles, resolveOpenspecGovernanceRoot, } from "../../task/frontend-project-capability.js";
 import { analyzeFrontendImplementationContract, writeFrontendImplementationContractArtifact, writeDeterministicJsonArtifact, assertFrontendSourceBindingFresh, deterministicSha256, sha256Hex, FrontendContractFailure, frontendNormalizationActionSchema, } from "./frontend-implementation-contract.js";
 import { captureFrontendWorktreeBaseline } from "./frontend-worktree-diff.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
@@ -25,6 +26,11 @@ export const frontendPrewriteFailureCodeSchema = z.enum([
     "mock-strategy-no-verification-commands",
     "target-outside-write-set",
     "verification-target-outside-write-set",
+    "openspec-not-read",
+    "candidate-missing-drift",
+    "openspec-citation-block-unparseable",
+    "openspec-not-cited",
+    "openspec-citation-not-read",
 ]);
 export const frontendPrewriteResultV1Schema = z
     .object({
@@ -196,14 +202,9 @@ function isFailedToolResult(event) {
         event.result?.error != null ||
         event.result?.ok === false);
 }
-async function checkOpenspecReadEvidence(input) {
-    const { runDir, candidatePaths, planNodeId, reviewNodeId, repoRoot } = input;
-    if (candidatePaths.length === 0)
-        return [];
+async function collectOpenspecReadPaths(input) {
+    const { runDir, planNodeId, reviewNodeId, repoRoot } = input;
     const matched = new Set();
-    const normalizedCandidates = new Set(candidatePaths
-        .map((candidate) => toRepoRelativePath(candidate, repoRoot))
-        .filter((candidate) => Boolean(candidate && isOpenspecSpecFilePath(candidate))));
     for (const nodeId of [planNodeId, reviewNodeId]) {
         const eventsPath = path.join(runDir, nodeId, "session-events.jsonl");
         try {
@@ -237,7 +238,7 @@ async function checkOpenspecReadEvidence(input) {
                         : null;
                     if (relativePath &&
                         !isFailedToolResult(event) &&
-                        normalizedCandidates.has(relativePath)) {
+                        isOpenspecSpecFilePath(relativePath)) {
                         matched.add(relativePath);
                     }
                     startedReads.delete(event.toolCallId);
@@ -252,6 +253,87 @@ async function checkOpenspecReadEvidence(input) {
     }
     return [...matched];
 }
+async function checkOpenspecReadEvidence(input) {
+    const { runDir, candidatePaths, planNodeId, reviewNodeId, repoRoot } = input;
+    if (candidatePaths.length === 0)
+        return [];
+    const allReadPaths = await collectOpenspecReadPaths({
+        runDir,
+        planNodeId,
+        reviewNodeId,
+        repoRoot,
+    });
+    const normalizedCandidates = new Set(candidatePaths
+        .map((candidate) => toRepoRelativePath(candidate, repoRoot))
+        .filter((candidate) => Boolean(candidate && isOpenspecSpecFilePath(candidate))));
+    return allReadPaths.filter((readPath) => normalizedCandidates.has(readPath));
+}
+function normalizeCitationPath(rawPath, repoRoot) {
+    let candidate = rawPath.trim();
+    const hashIndex = candidate.indexOf("#");
+    if (hashIndex >= 0)
+        candidate = candidate.slice(0, hashIndex);
+    candidate = candidate.replace(/\\/g, "/");
+    if (!candidate)
+        return null;
+    if (repoRoot) {
+        const relative = toRepoRelativePath(candidate, repoRoot);
+        return relative ? relative.replace(/\\/g, "/") : null;
+    }
+    return candidate;
+}
+/**
+ * Parses the deterministic openspec-citations fence from the effective plan
+ * output. Each non-empty line must be one JSON object {"path","section","line"}.
+ * Rows whose normalized path is not a supported openspec spec file are ignored
+ * (out of scope); rows that are invalid JSON or lack a string path mark the
+ * block unparseable (fail-closed when candidates are non-empty).
+ */
+export function parseOpenspecCitations(planText, repoRoot) {
+    const citations = [];
+    let blockPresent = false;
+    let unparseable = false;
+    const fenceRe = /```openspec-citations[ \t]*\r?\n([\s\S]*?)\r?\n```/g;
+    let match;
+    while ((match = fenceRe.exec(planText)) !== null) {
+        blockPresent = true;
+        const body = match[1] ?? "";
+        for (const rawLine of body.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            if (!line)
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                unparseable = true;
+                continue;
+            }
+            if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+                unparseable = true;
+                continue;
+            }
+            const rawPath = parsed.path;
+            if (typeof rawPath !== "string" || !rawPath.trim()) {
+                unparseable = true;
+                continue;
+            }
+            const normalized = normalizeCitationPath(rawPath, repoRoot);
+            if (!normalized || !isOpenspecSpecFilePath(normalized))
+                continue;
+            const section = typeof parsed.section === "string"
+                ? parsed.section
+                : "";
+            const lineValue = parsed.line;
+            const citationLine = typeof lineValue === "number" && Number.isInteger(lineValue)
+                ? lineValue
+                : null;
+            citations.push({ path: normalized, section, line: citationLine });
+        }
+    }
+    return { blockPresent, unparseable, citations };
+}
 async function finalizePrewrite(input, pending) {
     const sourceBindingSha256 = input.sourceBinding
         ? deterministicSha256(input.sourceBinding)
@@ -298,6 +380,7 @@ async function finalizePrewrite(input, pending) {
         canonicalSha256: pending.canonicalSha256,
         openspecReadPaths: pending.openspecReadPaths,
         openspecCandidatePaths: pending.openspecCandidatePaths,
+        openspecPolicy: pending.openspecPolicy,
     };
 }
 export async function runFrontendPrewriteGate(input) {
@@ -307,6 +390,7 @@ export async function runFrontendPrewriteGate(input) {
     const planNodeId = await selectNode(input.runDir, input.config.planFromNodeId, input.config.planFallbackFromNodeIds);
     const reviewNodeId = await selectNode(input.runDir, input.config.reviewFromNodeId, input.config.reviewFallbackFromNodeIds);
     const candidateRawSha256 = sha256Hex(await readNodeRawText(input.runDir, planNodeId));
+    const openspecPolicy = input.config.openspecPolicy ?? "scan-strict";
     const basePending = {
         planNodeId,
         reviewNodeId,
@@ -322,6 +406,7 @@ export async function runFrontendPrewriteGate(input) {
         classification: "accepted",
         openspecReadPaths: [],
         openspecCandidatePaths: input.config.openspecCandidatePaths ?? [],
+        openspecPolicy,
     };
     let planText;
     try {
@@ -498,6 +583,134 @@ export async function runFrontendPrewriteGate(input) {
             });
         }
     }
+    // Effective plan/review must actually read the candidate openspec paths when
+    // any exist. This fail-closes BEFORE the canonical contract is materialized
+    // so a writer is never authorized on top of unread normative evidence.
+    const candidatePaths = input.config.openspecCandidatePaths ?? [];
+    const candidateRoot = workspaceRoot ?? process.cwd();
+    // Drift precheck: candidates are frozen at generation time. A candidate that
+    // no longer exists on disk was deleted/renamed after generation and is a
+    // generation-contract defect, not an "unread" failure.
+    const missingCandidates = [];
+    if (candidatePaths.length > 0) {
+        for (const candidate of candidatePaths) {
+            try {
+                await stat(path.join(candidateRoot, candidate));
+            }
+            catch {
+                missingCandidates.push(candidate);
+            }
+        }
+    }
+    if (missingCandidates.length > 0) {
+        return finalizePrewrite(input, {
+            ...basePending,
+            verdict,
+            candidateJsonSha256: analysis.candidateJsonSha256,
+            normalizationActions: [],
+            mockStrategy,
+            classification: "blocked",
+            failureReason: `frontend prewrite gate blocked: openspec candidate paths frozen at generation time no longer exist on disk: ${missingCandidates.join(", ")}. 候选集在生成期冻结，这些候选在生成后被删除/改名，请修正后重新生成 DAG。`,
+            failureCode: "candidate-missing-drift",
+            openspecReadPaths: [],
+            openspecCandidatePaths: candidatePaths,
+        });
+    }
+    let openspecReadPaths;
+    if (openspecPolicy === "cited") {
+        openspecReadPaths = await collectOpenspecReadPaths({
+            runDir: input.runDir,
+            planNodeId,
+            reviewNodeId,
+            repoRoot: candidateRoot,
+        });
+        if (candidatePaths.length > 0) {
+            const parsed = parseOpenspecCitations(planText, candidateRoot);
+            if (!parsed.blockPresent || parsed.unparseable) {
+                return finalizePrewrite(input, {
+                    ...basePending,
+                    verdict,
+                    candidateJsonSha256: analysis.candidateJsonSha256,
+                    normalizationActions: [],
+                    mockStrategy,
+                    classification: "retryable-invalid",
+                    failureReason: `frontend prewrite gate: the effective plan output must end with a parseable \`\`\`openspec-citations fenced block (one JSON {"path","section","line"} per line). ${parsed.blockPresent
+                        ? "The block is present but contains unparseable lines."
+                        : "No openspec-citations block was found."}`,
+                    failureCode: "openspec-citation-block-unparseable",
+                    openspecReadPaths,
+                    openspecCandidatePaths: candidatePaths,
+                });
+            }
+            const citedPaths = new Set(parsed.citations.map((citation) => citation.path));
+            const notCited = candidatePaths.filter((candidate) => !citedPaths.has(candidate));
+            if (notCited.length > 0) {
+                return finalizePrewrite(input, {
+                    ...basePending,
+                    verdict,
+                    candidateJsonSha256: analysis.candidateJsonSha256,
+                    normalizationActions: [],
+                    mockStrategy,
+                    classification: "retryable-invalid",
+                    failureReason: `frontend prewrite gate: these openspec candidate paths were not cited in the plan openspec-citations block: ${notCited.join(", ")}`,
+                    failureCode: "openspec-not-cited",
+                    openspecReadPaths,
+                    openspecCandidatePaths: candidatePaths,
+                });
+            }
+            const readSet = new Set(openspecReadPaths);
+            const uncorroborated = [
+                ...new Set(parsed.citations
+                    .filter((citation) => !readSet.has(citation.path))
+                    .map((citation) => citation.path)),
+            ];
+            if (uncorroborated.length > 0) {
+                return finalizePrewrite(input, {
+                    ...basePending,
+                    verdict,
+                    candidateJsonSha256: analysis.candidateJsonSha256,
+                    normalizationActions: [],
+                    mockStrategy,
+                    classification: "retryable-invalid",
+                    failureReason: `frontend prewrite gate: these openspec paths were cited in the plan but have no successful read event in the effective plan/review: ${uncorroborated.join(", ")}`,
+                    failureCode: "openspec-citation-not-read",
+                    openspecReadPaths,
+                    openspecCandidatePaths: candidatePaths,
+                });
+            }
+        }
+        // cited with empty candidates: no read enforcement. The generation step
+        // emits an advisory instead of failing the gate.
+    }
+    else {
+        openspecReadPaths = await checkOpenspecReadEvidence({
+            runDir: input.runDir,
+            candidatePaths,
+            planNodeId,
+            reviewNodeId,
+            repoRoot: candidateRoot,
+        });
+        if (candidatePaths.length > 0) {
+            const readSet = new Set(openspecReadPaths);
+            const unread = candidatePaths.filter((candidate) => !readSet.has(candidate));
+            if (unread.length > 0) {
+                const governanceRoot = await resolveOpenspecGovernanceRoot(candidateRoot);
+                const excludedGovernanceCount = await countExcludedGovernanceSpecFiles(candidateRoot, governanceRoot);
+                return finalizePrewrite(input, {
+                    ...basePending,
+                    verdict,
+                    candidateJsonSha256: analysis.candidateJsonSha256,
+                    normalizationActions: [],
+                    mockStrategy,
+                    classification: "retryable-invalid",
+                    failureReason: `frontend prewrite gate: effective plan/review did not read these openspec candidate paths: ${unread.join(", ")}. Read each candidate and report applicable rules plus hit path/section/line number, conflicts, and missing specifications, then rerun. 实际成功读取: ${openspecReadPaths.length > 0 ? openspecReadPaths.join(", ") : "(none)"}; 候选总数: ${candidatePaths.length}; 排除治理目录 ${governanceRoot} 下 ${excludedGovernanceCount} 个文件（运行期诊断口径）; 候选集在生成期冻结，若候选与本任务无关属于生成期契约配置问题，应修正后重新生成 DAG。`,
+                    failureCode: "openspec-not-read",
+                    openspecReadPaths,
+                    openspecCandidatePaths: candidatePaths,
+                });
+            }
+        }
+    }
     // Materialize the canonical contract only after every governance check passed.
     const artifact = await writeFrontendImplementationContractArtifact({
         runDir: input.runDir,
@@ -505,14 +718,6 @@ export async function runFrontendPrewriteGate(input) {
         artifactName: input.config.artifactName,
         canonical: analysis.canonical,
     });
-    const candidatePaths = input.config.openspecCandidatePaths ?? [];
-    const openspecReadPaths = await checkOpenspecReadEvidence({
-        runDir: input.runDir,
-        candidatePaths,
-        planNodeId,
-        reviewNodeId,
-        repoRoot: workspaceRoot ?? process.cwd(),
-    });
     const classification = analysis.normalizationActions.length > 0 ? "accepted-normalized" : "accepted";
     return finalizePrewrite(input, {
         ...basePending,
@@ -551,12 +756,20 @@ export function formatFrontendPrewriteGateStdout(result) {
         lines.push(`SHA-256: ${result.artifact.sha256}`);
     }
     lines.push(`Prewrite result: ${result.prewriteResult.path}`);
+    lines.push(`Openspec policy: ${result.openspecPolicy}`);
     if (result.failureReason)
         lines.push(`Failure reason: ${result.failureReason}`);
     if (result.openspecReadPaths.length > 0) {
         lines.push(`openspec read: ${result.openspecReadPaths.join(", ")}`);
     }
-    else if (result.openspecCandidatePaths.length === 0) {
+    if (result.openspecCandidatePaths.length > 0) {
+        const readSet = new Set(result.openspecReadPaths);
+        const unread = result.openspecCandidatePaths.filter((candidate) => !readSet.has(candidate));
+        if (unread.length > 0) {
+            lines.push(`openspec unread: ${unread.join(", ")}`);
+        }
+    }
+    else {
         lines.push("openspec: unavailable");
     }
     return lines.join("\n");

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

@@ -7,9 +7,10 @@ import { assertValidDagSpec } from "./validate.js";
 import { DAG_AGENT_RUNTIME_PI_ONLY, DAG_REPAIR_WRITER_PROTOCOL_EXPLICIT_NODE_V1, DAG_RUNTIME_CONTRACT_SCHEMA_VERSION, DEFAULT_DAG_OUTPUT_LANGUAGE, DEFAULT_DAG_EXECUTOR_MODELS, parseDagSpec, } from "./types.js";
 import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
+import { extractTaskSourceOpenspecPaths } from "../../shared/openspec-spec.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.js";
-import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, isWriterTransportRetryCandidate, } from "./retry-policy.js";
+import { DEFAULT_READ_ONLY_PI_RETRY_POLICY, PLANNER_OUTPUT_LIMIT_RETRY_POLICY, PROTOCOL_AWARE_PI_RETRY_POLICY, STRUCTURED_REQUIRED_PI_RETRY_POLICY, BACKEND_TEST_WRITER_COMPLETENESS_RETRY_POLICY, WRITER_TRANSPORT_RETRY_POLICY, isSafeReadOnlyPiRetryCandidate, isWriterTransportRetryCandidate, } from "./retry-policy.js";
 import { REVIEW_JSON_VERDICT_OUTPUT_PROTOCOL, REVIEW_VERDICT_OUTPUT_PROTOCOL, } from "./output-protocol.js";
 import { resolveAdapter } from "../../adapters/index.js";
 import { loadHarnessManifest } from "../../governance/harness.js";
@@ -558,6 +559,39 @@ export function hasApiDependency(sources) {
         .some((clause) => !negationPatterns.some((pattern) => pattern.test(clause)) &&
         dependencyPatterns.some((pattern) => pattern.test(clause)));
 }
+/**
+ * Generation-time heuristic: does the task source mention interface/API/Mock
+ * needs anywhere (requirement or constraints)?
+ *
+ * Mirrors hasApiDependency's clause-level negation filtering so explicit
+ * "not involved / not implementing" clauses and out-of-scope sections do not
+ * become positive evidence. Used to emit a machine-visible advisory when auto
+ * mode narrows Mock to not-needed despite the source mentioning such needs.
+ */
+export function frontendSourceMentionsMock(sources) {
+    const text = [sources.requirementMarkdown, sources.constraintMarkdown]
+        .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
+        .map((entry) => normalizeTaskRequirementText(entry).replace(/`[^`\n]*`/g, " "))
+        .join("\n");
+    const signalPatterns = [
+        /mock/i,
+        /模拟服务/,
+        /接口桩/,
+        /\bmsw\b/i,
+        /(?<![A-Za-z0-9_])API(?![A-Za-z0-9_])/i,
+        /接口/,
+    ];
+    const negationPatterns = [
+        /(?:不涉及|无需|不需要|不依赖|不调用|不请求|不实现|没有|禁止|不得).{0,16}(?:接口|后端|服务端|远程数据|异步数据|API|mock|模拟|桩)/i,
+        /\b(?:no|without|does\s+not|do\s+not|must\s+not)\b.{0,24}\b(?:api|endpoint|request|backend|server|mock)\b/i,
+    ];
+    return text
+        .split(/[。！？!?；;，,\r\n]+/)
+        .map((clause) => clause.trim())
+        .filter(Boolean)
+        .some((clause) => !negationPatterns.some((pattern) => pattern.test(clause)) &&
+        signalPatterns.some((pattern) => pattern.test(clause)));
+}
 /**
  * Resolve frontend Mock mode from capability seed, task config, and interface dependency analysis.
  *
@@ -2111,6 +2145,7 @@ function resolveFrontendMockContextBlock(sources) {
         parts.push("Generation-time evidence does not require Mock. The assessment must still use contract/scout evidence: select not-needed when Mock is intentionally skipped, or select a safe Mock strategy if project evidence supports one.");
         if (frontendMockStrategyMustBeNotNeeded(sources)) {
             parts.push('Auto mode has no confirmed project Mock capability or no deterministic Mock verification command. The structured contract must set mockApi.strategy to "not-needed". Do not add Mock files or dependencies; keep the real request path as default and record any unproved backend behavior as Real Integration Gap.');
+            parts.push('HARD CONSTRAINT (frozen at generation time): this DAG allows only mockApi.strategy "not-needed"; the prewrite gate rejects any other strategy. If project governance (openspec / ai_workspace / decision records, e.g. a DEC rule requiring native) demands Mock-backed verification, that is a generation-time contract gap, not a plan-revision defect: declare frontendMock.verifyCommands (or policy: "required") in task.json and regenerate the DAG. Do not emit any mockApi.strategy outside the allowlist and do not add Mock files or dependencies within this run.');
         }
     }
     if (mode === "blocked") {
@@ -2129,6 +2164,32 @@ function frontendMockStrategyMustBeNotNeeded(sources) {
             capabilityStatus === "ambiguous" ||
             !hasDeterministicMockVerification));
 }
+function resolveFrontendOpenspecGateConfig(sources) {
+    const taskConfig = sources.taskConfig;
+    const policy = taskConfig.frontendOpenspec?.policy ?? "cited";
+    const declared = taskConfig.frontendOpenspec?.requiredReadPaths ?? [];
+    const taskSourceCited = extractTaskSourceOpenspecPaths([sources.requirementMarkdown, sources.constraintMarkdown ?? ""].join("\n"));
+    const scanStrict = sources.frontendProjectCapability?.designEvidence.normativePaths ?? [];
+    const dedupeSorted = (paths) => [...new Set(paths)].sort();
+    const openspecCandidateSources = {
+        declared: dedupeSorted(declared),
+        taskSourceCited: dedupeSorted(taskSourceCited),
+        scanStrict: dedupeSorted(scanStrict),
+    };
+    const openspecCandidatePaths = policy === "cited"
+        ? dedupeSorted([...declared, ...taskSourceCited])
+        : openspecCandidateSources.scanStrict;
+    return {
+        openspecPolicy: policy,
+        openspecCandidatePaths,
+        openspecCandidateSources,
+    };
+}
+const openspecCitationInstruction = [
+    "OpenSpec 引用块（citation block）：在 fenced json 契约块之后，追加**恰好一个** ```openspec-citations 围栏代码块（三反引号 + openspec-citations）。",
+    '该块内每行一个 JSON 对象 {"path":"<repo 相对 openspec 路径>","section":"<命中章节或空串>","line":<int 或 null>}，必须逐条列出你在本计划中实际读取并应用的每个 openspec 规范文件。',
+    "prewrite gate 会用真实 read 事件核验每条引用：引用存在但无成功 read 事件 → openspec-citation-not-read；契约冻结的必读候选未被引用 → openspec-not-cited；两者都 fail-closed。不要引用未读取的路径。",
+].join("\n");
 function resolveFrontendCapabilityContextBlock(sources) {
     const risk = sources.frontendRisk;
     const capability = sources.frontendProjectCapability;
@@ -2141,9 +2202,33 @@ function resolveFrontendCapabilityContextBlock(sources) {
     }
     if (capability) {
         parts.push("", capability.adapterGuidance);
-        if (capability.designEvidence.normativePaths.length > 0) {
-            parts.push(`openspec normative candidates: ${capability.designEvidence.normativePaths.slice(0, 12).join(", ")}`);
+        const classified = capability.designEvidence.classified;
+        const bucketLines = [];
+        const pushBucket = (label, paths) => {
+            if (paths.length > 0)
+                bucketLines.push(`${label}: ${paths.join(", ")}`);
+        };
+        pushBucket("schemas", classified.schemas);
+        pushBucket("code-template", classified.codeTemplate);
+        pushBucket("rule.api", classified.rule.api);
+        pushBucket("rule.mock", classified.rule.mock);
+        pushBucket("rule.router", classified.rule.router);
+        pushBucket("rule.hooks", classified.rule.hooks);
+        pushBucket("rule.utils", classified.rule.utils);
+        pushBucket("rule.components", classified.rule.components);
+        pushBucket("rule.other", classified.rule.other);
+        pushBucket("theme", classified.theme);
+        pushBucket("component", classified.component);
+        pushBucket("ui-other", classified.uiOther);
+        pushBucket("advisory-other", classified.advisoryOther);
+        parts.push("## Classified openspec specification paths (role semantics)");
+        if (bucketLines.length > 0) {
+            parts.push(...bucketLines);
         }
+        else {
+            parts.push("(no openspec specification paths discovered — greenfield)");
+        }
+        parts.push("Each consuming node MUST report in its output: applicable rules, the hit path/section/line number for every applied specification, and any conflicts or missing specifications. Missing or conflicting required specifications must fail closed rather than silently substituting nearby repository conventions.");
         parts.push(`A11y capability: ${capability.a11y.status}` +
             (capability.a11y.tools.length
                 ? ` (${capability.a11y.tools.join(", ")})`
@@ -2509,6 +2594,29 @@ async function buildFrontendHybridDagFromTask(sources) {
         `- Behavior command source: ${behaviorVerifyEvidence.commandSource}`,
         ...behaviorVerifyEvidence.commandLabels.map((command) => `  - ${JSON.stringify(command)}`),
     ].join("\n");
+    const advisories = [];
+    if (frontendSourceMentionsMock(frontendSources) &&
+        frontendMockStrategyMustBeNotNeeded(frontendSources)) {
+        advisories.push("auto 模式已将 Mock 策略收窄为 not-needed：任务源提到接口/API/Mock 需求，但仓库无确认 Mock 能力或无确定性 Mock 验证命令。若项目规范要求 Mock，请声明 frontendMock.verifyCommands 或 policy:required 后重新生成 DAG。");
+    }
+    const openspecGate = resolveFrontendOpenspecGateConfig(sources);
+    if (openspecGate.openspecPolicy === "cited") {
+        if (openspecGate.openspecCandidatePaths.length === 0) {
+            advisories.push("openspec 策略 cited：契约声明的 requiredReadPaths 与任务源引用均为空，prewrite gate 不强制读取 openspec；如需增强规范门禁，请在 task.json.frontendOpenspec.requiredReadPaths 声明必读路径或在任务源中显式引用 openspec 文件。");
+        }
+        else {
+            advisories.push(`openspec 策略 cited：候选 ${openspecGate.openspecCandidatePaths.length} 个（declared ${openspecGate.openspecCandidateSources.declared.length} / task-source-cited ${openspecGate.openspecCandidateSources.taskSourceCited.length}），plan/review 必须在 openspec-citations 引用块中逐条引用并真实读取。`);
+        }
+    }
+    else {
+        const openspecDiscovery = sources.frontendProjectCapability?.openspecDiscovery;
+        if (openspecDiscovery) {
+            advisories.push(`openspec 策略 scan-strict：候选来源 auto-discovered，共 ${openspecDiscovery.candidateCount} 个，排除治理目录 ${openspecDiscovery.governanceRoot} 下 ${openspecDiscovery.excludedGovernanceCount} 个文件`);
+            if (openspecDiscovery.truncated) {
+                advisories.push(`openspec 候选命中安全上限 ${openspecDiscovery.maxCandidates}，已截断（非静默）；请缩小 spec 范围或提高上限`);
+            }
+        }
+    }
     const spec = {
         version: 3,
         title: `Frontend implementation DAG: ${taskConfig.title}`,
@@ -2523,6 +2631,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         skillsByRole: FRONTEND_SKILLS_BY_ROLE,
         executorModels: sources.executorModelMatrix ?? DEFAULT_DAG_EXECUTOR_MODELS,
         verifyStrategy: resolveDagVerifyStrategy(taskConfig),
+        advisories: advisories.length > 0 ? advisories : undefined,
         tasks: [
             {
                 id: "frontend-contract-pi",
@@ -2595,6 +2704,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     sourceContext,
                     mockContextBlock,
                     frontendContractSchemaBlock,
+                    openspecCitationInstruction,
                 ].join("\n\n"),
             },
             {
@@ -2617,6 +2727,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
                     sourceContext,
+                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2651,6 +2762,8 @@ async function buildFrontendHybridDagFromTask(sources) {
                     fixedVerificationContext,
                     sourceContext,
                     frontendContractSchemaBlock,
+                    mockContextBlock,
+                    openspecCitationInstruction,
                 ].join("\n\n"),
             },
             {
@@ -2681,6 +2794,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
                     sourceContext,
+                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2725,8 +2839,13 @@ async function buildFrontendHybridDagFromTask(sources) {
                         outputDir: "contracts",
                         requireSourceFreshness: true,
                         implementationWriteSet: implementPaths.writeSet,
-                        openspecCandidatePaths: sources.frontendProjectCapability?.designEvidence
-                            .normativePaths ?? [],
+                        openspecPolicy: openspecGate.openspecPolicy,
+                        openspecCandidateSources: {
+                            declared: openspecGate.openspecCandidateSources.declared,
+                            taskSourceCited: openspecGate.openspecCandidateSources.taskSourceCited,
+                            scanStrict: openspecGate.openspecCandidateSources.scanStrict,
+                        },
+                        openspecCandidatePaths: openspecGate.openspecCandidatePaths,
                     },
                     cwd: ".",
                     timeoutMs: 60000,
@@ -5783,7 +5902,9 @@ function applyDefaultReadOnlyRetryPolicy(spec) {
         if (isSafeReadOnlyPiRetryCandidate(task)) {
             task.retryPolicy = task.outputProtocol
                 ? PROTOCOL_AWARE_PI_RETRY_POLICY
-                : DEFAULT_READ_ONLY_PI_RETRY_POLICY;
+                : task.role === "planner"
+                    ? PLANNER_OUTPUT_LIMIT_RETRY_POLICY
+                    : DEFAULT_READ_ONLY_PI_RETRY_POLICY;
             continue;
         }
         if (isWriterTransportRetryCandidate(task)) {

package/dist/workflows/dag/lifecycle.js

@@ -743,6 +743,7 @@ function findDoctorFailureNode(state) {
             nodeId: state.pausedByNodeId,
             status: node?.status,
             rawFailureCategory: node?.failureCategory,
+            skippedReason: node?.skippedReason,
         };
     }
     const errorEntry = Object.entries(state.nodes).find(([, node]) => node.status === "ERROR");
@@ -758,6 +759,7 @@ function findDoctorFailureNode(state) {
         nodeId: selected[0],
         status: selected[1].status,
         rawFailureCategory: selected[1].failureCategory,
+        skippedReason: selected[1].skippedReason,
     };
 }
 async function readRunOwnedBackendTestClassification(runDir) {
@@ -786,6 +788,7 @@ async function resolveDoctorFailureRouting(input) {
             normalizedFailureCategory: "unknown",
             nodeId: input.nodeId,
             productLineFailureCategory: classifiedCategory,
+            skippedReason: input.skippedReason,
         });
     }
     return routeDagFailure(input);
@@ -807,6 +810,7 @@ async function formatDagDoctorMarkdown(repoRoot, runId) {
         rawFailureCategory,
         normalizedFailureCategory: normalizedCategory,
         nodeId: failure.nodeId,
+        skippedReason: failure.skippedReason,
     });
     const evidence = failure.nodeId
         ? path.join(located.runDir, failure.nodeId, "result.summary.md")

package/dist/workflows/dag/node-execution.js

@@ -216,18 +216,28 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             "</retry_instruction>",
         ].join("\n");
     }
-    if (task.outputMode !== "structured-required" ||
-        previousFailureCategory !== "output-too-large") {
+    if (previousFailureCategory !== "output-too-large") {
         return basePrompt;
     }
+    if (task.outputMode === "structured-required") {
+        return [
+            basePrompt,
+            "",
+            "<retry_instruction>",
+            "Previous attempt exceeded the structured output size limit.",
+            "Return only the compact structured artifact required by this node's output contract.",
+            "Do not include explanatory prose, duplicated upstream context, long evidence excerpts, or additional markdown sections.",
+            "If a fenced JSON object is required, output exactly one fenced json block and nothing else.",
+            "</retry_instruction>",
+        ].join("\n");
+    }
     return [
         basePrompt,
         "",
         "<retry_instruction>",
-        "Previous attempt exceeded the structured output size limit.",
-        "Return only the compact structured artifact required by this node's output contract.",
-        "Do not include explanatory prose, duplicated upstream context, long evidence excerpts, or additional markdown sections.",
-        "If a fenced JSON object is required, output exactly one fenced json block and nothing else.",
+        "Previous attempt exceeded the output size limit.",
+        "Return a minimal plan: ordered steps, narrow writeSet boundaries, and verification commands.",
+        "Drop verbatim upstream quotes, long evidence excerpts, and repeated context.",
         "</retry_instruction>",
     ].join("\n");
 }

package/dist/workflows/dag/report.js

@@ -441,6 +441,7 @@ export async function buildDagRunReportEntry(input) {
                 normalizedFailureCategory,
                 nodeId,
                 executor: node.executor,
+                skippedReason: node.skippedReason,
             });
             const followUp = node.status === "ERROR" || node.status === "SKIPPED"
                 ? recommendFollowUpForFailureCategory(node.failureCategory)
@@ -505,6 +506,7 @@ export async function buildDagRunReportEntry(input) {
             normalizedFailureCategory: normalizeDagFailureCategory(pausedNode.failureCategory, pausedNode.status),
             failureCategory: pausedNode.failureCategory,
             nodeId: input.state.pausedByNodeId,
+            skippedReason: pausedNode.skippedReason,
         }
         : firstActionableNode
             ? {
@@ -513,6 +515,7 @@ export async function buildDagRunReportEntry(input) {
                     normalizeDagFailureCategory(firstActionableNode.failureCategory, firstActionableNode.status),
                 failureCategory: firstActionableNode.failureCategory,
                 nodeId: firstActionableNode.nodeId,
+                skippedReason: input.state.nodes[firstActionableNode.nodeId]?.skippedReason,
             }
             : {
                 status: input.state.status,
@@ -529,6 +532,9 @@ export async function buildDagRunReportEntry(input) {
         rawFailureCategory: runRecoverySource.failureCategory,
         normalizedFailureCategory: runRecoverySource.normalizedFailureCategory,
         nodeId: "nodeId" in runRecoverySource ? runRecoverySource.nodeId : undefined,
+        skippedReason: "skippedReason" in runRecoverySource
+            ? runRecoverySource.skippedReason
+            : undefined,
     });
     const runFollowUp = input.state.status === "failed" ||
         input.state.status === "partial_failed"