@tea-agent/loop-agent 0.28.13 → 0.29.1

package/AGENTS.md

@@ -49,7 +49,7 @@
 
 启动 loop-agent DAG 流程后，主 agent 应自主推进到整个流程结束，不要中途请求无谓的人工确认（如“要我现在执行 DAG 吗？”）。只要 dry-run / validate / writeSet 审查通过就应直接执行并跑完全部 ranks；遇到真问题（契约不一致、writeSet 越界、verify 失败且超出 maxFixLoops、用户明显未授权的高风险动作）才停。即便 profile 是 supervised/reviewed，也不默认在 review-gate 主动停下等人——控制器会在需要人工 approve 时自行提示，主 agent 的职责是推动流程跑完。
 
-DAG 执行期间主 agent 必须持续轮询监视直到 run 结束（FINISHED / FAILED / 需要 approve），不能轮询一次就停下等用户；轮询间隔应合理（避免频繁唤醒浪费 token，也不得住一个节点上赌一次就走）。判活必须用可靠方式：看 `state.json` 的 `runner.heartbeatAt` 是否持续刷新 + `session-events.jsonl` 是否在增长 + `dag doctor` 的 `liveness` 字段，不要只用 `tasklist /FI "PID eq X"` 这类过滤语法在 Git Bash 下会误报 DEAD，从而错判一个正常工作的 run 为 orphaned。遇到疑似 stall 先按 `docs/runtime/agent-dag-runner.md` 查 `lastMeaningfulProgressAt` / provider 活动，有真实进展就继续等，绝不盲目 supersede。
+DAG 执行期间主 agent 必须持续轮询监视直到 run 结束（FINISHED / FAILED / 需要 approve），不能轮询一次就停下等用户；轮询间隔应合理（避免频繁唤醒浪费 token，也不得住一个节点上赌一次就走）。判活必须用可靠方式：看 `state.json` 的 `runner.heartbeatAt` 是否持续刷新 + `session-events.jsonl` 是否在增长 + `dag doctor` 的 `liveness` 字段，不要只用 `tasklist /FI "PID eq X"` 这类过滤语法在 Git Bash 下会误报 DEAD，从而错判一个正常工作的 run 为 orphaned。遇到疑似 stall 先按 `docs/runtime/agent-dag-runner.md` 查 `lastMeaningfulProgressAt` / provider 活动，有真实进展就继续等，绝不盲目 supersede。持续监视过程中，主 agent 可在合适节点（例如 rank/节点状态变化、进入 verify/closeout、出现 stall 嫌疑或需要 approve 时）向用户做简短进度汇报（当前节点、状态、是否有风险），避免长时间静默；汇报是告知，不是请求确认，不得因此停下流程。
 
 DAG 执行期间，主 agent 不得修改 writeSet 外的任何工作区文件（包括 AGENTS.md、docs、根配置等）。bounded writer 节点的 write guard 用「节点运行期间的工作区 diff」作为越界证据，不区分改动来自 pi 还是主会话——主会话在 pi 节点跑的时候改了 writeSet 外文件，会让 write guard 把账算到 pi 头上、判节点 ERROR、下游 cascade skip。需要改文档/约束时，要么在 DAG 启动前改完，要么等 run 结束后改；务必与 DAG 写入节点在时间上互斥。排查任务路由问题时优先用 `resolveTaskDagTemplateSelection` / `classifyTaskDemand` 等纯函数探针或 `--output` 指定临时路径，不要反复 `dag execute --dry-run` / 无必要的 lifecycle 探测。dry-run 不执行节点；若确需预演，检查命令返回的 `.harness/dag-runs/dry-run/<runId>/` `runDir`，它不进入 active overview，也不能作为 `dag resume` 目标。优先用纯函数探针或 `task status`。
 

package/CHANGELOG.md

@@ -2,6 +2,66 @@
 
 ## [Unreleased]
 
+## [0.29.1] - 2026-08-07
+
+### 重点更新
+
+- 前端测试默认执行流程大幅精简，收敛至约 11 个静态节点，合并了多项检查与报告步骤
+- 前端测试浏览器默认改为无头（headless）模式，减少环境干扰
+- 优化证据缺失处理逻辑，非路径逃逸的异常不再强制阻断报告生成
+- 修复文档说明被误判为可执行命令的问题，提升执行稳定性
+
+### 新增
+
+- 新增前端测试标准场景物化节点，支持执行后针对阻塞或缺失证据进行最多两轮有界重跑
+- 新增前端测试标准场景规范模板（frontend-test-standard-scenarios.v1.json）
+- 前端测试独占节点支持 tools-only 写保护策略，在保留工具级写沙箱的同时跳过 Git 基线的硬失败限制
+
+### 改进
+
+- 前端测试默认 DAG 结构精简至约 11 个静态节点：合并双重重跑、检查清单与清单文件、证据与结果、L5 与 HTML 报告
+- 前端测试主 HTML 报告不再依赖回顾（retrospect）节点，回顾功能改为可选开启
+- 权威清单文件（manifest.json）仅记录规范化后的测试用例，并在未配置重试时省略相关静态节点
+- 强化运营 HTML 报告的状态过滤功能，并优化失败与阻塞原因的展示
+
+### 修复
+
+- 修复前端测试检查清单将不可用或阻塞状态的说明文字误判为非法可执行命令的问题
+- 修复前端测试收尾阶段因证据缺失或格式错误导致强制失败的问题，现仅对路径逃逸强制报错，其余降级为建议性提示
+- 修复前端测试合并后清单文件物化异常的问题，确保仅写入规范化用例并恢复负向测试用例
+- 回退误改的全局默认 Pi 模型（DEFAULT_PI_MODEL），将其恢复为 glm-5.2，模型路由统一交由 harness 复杂度矩阵处理
+
+## [0.29.0] - 2026-08-07
+
+### 重点更新
+
+- 新增 Automatic SemVer 自动化发布链，基于 Conventional Commit 增量自动决定版本号，且绝不自动发布破坏性 major 版本
+- Operator Chat 默认开放完整的 Pi 工具集（read/write/edit/bash 等），在保持安全硬边界的前提下提升操作便捷性
+- 后端测试在 16K 最大输出限制下引入分文件写入纪律与完整性恢复机制，彻底避免残缺资产被误判为成功
+- 控制台新增横向莫比乌斯环页签图标，以暖黑双环表达持续运行，并用克制橙色交接面标记受控切换
+
+### 新增
+
+- 新增 Automatic SemVer 每日发布入口：严格依据最新稳定 tag 到 main HEAD 的增量决定版本，feat 触发 minor，其余触发 patch，破坏性标记会安全停止
+- Operator Chat 默认注册并开放完整的 Pi 工具（read/write/edit/bash/grep/find/ls），Capabilities 与 system prompt 对齐 ADR 0011
+- Loop Operator Console 新增横向暖黑莫比乌斯环页签图标，并覆盖静态资源与 UI 边界检查
+- 客户端恢复机制支持静默忽略瞬时中断错误，并写入详细的恢复日志供运维人员核查
+
+### 改进
+
+- 后端测试在 pytest 执行前增加场景参数一致性检查，支持确定性有界自修，并在执行后生成结构化的《测试失败用例分析报告》
+- 测试框架不再硬编码模型 ID，改为动态解析真实的 Pi 模型矩阵，提升跨环境兼容性
+- 初始化升级流程在控制器基线合并中增加验证权限守卫，提升操作安全性
+- AGENTS 及初始化托管块现允许在监控 DAG 时进行简短的进度更新
+
+### 修复
+
+- 修复控制台在用户主动切换标签页时，任务失败错误信息残留并跨标签页持续显示的问题
+- 修复并发操作更新导致 JSON 路径产生竞态的问题，现对操作写入进行串行化处理
+- 修复 Windows 环境下文件原子替换遇到短暂占用时导致操作卡死的问题，现有界重试并清理临时文件
+- 修复后端测试 Markdown 生成器在已确认变更但无 diff 时误判的问题，现会进行严格的有界重试
+- 改进 Windows 环境下临时目录清理机制，在遇到目录非空或繁忙（ENOTEMPTY/EBUSY）错误时自动重试
+
 ## [0.28.13] - 2026-08-06
 
 ### 重点更新
@@ -174,26 +234,24 @@
 
 ## [0.28.1] - 2026-08-05
 
+### 重点更新
+
+- 提升前端/后端任务执行稳定性，减少“看起来成功、实际未写入”的误判
+- 缩短默认测试耗时，改善本地与发布验证体验
+
 ### 改进
 
-- cut npm test wall clock to ~264s and archive finished plans
-- avoid routing maintenance tasks to frontend dag
-- make openspec evidence non-blocking
-- disable frontend lint generation
-- tolerate prose before frontend contract json
-- fix frontend topology and verdict tests
-- reduce llm protocol validation failures
-- fix frontend prewrite contract normalization
+- 默认测试流程更快，并归档已完成计划
+- 维护类任务不再误入前端实现流程
+- 部分证据与 lint 检查改为非阻断，降低无关噪声对交付的干扰
+- 模型输出格式更宽松：说明文字、行内通过结论等常见写法更不易被误杀
 
 ### 修复
 
-- stabilize identity-sensitive tests
-- fail closed on backend writer no-op
-- validate frontend contract before writing
-- add structured frontend contract node
-- harden verification and JSON parsing
-- accept inline pass verdict
-- normalize empty model fields
+- 后端生成任务在未实际写入文件时不再误判为成功
+- 前端写入前补齐契约校验，避免无效契约进入实现阶段
+- 修正失败分类误把路径限制提示当成鉴权失败的问题
+- 加强验证与结果解析，减少畸形输出导致的卡死或误判
 
 ## [0.28.0] - 2026-08-05
 

package/dist/commands/client-recovery.js

@@ -8,6 +8,7 @@ export const CLIENT_RECOVERY_MODES = [
     "off",
 ];
 export const OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH = ".opencode/plugins/loop-agent-transient-retry.js";
+export const OPENCODE_TRANSIENT_RETRY_LOG_PATH = ".opencode/plugins/loop-agent-transient-retry.log";
 export const OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH = ".opencode/plugins/loop-agent-context-overflow-compact.js";
 export const PI_CONTEXT_OVERFLOW_EXTENSION_PATH = ".pi/extensions/loop-agent-context-overflow.js";
 /** Pi project settings are part of the managed init surface; never default to home. */
@@ -511,12 +512,29 @@ export function buildOpenCodeTransientRetryPluginSource() {
  * Compensates transient UnknownError cases that OpenCode built-in APIError
  * retry does not cover. Never runs concurrently with session.status === "retry".
  * Permanent failures use interaction "${PERMANENT_ERROR_INTERACTION}".
+ * User aborts (MessageAbortedError / cancel words) are silently cleared.
+ * Best-effort file log: ${OPENCODE_TRANSIENT_RETRY_LOG_PATH}.
  */
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { appendFile, mkdir } from "node:fs/promises";
+
 const PLUGIN_PATH = ${JSON.stringify(OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH)};
+const LOG_FILE_NAME = ${JSON.stringify(path.basename(OPENCODE_TRANSIENT_RETRY_LOG_PATH))};
+const LOG_PATH = (() => {
+  try {
+    const dir =
+      import.meta.dirname ?? path.dirname(fileURLToPath(import.meta.url));
+    return path.join(dir, LOG_FILE_NAME);
+  } catch {
+    return ${JSON.stringify(OPENCODE_TRANSIENT_RETRY_LOG_PATH)};
+  }
+})();
 const PERMANENT_INTERACTION = ${JSON.stringify(PERMANENT_ERROR_INTERACTION)};
 const BACKOFF_MS = ${JSON.stringify([...BACKOFF_MS])};
 const MAX_RETRIES = ${MAX_SESSION_RETRIES};
 ${buildGeneratedContextOverflowPatternSource()}
+void logToFile("load ok");
 
 const sessionState = new Map();
 const sessionStatus = new Map();
@@ -542,6 +560,26 @@ function textOf(error) {
   }
 }
 
+async function logToFile(line) {
+  try {
+    await mkdir(path.dirname(LOG_PATH), { recursive: true });
+    await appendFile(
+      LOG_PATH,
+      new Date().toISOString() + " " + line + "\\n",
+      "utf-8",
+    );
+  } catch {
+    // Best-effort observability log; never throw (ENOENT/EISDIR tolerated).
+  }
+}
+
+function isUserAbort(error) {
+  if (error && typeof error === "object" && typeof error.name === "string") {
+    if (/^MessageAbortedError$/i.test(error.name)) return true;
+  }
+  return /aborted by user|user cancel|cancelled|canceled/i.test(textOf(error));
+}
+
 function isPermanent(error) {
   const text = textOf(error);
   if (error && typeof error === "object" && typeof error.name === "string") {
@@ -624,6 +662,7 @@ function promptWasAccepted(response) {
 export default async function loopAgentTransientRetryPlugin({ client, $ }) {
   void $;
   void PLUGIN_PATH;
+  void logToFile("setup ok");
 
   async function drainPendingRecovery(sessionId) {
     const state = getState(sessionId);
@@ -662,9 +701,16 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
         throwOnError: true,
       });
     } catch {
+      void logToFile(
+        "prompt attempt=" + nextAttempt + " accepted=false session=" + sessionId,
+      );
       return;
     }
-    if (!promptWasAccepted(response)) return;
+    const accepted = promptWasAccepted(response);
+    void logToFile(
+      "prompt attempt=" + nextAttempt + " accepted=" + accepted + " session=" + sessionId,
+    );
+    if (!accepted) return;
 
     state.attempt = nextAttempt;
     if (pendingErrors.get(sessionId) === pending) {
@@ -680,9 +726,11 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
     }
     state.locked = true;
     state.rerunRequested = false;
+    void logToFile("worker start session=" + sessionId);
     const worker = drainPendingRecovery(sessionId)
       .catch(() => {})
       .finally(() => {
+        void logToFile("worker end session=" + sessionId);
         recoveryWorkers.delete(sessionId);
         const rerun = state.rerunRequested;
         state.rerunRequested = false;
@@ -751,12 +799,19 @@ export default async function loopAgentTransientRetryPlugin({ client, $ }) {
       if (event.type === "session.error") {
         if (!sessionId) return;
         const error = properties.error || properties;
+        if (isUserAbort(error)) {
+          clearSession(sessionId);
+          void logToFile("classify abort session=" + sessionId);
+          return undefined;
+        }
         if (!isTransientUnknown(error)) {
           pendingErrors.delete(sessionId);
           getState(sessionId).rerunRequested = false;
+          void logToFile("classify permanent session=" + sessionId);
           return { interaction: PERMANENT_INTERACTION, reason: "plugin-ignore-permanent-error" };
         }
         pendingErrors.set(sessionId, { error });
+        void logToFile("classify transient session=" + sessionId);
         startRecoveryWorker(sessionId);
         return { pending: true };
       }

package/dist/commands/init-upgrade.js

@@ -1,5 +1,5 @@
 import { execFile, spawn } from "node:child_process";
-import { watch } from "node:fs";
+import { lstatSync, watch } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdtemp, mkdir, readFile, readdir, readlink, realpath, rename, rm, stat, writeFile, } from "node:fs/promises";
 import os from "node:os";
@@ -8,6 +8,7 @@ import { fileURLToPath } from "node:url";
 import { resolveAdapter } from "../adapters/index.js";
 import { createNpmUpdateClient } from "../cli/update/npm-client.js";
 import { auditDocs } from "../governance/checks.js";
+import { harnessManifestSchema } from "../governance/manifest-types.js";
 import { isInitRuntimeActive, } from "../shared/runtime-activity.js";
 import { MAX_OVERFLOW_RECOVERIES, MAX_SESSION_RETRIES, OPENCODE_CONTEXT_OVERFLOW_COMPACT_PLUGIN_PATH, OPENCODE_TRANSIENT_RETRY_PLUGIN_PATH, PI_CONTEXT_OVERFLOW_EXTENSION_PATH, PI_PROJECT_SETTINGS_PATH, inspectProjectPiSettings, } from "./client-recovery.js";
 import { applyInitUpdate, checkInitUpdate, initializeLoopAgentProject, runInitDoctor, } from "./init.js";
@@ -338,6 +339,9 @@ function mergeAuthorityProjection(state, authority) {
         if (!sameJsonValue(state.mergeGuard.baselineWorkspace, authority.baselineWorkspace)) {
             throw new Error("init upgrade merge guard projection differs from controller baseline authority");
         }
+        if (!sameJsonValue(state.mergeGuard.verificationAuthority, authority.verificationAuthority)) {
+            throw new Error("init upgrade merge guard verification authority differs from controller baseline authority");
+        }
         if (state.mergeReceipts.length !== authority.priorMergeReceiptCount) {
             throw new Error("persisted pre-acceptance merge receipt count differs from controller authority");
         }
@@ -653,6 +657,12 @@ async function snapshotWorkspace(repoRoot) {
         const entries = await readdir(directory, { withFileTypes: true });
         entries.sort((left, right) => left.name.localeCompare(right.name));
         for (const entry of entries) {
+            // Git may expose the same temp repository through a short/long Windows
+            // path pair, making path.relative() lose the leading `.git` segment.
+            // Exclude the top-level Git administration directory by entry identity;
+            // init-upgrade protects its own controller anchors separately.
+            if (directory === repoRoot && entry.name === ".git")
+                continue;
             const absolute = path.join(directory, entry.name);
             const relative = toRepoPath(repoRoot, absolute);
             if (relative === ".git" || relative.startsWith(".git/"))
@@ -845,11 +855,8 @@ async function freezeVerificationSurface(repoRoot) {
         collected.add(await assertSafeRegularRepoFile(repoRoot, relativePath));
     };
     await add("harness.json");
-    const harness = JSON.parse(await readFile(path.join(repoRoot, "harness.json"), "utf-8"));
-    const governanceRoot = typeof harness.governanceRoot === "string" ? harness.governanceRoot : "ai_workspace/loop-agent";
-    const matrixPath = typeof harness.entrypoints?.verificationMatrix === "string"
-        ? harness.entrypoints.verificationMatrix
-        : `${governanceRoot}/verification-matrix.md`;
+    const harness = await readVerificationHarness(repoRoot);
+    const matrixPath = verificationMatrixPath(harness);
     await add(matrixPath);
     const commands = ["bash scripts/check-repo.sh", await discoverQuickVerification(repoRoot)];
     for (const command of commands) {
@@ -878,9 +885,68 @@ async function assertFrozenVerificationSurface(repoRoot, surface) {
         }
     }
 }
+function frozenVerificationMatrixPath(surface) {
+    const paths = surface.files
+        .map((entry) => entry.path)
+        .filter((pathName) => pathName === "verification-matrix.md" ||
+        pathName.endsWith("/verification-matrix.md"));
+    if (paths.length !== 1) {
+        throw new Error("verification authority surface must contain exactly one verification-matrix.md");
+    }
+    return paths[0];
+}
+function isControllerAuthorizedVerificationMergeTask(task, surface) {
+    const taskPath = normalizeAllowedPath(task.path);
+    if (taskPath === "harness.json")
+        return true;
+    return ((taskPath === "verification-matrix.md" ||
+        taskPath.endsWith("/verification-matrix.md")) &&
+        Boolean(surface?.files.some((entry) => entry.path === taskPath)));
+}
+async function assertFrozenVerificationSurfaceExcept(repoRoot, surface, exemptPath) {
+    if (!isFrozenVerificationSurface(surface)) {
+        throw new Error("verification authority surface manifest is invalid");
+    }
+    const canonicalExemptPath = exemptPath
+        ? normalizeAllowedPath(exemptPath)
+        : undefined;
+    for (const entry of surface.files) {
+        if (entry.path === canonicalExemptPath)
+            continue;
+        const normalized = await assertSafeRegularRepoFile(repoRoot, entry.path);
+        if (normalized !== entry.path || sha256(await readFile(path.join(repoRoot, normalized))) !== entry.sha256) {
+            throw new Error(`verification authority surface changed: ${entry.path}`);
+        }
+    }
+}
+async function validateControllerAuthorizedVerificationMerge(input) {
+    const taskPath = normalizeAllowedPath(input.task.path);
+    if (!isControllerAuthorizedVerificationMergeTask(input.task, input.surface))
+        return;
+    const harness = await readVerificationHarness(input.repoRoot);
+    const matrixPath = normalizeAllowedPath(verificationMatrixPath(harness));
+    const frozenMatrixPath = frozenVerificationMatrixPath(input.surface);
+    if (matrixPath !== frozenMatrixPath ||
+        (taskPath !== "harness.json" && taskPath !== frozenMatrixPath)) {
+        throw new Error("verification authority merge must retain the controller-frozen verification matrix path");
+    }
+    if (taskPath === "harness.json") {
+        harnessManifestSchema.parse(harness);
+        const authority = input.guard?.verificationAuthority;
+        if (authority &&
+            (!sameJsonValue(harness.executors ?? null, authority.executors) ||
+                !sameJsonValue(harness.workflowPolicy ?? null, authority.workflowPolicy))) {
+            throw new Error("verification authority harness.json merge cannot change controller executor or workflow authority");
+        }
+    }
+    const command = await discoverQuickVerification(input.repoRoot);
+    tokenizeCommand(command);
+    await commandRepositoryInputs(input.repoRoot, command);
+}
 function assertTaskOutsideVerificationSurface(task, surface) {
     const taskPath = normalizeAllowedPath(task.path);
-    if (surface.files.some((entry) => entry.path === taskPath)) {
+    if (surface.files.some((entry) => entry.path === taskPath) &&
+        !isControllerAuthorizedVerificationMergeTask(task, surface)) {
         throw new Error(`init upgrade merge task targets authority-sensitive verification input: ${taskPath}`);
     }
 }
@@ -918,11 +984,24 @@ function validateTaskBoundary(task) {
     }
     return allowed;
 }
+async function harnessVerificationAuthority(repoRoot, task) {
+    if (normalizeAllowedPath(task.path) !== "harness.json")
+        return undefined;
+    const harness = await readVerificationHarness(repoRoot);
+    return {
+        executors: cloneJson(harness.executors ?? null),
+        workflowPolicy: cloneJson(harness.workflowPolicy ?? null),
+    };
+}
 async function createMergeGuard(repoRoot, task) {
     for (const allowedPath of validateTaskBoundary(task)) {
         await assertSafeMergePath(repoRoot, allowedPath);
     }
-    return { task, baselineWorkspace: await snapshotWorkspace(repoRoot) };
+    return {
+        task,
+        baselineWorkspace: await snapshotWorkspace(repoRoot),
+        verificationAuthority: await harnessVerificationAuthority(repoRoot, task),
+    };
 }
 function isMergeReceipt(value) {
     if (!isRecord(value))
@@ -1203,6 +1282,7 @@ async function recordAcceptedMerge(input) {
             mergeAuthority: {
                 task: input.task,
                 baselineWorkspace: input.guard.baselineWorkspace,
+                verificationAuthority: input.guard.verificationAuthority,
                 priorMergeReceiptCount: input.state.mergeReceipts.length,
                 priorMergeReceiptsSha256: sha256(serializeJson(input.state.mergeReceipts)),
                 stateProjection: controllerStateProjection(input.state),
@@ -1237,11 +1317,14 @@ async function validateContinueMerge(directory, state, anchor) {
     }
     const authority = mergeAuthorityFromAnchor(anchor, state);
     const projection = mergeAuthorityProjection(state, authority);
-    await assertFrozenVerificationSurface(state.repoRoot, authority.verificationSurface);
     const task = authority.task;
+    await assertFrozenVerificationSurfaceExcept(state.repoRoot, authority.verificationSurface, isControllerAuthorizedVerificationMergeTask(task, authority.verificationSurface)
+        ? task.path
+        : undefined);
     const authoritativeGuard = {
         task,
         baselineWorkspace: authority.baselineWorkspace,
+        verificationAuthority: authority.verificationAuthority,
     };
     const allowed = new Set(validateTaskBoundary(task));
     for (const allowedPath of allowed) {
@@ -1283,6 +1366,12 @@ async function validateContinueMerge(directory, state, anchor) {
         return "no-change";
     }
     const currentSha256 = await verifyMergedFileInvariants(state.repoRoot, task);
+    await validateControllerAuthorizedVerificationMerge({
+        repoRoot: state.repoRoot,
+        task,
+        surface: authority.verificationSurface,
+        guard: authoritativeGuard,
+    });
     if (pending && pending.guard.currentSha256 !== currentSha256) {
         throw new Error("pending merge acceptance current hash is inconsistent");
     }
@@ -1483,13 +1572,14 @@ async function createVerificationWriteAudit(input) {
     const failures = [];
     const watchers = [];
     const watched = new Set();
+    const canonicalRepoRoot = await realpath(input.repoRoot);
     const piHome = path.join(os.homedir(), ".pi");
     const anchor = await controllerAnchorPath(input.state);
     const note = (scope, file) => {
         events.push(`${scope}=${file.split(path.sep).join("/")}`);
     };
     const ignoredWorkspacePath = (candidate) => {
-        const relative = toRepoPath(input.repoRoot, candidate);
+        const relative = toRepoPath(canonicalRepoRoot, candidate);
         return (relative === ".git" ||
             relative.startsWith(".git/") ||
             relative === "node_modules" ||
@@ -1510,9 +1600,21 @@ async function createVerificationWriteAudit(input) {
                     : canonical;
                 if (ignore?.(candidate))
                     return;
-                note(scope, path.relative(directory, candidate) || ".");
-                // A parent rename can introduce a new directory.  The event is already
-                // a failure; installing its watcher closes the delayed-descendant gap.
+                let existingDirectory = false;
+                try {
+                    existingDirectory = lstatSync(candidate).isDirectory();
+                }
+                catch {
+                    // A removed or transient path is still a write-boundary event.
+                }
+                // Windows can report a parent-directory notification when a read-only
+                // traversal opens an existing child directory. Nested watchers own real
+                // mutations below that child; persistent changes are also snapshot-checked.
+                if (!existingDirectory) {
+                    note(scope, path.relative(directory, candidate) || ".");
+                }
+                // A parent rename can introduce a new directory. Installing its watcher
+                // closes the delayed-descendant gap even when the container event is noise.
                 void install(scope, candidate, ignore).catch((error) => {
                     const code = error.code;
                     if (code !== "ENOENT" && code !== "ENOTDIR") {
@@ -1536,7 +1638,7 @@ async function createVerificationWriteAudit(input) {
             await install(scope, child, ignore);
         }
     };
-    await install("workspace", input.repoRoot, ignoredWorkspacePath);
+    await install("workspace", canonicalRepoRoot, ignoredWorkspacePath);
     await install("controller", runRoot(input.repoRoot));
     await install("controller-anchor", anchor.anchorRoot);
     const piHomeEntry = await lstat(piHome).catch((error) => {
@@ -1901,14 +2003,24 @@ async function runVerificationCommand(input) {
     }
     return result;
 }
-async function discoverQuickVerification(repoRoot) {
-    const harness = JSON.parse(await readFile(path.join(repoRoot, "harness.json"), "utf-8"));
+function verificationMatrixPath(harness) {
     const governanceRoot = typeof harness.governanceRoot === "string"
         ? harness.governanceRoot
         : "ai_workspace/loop-agent";
-    const matrixPath = typeof harness.entrypoints?.verificationMatrix === "string"
+    return typeof harness.entrypoints?.verificationMatrix === "string"
         ? harness.entrypoints.verificationMatrix
         : `${governanceRoot}/verification-matrix.md`;
+}
+async function readVerificationHarness(repoRoot) {
+    const parsed = JSON.parse(await readFile(path.join(repoRoot, "harness.json"), "utf-8"));
+    if (!isRecord(parsed)) {
+        throw new Error("verification authority harness.json must contain a JSON object");
+    }
+    return parsed;
+}
+async function discoverQuickVerification(repoRoot) {
+    const harness = await readVerificationHarness(repoRoot);
+    const matrixPath = verificationMatrixPath(harness);
     await assertSafeMergePath(repoRoot, matrixPath);
     const matrix = await readFile(path.join(repoRoot, matrixPath), "utf-8");
     const targetTests = matrix.match(/^\|\s*target project tests are valid\s*\|\s*`([^`]+)`/im)?.[1];
@@ -2046,6 +2158,44 @@ async function runFinalVerification(state, authoritativeHomeFingerprint, surface
         humanDecisionClean: state.humanDecisions.length === 0,
     };
 }
+function authoritativeVerificationFailureReason(verification) {
+    const sources = [
+        verification.quickVerification,
+        verification.checkRepo,
+        verification.inspect,
+        verification.docsAudit,
+    ];
+    for (const source of sources) {
+        if (!isRecord(source))
+            continue;
+        const candidates = [
+            typeof source.error === "string" ? source.error : undefined,
+            source.exitCode === null && typeof source.stderr === "string"
+                ? source.stderr
+                : undefined,
+        ];
+        for (const value of candidates) {
+            if (!value)
+                continue;
+            for (const line of value.split(/\r?\n/)) {
+                const reason = line.trim();
+                if (reason.length <= 500 &&
+                    (reason ===
+                        "verification authority harness.json merge cannot change controller executor or workflow authority" ||
+                        reason ===
+                            "verification authority rejects direct node code evaluation" ||
+                        reason ===
+                            "verification authority rejects package command code evaluation" ||
+                        /^verification authority (?:surface changed|input is not a regular file): [A-Za-z0-9_./-]+$/.test(reason) ||
+                        reason ===
+                            "verification authority merge must retain the controller-frozen verification matrix path")) {
+                    return reason;
+                }
+            }
+        }
+    }
+    return undefined;
+}
 function verificationPassed(verification) {
     const doctor = verification.doctor;
     const inspect = verification.inspect;
@@ -2160,9 +2310,15 @@ async function executeUpgrade(directory, state, input) {
             nextAction: "Controller identity drift detected. Re-run with the frozen controller; no target-project writes were made.",
         };
     }
-    state.phase = "VERSION_GATE";
+    const recordedCurrentChoice = input.mode === "continue" &&
+        input.versionChoice === undefined &&
+        state.versionGate.choice === "current"
+        ? "current"
+        : undefined;
+    if (!recordedCurrentChoice)
+        state.phase = "VERSION_GATE";
     state.versionGate = await currentVersionGate(input, identity);
-    const choice = input.versionChoice;
+    const choice = input.versionChoice ?? recordedCurrentChoice;
     if (state.versionGate.outcome === "newer-available" && !choice) {
         state.status = "needs-human-decision";
         state.nextAction =
@@ -2274,6 +2430,13 @@ async function executeUpgrade(directory, state, input) {
         const activeTask = post.modelMergeTasks[0];
         const verificationSurface = await freezeVerificationSurface(state.repoRoot);
         assertTaskOutsideVerificationSurface(activeTask, verificationSurface);
+        if (verificationSurface.files.some((entry) => entry.path === normalizeAllowedPath(activeTask.path))) {
+            await validateControllerAuthorizedVerificationMerge({
+                repoRoot: state.repoRoot,
+                task: activeTask,
+                surface: verificationSurface,
+            });
+        }
         state.mergeTasks = [activeTask];
         state.mergeGuard = await createMergeGuard(state.repoRoot, activeTask);
         // Bind the Git-dir anchor to the state actually handed to the model.
@@ -2329,8 +2492,10 @@ async function executeUpgrade(directory, state, input) {
     }
     else {
         state.status = "failed";
-        state.nextAction =
-            "Verification failed. Inspect verification.json; repair only the controller-returned concrete merge path or address the reported external blocker, then use --continue.";
+        const authorityReason = authoritativeVerificationFailureReason(verification);
+        state.nextAction = authorityReason
+            ? `Verification failed: ${authorityReason}. Inspect verification.json, repair only the controller-returned concrete merge path, then use --continue.`
+            : "Verification failed. Inspect verification.json; repair only the controller-returned concrete merge path or address the reported external blocker, then use --continue.";
     }
     await saveState(directory, state);
     await writeReport(directory, state, verification);

package/dist/commands/init.js

@@ -2217,7 +2217,7 @@ function buildTargetFeatureWorkflow(input) {
         '- `taskKind: "backend-test"` selects the dedicated backend test DAG. Its Pi nodes analyze requirements, generate and review backend cases, generate pytest, and retrospect on results; shell gate/execution nodes enforce the review verdict and run the target project\'s pytest. The backend test templates (`backend-test-dag.json` and the `backend-test-dag.*.prompt.md` files) ship inside the loop-agent package as static references and are projected to target projects under the governance `templates/` directory.',
         '- `taskKind: "knowledge-sync"` selects the Feature-scoped test-knowledge write-back DAG (collect → draft → validate → apply → pointer). Bind `featureId` in `task.json` (or hardConstraints / requirement text). It writes only under `features/<featureId>/…` after final verification evidence exists.',
         '- `taskKind: "knowledge-graph-bootstrap"` selects the business knowledge-graph bootstrap DAG (preflight → inventory → propose → validate → review → gate → promote → materialize). AI writes only `knowledge/bootstrap/staging/**`; promote is merge-new-only.',
-        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headed <base-url>`; the generic playwright-cli skill is unchanged.',
+        '- `taskKind: "frontend-test"` selects the FE-test RAG DAG. It writes a traceable frontend RAG package and Markdown case manifest, then executes manifest cases serially with `playwright-cli` in isolated test environments and retains per-case evidence. It never generates pytest or Playwright source code. `frontendTest.maxCasesPerBatch` defaults to 20 (maximum 50); optional `maxTokensPerCase` and `maxTotalTokens` stop only later cases after a completed case\'s token usage is recorded, marking them `blocked: token-budget-exhausted`. Generated browser startup uses `playwright-cli open --browser=chrome --headless <base-url>`; the generic playwright-cli skill is unchanged.',
         "- Only eligible read-only Pi nodes (planner, scout, reviewer, verifier, closeout with no write-capable tool profile) receive the conservative automatic retry policy. Supervisor, implementer, writer, docs-only, dynamic, shell, static, and decision-gate nodes are not retried automatically. Eligible nodes cannot write repository files; the controller only records immutable attempt evidence under `.harness/dag-runs/<state>/<run-id>/<node-id>/attempt-<n>.json`.",
         "",
         "Use the package-backed public knowledge CLI for graph operations. Do not require target projects to run package-only kb runtime scripts:",