@tea-agent/loop-agent 0.39.0-next.30 → 0.39.0-next.32

package/CHANGELOG.md

@@ -4,9 +4,13 @@
 
 ### 重点更新
 
+- Console「设置」页新增「模型配置（models.json）」区块：以弹框形式增/改/删 Pi 的模型条目，支持 6 个定义字段（id、name、contextWindow、maxTokens、input、reasoning）。新增时 Provider 用下拉选择、其余字段自动补默认值；编辑时 Provider 只读且仅在原位置就地替换，只改表单内字段、不覆盖配置里页面未展示的其它字段（如 cost/compat）；不读写 API key（凭据走 Pi CLI）。编辑已存在的模型不再被移到最后。
+- 前端风险分级细分 manifest 触及语义：`allowedPaths` 含 `package.json`/lockfile 或需求文本提到 package.json 不再单独触发 `new-dependency` high-risk（改一行 script、调构建参数的任务不再被顶到强制全门禁并误标高风险），只有任务文本同时出现安装语言（npm install / yarn add / pnpm add / 新增依赖等）才升级；仅路径触及时记 `new-dependency:manifest-path-without-install-language` 拒绝信号，审计可溯。
+- 前端验证 fallback 生成期诚实化：真实项目无可读取的 `package.json` scripts 且未探测到本地 tsc 时，不再注入必然失败的 `npm run typecheck` / `npm run build` / `npm test`（纯静态 / vanilla JS 站点原会在 verify 阶段假失败），改为执行显式 no-op 标记命令（`No frontend verification command configured`，进入冻结命令集可被 contract 引用，trace 如实记录 not-run），并写生成期 advisory 提示用 `--verify` 或执行约束显式声明验证命令后重新生成 DAG。无 repoRoot 的单测 fixture 保留历史 generic fallback。**标记不构成验证证据（fail-closed）**：verification trace 将绑定标记的 target 判为失败、只含标记的 static 证据判为 unavailable，repair 分类归为 non-repairable `contract`，verify 节点以 `frontend verification unavailable` 硬失败阻断 review/closeout——无真实验证命令的 run 无法走完绿灯链。
 - frontend-test `passed` 回执链改按 dispatch 序号判序（B-HASH-01）：`summarizePlaywrightCliReceipts` 先按 `sequence` 排序再判 open→find→cleanup 连续链；并行 `find`/`screenshot` 按完成时间落盘导致的乱序不再误杀执行已通过的 case（Wave 1 实测 4 条 passed 被改判 `browser-command-evidence-missing`）。真 gap / 重复序号仍 fail-closed。
 - `tool-policy` 失败归一为 `executor`（B-REC-03）：前端 preflight 能力拒绝（缺 `@playwright/cli` JS entry、allowlist 拒绝）不再落 `unknown`→`manual-review`+`humanRequired`；`dag report` 给出 `rerun-after-fix`，Console `standaloneTaskRerun` 的 R2 gate 放行 run-failed 同 task 整单重跑，无需人工决策门或 sibling task。
 - Operator Chrome Band1 模式切换入口补显式 `aria-label`（B-FIND-01，方案 A）：`操作`/`观测` mode link 原为 inline-flex 裸文本节点，不参与 name-from-content，a11y snapshot 序列化为无名 link，`find` 无法断言；补 `aria-label` 后实测 `find "观测"` 1 命中、click 后 `find "运行总览"` 1 命中，AC-FE-CHROME-003 恢复可见断言路径。
+- Inspect 异常 Task 页空态文案统一（B-FIND-02）：`failures.js` 运行时空态由 `当前没有失败或阻塞的 Task。` 改回与静态 `#failures-empty`、页面标题及回归目录 AC-FE-INS-004 一致的 `当前没有异常 Task`，消除静态/运行时文案漂移；实测新文案 find 1 命中、旧文案 0 命中。
 
 - `next-release.yml` 防重复发布守卫补充幂等语义：`mode=recover`（dist-tags.next 已指向出自本 HEAD 的 tarball）时，手动 `workflow_dispatch` 重入不再撞 duplicate publish 硬失败，改为写 summary 后干净退出（§5.1 规则 4）；非 recover 的重复发布仍硬失败。
 
@@ -19,6 +23,7 @@
 ### 新增
 
 - Operator Chat 时间线左缘新增「用户消息锚点栏」：每个用户输入一枚横向小条（12×3px 微圆角），紧凑等距排列并在时间线高度内垂直居中；条数超出栏高时相邻锚点自动聚合为稍宽的聚合条（悬停展开「N 条聚合输入」逐条列表，时间 + 单行预览，逐条点击定位）。悬停时小条向对话一侧平滑伸长（12→18px）并变橙，浮窗右侧弹出（白底圆角，正文最多 3 行、超出省略号，附序号与时间）；单击平滑滚动定位到对应消息（精确停靠在视口顶部偏移 8px）；覆盖视口顶部的锚点保持高亮。空会话自动隐藏；历史分页/流式更新/窗口缩放时自动重算（rAF 节流）。
+- frontend-test 产物根可配置：`task.json.frontendTest.testRoot` 缺省仍为 `testcase/frontend`，省略时生成的 DAG 路径与历史默认根一致；自定义根（如 `qa/frontend-test`）在编译期冻结并驱动 writer、gate、playwright 围栏与 `allowedPaths`。`.harness/**` 等隐藏/治理树在生成期拒绝。
 - 实验能力「编辑失败节点提示词后从节点重跑」（默认关闭）：内部开关 `HARNESS_DAG_RERUN_PROMPT_OVERRIDE=1` 启用后，`dag rerun` 支持 `--prompt-override <nodeId>@<file>`（全文替换）与 `--prompt-override-append <nodeId>@<file>`（追加指令：保留冻结原提示词，末尾追加 `<operator_addendum>` 块）。仅限 ERROR 且位于 reset closure 内的节点；mode + base/最终 prompt sha256 计入 planHash（execute 漂移即 `PLAN_DRIFT`），父 run spec 冻结、provenance（含 mode）落 `continuation.promptOverrides`。Console 新增 `dagPromptOverrideConfig` 开关探测 action，`dagRerunPlan`/`dagRerun` 接受 `promptOverrides`（`{nodeId, prompt, mode?}`）；Inspect DAG 节点 inspector 新增「提示词重启」tab——默认「追加指令」模式（只读底稿 + 追加编辑器），可切换「全文替换（高级）」，预检通过展示执行估算，提交后续跑并跳转新 run，全程不离开图页；开关开启时 `/inspect` 只注入 **scoped** 变体凭据（独立 cookie + `__INSPECT_MUTATION_TOKEN__`，与 Console 通用 token 互不可重放），mutations 路由对 inspect 凭据仅放行 `dagRerunPlan`/`dagRerun`（其余 action 403 `ACTION_NOT_IN_INSPECT_SCOPE`），Inspect 不获得通用写能力；开关关闭时不注入任何 token、tab 不出现，检视面保持严格只读。
 - 观察面 DAG Inspector 节点详情适配 Pi 扩展：执行器输入摘要展示节点声明的 `piExtensions` 短 id；新增「Pi 扩展运行事实」展示 `pi-extensions.json` 的 resolved（包名@版本）与 missing 降级原因（缺包降级不再静默）；产物未生成/损坏时降级提示不阻断接口，绝对路径不外泄。
 - 后端实现 DAG（standard / review-gated / supervised）的 Pi 节点支持按桶显式加载本机 Pi 导航扩展：读侧节点（除 closeout）加载 `pi-codegraph` + `pi-lens`，写侧节点只加载 `pi-codegraph`（pi-lens 的 `ast_grep_replace` 可绕过 writeSet，不加载）；前端/测试模板与省略字段节点保持扩展全关。扩展发现始终关闭，只经白名单解析 `~/.pi/agent` 与项目 `.pi` settings 的已装包（缺包降级不失败，产物 `pi-extensions.json` 记录 requested/resolved/missing）；session 后 pin 工具面剔 builtin 同名、deny 面与写工具，writer 的 `edit`/`write` 仍为 policy-wrapped；`.codegraph/**` index 同步不再计入 write-guard 越界。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.38.3",
-  "gitSha": "07a0a9bcee0b9aa29cafc085485f3aed7ae03cec",
-  "builtAt": "2026-08-22T12:04:10.935Z"
+  "gitSha": "e37cf1f3b4a5c98e7fc60de321be5a571ce3a105",
+  "builtAt": "2026-08-23T12:41:22.938Z"
 }

package/dist/executors/dag-pi-executor.js

@@ -12,6 +12,7 @@ import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelai
 import { isTargetTemplateTransientRetryNode, isWriterEmptyDiffRetryCandidate, isWriterTransportRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_CLEAN_TIMEOUT_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
 import { assessBackendTestMdPlanCompleteness, assessBackendTestMdWriterCompleteness, assessBackendTestPytestPlanCompleteness, assessBackendTestPytestWriterCompleteness, assessBackendTestShardChildCompleteness, backendTestWriterProgressRoleForTask, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, isBackendTestMdPlanTask, isBackendTestPytestPlanTask, isBackendTestShardChildTask, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
+import { frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 /**
  * Writer classification for a length-stopped thinking-only attempt: the model
@@ -512,10 +513,11 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                         throw new Error(`unknown command capability: ${capability}`);
                     }
                     if (capability === "playwright-cli") {
-                        const caseId = resolveCaseIdFromWriteSet(input.task.writeSet) ??
+                        const layout = frontendTestLayoutFromSpec(meta.spec);
+                        const caseId = resolveCaseIdFromWriteSet(input.task.writeSet, layout) ??
                             input.task.id;
-                        const evidenceDir = resolveEvidenceDirFromWriteSet(input.task.writeSet) ??
-                            `testcase/frontend/evidence/${caseId}`;
+                        const evidenceDir = resolveEvidenceDirFromWriteSet(input.task.writeSet, layout) ??
+                            `${layout.evidenceDir}/${caseId}`;
                         playwrightToolContext = {
                             repoRoot: input.cwd,
                             runDir: meta.runDir,
@@ -523,7 +525,8 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                             caseId,
                             evidenceDir,
                             baseUrl: await resolveValidatedFrontendBaseUrlFromContext(input.cwd, meta.runDir),
-                            inputRoot: "testcase/frontend/fixtures",
+                            inputRoot: layout.fixturesDir,
+                            layout,
                         };
                         // Cleanup must be confirmed before a new case; otherwise default-session
                         // isolation is unknown and no Pi invocation is permitted.

package/dist/executors/pi-playwright-cli-tool.js

@@ -4,7 +4,8 @@ import { appendFile, lstat, mkdir, readFile, realpath, stat, } from "node:fs/pro
 import path from "node:path";
 import { processTreeSpawnOptions, terminateProcessTree, } from "./process-tree.js";
 import { resolvePlaywrightCliLauncher } from "./playwright-cli-launcher.js";
-import { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, } from "../shared/playwright-cli-command-policy.js";
+import { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, parsePlaywrightCliFindMatchCount, } from "../shared/playwright-cli-command-policy.js";
+import { defaultFrontendTestLayout, escapeRegexLiteral, } from "../workflows/dag/frontend-test-layout.js";
 export { PLAYWRIGHT_CLI_ALLOWED_COMMANDS, isPlaywrightCliCommand, };
 /** Logical capability name only; execution always uses the verified JS launcher. */
 export const PLAYWRIGHT_CLI_EXECUTABLE = "playwright-cli";
@@ -144,8 +145,10 @@ export function summarizePlaywrightCliReceipts(receipts) {
         if (PLAYWRIGHT_CLI_INTERACTION_COMMANDS.has(receipt.command) && succeeded) {
             hasInteractionOrAssertion = true;
         }
-        // A successful find is the only model-visible semantic assertion in v1.
-        if (receipt.command === "find" && succeeded) {
+        // A successful find (or find-unique, its semantic wrapper) is the only
+        // model-visible semantic assertion in v1.
+        if ((receipt.command === "find" || receipt.command === "find-unique") &&
+            succeeded) {
             hasMeaningfulAssertion = true;
             if (ordered && sawOpen)
                 sawMeaningfulAssertionAfterOpen = true;
@@ -265,7 +268,8 @@ function validateOpenArgs(args, baseUrl) {
 }
 function resolveEvidenceRelative(rawPath, ctx) {
     const evidenceDir = normalizePosix(ctx.evidenceDir).replace(/\/$/, "");
-    const evidencePrefix = `testcase/frontend/evidence/${ctx.caseId}`;
+    const layout = ctx.layout ?? defaultFrontendTestLayout();
+    const evidencePrefix = `${layout.evidenceDir}/${ctx.caseId}`;
     if (!(evidenceDir === evidencePrefix ||
         evidenceDir.startsWith(`${evidencePrefix}/`))) {
         throw new PlaywrightCliPolicyError("evidence-dir-invalid", `evidenceDir must be under ${evidencePrefix}`);
@@ -289,7 +293,7 @@ function resolveEvidenceRelative(rawPath, ctx) {
     if (candidate.startsWith(`${evidenceDir}/`) || candidate === evidenceDir) {
         return candidate;
     }
-    if (candidate.startsWith("testcase/frontend/evidence/") &&
+    if (candidate.startsWith(`${layout.evidenceDir}/`) &&
         !candidate.startsWith(`${evidencePrefix}/`)) {
         throw new PlaywrightCliPolicyError("path-cross-case", "output path escapes current case evidenceDir");
     }
@@ -470,11 +474,12 @@ function assertInputPathAllowed(rawPath, ctx) {
     if (!isSafeRelativePosix(candidate)) {
         throw new PlaywrightCliPolicyError("input-path-unsafe", `unsafe input path: ${rawPath}`);
     }
+    const layout = ctx.layout ?? defaultFrontendTestLayout();
     const allowedPrefixes = [
-        `testcase/frontend/evidence/${ctx.caseId}/`,
-        "testcase/frontend/cases/",
-        "testcase/frontend/rag/",
-        "testcase/frontend/fixtures/",
+        `${layout.evidenceDir}/${ctx.caseId}/`,
+        `${layout.casesDir}/`,
+        `${layout.ragDir}/`,
+        `${layout.fixturesDir}/`,
     ];
     if (!allowedPrefixes.some((prefix) => candidate === prefix.slice(0, -1) || candidate.startsWith(prefix)) &&
         !candidate.startsWith(normalizePosix(ctx.evidenceDir) + "/")) {
@@ -530,6 +535,17 @@ export function preparePlaywrightCliArgv(input, ctx) {
     else if (command === "pdf" || command === "snapshot") {
         args = normalizePdfOrSnapshotArgs(command, rawArgs, ctx);
     }
+    else if (command === "find-unique") {
+        // find-unique is a controller-side semantic wrapper: the underlying CLI
+        // only knows `find`; uniqueness (matchCount === 1) is judged by the
+        // executor after parsing the find output. Require exactly one text
+        // literal — a unique-control assertion is meaningless with multiple.
+        const literals = rawArgs.filter((arg) => !arg.startsWith("-"));
+        if (rawArgs.length !== 1 || literals.length !== 1) {
+            throw new PlaywrightCliPolicyError("find-unique-args", "find-unique requires exactly one text literal and no flags");
+        }
+        args = literals;
+    }
     else {
         args = rewriteArgsForPaths(command, rawArgs, ctx);
     }
@@ -616,8 +632,8 @@ async function validatePlaywrightCliOutputPath(command, args, ctx) {
     if (!outputFilename)
         return;
     const repoRoot = path.resolve(ctx.repoRoot);
-    const caseEvidenceRoot = path.resolve(repoRoot, "testcase", "frontend", "evidence", ctx.caseId);
-    const evidenceDir = path.resolve(repoRoot, ctx.evidenceDir);
+    const caseEvidenceRoot = path.resolve(repoRoot, ctx.evidenceDir);
+    const evidenceDir = caseEvidenceRoot;
     const target = path.resolve(repoRoot, outputFilename);
     if (!pathIsContained(repoRoot, caseEvidenceRoot) ||
         !pathIsContained(caseEvidenceRoot, evidenceDir) ||
@@ -825,7 +841,10 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         };
     }
     let executable = PLAYWRIGHT_CLI_EXECUTABLE;
-    let argv = [command, ...args];
+    // find-unique executes as the underlying CLI `find` command; uniqueness is
+    // a controller-side judgment on the parsed match count.
+    const cliCommand = command === "find-unique" ? "find" : command;
+    let argv = [cliCommand, ...args];
     try {
         await validatePlaywrightCliOutputPath(command, args, ctx);
         await validatePlaywrightCliInputFiles(command, args, ctx);
@@ -834,7 +853,7 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         if (!ctx.runCommand) {
             const launcher = resolvePlaywrightCliLauncher(ctx.repoRoot);
             executable = launcher.executable;
-            argv = [...launcher.argvPrefix, command, ...args];
+            argv = [...launcher.argvPrefix, cliCommand, ...args];
         }
     }
     catch (error) {
@@ -894,6 +913,19 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
     }
     const finishedAt = new Date();
     const combined = `${runResult.stdout}\n${runResult.stderr}`;
+    // find-family commands report their match count in stdout with exit code
+    // 0 even on zero matches — parse the count so receipts carry the real
+    // assertion signal for finalize-side audits.
+    const matchCount = command === "find" || command === "find-unique"
+        ? parsePlaywrightCliFindMatchCount(runResult.stdout || "")
+        : undefined;
+    // find-unique fails closed unless exactly one match was found (including
+    // zero and unparseable outputs).
+    const findUniqueFailed = command === "find-unique" && matchCount !== 1 && !runResult.timedOut;
+    const effectiveExitCode = findUniqueFailed && runResult.exitCode === 0 ? 1 : runResult.exitCode;
+    const effectiveStderr = findUniqueFailed
+        ? `${runResult.stderr}${runResult.stderr ? "\n" : ""}find-unique: expected exactly 1 match, got ${matchCount === undefined ? "unparseable output" : `${matchCount}`}`
+        : runResult.stderr;
     const receipt = {
         schemaVersion: 1,
         caseId: ctx.caseId,
@@ -902,25 +934,28 @@ export async function executePlaywrightCliCommand(input, ctx, signal) {
         argsRedacted: redactPlaywrightCliArgs(command, args),
         startedAt: startedAt.toISOString(),
         finishedAt: finishedAt.toISOString(),
-        exitCode: runResult.exitCode,
+        exitCode: effectiveExitCode,
         durationMs: finishedAt.getTime() - startedAt.getTime(),
         outputSha256: createHash("sha256").update(combined).digest("hex"),
         toolVersion: ctx.toolVersion ?? "unknown",
         timedOut: runResult.timedOut || undefined,
+        ...(matchCount !== undefined ? { matchCount } : {}),
         errorClass: runResult.timedOut
             ? "timeout"
             : runResult.signal === "abort"
                 ? "abort"
-                : runResult.exitCode === 0
+                : effectiveExitCode === 0
                     ? undefined
-                    : "nonzero-exit",
+                    : findUniqueFailed
+                        ? "find-unique-count-mismatch"
+                        : "nonzero-exit",
     };
     await appendReceipt(ctx, receipt);
     return {
-        ok: runResult.exitCode === 0 && !runResult.timedOut,
-        exitCode: runResult.exitCode,
+        ok: effectiveExitCode === 0 && !runResult.timedOut,
+        exitCode: effectiveExitCode,
         stdout: runResult.stdout,
-        stderr: runResult.stderr,
+        stderr: effectiveStderr,
         timedOut: runResult.timedOut,
         receipt,
         errorClass: receipt.errorClass,
@@ -992,22 +1027,26 @@ export async function createPlaywrightCliTool(ctx) {
 export const PI_COMMAND_CAPABILITY_REGISTRY = {
     "playwright-cli": createPlaywrightCliTool,
 };
-export function resolveCaseIdFromWriteSet(writeSet) {
+export function resolveCaseIdFromWriteSet(writeSet, layout = defaultFrontendTestLayout()) {
+    const prefix = layout.evidenceDir.replace(/\/$/, "");
+    const escaped = escapeRegexLiteral(prefix);
+    const exact = new RegExp(`^${escaped}/([^/]+)(?:/\\*\\*)?$`);
+    const nested = new RegExp(`^${escaped}/([^/]+)/`);
     for (const entry of writeSet ?? []) {
         const normalized = normalizePosix(entry);
-        const match = normalized.match(/^testcase\/frontend\/evidence\/([^/]+)(?:\/\*\*)?$/);
+        const match = normalized.match(exact);
         if (match?.[1] && match[1] !== "**" && match[1] !== "*") {
             return match[1];
         }
-        const nested = normalized.match(/^testcase\/frontend\/evidence\/([^/]+)\//);
-        if (nested?.[1])
-            return nested[1];
+        const nestedMatch = normalized.match(nested);
+        if (nestedMatch?.[1])
+            return nestedMatch[1];
     }
     return undefined;
 }
-export function resolveEvidenceDirFromWriteSet(writeSet) {
-    const caseId = resolveCaseIdFromWriteSet(writeSet);
+export function resolveEvidenceDirFromWriteSet(writeSet, layout = defaultFrontendTestLayout()) {
+    const caseId = resolveCaseIdFromWriteSet(writeSet, layout);
     if (!caseId)
         return undefined;
-    return `testcase/frontend/evidence/${caseId}`;
+    return `${layout.evidenceDir}/${caseId}`;
 }

package/dist/executors/shell-executor.js

@@ -30,6 +30,7 @@ import { materializeFrontendLintAssessment, materializeFrontendLintBaseline, } f
 import { formatTraceabilityGateStdout, materializeBackendTestCaseManifest, runBackendTestTraceabilityGate, } from "../workflows/dag/backend-test-case-manifest.js";
 import { materializeBackendTestExecutionContract } from "../workflows/dag/backend-test-execution-contract.js";
 import { resolveBackendTestLayout } from "../workflows/dag/backend-test-layout.js";
+import { frontendTestLayoutFromSpec, } from "../workflows/dag/frontend-test-layout.js";
 import { backendTestGapDocSchema, ingestBackendTestGap, } from "../workflows/dag/backend-test-gap-fill.js";
 import { analyzeBackendTestCaseCoverage, analyzeBackendTestMarkdownPytestCorrespondence, materializeBackendTestCaseManifestFromFacts, } from "../workflows/dag/backend-test-case-coverage-analysis.js";
 import { materializeBackendTestResultFromPytestHtml, materializeBackendTestResultFromRunDir, parsePytestHtmlReport, } from "../workflows/dag/backend-test-result-contract.js";
@@ -2019,10 +2020,12 @@ async function executeFrontendVerificationBundle(input, meta) {
 async function executeFrontendTestCaseChecklist(input, meta) {
     const started = Date.now();
     try {
+        const layout = frontendTestLayoutFromSpec(meta.spec);
         const declaredAcIds = (meta.spec.sourceBinding?.requirementIds ?? []).filter((id) => /^AC(?:-[A-Z0-9]+)+$/i.test(id));
         const result = await validateFrontendCaseChecklist({
             workspaceRoot: input.cwd,
             declaredAcIds,
+            layout,
         });
         if (result.issues.length) {
             return {
@@ -2057,6 +2060,7 @@ async function executeFrontendTestL5Report(input, meta) {
         const output = await renderFrontendTestL5Report({
             workspaceRoot: input.cwd,
             runDir: meta.runDir,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         return {
             ok: true,
@@ -2082,6 +2086,7 @@ async function executeFrontendTestHtmlReport(input, meta) {
         const output = await renderFrontendTestHtmlReport({
             workspaceRoot: input.cwd,
             runDir: meta.runDir,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         return {
             ok: true,
@@ -2101,11 +2106,12 @@ async function executeFrontendTestHtmlReport(input, meta) {
         };
     }
 }
-async function executeFrontendTestStandardScenarios(input) {
+async function executeFrontendTestStandardScenarios(input, meta) {
     const started = Date.now();
     try {
         const result = await copyFrontendTestStandardScenarios({
             workspaceRoot: input.cwd,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         return {
             ok: true,
@@ -2125,10 +2131,11 @@ async function executeFrontendTestStandardScenarios(input) {
         };
     }
 }
-async function executeFrontendTestEnvironmentProbe(input) {
+async function executeFrontendTestEnvironmentProbe(input, meta) {
     const started = Date.now();
     const result = await probeFrontendTestEnvironment({
         workspaceRoot: input.cwd,
+        layout: frontendTestLayoutFromSpec(meta.spec),
     });
     if (result.ok) {
         return {
@@ -2147,11 +2154,12 @@ async function executeFrontendTestEnvironmentProbe(input) {
         durationMs: Date.now() - started,
     };
 }
-async function executeFrontendTestEvidenceValidation(input) {
+async function executeFrontendTestEvidenceValidation(input, meta) {
     const started = Date.now();
     try {
         const result = await validateFrontendCaseEvidence({
             workspaceRoot: input.cwd,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         const output = `frontend case evidence validation cases=${result.cases} findings=${result.issues.length}${result.issues.length ? ` issues=${JSON.stringify(result.issues)}` : ""}`;
         if (result.hardFail) {
@@ -2190,6 +2198,7 @@ async function executeFrontendTestCaseManifest(input, meta) {
         const checklist = await validateFrontendCaseChecklist({
             workspaceRoot: input.cwd,
             declaredAcIds,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         if (checklist.issues.length) {
             return {
@@ -2204,6 +2213,7 @@ async function executeFrontendTestCaseManifest(input, meta) {
             workspaceRoot: input.cwd,
             maxCases: gate.maxCases,
             declaredAcIds,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         return {
             ok: true,
@@ -2242,6 +2252,7 @@ async function executeFrontendTestResultFinalize(input, meta) {
     try {
         const evidence = await validateFrontendCaseEvidence({
             workspaceRoot: input.cwd,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         advisoryStdout = `frontend case evidence validation cases=${evidence.cases} findings=${evidence.issues.length}${evidence.issues.length ? ` issues=${JSON.stringify(evidence.issues)}` : ""}`;
         // Advisory findings must not block materialize; only hardFail (path escape) does.
@@ -2260,6 +2271,7 @@ async function executeFrontendTestResultFinalize(input, meta) {
             artifactName: "frontend-test-result.json",
             outputDir: "contracts",
             sourceBinding: meta.spec.sourceBinding,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         return {
             ok: true,
@@ -2298,12 +2310,14 @@ async function executeFrontendTestReports(input, meta) {
             const l5 = await renderFrontendTestL5Report({
                 workspaceRoot: input.cwd,
                 runDir: meta.runDir,
+                layout: frontendTestLayoutFromSpec(meta.spec),
             });
             lines.push(`Frontend L-5 report: ${l5.htmlPath}\nMarkdown: ${l5.markdownPath}\nStatus: ${l5.metrics.status}`);
         }
         const report = await renderFrontendTestHtmlReport({
             workspaceRoot: input.cwd,
             runDir: meta.runDir,
+            layout: frontendTestLayoutFromSpec(meta.spec),
         });
         lines.push(`Frontend test report: ${report.htmlPath}\nMarkdown: ${report.markdownPath}\nOutcome: ${report.outcome}\nCases: ${report.caseCount}`);
         return {
@@ -2495,10 +2509,10 @@ async function executeDagShellNodeInner(input, meta) {
         }
     }
     if (shell?.frontendTestStandardScenarios) {
-        return executeFrontendTestStandardScenarios(input);
+        return executeFrontendTestStandardScenarios(input, meta);
     }
     if (shell?.frontendTestEnvironmentProbe) {
-        return executeFrontendTestEnvironmentProbe(input);
+        return executeFrontendTestEnvironmentProbe(input, meta);
     }
     if (shell?.frontendBrowserToolPreflight) {
         const started = Date.now();
@@ -2554,14 +2568,16 @@ async function executeDagShellNodeInner(input, meta) {
                 label: "Pi SDK custom-tool 能力",
                 ok: true,
             });
+            const layout = frontendTestLayoutFromSpec(meta.spec);
             const toolProbe = await createPlaywrightCliTool({
                 repoRoot: input.cwd,
                 runDir: meta.runDir,
                 nodeId: input.task.id,
                 caseId: "frontend-browser-preflight",
-                evidenceDir: "testcase/frontend/evidence/frontend-browser-preflight",
+                evidenceDir: `${layout.evidenceDir}/frontend-browser-preflight`,
                 baseUrl: "http://localhost:5173/",
-                inputRoot: "testcase/frontend/fixtures",
+                inputRoot: layout.fixturesDir,
+                layout,
             });
             if (toolProbe.name !== "playwright_cli") {
                 steps.push({
@@ -2703,7 +2719,7 @@ async function executeDagShellNodeInner(input, meta) {
         return executeFrontendTestCaseManifest(input, meta);
     }
     if (shell?.frontendTestEvidenceValidation) {
-        return executeFrontendTestEvidenceValidation(input);
+        return executeFrontendTestEvidenceValidation(input, meta);
     }
     if (shell?.frontendTestResultFinalize) {
         return executeFrontendTestResultFinalize(input, meta);
@@ -2810,6 +2826,7 @@ async function executeDagShellNodeInner(input, meta) {
                         artifactName: gate.artifactName,
                         outputDir: gate.outputDir,
                         sourceBinding: meta.spec.sourceBinding,
+                        layout: frontendTestLayoutFromSpec(meta.spec),
                     });
                     break;
                 default:

package/dist/shared/playwright-cli-command-policy.js

@@ -9,6 +9,7 @@ export const PLAYWRIGHT_CLI_ALLOWED_COMMANDS = [
     "goto",
     "snapshot",
     "find",
+    "find-unique",
     "click",
     "dblclick",
     "fill",
@@ -35,6 +36,20 @@ export const PLAYWRIGHT_CLI_ALLOWED_COMMANDS = [
     "requests",
     "request",
 ];
+/**
+ * Parse the match count from a playwright-cli find output. The CLI prints
+ * `Found N match(es) for "...":` on success and `No matches found for "...".`
+ * on zero — both with exit code 0, so the count is the only assertion signal.
+ * Returns undefined when the output shape is unrecognized (e.g. error pages).
+ */
+export function parsePlaywrightCliFindMatchCount(output) {
+    const found = /Found\s+(\d+)\s+match(?:es)?\s+for\b/i.exec(output);
+    if (found)
+        return Number(found[1]);
+    if (/No matches found for\b/i.test(output))
+        return 0;
+    return undefined;
+}
 const allowedCommandSet = new Set(PLAYWRIGHT_CLI_ALLOWED_COMMANDS);
 export function isPlaywrightCliCommand(value) {
     return allowedCommandSet.has(value);

package/dist/task/config-types.js

@@ -87,6 +87,12 @@ export const frontendOpenspecConfigSchema = z.object({
 /** Batch limits and gate profile for the browser-driven frontend test DAG.
  * Token fields are post-case stop thresholds, not model-provider hard caps. */
 export const frontendTestConfigSchema = z.object({
+    /**
+     * Repository-relative frontend-test artifact root.
+     * Default "testcase/frontend". Semantic validation lives in
+     * resolveFrontendTestLayout (fail-closed), not in this schema.
+     */
+    testRoot: z.string().min(1).optional(),
     maxCasesPerBatch: z.number().int().min(1).max(50).optional(),
     maxTokensPerCase: z.number().int().positive().optional(),
     maxTotalTokens: z.number().int().positive().optional(),

package/dist/task/source-prepare/parse-intent.js

@@ -35,8 +35,15 @@ const HEADING_ALIASES = {
     assumptions: new Set(["假设", "assumptions"]),
 };
 const OBJECTIVE_MAX_CHARS = 1200;
-/** Product Requirement V3/V4 style embedded AC heading, e.g. AC-FE-001 / AC-BE-12 / AC-001. */
-const EMBEDDED_AC_HEADING = /^(AC(?:[-_](?:FE|BE|UI|API))?[-_]?\d+(?:[-_]\d+)?)\s*[:：]?\s*(.*)$/iu;
+/**
+ * Product Requirement V3/V4 style embedded AC heading, e.g. AC-FE-001 /
+ * AC-BE-12 / AC-001 — and catalog-qualified feature segments such as
+ * AC-FE-INS-001 / AC-FE-CHAT-005 (uppercase letter/digit segments).
+ * Catalog ids embedded in bold (“**AC-FE-INS-001**：…”) must bind as-is;
+ * falling through to a minted AC-00N historically produced dual ids and
+ * acceptanceCoverage.missing noise (2026-08-23 fe-test loop finding 5).
+ */
+const EMBEDDED_AC_HEADING = /^(AC(?:[-_](?:FE|BE|UI|API))?[-_]?[A-Z0-9]+(?:[-_][A-Z0-9]+)*)\s*[:：]?\s*(.*)$/u;
 function stripFencedAndComments(text) {
     // Remove fenced code blocks and HTML comments so headings inside them are ignored.
     return text
@@ -52,12 +59,25 @@ function normalizeAcceptanceId(raw) {
         .replace(/^(AC)(FE|BE|UI|API)(?=-|\d)/u, "$1-$2");
 }
 function parseEmbeddedAcHeading(headingText) {
-    const normalized = headingText.trim().replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "");
+    const normalized = headingText
+        .trim()
+        // Strip leading section numbers ("2.1、" style) and bold/emphasis
+        // wrappers ("**AC-FE-INS-001**") so embedded catalog ids bind.
+        .replace(/^(?:\d+(?:\.\d+)*[.．、]?\s*)+/u, "")
+        .replace(/^\*\*|\*\*$/g, "")
+        .replace(/^__|__$/g, "")
+        .trim();
     const match = EMBEDDED_AC_HEADING.exec(normalized);
     if (!match)
         return null;
     const id = normalizeAcceptanceId(match[1]);
-    const text = match[2]?.trim() || id;
+    // Bold-wrapped ids leave their closing marker inside the captured text
+    // ("**AC-FE-INS-001**：xxx" captures "**：xxx"); strip emphasis remnants
+    // and leading separators so the bound text is clean prose.
+    const text = (match[2] ?? "")
+        .replace(/^[*_]+\s*/, "")
+        .replace(/^\s*[:：]\s*/, "")
+        .trim() || id;
     return { id, text };
 }
 function normalizeHeadingText(raw) {

package/dist/worker/console/chat/pi-console-config.js

@@ -1,6 +1,13 @@
 import { createHash, randomBytes } from "node:crypto";
 import { open, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+/** 新建模型时，未显式提供的字段使用的默认值（仅含 6 个定义参数）。 */
+const DEFAULT_MODEL_FIELDS = {
+    contextWindow: 32000,
+    maxTokens: 8192,
+    reasoning: false,
+    input: ["text"],
+};
 const revision = (raw) => createHash("sha256").update(raw).digest("hex");
 export async function readModelsConfig(agentDir) {
     let raw = "{}";
@@ -29,6 +36,18 @@ export async function readModelsConfig(agentDir) {
                     return {
                         id: String(item.id ?? ""),
                         name: typeof item.name === "string" ? item.name : undefined,
+                        contextWindow: typeof item.contextWindow === "number"
+                            ? item.contextWindow
+                            : undefined,
+                        maxTokens: typeof item.maxTokens === "number"
+                            ? item.maxTokens
+                            : undefined,
+                        input: Array.isArray(item.input)
+                            ? item.input.filter((entry) => typeof entry === "string")
+                            : undefined,
+                        reasoning: typeof item.reasoning === "boolean"
+                            ? item.reasoning
+                            : undefined,
                     };
                 })
                     .filter((model) => model.id)
@@ -81,19 +100,25 @@ export async function patchModelsConfig(agentDir, input) {
                 code: "INVALID_INPUT",
                 status: 400,
             });
+        const fields = validateModelFields(input.model);
+        const existingIndex = models.findIndex((model) => model.id === input.model.id);
+        const merged = {
+            // id/name 在前；新建模型用默认字段补齐（保证定义完整），更新保留已有值。
+            id: input.model.id,
+            ...(fields.name !== undefined ? { name: fields.name } : {}),
+            ...(existingIndex >= 0 ? models[existingIndex] : DEFAULT_MODEL_FIELDS),
+            ...fields,
+        };
         provider.models =
             input.action === "remove-model"
                 ? models.filter((model) => model.id !== input.model.id)
-                : [
-                    ...models.filter((model) => model.id !== input.model.id),
-                    {
-                        ...(models.find((model) => model.id === input.model.id) ?? {}),
-                        id: input.model.id,
-                        ...(input.model.name !== undefined
-                            ? { name: input.model.name }
-                            : {}),
-                    },
-                ];
+                : existingIndex >= 0
+                    ? [
+                        ...models.slice(0, existingIndex),
+                        merged,
+                        ...models.slice(existingIndex + 1),
+                    ]
+                    : [...models, merged];
     }
     const body = `${JSON.stringify(parsed, null, 2)}\n`;
     const tmp = path.join(agentDir, `.models.${process.pid}.${randomBytes(4).toString("hex")}.tmp`);
@@ -108,6 +133,52 @@ export async function patchModelsConfig(agentDir, input) {
     await rename(tmp, file);
     return readModelsConfig(agentDir);
 }
+/** Whitelist + validate model fields carried by a client upsert. Never accept
+ *  arbitrary keys; only known numeric/boolean/string-array shape fields. */
+function validateModelFields(model) {
+    const fields = {};
+    if (model.name !== undefined)
+        fields.name = String(model.name);
+    if (model.contextWindow !== undefined) {
+        if (typeof model.contextWindow !== "number" || model.contextWindow < 0)
+            throw invalid("contextWindow must be a non-negative number");
+        fields.contextWindow = model.contextWindow;
+    }
+    if (model.maxTokens !== undefined) {
+        if (typeof model.maxTokens !== "number" || model.maxTokens < 0)
+            throw invalid("maxTokens must be a non-negative number");
+        fields.maxTokens = model.maxTokens;
+    }
+    if (model.reasoning !== undefined) {
+        if (typeof model.reasoning !== "boolean")
+            throw invalid("reasoning must be a boolean");
+        fields.reasoning = model.reasoning;
+    }
+    if (model.input !== undefined) {
+        if (!Array.isArray(model.input) ||
+            !model.input.every((item) => typeof item === "string"))
+            throw invalid("input must be an array of strings");
+        fields.input = model.input.map((item) => String(item));
+    }
+    if (model.cost !== undefined) {
+        if (!model.cost || typeof model.cost !== "object")
+            throw invalid("cost must be an object");
+        const cost = {};
+        for (const key of ["input", "output", "cacheRead", "cacheWrite"]) {
+            const value = model.cost[key];
+            if (value !== undefined) {
+                if (typeof value !== "number" || value < 0)
+                    throw invalid(`cost.${key} must be a non-negative number`);
+                cost[key] = value;
+            }
+        }
+        fields.cost = cost;
+    }
+    return fields;
+}
+function invalid(message) {
+    return Object.assign(new Error(message), { code: "INVALID_INPUT", status: 400 });
+}
 /** Max bytes of a package.json we are willing to read (read-only, bounded). */
 export const MAX_PACKAGE_JSON_BYTES = 64 * 1024;
 /** Max directory levels walked upward from an owned resolved resource path. */