@tea-agent/loop-agent 0.44.0-next.8 → 0.44.0-next.9

package/CHANGELOG.md

@@ -23,6 +23,103 @@
 
 - Console 操作文案改为面向操作者的说明并给出下一步：等待超时不再伪装成「需要核对」，改为提示操作可能仍在后台运行；「源内容已变更」「前端拆分状态被并发修改」等原本直接展示英文原文的错误，改为说明原因与具体处理步骤；恢复页按钮与提示去掉 reconcile / supersede / orphan / Human Gate 等术语。
 
+- Operator Chat 新增对话驱动的真实浏览器自动化：右侧「浏览器」面板同步共享状态，登录态与下载隔离在仓库外；模型可操作同一浏览器完成导航、搜索、结构化快照、元素操作与截图，不读写仓库文件，也不暴露页面脚本执行。
+- 模型驱动的共享浏览器默认改为可见外部窗口，并保留右侧预览；地址、搜索与元素操作不再默认生成大截图，搜索逐字填写并提交真实表单，启动时降低自动化指纹；无法嵌入的页面提供外部打开与聚焦入口，同一持久配置可完成站点安全验证。
+- 修复观测页「执行历史」把仍在重试的节点误报为「最终失败」的问题：只要节点最后一个已记录的尝试失败，就会显示「N 次 · 最终失败」，即使该节点仍在运行、重试已经排队，会让人误判运行已结束。现在节点处于运行/已启动/暂停状态时改为「N 次 · 最近一次失败，仍在重试」，真正到达终态才显示「最终失败」；修复轮次的多轮标签同样处理。
+
+- 修复重试额度提升到 5 次后遗留的过期说明：只读 Pi 节点的默认重试次数已在 2026-09-05 由 3 次提升到 5 次，但运行时文档、模板示例与 npm 包内置的 `backend-test-dag.json` 仍写着 3 次，导致目标项目看到的仍是旧额度。现已同步为 5 次，并把模板漂移检查扩展到重试策略字段，避免同类过期再次漏过。
+
+- 修复 Console「更新程序」被一条卡住的旧操作永久堵死的问题：停在「等待核对」的操作记录已被启动对账跳过、自身无法再推进，却又被当成「仍在运行」，导致之后每次更新都提示「另一个 Console 操作正在进行」。现将其明确归为已结束、不再占用操作位，并在恢复页保留可见；同时补全「已安装成功但接棒失败」记录的自动收敛，不再永久停留。
+
+- Console 操作文案改为面向操作者的说明并给出下一步：等待超时不再伪装成「需要核对」，改为提示操作可能仍在后台运行；「源内容已变更」「前端拆分状态被并发修改」等原本直接展示英文原文的错误，改为说明原因与具体处理步骤；恢复页按钮与提示去掉 reconcile / supersede / orphan / Human Gate 等术语。
+
+- 前端配对观测支持核对六类浏览器报告的登记、终态资源和检查结果，拒绝矛盾或缺失证据；浏览器通过与完整产品验收分开记录，环境异常保留未知。
+
+- 实验语料登记新增六类前端配对格式，核对需求、初始文件与检查器实物摘要；复用现有实验计划生成器，保留通用语料原有约束。
+
+- 前端配对验收可读取任务已登记的网关快照，按实验格归属汇总供应商调用；拒绝缺失或摘要不符的证据，明确区分观测记录与尚未证明的全任务统计。
+
+- 前端配对任务可冻结网关布局，启动前核对实验计划、全部实验格、合同和登记顺序；网关引用先登记的计划摘要，避免摘要相互依赖。
+
+- 前端实验日志可按预登记拓扑核对跨网关请求图，只汇总供应商边并追溯实验格；断链、串网关与重复ID拒绝，未解析的失败转发保持未知成本。
+
+- 前端实验支持按固定摘要核对单网关合同、逐请求日志和总账，拒绝缺行/重复/身份或用量冲突；未知用量继续区别于保守预留，不将单网关记录冒充全任务证据。
+
+- 修复实验计量网关多实例同时打开同一账本可超额的问题：增加独占writer锁，正常关闭和启动失败释放，旧锁不自动夺取或重置预算。
+
+- 实验网关记录请求转发关联和上游类型，区分多层日志与供应商侧调用尝试；内部关联头不发送给供应商，共享总额度经过跨实验格HTTP回归验证。
+
+- 归档前端实验计量网关，补充实验格绑定、请求正文摘要、选定显式参数和响应模型记录；日志不保存提示词或凭据，重启时拒绝实验身份漂移。
+
+- 修正前端评测的任务成本口径：预算预留数和DAG阶段耗时单独保留，缺少全任务实采时不再当成实际请求数或总耗时；缺来源用量时不把局部token当成总量。
+
+- 前端配对统计补充首次和最终成功率差异的保守置信区间，保留缺失样本与小样本不确定性，不自动据此晋升候选。
+
+- 前端配对验收可核对预登记的来源、预算、初始树及全任务模型收据；快照漂移拒绝，缺少采样参数或供应商实际模型版本证据时继续保留未知。
+
+- 修复前端计划把现有只读测试误判为写入越界的问题；计划预检和正式策略门禁均允许安全读取已有测试，新增或修改文件仍严格受写入范围约束。
+
+- 前端评审按合同核验行为测试报告覆盖，缺失整组报告、仅执行其他文件、失败或跳过用例时阻止进入评审；完整原始报告与分片继续按摘要复核。
+
+- 修正旧计数器浏览器证据把任务成功率误计为通过的问题：浏览器成功仅保留局部事实，完整质量门禁缺失时交付结论保持未知，已证实的行为失败仍保留。
+
+- Counter 独立浏览器报告可接入任务统计，核对登记的检查器、终态产物和完整检查项；自测、串运行与矛盾通过标记被拒绝，执行错误保留未知。
+
+- 前端任务统计可读取冻结运行和完整根账本，保留失败消耗；缺少来源或独立行为验收时保留未知，避免将 DAG 完成状态直接计为正确交付。
+
+- 显式前端配对评测可在运行前核验协议摘要、已登记样本和实际控制器指纹，并将绑定冻结进运行事实；恢复时重新核验，版本不符在分配运行目录前拒绝。
+
+- 前端配对评测新增预登记身份核验，重验候选文件、计划内容和登记时间，仅接受明确登记的版本差异，共同模型/输入/预算/验收身份变化继续拒绝。
+
+- 前端评测新增基于已登记样本的任务级描述统计，区分首次成功与最终完成，保留失败成本和未知观测；统计本身不构成验收或晋升结论。
+
+- 修复 Console 放弃或替代孤立运行时的命令参数错误；运行器收到退出信号时保留监听器直到状态保存结束，避免 Pi 的退出依赖提前终止进程。
+
+- 前端 SDK 收到明确预算耗尽错误时主动结束自动重试等待，处理重试对象延后创建的取消时序；普通限流仍可重试，退出未确认仍阻断后续执行。
+
+- 前端风险分级与流程路由统一识别明确的排除条款，避免“无需新增依赖或构建系统”误升级；有例外条件或正向需求时仍保留风险信号。
+
+- 修复前端契约补充分组信息后，规划阶段重复计算同一需求、错误阻断执行的问题；按需求 ID 读取最新记录并保留完整历史。
+
+- 来源成本证据绑定冻结合同版本，区分当前与历史批次，拒绝同版本内容冲突和版本归属漂移。
+
+- 来源成本验收核对批次记录、请求时间与任务归属；缺批次编号或记录损坏时保留未知，防止旧记录混入完整证据。
+
+- 前端来源准备记录独立执行编号及前后合同版本，请求可追溯到具体重试批次，失败记录继续保留。
+
+- 前端配对验收新增全任务成本检查，避免 Plan 局部节省掩盖来源和后续执行成本上涨；用量未知不再获得整体通过。
+
+- 前端 DAG 将已确认的来源处理 token 纳入累计预算；验收核对冻结收据，证据丢失或变化时保留未知状态，避免漏算成本。
+
+- 任务请求预留记录所属观测会话，来源用量可按会话核对；缺失、冲突或无法归属的用量继续标为未知，避免漏算为零。
+
+- 前端语义整理接入共享任务请求额度，预算停止后不再换模型重试，并为用量记录保存输入文档指纹。
+
+- 前端 DAG 冻结并继承任务请求账本，来源与后续 DAG 共用预留额度；账本缺失、身份漂移或计数回退拒绝运行，未知来源 token 保留缺失标记。
+
+- 来源整理与复核默认使用任务持久请求账本，先保存预留再调用模型；重启不清零，损坏账本、额度漂移及未绑定旧用量会阻断。来源账本与 DAG 的累计继承仍待完成。
+
+- 来源整理与复核适配器支持传递共享请求预算预留回调，供统一预算账本接入；默认任务的来源费用与 DAG 账本整合仍在进行中。
+
+- 修复前端验收漏算 continuation 父运行成本、同一模型列表掩盖实际模型变化、回归场景仅凭声明通过的问题；恢复预算账本拒绝用量倒退、额度漂移和缺失事实丢失。
+
+- 来源整理与独立复核收到预算耗尽后立即停止模型回退，失败信息按实际尝试数记录。
+- 前端 canary 支持从独立评测目录读取绑定运行指纹的验收记录和配对文件；核对真实 Plan 模型、设计评审终态和逐项验收结果，缺证据、错配或行为漏检继续阻断整体通过。
+
+- 明确的模型调用预算耗尽错误保留为预算停止，不再被网络错误覆盖并触发节点重试或模型回退。
+
+- 前端 Scout 同一次节点执行中重试时复用已成功提交事实的分支，仅补失败或缺事实分支；模型变更不复用，已消耗 token 不重复累计。明确设计与测试入口的调查分工，减少重复查看依赖内部实现。
+
+- 来源保真复核仅在项目配置的模型档位间回退，不再自动尝试全局目录中的其他模型。
+
+- 修复结构化 draft 创建前端任务时漏建来源账本、导致 Contract 节点在模型调用前失败的问题；统一使用现有来源保真校验。
+
+- 前端评审获得合同引用的未修改测试源码与实际测试执行记录，按 hash 复核来源及完整性；data/Mock 分批不再重复扣除固定提示词预算，共享领域仍完整处理。
+
+- 前端 DAG 恢复按问题归属从 Contract、Scout、Plan 或实现节点重跑，清除失效的下游批准；父 Plan 快照绑定来源、账本和当前评审，避免复用过期问题。
+- 前端评审支持受冻结需求约束的修复断言；无效断言保留阻断问题。Plan 无进展时停止追加模型请求，成功终态不被迟到错误推翻。
+- 前端测试执行前核对 Vitest 报告能力和 npm 测试脚本（含前后置钩子）；保留计划证据等级与接口边界，明确测试文件通过不等于需求行为已充分验证。
+- 前端合同保留必须遵守的能力条款，交付文件进入写入范围；交付义务不再豁免真实实现位置的归属检查。
 - 修复后端测试 DAG 模板遗漏 `upstream-unavailable` 重试类别的问题：内置模板的 Markdown 计划节点缺少该类别，与运行时生成器不一致，导致照模板配置的项目少一类重试；现已补齐，并把模板漂移检查扩展到重试策略字段，避免同类不一致再次漏过。
 
 - Operator Chat 右侧辅助栏改为三个表面：仓库、会话、工作台。点上下文环进入「会话 / 上下文」，文件和终端不再与会话检查挤在同一条标签上；工作台用内侧图标轨切换终端、浏览器和数据库。

package/dist/application/evaluation/budget.js

@@ -208,3 +208,24 @@ export function formatBudgetReportMarkdown(ledger) {
     }
     return `${lines.join("\n")}\n`;
 }
+export const frontendObservedSessionIdentitySchema = z.object({
+    sourceExecutionId: z.string().uuid().optional(),
+    sessionId: z.string().min(1), phase: z.string().min(1), executionKind: z.enum(["model", "runtime"]), dispatchReason: z.enum(["initial", "correction"]),
+    scopeIds: z.array(z.string()), taskId: z.string().nullable(), runId: z.string().nullable(), nodeId: z.string().nullable(), attempt: z.number().int().nullable(),
+    sourceDigest: z.string().nullable(), contractDigest: z.string().nullable(),
+}).strict();
+/** Durable task request authority and the source-bound snapshot carried by a DAG. */
+export const sourceProviderBudgetSchema = z.object({
+    schemaVersion: z.literal(1), taskId: z.string().min(1), budgetId: z.string().uuid(),
+    maxProviderRequests: z.number().int().positive(), reservedRequests: z.number().int().nonnegative(),
+    requestSessions: z.record(z.object({ identity: frontendObservedSessionIdentitySchema, reservedRequests: z.number().int().positive() }).strict()).optional(),
+}).strict().refine(value => value.reservedRequests <= value.maxProviderRequests && Object.entries(value.requestSessions ?? {}).every(([key, session]) => key === `${session.identity.runId ?? "task"}:${session.identity.sessionId}` && session.identity.executionKind === "model" && session.identity.taskId === value.taskId) && Object.values(value.requestSessions ?? {}).reduce((sum, session) => sum + session.reservedRequests, 0) <= value.reservedRequests);
+export const sourceProviderBudgetBindingSchema = z.object({
+    ledger: sourceProviderBudgetSchema,
+    contract: z.object({ revision: z.number().int().nonnegative(), canonicalHash: z.string().regex(/^[a-f0-9]{64}$/) }).strict().optional(),
+    sourceBindingSha256: z.string().regex(/^[a-f0-9]{64}$/),
+    evidence: z.object({ executions: z.array(z.object({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/), content: z.string() }).strict()).optional(), receipts: z.array(z.object({ path: z.string().min(1), sha256: z.string().regex(/^[a-f0-9]{64}$/), content: z.string() }).strict()), diagnostics: z.array(z.string()) }).strict().optional(),
+}).strict();
+export function sourceBudgetContractIdentity(binding) {
+    return binding ? { revision: binding.revision, canonicalHash: binding.canonicalHash } : undefined;
+}

package/dist/application/evaluation/corpus-hash.js

@@ -9,24 +9,19 @@ function normalizeTask(task) {
         featureId: task.featureId ?? null,
     };
 }
-/**
- * Canonical payload for corpusHash.
- * Excludes corpusId, createdAt, description, corpusHash, and free-text notes.
- */
+/** Excludes display metadata, but binds every frontend input and oracle ref. */
 export function buildCanonicalCorpusPayload(manifest) {
-    const tasks = manifest.tasks
-        .map((task) => normalizeTask(task))
-        .sort((a, b) => (a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0));
-    return {
-        schemaVersion: 1,
-        tasks,
-    };
+    const files = (refs) => refs.map(ref => ({ path: ref.path, sha256: ref.sha256 })).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+    const tasks = (manifest.schemaVersion === 2
+        ? manifest.tasks.map(task => ({ ...normalizeTask(task), category: task.category,
+            requirements: files(task.requirements), initialFiles: files(task.initialFiles), oracleFiles: files(task.oracleFiles) }))
+        : manifest.tasks.map(normalizeTask))
+        .sort((a, b) => a.taskRef < b.taskRef ? -1 : a.taskRef > b.taskRef ? 1 : 0);
+    return { schemaVersion: manifest.schemaVersion,
+        ...(manifest.schemaVersion === 2 ? { purpose: manifest.purpose } : {}), tasks };
 }
 export function computeCorpusHash(manifest) {
-    const payload = buildCanonicalCorpusPayload(manifest);
-    const digest = createHash("sha256")
-        .update(stableStringify(payload))
-        .digest("hex");
+    const digest = createHash("sha256").update(stableStringify(buildCanonicalCorpusPayload(manifest))).digest("hex");
     return formatContentSha(digest);
 }
 export function assertCorpusHashMatches(manifest) {

package/dist/application/evaluation/corpus.js

@@ -1,7 +1,8 @@
-import { loadCorpusManifestFromPath, listCorpusIds, materializeCorpusManifest, readCorpusManifest, registerCorpusManifest, summarizeCorpus, } from "../../infrastructure/evaluation/corpus-store.js";
+import { loadCorpusManifestFromPath, assertCorpusArtifacts, listCorpusIds, materializeCorpusManifest, readCorpusManifest, registerCorpusManifest, summarizeCorpus, } from "../../infrastructure/evaluation/corpus-store.js";
 export async function validateCorpus(input) {
     const raw = await loadCorpusManifestFromPath(input.repoRoot, input.manifestPath);
     const manifest = await materializeCorpusManifest(raw);
+    await assertCorpusArtifacts(input.repoRoot, manifest);
     return { manifest, summary: summarizeCorpus(manifest) };
 }
 export async function registerCorpus(input) {

package/dist/application/evaluation/frontend-browser-acceptance.js

@@ -0,0 +1,77 @@
+import { realpath } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+import { z } from "zod";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const refSchema = z.object({ path: z.string().min(1), sha256: digest }).strict();
+const files = ["index.html", "src/app.js", "test/counter.test.js", "acceptance-prd.md"];
+const requiredChecks = ["initial", "idle", "limit", "reset", "loading", "empty", "real-integration"];
+const additionalChecks = ["noPageErrors", "preservesQuery", "loadedState", "disabledWhileLoading", "replacesOldItems", "errorState", "errorClearsOldItems"];
+const checksSchema = (keys) => z.object(Object.fromEntries(keys.map(key => [key, z.boolean()]))).strict();
+/** Adapter only for the frozen counter corpus and independent browser script. */
+export async function readFrontendBrowserAcceptance(input) {
+    const observed = [];
+    const read = async (root, name, expected) => {
+        const target = path.resolve(root, name);
+        const bytes = await readFileBoundarySafe({ boundaryRoot: root, targetPath: target, label: "frontend browser acceptance" });
+        if (expected && sha(bytes) !== expected)
+            throw Error(`browser evidence hash mismatch: ${name}`);
+        observed.push({ root, target, bytes });
+        return bytes;
+    };
+    const readRef = (value) => { const ref = refSchema.parse(value); return read(input.repoRoot, ref.path, ref.sha256); };
+    const contract = z.object({ schemaVersion: z.literal(1), kind: z.literal("counter-browser-acceptance-v1"), checker: refSchema, oracle: refSchema }).strict().parse(JSON.parse((await readRef(input.contract)).toString("utf8")));
+    await readRef(contract.checker);
+    await readRef(contract.oracle);
+    const raw = JSON.parse((await readRef(input.report)).toString("utf8"));
+    const header = z.object({ schemaVersion: z.literal(1), evidenceKind: z.literal("actual-task-artifact-browser"), runId: z.string().min(1), runStatus: z.enum(["finished", "failed", "partial_failed"]), stateSha256: digest, checkpointSha256: digest, checkerSha256: digest, frozenOracleSha256: digest,
+        sourceHashes: z.object(Object.fromEntries(files.map(file => [file, digest]))).strict(), pass: z.boolean() }).passthrough().parse(raw);
+    if (header.checkerSha256 !== contract.checker.sha256 || header.frozenOracleSha256 !== contract.oracle.sha256)
+        throw Error("browser checker not registered");
+    const state = JSON.parse((await read(input.runDir, "state.json", header.stateSha256)).toString("utf8"));
+    if (typeof state.cwd !== "string" || await realpath(state.cwd) !== await realpath(input.repoRoot))
+        throw Error("browser workspace mismatch");
+    if (state.runId !== header.runId || state.status !== header.runStatus || !state.finishedAt)
+        throw Error("browser run identity mismatch");
+    const checkpoint = z.object({ gitHeadSha: z.string().regex(/^[a-f0-9]{40,64}$/), changedPaths: z.array(z.object({ path: z.string(), contentSha256: digest.optional() }).passthrough()) }).passthrough().parse(JSON.parse((await read(input.runDir, ".runtime/workspace-checkpoint-terminal.json", header.checkpointSha256)).toString("utf8")));
+    for (const name of files) {
+        const changed = checkpoint.changedPaths.filter(row => row.path === name);
+        if (changed.length > 1)
+            throw Error("ambiguous browser checkpoint path");
+        const expected = changed.length ? changed[0].contentSha256 : sha(execFileSync("git", ["show", `${checkpoint.gitHeadSha}:${name}`], { cwd: input.repoRoot }));
+        if (header.sourceHashes[name] !== expected)
+            throw Error(`browser artifact not bound to terminal checkpoint: ${name}`);
+    }
+    let passed;
+    const diagnostics = ["counter-browser-only-product-gates-pending"];
+    if (typeof raw.error === "string") {
+        if (raw.result !== undefined || raw.additional !== undefined)
+            throw Error("browser execution error conflicts with completed checks");
+        if (header.pass)
+            throw Error("browser error cannot pass");
+        passed = null;
+        diagnostics.push("browser-execution-error");
+    }
+    else {
+        const result = z.object({ checks: checksSchema(requiredChecks), failedChecks: z.array(z.string()) }).passthrough().parse(raw.result);
+        const additional = checksSchema(additionalChecks).parse(raw.additional);
+        const errors = z.array(z.string()).parse(raw.errors);
+        const failed = Object.entries(result.checks).filter(([, value]) => !value).map(([key]) => key).sort();
+        if (JSON.stringify(failed) !== JSON.stringify([...result.failedChecks].sort()))
+            throw Error("browser failed-check list mismatch");
+        passed = failed.length === 0 && Object.values(additional).every(Boolean) && errors.length === 0;
+        if (header.pass !== passed)
+            throw Error("browser summary contradicts checks");
+        if (passed && state.status !== "finished")
+            throw Error("failed run cannot become successful browser delivery");
+    }
+    for (const entry of observed) {
+        const latest = await readFileBoundarySafe({ boundaryRoot: entry.root, targetPath: entry.target, label: "browser evidence recheck" });
+        if (!latest.equals(entry.bytes))
+            throw Error("browser evidence changed during collection");
+    }
+    return { passed, diagnostics, runId: header.runId, reportSha256: input.report.sha256, contractSha256: input.contract.sha256 };
+}

package/dist/application/evaluation/frontend-corpus-browser-acceptance.js

@@ -0,0 +1,175 @@
+import { createHash } from "node:crypto";
+import { execFileSync } from "node:child_process";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+import { z } from "zod";
+import { readFileBoundarySafe } from "../../shared/path-safety.js";
+import { dagEvaluationBindingSchema } from "../../workflows/dag/types.js";
+import { verifyControllerIdentityForResume } from "../../workflows/dag/controller-identity.js";
+import { assertFrontendPairExecution } from "./frontend-pair-registration.js";
+import { corpusManifestSchema } from "./types.js";
+import { assertCorpusHashMatches } from "./corpus-hash.js";
+const sha = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const digest = z.string().regex(/^[a-f0-9]{64}$/);
+const ref = z.object({ path: z.string().min(1), sha256: digest }).strict();
+const contractSchema = z.object({ schemaVersion: z.literal(1), kind: z.literal("frontend-corpus-browser-acceptance-v1"), corpus: ref, checker: ref, oracle: ref, coverage: ref }).strict();
+const observationSchema = z.object({
+    schemaVersion: z.literal(1), evidenceKind: z.literal("unbound-corpus-browser-observation"), runId: z.null(), caseId: z.string(),
+    browser: z.string().nullable(), pass: z.boolean(), checks: z.record(z.boolean()), failedChecks: z.array(z.string()),
+    pageErrors: z.array(z.string()), resourceErrors: z.array(z.string()), servedFiles: z.record(digest), checkerSha256: digest,
+    infrastructureError: z.string().optional(),
+}).passthrough();
+const reportSchema = z.object({
+    schemaVersion: z.literal(1), evidenceKind: z.literal("actual-corpus-task-browser"), caseId: z.string(), runId: z.string().min(1),
+    runStatus: z.enum(["finished", "failed", "partial_failed"]), taskRef: z.string(), cellId: z.string(), artifactHashes: z.record(digest),
+    stateSha256: digest, runSha256: digest, checkpointSha256: digest, registration: ref, contractSha256: digest, corpusSha256: digest,
+    checkerSha256: digest, oracleSha256: digest, coverageSha256: digest, pass: z.boolean(), allChecksPresent: z.boolean(), observation: observationSchema,
+}).strict();
+const webAsset = (name) => name === "index.html" || ["src/", "data/", "public/", "assets/"].some(prefix => name.startsWith(prefix));
+function safeName(name) {
+    if (!name || name.includes("\\") || name.includes(":") || name.includes("\0") || name.startsWith("/") || name.split("/").some(part => !part || part === "." || part === ".."))
+        throw Error("invalid corpus browser artifact path");
+    return name;
+}
+/** Validates browser facts for a registered run. Success here does not prove
+ * source fidelity, writer boundaries, Node-test quality, or model execution. */
+export async function readFrontendCorpusBrowserAcceptance(input) {
+    const observed = [];
+    const read = async (root, name, expected) => {
+        const bytes = await readFileBoundarySafe({ boundaryRoot: root, targetPath: path.resolve(root, name), label: "corpus browser evidence" });
+        if (expected !== undefined && sha(bytes) !== expected)
+            throw Error(`corpus browser evidence hash mismatch: ${name}`);
+        observed.push({ root, name, bytes });
+        return bytes;
+    };
+    const readRef = (value) => { const parsed = ref.parse(value); return read(input.repoRoot, parsed.path, parsed.sha256); };
+    const report = reportSchema.parse(JSON.parse((await readRef(input.report)).toString("utf8")));
+    const contract = contractSchema.parse(JSON.parse((await readRef(input.contract)).toString("utf8")));
+    if (report.contractSha256 !== input.contract.sha256 || report.corpusSha256 !== contract.corpus.sha256 ||
+        report.checkerSha256 !== contract.checker.sha256 || report.oracleSha256 !== contract.oracle.sha256 ||
+        report.coverageSha256 !== contract.coverage.sha256 || report.observation.checkerSha256 !== contract.oracle.sha256)
+        throw Error("corpus browser checker identity mismatch");
+    await readRef(contract.checker);
+    await readRef(contract.oracle);
+    const corpus = corpusManifestSchema.parse(JSON.parse((await readRef(contract.corpus)).toString("utf8")));
+    if (corpus.schemaVersion !== 2)
+        throw Error("corpus browser requires frontend corpus");
+    assertCorpusHashMatches(corpus);
+    for (const task of corpus.tasks)
+        for (const value of [...task.requirements, ...task.initialFiles, ...task.oracleFiles])
+            await readRef(value);
+    const coverage = z.object({ schemaVersion: z.literal(1), cases: z.record(z.record(z.array(z.string().min(1)).min(1))) }).passthrough()
+        .parse(JSON.parse((await readRef(contract.coverage)).toString("utf8")));
+    const state = JSON.parse((await read(input.runDir, "state.json", report.stateSha256)).toString("utf8"));
+    const spec = JSON.parse((await read(input.runDir, "run.json", report.runSha256)).toString("utf8"));
+    if (state.evidenceKind?.includes("selftest"))
+        throw Error("selftest cannot be corpus run evidence");
+    if (typeof state.cwd !== "string" || await realpath(state.cwd) !== await realpath(input.repoRoot))
+        throw Error("corpus browser workspace mismatch");
+    if (state.runId !== report.runId || state.status !== report.runStatus || !Number.isFinite(Date.parse(state.startedAt)) ||
+        !state.finishedAt || !Number.isFinite(Date.parse(state.finishedAt)) || Date.parse(state.finishedAt) < Date.parse(state.startedAt))
+        throw Error("corpus browser terminal identity mismatch");
+    const binding = dagEvaluationBindingSchema.parse(state.evaluation);
+    if (!binding.frontendPair || JSON.stringify(binding) !== JSON.stringify(spec.evaluation) || binding.taskRef !== report.taskRef ||
+        binding.frontendPair.cellId !== report.cellId || binding.frontendPair.registration.path !== report.registration.path ||
+        binding.frontendPair.registration.sha256 !== report.registration.sha256)
+        throw Error("corpus browser frozen evaluation mismatch");
+    const controller = JSON.parse((await read(input.runDir, "controller-identity.json")).toString("utf8"));
+    if (state.controllerIdentityRef?.path !== "controller-identity.json" || controller.status !== "pinned" || !controller.identity)
+        throw Error("corpus browser controller not pinned");
+    const pinned = await verifyControllerIdentityForResume({ runDir: input.runDir, state, currentIdentity: controller.identity });
+    const registration = await assertFrontendPairExecution({ repoRoot: input.repoRoot, binding, controllerFingerprint: pinned.identity.packageFingerprint.value, startedAt: state.startedAt });
+    if (registration.shared.acceptance !== input.contract.sha256)
+        throw Error("corpus browser acceptance contract not registered");
+    await readRef(report.registration);
+    const tasks = corpus.tasks.filter(task => task.taskRef === binding.taskRef);
+    if (tasks.length !== 1)
+        throw Error("corpus browser task missing");
+    const task = tasks[0];
+    if (task.category !== report.caseId || task.category !== report.observation.caseId || task.split !== binding.split || !task.seeds.includes(binding.seed))
+        throw Error("corpus browser case mismatch");
+    for (const key of ["checker", "oracle", "coverage"])
+        if (!task.oracleFiles.some(value => value.path === contract[key].path && value.sha256 === contract[key].sha256))
+            throw Error("corpus browser checker not owned by task");
+    const caseCoverage = coverage.cases[task.category];
+    if (!caseCoverage || !Object.keys(caseCoverage).length)
+        throw Error("corpus browser coverage missing");
+    const required = new Set([...Object.values(caseCoverage).flat(), "no-page-errors", "bound-resources"]);
+    const observation = report.observation;
+    if (Object.keys(observation.checks).some(name => !required.has(name) && name !== "interaction-completed"))
+        throw Error("unknown corpus browser check");
+    if (observation.checks["interaction-completed"] === true)
+        throw Error("invalid corpus interaction diagnostic");
+    // The producer records infrastructure errors before case interactions. It
+    // cannot relabel completed business checks as an environment-only failure.
+    if (observation.infrastructureError !== undefined && Object.keys(observation.checks).some(name => name !== "bound-resources"))
+        throw Error("corpus browser infrastructure phase contradicts checks");
+    const allPresent = [...required].every(name => Object.hasOwn(observation.checks, name));
+    if (allPresent !== report.allChecksPresent)
+        throw Error("corpus browser check coverage mismatch");
+    const failed = Object.entries(observation.checks).filter(([, passed]) => !passed).map(([name]) => name).sort();
+    if (JSON.stringify(failed) !== JSON.stringify([...observation.failedChecks].sort()))
+        throw Error("corpus browser failed-check list mismatch");
+    for (const [name, errors] of [["no-page-errors", observation.pageErrors], ["bound-resources", observation.resourceErrors]])
+        if (Object.hasOwn(observation.checks, name) && observation.checks[name] !== (errors.length === 0))
+            throw Error("corpus browser error flags mismatch");
+    const observedPass = observation.infrastructureError === undefined && Object.keys(observation.checks).length > 0 && failed.length === 0;
+    if (observation.pass !== observedPass || report.pass !== (state.status === "finished" && observedPass && allPresent))
+        throw Error("corpus browser summary contradicts checks");
+    const checkpoint = z.object({ schemaVersion: z.literal(1), gitHeadSha: z.string().regex(/^[a-f0-9]{40,64}$/),
+        changedPaths: z.array(z.object({ path: z.string(), state: z.string(), contentSha256: digest.optional(), mode: z.string().optional() }).passthrough()) }).passthrough()
+        .parse(JSON.parse((await read(input.runDir, ".runtime/workspace-checkpoint-terminal.json", report.checkpointSha256)).toString("utf8")));
+    const changes = new Map();
+    for (const row of checkpoint.changedPaths) {
+        safeName(row.path);
+        if (changes.has(row.path))
+            throw Error("duplicate corpus checkpoint path");
+        changes.set(row.path, row);
+    }
+    const entries = new Map();
+    const tree = execFileSync("git", ["ls-tree", "-rz", "--full-tree", checkpoint.gitHeadSha], { cwd: input.repoRoot, maxBuffer: 16 * 1024 * 1024 }).toString("utf8");
+    for (const item of tree.split("\0").filter(Boolean)) {
+        const tab = item.indexOf("\t"), name = item.slice(tab + 1), [mode, type] = item.slice(0, tab).split(" ");
+        if (webAsset(name))
+            entries.set(safeName(name), { mode, type: type });
+    }
+    for (const [name, row] of changes)
+        if (webAsset(name)) {
+            if (row.state === "deleted")
+                entries.delete(name);
+            else
+                entries.set(name, { mode: row.mode, type: "blob" });
+        }
+    if (!entries.has("index.html") || !entries.has("src/app.js") || JSON.stringify([...entries.keys()].sort()) !== JSON.stringify(Object.keys(report.artifactHashes).sort()))
+        throw Error("corpus browser terminal resource set mismatch");
+    for (const [name, entry] of entries) {
+        if (entry.type !== "blob" || entry.mode && !["100644", "100755"].includes(entry.mode))
+            throw Error("unsupported corpus browser resource mode");
+        const changed = changes.get(name);
+        if (changed && !changed.contentSha256)
+            throw Error("corpus browser checkpoint digest missing");
+        const expected = changed ? changed.contentSha256 : sha(execFileSync("git", ["show", `${checkpoint.gitHeadSha}:${name}`], { cwd: input.repoRoot, maxBuffer: 16 * 1024 * 1024 }));
+        if (report.artifactHashes[name] !== expected)
+            throw Error("corpus browser terminal resource hash mismatch");
+    }
+    for (const [name, value] of Object.entries(observation.servedFiles))
+        if (!entries.has(safeName(name)) || report.artifactHashes[name] !== value)
+            throw Error("corpus browser served unbound resource");
+    if (report.pass && (!observation.servedFiles["index.html"] || !observation.servedFiles["src/app.js"]))
+        throw Error("corpus browser entry request missing");
+    for (const snapshot of observed) {
+        const latest = await readFileBoundarySafe({ boundaryRoot: snapshot.root, targetPath: path.resolve(snapshot.root, snapshot.name), label: "corpus browser recheck" });
+        if (!latest.equals(snapshot.bytes))
+            throw Error("corpus browser evidence changed during collection");
+    }
+    const diagnostics = ["corpus-browser-only-product-gates-pending"];
+    let browserPassed = failed.length || observation.pageErrors.length || observation.resourceErrors.length ? false : allPresent ? true : null;
+    if (observation.infrastructureError !== undefined) {
+        browserPassed = observation.resourceErrors.length ? false : null;
+        diagnostics.push("corpus-browser-infrastructure-error");
+    }
+    else if (!allPresent)
+        diagnostics.push("corpus-browser-checks-incomplete");
+    return { browserPassed, diagnostics, runId: report.runId, caseId: report.caseId, taskRef: report.taskRef, cellId: report.cellId,
+        corpusHash: corpus.corpusHash, reportSha256: input.report.sha256, contractSha256: input.contract.sha256, artifactHashes: report.artifactHashes };
+}