@tea-agent/loop-agent 0.36.4-beta.0 → 0.37.0

package/dist/workflows/dag/failure-routing.js

@@ -44,9 +44,7 @@ function routeToProductLine(input) {
         case "decision-envelope":
             return "NeedsHuman";
         case "skipped":
-            return input.skippedReason === "frontend-prewrite-not-authorized"
-                ? "ContractMismatch"
-                : "DependencyFailure";
+            return "DependencyFailure";
         case "shell-command":
             if (/\b(ENOENT|PATH|command not found|No such file|not found in PATH|bash: .*: No such file)\b/i.test(raw)) {
                 return "EnvFailure";
@@ -92,12 +90,9 @@ export function routeDagFailure(input) {
     if (!productLineFailureCategory)
         return {};
     const recommendedFollowUp = productLineFailureCategory === "ContractMismatch" &&
-        input.skippedReason === "frontend-prewrite-not-authorized"
-        ? "fix-frontend-task-contract-and-regenerate-dag"
-        : productLineFailureCategory === "ContractMismatch" &&
-            isFrontendDesignGateNode(input.nodeId ?? "")
-            ? "frontend-plan-revision-and-rerun"
-            : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
+        isFrontendDesignGateNode(input.nodeId ?? "")
+        ? "frontend-plan-revision-and-rerun"
+        : FOLLOW_UP_BY_PRODUCT_LINE[productLineFailureCategory];
     return {
         productLineFailureCategory,
         recommendedFollowUp,

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

@@ -25,7 +25,6 @@ export const frontendPrewriteFailureCodeSchema = z.enum([
     "mock-strategy-no-verification-commands",
     "target-outside-write-set",
     "verification-target-outside-write-set",
-    "openspec-not-read",
 ]);
 export const frontendPrewriteResultV1Schema = z
     .object({
@@ -499,9 +498,13 @@ 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.
+    // Materialize the canonical contract only after every governance check passed.
+    const artifact = await writeFrontendImplementationContractArtifact({
+        runDir: input.runDir,
+        outputDir: input.config.outputDir,
+        artifactName: input.config.artifactName,
+        canonical: analysis.canonical,
+    });
     const candidatePaths = input.config.openspecCandidatePaths ?? [];
     const openspecReadPaths = await checkOpenspecReadEvidence({
         runDir: input.runDir,
@@ -510,31 +513,6 @@ export async function runFrontendPrewriteGate(input) {
         reviewNodeId,
         repoRoot: workspaceRoot ?? process.cwd(),
     });
-    if (candidatePaths.length > 0) {
-        const readSet = new Set(openspecReadPaths);
-        const unread = candidatePaths.filter((candidate) => !readSet.has(candidate));
-        if (unread.length > 0) {
-            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.`,
-                failureCode: "openspec-not-read",
-                openspecReadPaths,
-                openspecCandidatePaths: candidatePaths,
-            });
-        }
-    }
-    // Materialize the canonical contract only after every governance check passed.
-    const artifact = await writeFrontendImplementationContractArtifact({
-        runDir: input.runDir,
-        outputDir: input.config.outputDir,
-        artifactName: input.config.artifactName,
-        canonical: analysis.canonical,
-    });
     const classification = analysis.normalizationActions.length > 0 ? "accepted-normalized" : "accepted";
     return finalizePrewrite(input, {
         ...basePending,
@@ -578,14 +556,7 @@ export function formatFrontendPrewriteGateStdout(result) {
     if (result.openspecReadPaths.length > 0) {
         lines.push(`openspec read: ${result.openspecReadPaths.join(", ")}`);
     }
-    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 {
+    else if (result.openspecCandidatePaths.length === 0) {
         lines.push("openspec: unavailable");
     }
     return lines.join("\n");

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

@@ -9,7 +9,7 @@ import { planMavenVerification, } from "../../verification/maven/index.js";
 import { pathMatchesPattern } from "../../shared/git-progress.js";
 import { BASELINE_FORBIDDEN_PATHS } from "./governance-constants.js";
 import { buildDecisionEnvelopePromptContract } from "./decision-envelope.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 { 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 { 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,39 +558,6 @@ 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.
  *
@@ -2144,7 +2111,6 @@ 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") {
@@ -2175,33 +2141,9 @@ function resolveFrontendCapabilityContextBlock(sources) {
     }
     if (capability) {
         parts.push("", capability.adapterGuidance);
-        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)");
+        if (capability.designEvidence.normativePaths.length > 0) {
+            parts.push(`openspec normative candidates: ${capability.designEvidence.normativePaths.slice(0, 12).join(", ")}`);
         }
-        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(", ")})`
@@ -2567,11 +2509,6 @@ 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 spec = {
         version: 3,
         title: `Frontend implementation DAG: ${taskConfig.title}`,
@@ -2586,7 +2523,6 @@ 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",
@@ -2681,7 +2617,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
                     sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2716,7 +2651,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     fixedVerificationContext,
                     sourceContext,
                     frontendContractSchemaBlock,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -2747,7 +2681,6 @@ async function buildFrontendHybridDagFromTask(sources) {
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,
                     sourceContext,
-                    mockContextBlock,
                 ].join("\n\n"),
             },
             {
@@ -5850,9 +5783,7 @@ function applyDefaultReadOnlyRetryPolicy(spec) {
         if (isSafeReadOnlyPiRetryCandidate(task)) {
             task.retryPolicy = task.outputProtocol
                 ? PROTOCOL_AWARE_PI_RETRY_POLICY
-                : task.role === "planner"
-                    ? PLANNER_OUTPUT_LIMIT_RETRY_POLICY
-                    : DEFAULT_READ_ONLY_PI_RETRY_POLICY;
+                : DEFAULT_READ_ONLY_PI_RETRY_POLICY;
             continue;
         }
         if (isWriterTransportRetryCandidate(task)) {

package/dist/workflows/dag/lifecycle.js

@@ -743,7 +743,6 @@ 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");
@@ -759,7 +758,6 @@ function findDoctorFailureNode(state) {
         nodeId: selected[0],
         status: selected[1].status,
         rawFailureCategory: selected[1].failureCategory,
-        skippedReason: selected[1].skippedReason,
     };
 }
 async function readRunOwnedBackendTestClassification(runDir) {
@@ -788,7 +786,6 @@ async function resolveDoctorFailureRouting(input) {
             normalizedFailureCategory: "unknown",
             nodeId: input.nodeId,
             productLineFailureCategory: classifiedCategory,
-            skippedReason: input.skippedReason,
         });
     }
     return routeDagFailure(input);
@@ -810,7 +807,6 @@ 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,28 +216,18 @@ function buildAttemptPrompt(task, basePrompt, attemptNumber, previousFailureCate
             "</retry_instruction>",
         ].join("\n");
     }
-    if (previousFailureCategory !== "output-too-large") {
+    if (task.outputMode !== "structured-required" ||
+        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 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.",
+        "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");
 }

package/dist/workflows/dag/report.js

@@ -441,7 +441,6 @@ export async function buildDagRunReportEntry(input) {
                 normalizedFailureCategory,
                 nodeId,
                 executor: node.executor,
-                skippedReason: node.skippedReason,
             });
             const followUp = node.status === "ERROR" || node.status === "SKIPPED"
                 ? recommendFollowUpForFailureCategory(node.failureCategory)
@@ -506,7 +505,6 @@ export async function buildDagRunReportEntry(input) {
             normalizedFailureCategory: normalizeDagFailureCategory(pausedNode.failureCategory, pausedNode.status),
             failureCategory: pausedNode.failureCategory,
             nodeId: input.state.pausedByNodeId,
-            skippedReason: pausedNode.skippedReason,
         }
         : firstActionableNode
             ? {
@@ -515,7 +513,6 @@ 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,
@@ -532,9 +529,6 @@ 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"

package/dist/workflows/dag/retry-policy.js

@@ -118,17 +118,6 @@ export const STRUCTURED_REQUIRED_PI_RETRY_POLICY = {
     ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
     retryCategories: [...STRUCTURED_REQUIRED_DAG_RETRY_CATEGORIES],
 };
-/**
- * Planner read-only nodes (standard DAG contract-pi / plan-pi) may retry with
- * a compact-output instruction when the model produced an oversized assistant
- * response. Only `output-too-large` is added on top of the default set;
- * report/review and other read-only roles keep the default set so they do not
- * silently learn new output semantics.
- */
-export const PLANNER_OUTPUT_LIMIT_RETRY_POLICY = {
-    ...DEFAULT_READ_ONLY_PI_RETRY_POLICY,
-    retryCategories: [...DEFAULT_DAG_RETRY_CATEGORIES, STRUCTURED_OUTPUT_RETRY_CATEGORY],
-};
 /**
  * Default retry for reviewer / recovery nodes that declare outputProtocol.
  * Includes protocol-invalid so missing VERDICT lines are corrected in-node.

package/dist/workflows/dag/runner.js

@@ -115,6 +115,22 @@ export async function buildDagRunId(spec, options) {
     const existing = await listExistingDagRunIds(options.cwd);
     return collisionSafeDagRunId(baseId, existing, now);
 }
+/**
+ * Append a human-readable round label to a run title when the runId carries
+ * a `-rN` collision suffix (2026-08-16): the sidebar / Inspect list showed
+ * identical titles for reruns and only the id hinted at the round.
+ */
+export function titleWithRoundLabel(title, runId) {
+    const match = /-r(\d{1,2})$/.exec(runId);
+    if (!match)
+        return title;
+    const round = Number.parseInt(match[1], 10);
+    if (!Number.isFinite(round) || round < 2)
+        return title;
+    // Never stack labels on reruns of reruns.
+    const base = title.replace(/\s*（第\s*\d+\s*轮）$/u, "");
+    return `${base}（第 ${round} 轮）`;
+}
 export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "dag") {
     const nodes = {};
     for (const task of spec.tasks) {
@@ -136,7 +152,7 @@ export function createInitialRunState(spec, opts, ranks, runId = opts.runId ?? "
             : "execute";
     const state = {
         version: 1,
-        title: spec.title,
+        title: titleWithRoundLabel(spec.title, runId),
         runId,
         cwd: opts.cwd,
         startedAt: new Date().toISOString(),
@@ -263,7 +279,7 @@ export async function runDag(spec, opts) {
     }
     if (opts.dryRun || opts.initOnly) {
         return {
-            title: spec.title,
+            title: state.title,
             runId: state.runId,
             status: state.status,
             ranks,
@@ -717,7 +733,7 @@ async function executeDagCheckpoint(input) {
         await writeBudgetLedgerArtifacts(runDir, state.budgetLedger);
         await persistState({ allowCompletedFactsWrite: true });
         return {
-            title: spec.title,
+            title: state.title,
             runId: state.runId,
             status: state.status,
             ranks,

package/dist/workflows/dag/types.js

@@ -822,8 +822,6 @@ export const dagSpecSchema = z
     defaults: dagDefaultsSchema,
     skillsByRole: z.record(z.string(), z.array(z.string())).optional(),
     executorModels: dagExecutorModelsSchema.optional(),
-    /** Generation-time advisories surfaced as machine-visible warnings. */
-    advisories: z.array(z.string()).optional(),
     tasks: z.array(dagTaskSchema).min(1),
 })
     .superRefine((spec, ctx) => {

package/dist/workflows/dag/validate.js

@@ -14,7 +14,6 @@ const GOVERNANCE_WARNING_TYPES = new Set([
     "shell-verdict-gate-multi-command-state",
     "shell-verdict-gate-handwritten-inline",
     "orphan-writer-source-binding",
-    "advisory",
 ]);
 const ROOT_ARTIFACT_PATH_PROBES = [
     "artifacts/修改记录.md",
@@ -33,11 +32,10 @@ export function collectGovernanceWarnings(issues) {
     return issues.filter(isGovernanceWarning);
 }
 function collectBlockingIssues(issues, options = {}) {
-    const nonAdvisory = issues.filter((issue) => issue.type !== "advisory");
     if (options.strictGovernance) {
-        return nonAdvisory;
+        return [...issues];
     }
-    return nonAdvisory.filter((issue) => !isGovernanceWarning(issue));
+    return issues.filter((issue) => !isGovernanceWarning(issue));
 }
 function normalizePath(value) {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
@@ -958,9 +956,6 @@ export function validateDagSpec(spec) {
     validateSameRankWriteSetConflicts(spec, ranks, issues);
     validateSameRankAgentAttributionRisks(spec, ranks, issues);
     validateWriterSourceBinding(spec, issues);
-    for (const advisory of spec.advisories ?? []) {
-        issues.push({ type: "advisory", message: advisory });
-    }
     return issues;
 }
 function validateProjectGovernanceTaskConfig(task, spec, issues) {

package/docs/templates/frontend-design-contract.md

@@ -1,62 +1,42 @@
 # 前端设计契约模板
 
-本模板只承载**通用编写协议 + 三要素 + fail-closed 规则**，不包含任何具体业务组件名、项目专属路径或项目专属命令。设计契约在进入实现前由 `frontend-plan-pi` 落入结构化 implementation contract，`frontend-design-review-pi` 按本模板逐节审查；每一节都要给出「**要写什么** / **DAG 如何消费** / **缺失/冲突时 fail-closed**」三要素。
-
 ## 页面目标
 
-- **要写什么**：写清每个目标页面的职责、用户到达该页面的目的与成功结果，逐页列出，与需求.md 的用户目标/目标页面一一对应。
-- **DAG 如何消费**：`frontend-plan-pi` 据它确定 `targets.routes` 与每页的实现步骤，`frontend-design-review-pi` 据它核对范围与需求一致性。
-- **缺失/冲突时 fail-closed**：页面目标与需求不一致、缺页或目标含糊（无成功结果）时阻塞，不得自行补页或改目标。
+TODO
 
 ## 信息结构
 
-- **要写什么**：写清每页展示的信息层级与数据来源（字段、分组、优先级、空/错误占位），接口数据与静态文案分开写。
-- **DAG 如何消费**：`frontend-plan-pi` 据它安排组件数据流与状态展示，`frontend-design-review-pi` 据它核对接口字段映射。
-- **缺失/冲突时 fail-closed**：信息层级缺失、数据来源不可追溯、与接口字段冲突时阻塞，不得臆造字段或层级。
+TODO
 
 ## 组件拆分
 
-- **要写什么**：把页面拆成组件树，逐组件写职责、复用边界、props/状态归属与可替换点；复用现有设计系统组件时引用其来源路径。
-- **DAG 如何消费**：`frontend-plan-pi` 据它确定 `targets.files` 与实现顺序，`frontend-design-review-pi` 据它审查拆分是否越界/重复。
-- **缺失/冲突时 fail-closed**：组件边界不清、同一职责被拆到多处、或与设计规范冲突时阻塞，不得按邻近代码自行决定复用。
+TODO
 
 ## 交互规则
 
-- **要写什么**：逐条写清每个交互的触发、预期行为、状态变化与可恢复性（对应需求.md 的交互要求）。
-- **DAG 如何消费**：`frontend-plan-pi` 据它填充 `interactions[]`（`trigger` + `expectedBehavior`），verify 用行为命令断言。
-- **缺失/冲突时 fail-closed**：交互无预期行为、与 UI 状态冲突、或不可自动化断言时阻塞。
+TODO
 
 ## UI 状态
 
-- **要写什么**：逐状态（loading/empty/error/success/disabled）写清触发条件、展示内容与转移；不适用状态写 `N/A` + 非空理由。
-- **DAG 如何消费**：进入 implementation contract 的 `uiStates[]`，verify 逐状态断言，`frontend-review-pi` 据它核对实现是否遗漏状态。
-- **缺失/冲突时 fail-closed**：适用状态缺失预期、N/A 无理由、或状态展示与交互/接口状态冲突时阻塞。
+TODO
 
 ## Mock / API 策略
 
-策略枚举固定为 `native | browser-intercept | request-adapter | not-needed | blocked`，与 runtime Mock 语义一致：`blocked` 永远不通过（缺少/冲突接口契约、路径或依赖未授权、无法证明生产默认关闭、固定验证入口无法覆盖、或唯一方案是注释真实请求时必须选它）；`not-needed` 必须有后端可用或任务不涉及远程接口的真实/无远程证据，且固定 behavior 入口能覆盖相应行为；显式 `policy=required` 不接受 `not-needed`。契约只接受当前 policy 允许的非 `blocked` 首行。
-
-- **接口文档或 schema — 要写什么**：引用接口文档/schema 路径与版本，作为 fixture 与字段映射的唯一来源。**DAG 如何消费**：`frontend-plan-pi` 据它冻结 endpoint/fixture 映射，prewrite gate 校验 fixture 可追溯。**缺失/冲突时 fail-closed**：无文档/schema、字段冲突时选 `blocked`，不得自行发明接口。
-- **策略**：只写枚举中的一个值：`native | browser-intercept | request-adapter | not-needed | blocked`。
-- **endpoint / fixture / UI 状态映射 — 要写什么**：逐 endpoint 列 method、path、fixture 路径与消费组件，并映射到 UI 状态。**DAG 如何消费**：写入 `mockApi.endpoints[]`（method/path/fixture/consumer），非 `not-needed` 策略要求每个 endpoint 都有 fixture 与 consumer。**缺失/冲突时 fail-closed**：非 `not-needed` 却缺 fixture/consumer、endpoint 与 UI 状态映射不一致时阻塞。
-- **显式启用方式与 production 默认关闭边界 — 要写什么**：写清真实请求为默认路径、Mock 仅通过显式开关（环境变量/构建开关）启用的具体边界。**DAG 如何消费**：`productionDefaultOff` 恒为 `true`，`frontend-review-pi` 检查是否注释真实请求或默认开启 Mock。**缺失/冲突时 fail-closed**：无法证明生产默认关闭、或 Mock 会进入生产入口时选 `blocked`。
-- **DAG 已固化的验证入口 — 要写什么**：引用 DAG 生成时已冻结的 static/behavior/Mock 命令 label，不发明新命令。**DAG 如何消费**：`verificationTarget.commandLabel` 必须逐字落在冻结命令集合内，否则 contract 物化 `invalid-output`。**缺失/冲突时 fail-closed**：策略需要 Mock 验证命令却没有冻结命令时生成期 fail-closed（`no authorized Mock verification commands`）。
-- **Real Integration Gap 与后端就绪后的复验 — 要写什么**：写清当前未联通的真实集成缺口，以及后端就绪后的复验路径。**DAG 如何消费**：进入 `evidenceGaps[]`，closeout 报告 `Real integration: pending`，复验任务 `<task-id>-real-api-integration-verify` 由操作者显式触发。**缺失/冲突时 fail-closed**：把 Mock 证据当真实联调证据时 review 拒绝。
+- 接口文档或 schema：TODO
+- 策略：`native | browser-intercept | request-adapter | not-needed | blocked`
+- endpoint / fixture / UI 状态映射：TODO
+- 显式启用方式与 production 默认关闭边界：TODO
+- DAG 已固化的验证入口：TODO
+- Real Integration Gap 与后端就绪后的复验：TODO
 
 ## 样式与设计系统映射
 
-- **要写什么**：写清页面用到的主题/Token、设计系统组件与样式来源（引用具体来源路径），自定义样式与复用样式的边界。
-- **DAG 如何消费**：`frontend-plan-pi` 据它安排样式实现，`frontend-design-review-pi` 据它核对是否与设计系统冲突。
-- **缺失/冲突时 fail-closed**：样式来源缺失、Token/组件冲突、或自定义样式会破坏设计系统时阻塞。
+TODO
 
 ## 响应式范围
 
-- **要写什么**：写清支持的视口范围（desktop/mobile/tablet）与断点、每个断点下的布局差异。
-- **DAG 如何消费**：进入 contract 的 target runtime environment，`frontend-plan-pi` 据它决定响应式策略。
-- **缺失/冲突时 fail-closed**：视口范围与需求运行环境不一致、或断点未覆盖声明环境时阻塞。
+TODO
 
 ## 风险与非目标
 
-- **要写什么**：写清设计上的已知风险、依赖缺口与明确不做/排除的设计范围。
-- **DAG 如何消费**：进入 `evidenceGaps[]` 与 Non-goals，`frontend-review-pi`/closeout 据它保留风险与后续项。
-- **缺失/冲突时 fail-closed**：范围与需求非目标冲突、或风险被隐藏时阻塞。
+TODO

package/docs/templates/frontend-task-constraints.md

@@ -1,55 +1,35 @@
 # 前端任务执行约束模板
 
-本模板只承载**通用探索协议 + 结果 schema + 缺失/冲突时 fail-closed 规则**，不包含任何具体业务组件名、项目专属路径或项目专属命令。项目事实由生成期能力探测（`openspec/schemas/**`、`openspec/project-specs/**`、`ai_workspace/**`）产出并经语义归类注入任务契约。
-
 ## 技术约束
 
-- **要探索什么**：项目 `package.json` 的直接依赖与 scripts、框架/路由/状态/数据获取/组件库/样式/测试/构建相关配置与引导文件，以及 `openspec/schemas/**` 与 `openspec/project-specs/rules/**` 中声明技术边界的规范。
-- **结果必须包含**：每一条适用技术规则的源路径、命中章节与行号；被排除依赖的明确理由；与既有技术栈一致的运行时要求（编译、构建、入口、环境变量）。
-- **缺失/冲突时如何 fail-closed**：无法找到技术规范来源时，显式标注 `source: unavailable` 并只采用任务源与现有代码的可验证事实；发现冲突规则时不臆造取舍，先记录冲突并返回 `request-revision`/blocked，而不是静默采用邻近代码惯例。
+TODO
 
 ## 代码风格约束
 
-- **要探索什么**：`openspec/project-specs/templates/**`（代码模板）与 `openspec/project-specs/rules/**` 中组件/钩子/工具等代码风格规则，以及现有组件、主题/Token、stories 与测试作为较弱 repository fallback。
-- **结果必须包含**：命中模板/规则的源路径、章节与行号；命名、目录、导出、类型、样式组织等可执行约定；冲突字段逐条列出。
-- **缺失/冲突时如何 fail-closed**：没有模板/规则命中时明确说明并记录 `repository fallback` 证据；冲突未解决时不得进入实现，必须返回阻塞信息。
+TODO
 
 ## 设计约束
 
-- **要探索什么**：`openspec/project-specs/ui/**`（主题/组件目录）与 `openspec/project-specs/rules/**` 中页面/组件拆分、交互、UI 状态与响应式相关规则。
-- **结果必须包含**：命中设计规范/组件目录的源路径、章节与行号；组件拆分与复用边界、样式与设计系统映射、UI 状态与响应式范围。
-- **缺失/冲突时如何 fail-closed**：设计规范缺失时明确记录来源为 `unavailable` 并保留为已知风险；组件/主题冲突时必须阻断，不能按邻近代码自行决定。
+TODO
 
 ## 验证约束
 
-- **要探索什么**：项目 `package.json` scripts 中真实存在的 lint/typecheck/build/test 命令，以及任务源 `需求.md`/`执行约束.md` 中声明的验证命令。
-- **结果必须包含**：命令的 label、原始命令文本与来源（scripts/任务源）；每条命令可自终止（启动→断言→退出）的说明。
-- **缺失/冲突时如何 fail-closed**：只在确定命令真实存在时写入冻结命令集；不发明 shell 命令。命令不可执行或漂移时 fail closed，不宣称验证通过。
+TODO
 
 ## Mock 约束（数据型任务）
 
-本段决定生成期 `allowedMockStrategies` 与冻结的 Mock 验证命令。只有当生成期**能证明任务确实包含 Mock 且有确定性验证命令**时，DAG 才会放行 `native` / `browser-intercept` / `request-adapter`；否则自动收敛为 `not-needed`，design review 若按项目规范改选 `native`，会在 prewrite 被 `mock-strategy-outside-allowed` 拦截、`implement` 被跳过。
-
-- **何时必须填**：项目规范（`openspec/project-specs/**`、`ai_workspace/**`、mock 规则或类似 DEC-* 决策）要求/建议 Mock；或需求涉及远端接口且后端未就绪。规范要求 Mock 时，优先 `task.json.frontendMock.policy: "required"`。
-- **命令要探索、不要硬编码**：到项目 `package.json` scripts 里找实际存在的 Mock 相关脚本（如 `mock`、`mock:*`、`dev:mock`，或名字含 mock 的脚本），结合既有 service root 的 handler/fixture/bootstrap 启动方式，确定一条**真实存在、确定、可自终止**（启动→断言→退出 0）的验证命令。常驻 dev server 必须包装成自终止脚本（start→assert→stop），否则 verify shell 会超时 fail-closed。
-- **写入 task.json**：把探索到的命令原样写进 `frontendMock.verifyCommands`（`label` 唯一、`command` 与项目脚本一致）。`label` 会进入冻结命令集，implementation contract 的 `verificationTarget.commandLabel` 必须逐字引用它。
-- **命令来源白名单**：只允许项目 `package.json` 已有脚本、Mock capability seed、或本段声明的 `verifyCommands`；plan/design 阶段不能发明 shell 命令。
-- **Mock/API/schema 规范路径**：到 `openspec/project-specs/**`（rules 中的 mock/api 规则、templates 中的接口模板）与 `ai_workspace/**` 检索；结果必须列出源路径、章节与行号。缺失或冲突时 fail closed，不自行发明接口契约。
-- **既有 Mock service root、handler/fixture/bootstrap**：检索项目现有 Mock 服务根目录、handler、fixture 与 bootstrap 启动方式；结果必须列出发现路径，未发现时明确记录 `unavailable`。
-- **既有 browser/e2e interception 或 request adapter/DI seam**：检索项目现有浏览器/e2e 拦截或请求适配层/依赖注入 seam；结果必须列出发现路径或明确记录缺失。
-- **production 禁用边界**：结果必须说明真实请求为默认路径、Mock 仅通过显式测试/开发开关启用的具体边界；无法证明生产默认关闭时返回 `blocked`。
-- **真实请求默认路径与 Mock 显式启用方式**：结果必须写出真实请求默认路径与 Mock 显式启用方式（如环境变量/构建开关），不得通过注释真实请求或在生产组件内硬编码假数据实现。
-- **`task.json.frontendMock.policy`**：`auto | required | disabled`（规范强制 Mock 用 `required`）
-- **被拦截时怎么修**：`mock-strategy-outside-allowed` / `no authorized Mock verification commands` 是**生成期契约问题，不是 plan 问题**——补 `frontendMock.verifyCommands`（或 `policy: "required"` + 命令）后**重新生成 DAG** 再跑，plan-revision 无法修复它。
+- Mock/API/schema 规范路径：TODO
+- 既有 Mock service root、handler/fixture/bootstrap：TODO
+- 既有 browser/e2e interception 或 request adapter/DI seam：TODO
+- 启动、健康检查和专项验证命令：TODO
+- production 禁用边界：TODO
+- 真实请求默认路径与 Mock 显式启用方式：TODO
+- `task.json.frontendMock.policy`：`auto | required | disabled`
 
 ## allowedPaths
 
-- **要探索什么**：任务源 `需求.md`/`执行约束.md`/`task.json` 中声明的写入边界，以及本次交付实际涉及的文件/目录。
-- **结果必须包含**：与 `task.json.allowedPaths` 一致且窄化的路径列表；任何越界路径都必须在 plan 中记为阻断性 scope conflict。
-- **缺失/冲突时如何 fail-closed**：缺失允许路径或发现计划目标在允许路径之外时，不得擅自扩大边界，返回 blocked。
+TODO
 
 ## forbiddenPaths
 
-- **要探索什么**：任务源与 `task.json` 中声明的禁止写入路径（运行时产物、依赖目录、构建输出、私有路径等）。
-- **结果必须包含**：禁止写入的路径清单，以及实现/验证步骤不触碰这些路径的确认。
-- **缺失/冲突时如何 fail-closed**：任何写入落入禁止路径立即阻断；禁止路径语义不变，不得新增读取权限字段或扩大写入边界。
+TODO