@tea-agent/loop-agent 0.39.0-next.31 → 0.39.0-next.33

package/CHANGELOG.md

@@ -4,6 +4,11 @@
 
 ### 重点更新
 
+- 修复 Console 四处评审缺陷（合并前收口）：① 向导「运行」进度块接通——`runDag` 只返回 operationId，原实现读的 `recovery.dagRunId` 在向导路径永远为空；现在确认页先快照基线 run、进入运行页后轮询 `observeLink`，以 (taskId, operationId) 任一变化为失效信号（operationId 覆盖「重新运行」按钮——它不改变向导步骤；taskId 覆盖运行步骤中手动改任务 ID 的场景，失效时基线一并重置，避免沿用上一任务的 run）：新派发/切任务会清掉旧选中 run 并重新解析，**只接受与当前任务基线不同的新 run**；从 Recovery 带回的共享选中 run 先做归属校验——`GET /api/dag-runs/:id` 详情响应新增 `taskId` 投影（源自 run.json 的 `taskContractBinding`→`sourceBinding`→Hybrid 标题，与 observeLink/candidates 同一绑定真源，不受候选列表 limit 截断影响；404 视为失效选中、无绑定视为不可判定），非本任务的 run 不展示；校验全程由 effect 生命周期栅栏保护——任务/运行/选中在异步校验期间变化时，旧响应直接丢弃、不会改写新状态；校验暂不可用时按有界退避（2s→30s，约 2 分钟）自动重试而非被动等待状态变化，重试计划为纯函数并有行为测试；**展示层另有闸门**——进度面板与运行操作只消费「本解析器已采纳/已验证」的 run（组件 state），未验证期间（校验中、重试中、give-up 后）进度面板保持空缺，不会即时或永久显示其他任务的 DAG；「打开检视」「侧栏预览」两个入口同样双重门禁（按钮无已验证 run 即禁用 + 处理器复核 verifiedRunId），共享的 openInspectSplit 解析器不再能带出未验证的外来 run。解析决策本身抽取为纯状态机 `pages/tasks/run-id-resolution.ts`（首跑/重跑/切任务/外来选中/基线门控五类迁移），Effects 只做薄适配，主流程「确认页基线快照 → runDag 派发 → observeLink 轮询 → 新 run 采纳」有完整行为测试。基线快照为三态（成功/权威无运行/暂不可查），**查询失败不会被当成「没有历史运行」**——快照重试期间基线保持未知、探测轮询等待，不会把旧运行误判为新运行；新 run 创建失败或注册较慢时进度面板宁可空缺也不把上一次已终止的 DAG 当作当前运行（轮询上限 5 分钟后安静停止）。② 失败建议数据契约修正——旅程卡原先把原始 run 级 `failureCategory` 直接查归一化建议表（`missing-api-key`/`nonzero-exit` 等永远查不中，节点分类又在安全投影中被丢弃）；现在纯分类核心下沉 `src/shared/dag-failure-category.ts`（console↔workflows 双向共享叶，不破坏 console 禁止 import workflows 的边界测试），服务端投影把 run 级与节点级分类都归一化输出（success/skipped 不出），卡片按「失败节点分类优先、run 级兜底」取值，失败卡始终有可操作建议。③ Recovery interrupt 资格轮询在运行中档位同步刷新 run 状态——原先状态只在选中时读一次，运行中的 run 结束后仍永久保持 4 秒快轮询；现在 4 秒档附带轻量 `GET /api/dag-runs/:id` 刷新 `effectiveStatus`，终态后自动退到 30 秒。④ Inspect 紧凑检视一次瞬时刷新失败不再永久显示错误——成功刷新回合会清除上一轮 error 横幅。
+- Operator Chat 输入框两项交互增强：① **↑/↓ 历史输入召回**——每次发送的文本进入输入历史（连续重复折叠、上限 100 条），光标在首行按 ↑ 逐条向旧回溯、按 ↓ 向新前进，越过最新一条时恢复回溯前**未发送的草稿**（草稿不会被历史浏览冲掉）；多行文本中部的方向键仍是普通光标移动，IME 组词与 @文件/命令面板打开时不抢占。② **运行中排队下一轮指令**——当前回合运行中 Enter 不再被吞掉，消息作为「排队消息」绑定当前 Turn（服务端 `PUT deferred-turn` 从仅限 stopping 放开为 running/stopping，错误码 `TURN_NOT_STOPPING`→`TURN_NOT_ACTIVE`），当前回合结束（正常完成或停止）后自动发送；排队条提供「立即发送」（停止当前回复并立即发出）、「编辑」（移回输入框改写后再排）、「删除」三种操作，运行中输入框右侧提供排队发送按钮（与停止按钮并列）；排队条单行展示（状态 + 省略号预览 + 操作按钮一行），输入框默认一行高（自动增高上限 280px 不变）。
+- 向导「运行」面板结构化与预期管理（A2/C9）：新增实时运行进度块——节点完成计数与百分比进度条（含 progressbar 无障碍语义）、当前运行节点名称与已运行时长、失败节点与错误摘要，数据来自 `/api/dag-runs/:id` 每 5 秒轮询并在终态自动停止；`effectiveStatus=running-suspected-stall` 时显示橙色「疑似停滞」提示条（建议打开检视查看节点活动或到恢复页协作中止/诊断），把 20–40 分钟长跑的「日志噪音等待」变为有阶段感、可判断的等待。原始 SSE 事件日志默认折叠为「原始事件日志（最近 80 条）」，需要排查时再展开。
+- Console 前端三项体验优化（P0/P2）：① Recovery 页 DAG 紧凑检视侧栏（InspectSplitPanel）从一次性快照改为实时刷新——运行中每 5 秒自动拉取节点/事件并新增「进行中/已结束」刷新状态行，到达终态（finished/failed/partial_failed/superseded/abandoned）自动停止轮询，刷新轮不清空既有内容避免闪烁；② Chat 任务旅程卡失败态新增按归一化 failureCategory 的可操作「建议」行（validation/executor/write-guard/timeout/auth/human-required/human-rejected/shell-command/static-error/decision-envelope/unknown 各映射到具体下一步：从失败节点重跑、修正契约后重新生成、跳「模型与认证」页等），不再只报「原因分类为 X」；③ Recovery 页 interrupt 资格轮询退避：选中 run 已终态（含 interrupted）时从 4 秒降到 30 秒，运行中保持 4 秒。
+- 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。
@@ -22,6 +27,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": "9c8a26e4c446c1e299e8557cbbd19fe1096b4612",
-  "builtAt": "2026-08-23T04:17:57.293Z"
+  "version": "0.39.0-next.33",
+  "gitSha": "3a40d2f56f5b7d83ab97b7c031dc20932f95d1b6",
+  "builtAt": "2026-08-23T12:58:20.258Z"
 }

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

@@ -5,6 +5,7 @@ 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, 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";
@@ -267,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}`);
@@ -291,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");
     }
@@ -472,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) + "/")) {
@@ -629,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) ||
@@ -1024,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/dag-failure-category.js

@@ -0,0 +1,138 @@
+/**
+ * Pure DAG failure-category classification shared by the workflows kernel and
+ * the Operator Console projection (console sources may not import
+ * src/workflows — security-and-tools boundary test).
+ *
+ * No runtime imports: this module is a leaf safe for both the CLI kernel and
+ * the browser bundle.
+ */
+export const DAG_NORMALIZED_FAILURE_CATEGORY_VALUES = [
+    "success",
+    "validation",
+    "executor",
+    "write-guard",
+    "timeout",
+    "auth",
+    "human-required",
+    "human-rejected",
+    "shell-command",
+    "static-error",
+    "decision-envelope",
+    "skipped",
+    "unknown",
+];
+const RAW_TO_NORMALIZED = {
+    success: "success",
+    "write-guard": "write-guard",
+    timeout: "timeout",
+    // Clean implementer stall with zero writes — still a timeout class for report,
+    // but retryable under WRITER_TRANSPORT_RETRY_POLICY.
+    "writer-clean-timeout": "timeout",
+    "missing-api-key": "auth",
+    auth: "auth",
+    "human-rejected": "human-rejected",
+    "human-required": "human-required",
+    "decision-envelope-invalid": "decision-envelope",
+    "nonzero-exit": "shell-command",
+    "spawn-error": "shell-command",
+    "test-timeout": "timeout",
+    "static-error": "static-error",
+    "invalid-output": "validation",
+    "structured-output-truncated": "validation",
+    "output-too-large": "validation",
+    "structured-repair-exhausted": "validation",
+    "governance-blocked": "validation",
+    "path-violation": "validation",
+    "empty-output": "validation",
+    "verify-failure": "validation",
+    "test-failure": "validation",
+    "verification-plan-stale": "validation",
+    network: "executor",
+    quota: "executor",
+    "rate-limit": "executor",
+    unavailable: "executor",
+    // Deterministic capability/policy refusal: missing verified launcher JS
+    // entry, capability allowlist rejection, or missing bounded write tool
+    // profile. These are environment/config defects the operator repairs
+    // before rerunning; classify as executor so recovery recommends
+    // rerun-after-fix WITHOUT forcing a human-decision gate on
+    // standaloneTaskRerun (run-failed same-task rerun).
+    "tool-policy": "executor",
+    unknown: "unknown",
+};
+/** Status inputs are deliberately `string`: projection layers pass bounded
+ *  text from CLI JSON; unmatched values simply fall through to unknown. */
+function isFinishedStatus(status) {
+    return status === "FINISHED" || status === "finished";
+}
+function isInProgressStatus(status) {
+    return (status === "PENDING" ||
+        status === "RUNNING" ||
+        status === "pending" ||
+        status === "running");
+}
+function isFailureStatus(status) {
+    return (status === "ERROR" ||
+        status === "failed" ||
+        status === "partial_failed");
+}
+function mapRawCategory(raw) {
+    const direct = RAW_TO_NORMALIZED[raw];
+    if (direct)
+        return direct;
+    const lower = raw.toLowerCase();
+    if (lower.includes("timeout"))
+        return "timeout";
+    if (lower.includes("validation") ||
+        lower.includes("invalid") ||
+        lower.includes("verification-plan-stale") ||
+        lower.includes("plan-stale"))
+        return "validation";
+    if (lower.includes("auth") || lower.includes("api-key"))
+        return "auth";
+    if (lower.includes("write-guard") || lower.includes("write_guard"))
+        return "write-guard";
+    if (lower.includes("decision-envelope") || lower.includes("decision_envelope"))
+        return "decision-envelope";
+    if (lower.includes("human-rejected"))
+        return "human-rejected";
+    if (lower.includes("human-required"))
+        return "human-required";
+    if (lower.includes("static-error"))
+        return "static-error";
+    if (lower.includes("nonzero-exit") ||
+        lower.includes("spawn-error") ||
+        lower.includes("shell"))
+        return "shell-command";
+    return undefined;
+}
+export function isDagFailureCategory(value) {
+    return DAG_NORMALIZED_FAILURE_CATEGORY_VALUES.includes(value);
+}
+export function normalizeDagFailureCategory(raw, status) {
+    if (status === "SKIPPED") {
+        return "skipped";
+    }
+    if (raw !== undefined) {
+        const mapped = mapRawCategory(raw);
+        if (mapped) {
+            if (mapped === "success") {
+                return isFinishedStatus(status) ? "success" : "unknown";
+            }
+            return mapped;
+        }
+    }
+    if (raw === undefined && isFinishedStatus(status)) {
+        return "success";
+    }
+    if (isInProgressStatus(status)) {
+        return "unknown";
+    }
+    if (isFailureStatus(status)) {
+        return "unknown";
+    }
+    if (raw === "success" && isFinishedStatus(status)) {
+        return "success";
+    }
+    return "unknown";
+}

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/worker/console/chat/operation-card.js

@@ -64,7 +64,14 @@ function safeRunSummary(value) {
             const status = String(node.status ?? "");
             if (!id || !status)
                 return [];
-            return [{ id, status }];
+            const failureCategory = String(node.failureCategory ?? "");
+            return [
+                {
+                    id,
+                    status,
+                    ...(failureCategory ? { failureCategory } : {}),
+                },
+            ];
         })
             .slice(0, 20);
     }

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. */

package/dist/worker/console/chat/routes.js

@@ -728,13 +728,15 @@ export async function handlePutDeferredTurn(req, res, deps, sessionId) {
         return;
     }
     const active = deps.events.getActiveTurn(sessionId);
-    if (!active || !active.abortRequestedAt || active.turnId !== blockedByTurnId) {
+    // Queueing binds to the active Turn (running OR stopping); the durable
+    // follow-up auto-dispatches when that Turn reaches a terminal state.
+    if (!active || active.turnId !== blockedByTurnId) {
         sendJson(res, 409, {
             ok: false,
             accepted: false,
             error: {
-                code: "TURN_NOT_STOPPING",
-                message: "只有仍在停止中的当前 Turn 可以保存停止后发送消息",
+                code: "TURN_NOT_ACTIVE",
+                message: "没有匹配的运行中 Turn，无法保存待发送消息",
             },
             activeTurn: active ? turnSummary(active) : null,
         });