@tea-agent/loop-agent 0.44.0-next.10 → 0.44.0-next.12

package/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### 新增
 
+- 前端 DAG 的行为验证不再只认 Vitest：测试框架改为可插拔适配层，首批支持 Vitest、Jest 与 Playwright Test。三类项目都能用**真实报告**证明契约绑定的测试文件确实执行且通过，`npm`/`pnpm`/`yarn` 的常用测试入口走同一套识别逻辑，直接命令与 `package.json` 脚本不会再得出不同结论。
+- 未适配的测试框架（Cypress、`node --test`、Mocha、自定义脚本等）现在明确报「缺少适配能力」，并附上具体命令与原因；此前这类命令会被判为不支持，错误信息还暗示你「必须改用 Vitest」，把工具的能力缺口显示成了用户配置错误。
+- 行为验证保留「测试确实执行过」的校验：零测试、全部跳过、报告缺失、报告过期、契约绑定文件未执行都判失败，不会退回只看退出码（全部跳过的运行退出码是 0）。
+
 - main 上的 npm `next` 预发布改为跑默认测试（fast + integration），不再在每次发布时重复跑约 6 分钟的 I/O-heavy 池；完整三池仍由 PR、正式 release 线、本地推送前检查与发布前钩子承担。同时把该预发布任务的 I/O 并发从 1 调到 2，并把 npm 包可见性确认的等待窗口从约 3 分钟拉长到约 10 分钟，避免包已发出却因仓库异步处理未完成而被判失败。
 
 - 修复 main 分支的 next 发布链在类型检查阶段内存溢出失败的问题：完整源码与测试的类型图已超过 Node 默认约 2 GiB 堆上限，类型检查进程因此中止（exit 134），导致 `next` 发布无法完成。此前该上限只在部分验证入口生效，其余入口直接运行类型检查就会因默认堆不足而失败；现把上限固化到类型检查命令本身，各验证入口与本地开发统一生效，不再依赖各入口自行声明。
@@ -137,6 +141,7 @@
 
 ### 改进
 
+- DAG 运行时内部按职责拆开：模型配置、领域工具、分段会话、模板族、终态判定与检查点各自独立维护，测试也按行为分成可单独调度的文件。命令、任务流程与用户可见结果不变。本机默认测试并行下整池耗时未证实变快。
 - Operator Chat 输入框下方的会话统计对齐 DSH：长串静态文字收敛为两个可点击摘要，可分别查看模型/工具用时、TTFT、TPS 与 Token 分项；详情卡互斥并支持外部点击或 Escape 关闭，窄屏打开时不会推动输入框或消息流。
 - Operator Chat 长会话新增完整轮次轨道与按需历史定位，可从任意用户消息精确新建会话；历史图片刷新后仍可预览，仓库文件链接可直接定位到行，最终回答显示单轮 token/耗时，并支持可持久化的紧凑/完整阅读模式。图片文件与消息记录分离保存，删除、分叉和失败回滚会同步清理，附件读取重新校验类型与引用。
 - 本地分支合并默认只执行与影响面匹配的定向测试、类型检查、构建和治理检查；完整测试推迟到 push 或完整交付前，并通过 receipt、`verify:tree` 或 pre-push 在最终 tree 上只执行一次。发布与推送门禁仍包含 I/O-heavy 测试。
@@ -149,6 +154,12 @@
 
 ### 修复
 
+- 前端 DAG 的验证失败不再把配置问题算到业务代码头上：报告缺失或过期、报告协议错误、命令或脚本哈希漂移、框架未适配都归为验证配置问题，不再触发一轮无意义的实现重写；测试断言失败仍归实现问题。
+- 已经自带 `--reporter`/`--outputFile` 的测试命令或脚本不会被悄悄覆盖；无法安全注入报告参数时在生成阶段直接报错，要求改用可注入的入口。
+- 修复 Playwright 项目在 Review 阶段被误判失败的问题：审查重读报告时没有带上协议，仍按 Vitest 解析，导致 Playwright 报告因缺少 `testResults` 报错，即使执行与 trace 已经通过。report 引用现在记录协议，review 按同一协议解析并校验一致性。
+- 修复 Playwright 报告路径按 `testDir` 解析错误的问题：报告中的文件路径相对 Playwright 自身的 `config.rootDir`，此前按进程 cwd 解析，配了 `testDir: "./tests"` 的项目会得到 `orders.spec.js` 而非 `tests/orders.spec.js`，契约目标永远无法匹配。
+- 修复新建 Jest/Playwright 项目被误报“绑定漂移”的问题：`deferred` 观测的协议只是占位值，此前无条件参与比较，writer 一补上合法测试脚本就触发 `FRONTEND_TEST_BINDING_DRIFT`；现在只有已解析出 adapter 的观测才比较协议，真实脚本改动仍会被拦截。
+
 - 修复 macOS/Linux 开发路径在 Windows 暴露的三类兼容问题：前端组合验证夹具不再依赖 POSIX 单引号；无 `.gitmodules` 的仓库不再把 Git 空结果误判为启动失败；定时任务用 Git 规范化内容生成稳定树指纹，CRLF checkout 不再造成虚假 evidence drift。托管任务路径与嵌套 submodule 测试也统一使用跨平台路径语义。
 - 切换会话后，旧会话尚未确认的输入不会再出现在新会话中。
 - 修复 Windows 上 Pi 节点在没有提交改动时误报“文件在打开期间被替换”的问题，同时保留原有文件安全检查。

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.44.0-next.10",
-  "gitSha": "9ab06d59ee69d2e55b671bba52ee83e0362ec56f",
-  "builtAt": "2026-09-17T03:17:20.149Z"
+  "version": "0.44.0-next.12",
+  "gitSha": "91181001a8cbed75a00a8a6d8e76ae5fab889b36",
+  "builtAt": "2026-09-17T10:04:11.141Z"
 }

package/dist/executors/dag-pi/sessions/index.js

@@ -0,0 +1,6 @@
+/** DAG Pi 会话族兼容转发：既有测试从 entry 导入的符号统一经此转发，逐步迁移后移除。 */
+export { estimateFrontendPlanRequirementRecordCalls, batchFrontendPlanRequirements, FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY, FRONTEND_PLAN_BATCH_MAX_SESSIONS, mapWithConcurrency, buildFrontendPlanWorkload, collectFrontendPlanRequirementIds, loadOrCreateFrontendPlanCoverageLayout, collectFrontendVerificationCommandFiles } from "./plan-batches.js";
+export { compactFrontendPlanLedgerContext, compactFrontendPlanPromptForRequirementSlice } from "./plan-prompts.js";
+export { isPlannerThinkingExhausted, isWriterThinkingExhausted, readWriterThinkingExhaustionEvidence, WRITER_BUDGET_EXHAUSTED_CATEGORY, WRITER_TOKEN_BUDGET, WRITER_THINKING_EXHAUSTED_CATEGORY, PLANNER_THINKING_EXHAUSTED_CATEGORY } from "./writer-evidence.js";
+export { aggregateParallelPiResults, combineSequentialPiResults, runFrontendScoutParallelSessions } from "./scout-parallel.js";
+export { runFrontendContractSegmentedSessions, runFrontendPlanSegmentedSessions, runFrontendReviewSegmentedSessions, runFrontendScoutSegmentedSessions } from "./segmented-plan.js";

package/dist/executors/dag-pi/sessions/plan-batches.js

@@ -0,0 +1,280 @@
+/** DAG Pi 分段会话的批次规划：work 装配、批次上限、覆盖布局与并发映射。覆盖布局会读写 coverage-layout.json；禁止反向依赖执行器入口。 */
+import path from "node:path";
+import { readFile, stat } from "node:fs/promises";
+import { z } from "zod";
+import { FRONTEND_SCOPE_TARGET_BYTES, packFrontendInputUnits, parseFrontendInputBlock } from "../../../workflows/dag/frontend-input-projection.js";
+import { sha256OfCanonicalJson } from "../../../task/contract/hash.js";
+import { writeDagNodeJsonArtifact } from "../../../infrastructure/harness/artifact-store.js";
+import { isRecordObject } from "../guards.js";
+export const FRONTEND_PLAN_SEGMENTS = [
+    {
+        id: "coverage",
+        toolNames: new Set([
+            "record_plan_requirement",
+            "record_plan_group_coverage",
+            "record_plan_verification_target",
+            "record_plan_evidence_gap",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN PHASE — requirement coverage only.",
+            "Your ONLY job: for every frozen requirement, emit record_plan_requirement (requirement → implementation files) and record_plan_verification_target facts (verification target bound to requirement ids and files). Group related requirements under one non-static behavior target when one observable test behavior proves them together; do not mechanically create one target per requirement. Target ids identify contract entries, not test-title markers. Reuse affected existing test files and their names; do not add tests or rename titles just to carry generated ids. Never submit prose as a symbol. Do NOT record components, UI states, mock, dependency, or routes — a follow-up session owns those.",
+            "A coverage session is complete only when EVERY requirement assigned to this session (the full inventory, or the exact COVERAGE BATCH / shard list when present) has committed coverage facts: a record_plan_requirement entry plus verification targets, or a committed evidence gap. Keep committing in batches of up to 4 record_* calls per assistant message until then; do not write a concluding summary while any assigned requirement is still uncommitted — an early stop strands the remainder into a MISSING-FACT repair session and doubles the sessions needed.",
+            "If a requirement genuinely cannot have a verification target, record a non-empty record_plan_evidence_gap. Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "ux-registry",
+        toolNames: new Set(["record_state_registry", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global UX vocabulary.",
+            "Bootstrap the global UX vocabulary from the execution-group index and authoritative declared states. This is navigation, not permission to decide unseen behavior. Detailed complete scopes may extend the registry with replace:true while preserving live names. UI states use declaredUiStates ids when present. Interaction names are stable kebab-case behavior domains; merge requirements that describe the same behavior instead of renaming it per AC slice. Empty arrays explicitly declare that no UX vocabulary applies. Do not record component choices or state-flow details in this phase.",
+            "Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "ux-local",
+        toolNames: new Set([
+            "record_state_registry",
+            "record_component_choice",
+            "record_state_flow",
+            "record_plan_verification_target",
+            "adopt_staged_fact",
+        ]),
+        instruction: [
+            "PLAN PHASE — global UX decisions.",
+            "Requirements and verification targets are already committed in the ledger; do not re-record unchanged facts. Review the current complete execution-group scope and the committed global UX registry together, then record each component choice, UI state and interaction exactly once. Bind each applicable state to its verificationTargetIds; the runtime derives the reverse VT.uiStates relation. If a VT requires correction, record_plan_verification_target with replace:true is available after declaring its states; preserve its requirement coverage. Multiple requirements describing one behavior share one registry name and state-flow entry; never repeat or rename it per AC. Cross-cutting data flow belongs to the global Mock/data phase. Do not record routes, Mock/API policy, dependencies, or design deviations here.",
+            "Do not call finalize_plan; it is not available in this phase.",
+        ].join(" "),
+    },
+    {
+        id: "global-route",
+        toolNames: new Set(["record_route_selection", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global route decision.",
+            "Use the Scout target surface and record only the selected route(s). Do not record requirement-local UX, Mock/data, dependency, or deviation facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+    {
+        id: "global-mock-data",
+        toolNames: new Set(["record_data_flow", "record_mock_api", "record_mock_endpoint", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global Mock/API and data policy.",
+            "Record the cross-cutting interaction-to-endpoint data flow and Mock/API strategy only. Keep this decision set separate from route, component, state, dependency, and deviation facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+    {
+        id: "global-dependency-deviation",
+        toolNames: new Set(["record_dependency", "record_design_deviation", "adopt_staged_fact"]),
+        instruction: [
+            "PLAN PHASE — global dependency and design-deviation policy.",
+            "Record only dependency policy and design-evidence conflicts. Do not record route, Mock/data, or requirement-local UX facts. Do not call finalize_plan.",
+        ].join(" "),
+    },
+];
+export function estimateFrontendPlanRequirementRecordCalls(fact) {
+    const record = fact && typeof fact === "object" && !Array.isArray(fact)
+        ? fact
+        : {};
+    const declaredTargetCount = Array.isArray(record.verificationTargetIds)
+        ? record.verificationTargetIds.filter((value) => typeof value === "string" && value.trim()).length
+        : Array.isArray(record.verificationTargets)
+            ? record.verificationTargets.length
+            : 0;
+    const evidence = record.evidence && typeof record.evidence === "object"
+        ? record.evidence
+        : undefined;
+    const targetCount = Math.max(declaredTargetCount, evidence?.behavior === "required" ? 2 : 1);
+    return 1 + targetCount;
+}
+export function batchFrontendPlanRequirements(input) {
+    const batches = [];
+    let current = [];
+    let currentCost = 0;
+    for (const id of input.requirementIds) {
+        const cost = Math.max(1, input.requirementCosts?.get(id) ?? 2);
+        if (current.length > 0 &&
+            (currentCost + cost > input.maxEstimatedRecordCalls ||
+                (input.maxRequirements !== undefined &&
+                    current.length >= input.maxRequirements))) {
+            batches.push(current);
+            current = [];
+            currentCost = 0;
+        }
+        current.push(id);
+        currentCost += cost;
+    }
+    if (current.length > 0)
+        batches.push(current);
+    return batches;
+}
+export const FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS = 10;
+export const FRONTEND_PLAN_COVERAGE_MAX_CONCURRENCY = 4;
+export const FRONTEND_PLAN_BATCH_MAX_SESSIONS = 128;
+export const FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS = 8;
+export const FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS = 24;
+export async function mapWithConcurrency(items, limit, worker, shouldReduceConcurrency) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    let concurrency = Math.max(1, limit);
+    const running = new Map();
+    try {
+        while (nextIndex < items.length || running.size > 0) {
+            while (nextIndex < items.length && running.size < concurrency) {
+                const index = nextIndex++;
+                running.set(index, worker(items[index], index).then(result => ({ index, result })));
+            }
+            const { index, result } = await Promise.race(running.values());
+            running.delete(index);
+            results[index] = result;
+            // Drain existing work; only pending shards use the reduced cap.
+            // Failed shards remain failed and receive no extra retry allowance.
+            if (shouldReduceConcurrency(result))
+                concurrency = Math.max(1, Math.floor(concurrency / 2));
+        }
+    }
+    catch (error) {
+        await Promise.allSettled(running.values());
+        throw error;
+    }
+    return results;
+}
+export function collectFrontendVerificationCommandFiles(basePrompt) {
+    const files = new Set();
+    const configRe = /--config\s+([\w@./-]+\.(?:js|mjs|cjs|ts|json))/g;
+    const checkRe = /node\s+--check\s+([\w@./-]+\.(?:js|mjs|cjs))/g;
+    for (const re of [configRe, checkRe]) {
+        for (const match of basePrompt.matchAll(re)) {
+            const file = match[1];
+            if (file && file.includes("/"))
+                files.add(file);
+        }
+    }
+    return [...files].sort();
+}
+export function countFrontendPlanTargetSurfaces(basePrompt) {
+    const match = /<frontend_plan_input>[\s\S]*?<\/frontend_plan_input>/.exec(basePrompt);
+    if (!match)
+        return undefined;
+    for (const line of match[0].split(/\r?\n/)) {
+        try {
+            const payload = JSON.parse(line);
+            if (Array.isArray(payload.targetSurface))
+                return payload.targetSurface.length;
+        }
+        catch {
+            // surrounding lines are prose
+        }
+    }
+    return undefined;
+}
+export function buildFrontendPlanWorkload(input) {
+    const allRequirementIds = input.requirementIds;
+    const compiledInput = parseFrontendInputBlock(input.basePrompt, "plan")?.payload;
+    const fullUnits = new Map(compiledInput?.requirements.map(r => [r.id, r]) ?? []);
+    const declaredGroups = Array.isArray(compiledInput?.executionGroups)
+        ? compiledInput.executionGroups.filter(isRecordObject) : [];
+    const workGroups = declaredGroups.map(g => ({
+        id: String(g.id), kind: String(g.kind),
+        requirementIds: Array.isArray(g.requirementIds)
+            ? g.requirementIds.filter((id) => typeof id === "string" && allRequirementIds.includes(id)) : [],
+    })).filter(g => g.requirementIds.length);
+    const groupedIds = new Set(workGroups.flatMap(g => g.requirementIds));
+    for (const id of allRequirementIds) {
+        if (!groupedIds.has(id))
+            workGroups.push({ id, kind: "unclassified", requirementIds: [id] });
+    }
+    const workCost = (ids) => 1 + ids.reduce((total, id) => total + Math.max(1, (input.requirementCosts?.get(id) ?? 2) - 1), 0);
+    const policy = input.sessionOptions.frontendExecutionPolicy;
+    const targetBytes = policy?.scopeTargetBytes ?? FRONTEND_SCOPE_TARGET_BYTES;
+    const buildWorkBatches = (ids) => {
+        const work = workGroups.flatMap((g, index) => {
+            const members = g.requirementIds.filter(id => ids.includes(id));
+            return members.length ? [{ id: `${index}:${g.id}`, requirementIds: members,
+                    requirements: members.map(id => fullUnits.get(id) ?? { id }), estimatedCalls: workCost(members) }] : [];
+        });
+        // Pack complete work units, not the repeated request scaffold. Deducting
+        // fixed context/tools can leave a one-byte budget and force one AC per
+        // session without reducing that overhead. The SDK checks the actual
+        // request against model capacity; capacity recovery splits unfinished work.
+        return packFrontendInputUnits(work, {
+            targetBytes,
+            maxUnits: policy?.maxScopeUnits ?? 4,
+            maxCost: FRONTEND_PLAN_COVERAGE_MAX_RECORD_CALLS, cost: g => g.estimatedCalls,
+        }).map(batch => batch.flatMap(g => g.requirementIds));
+    };
+    // This renderer also carries the Plan's evolving UX checkpoint on resume.
+    // Only the Contract/Scout-derived input participates in ownership binding.
+    const { committedUx: _committedUx, ...frozenInput } = compiledInput ?? {};
+    return {
+        frozenInput, workGroups, buildWorkBatches,
+        compactEligible: input.requirementCosts !== undefined &&
+            workGroups.length <= FRONTEND_PLAN_SMALL_MAX_REQUIREMENTS &&
+            workGroups.reduce((total, group) => total + workCost(group.requirementIds), 0) <= FRONTEND_PLAN_SMALL_MAX_ESTIMATED_CALLS &&
+            countFrontendPlanTargetSurfaces(input.basePrompt) === 1,
+    };
+}
+export function collectFrontendPlanRequirementIds(contractFacts) {
+    return [
+        ...new Set(contractFacts
+            .filter((record) => record.fact?.kind ===
+            "requirement")
+            .map((record) => record.fact?.id)
+            .filter((id) => typeof id === "string")),
+    ];
+}
+export const frontendPlanCoverageLayoutSchema = z.object({
+    schemaVersion: z.literal(1),
+    bindingSha256: z.string(),
+    coverageBatches: z.array(z.array(z.string().min(1)).min(1)).min(1),
+    layoutSha256: z.string(),
+}).strict();
+export async function loadOrCreateFrontendPlanCoverageLayout(input) {
+    const fileName = "coverage-layout.json";
+    const file = path.join(input.runDir, input.nodeId, fileName);
+    const bindingSha256 = sha256OfCanonicalJson(input.binding);
+    let raw;
+    try {
+        raw = await readFile(file, "utf8");
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+    let layout;
+    if (raw !== undefined) {
+        layout = frontendPlanCoverageLayoutSchema.parse(JSON.parse(raw));
+    }
+    else {
+        // Losing the ownership receipt must never repartition acknowledged facts.
+        for (const relative of ["plan-typed-facts.jsonl", "parallel"]) {
+            const existing = await stat(path.join(input.runDir, input.nodeId, relative)).catch(error => {
+                if (error.code !== "ENOENT")
+                    throw error;
+                return undefined;
+            });
+            if (existing && (existing.isDirectory() || existing.size > 0)) {
+                throw Error("FRONTEND_PLAN_LAYOUT_MISSING: preserve the existing ledger and restart its owning phase");
+            }
+        }
+        const descriptor = {
+            schemaVersion: 1, bindingSha256,
+            coverageBatches: input.workload.compactEligible ? [input.requirementIds] : input.workload.buildWorkBatches(input.requirementIds),
+        };
+        layout = { ...descriptor, layoutSha256: sha256OfCanonicalJson(descriptor) };
+    }
+    const { layoutSha256, ...descriptor } = layout;
+    if (layout.bindingSha256 !== bindingSha256 || layoutSha256 !== sha256OfCanonicalJson(descriptor)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_MISMATCH: frozen coverage ownership or input binding changed");
+    }
+    const members = layout.coverageBatches.flat();
+    const owners = new Map(layout.coverageBatches.flatMap((batch, index) => batch.map(id => [id, index])));
+    if (members.length !== owners.size || members.length !== input.requirementIds.length ||
+        input.requirementIds.some(id => !owners.has(id)) ||
+        input.workload.workGroups.some(group => new Set(group.requirementIds.map(id => owners.get(id))).size !== 1)) {
+        throw Error("FRONTEND_PLAN_LAYOUT_INVALID: coverage must partition complete execution groups exactly once");
+    }
+    if (raw === undefined)
+        await writeDagNodeJsonArtifact(input.runDir, input.nodeId, fileName, layout);
+    return layout.coverageBatches;
+}