@tea-agent/loop-agent 0.28.12 → 0.29.0

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,54 @@
 
 ## [Unreleased]
 
+## [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
+
+### 重点更新
+
+- 显著缩短 CI 与发布流程的测试耗时，优化 2 vCPU runner 上的并发策略
+- 修复集成测试在多核环境下因工作区指纹竞态导致的不稳定问题
+
+### 改进
+
+- 优化 CI/发布环境的测试执行效率：固定 fast 测试池为 2 个 worker，移除重复的 pre-prepare 类型检查，并将 npm dist-tag 收敛轮询改为前快后慢的退避策略
+- 默认 fast 测试池现按可用 CPU 核数（上限 4）分配，避免在 2 核环境下意外退化为串行执行
+
+### 修复
+
+- 修复集成测试在多 worker 下因读取工作区指纹竞态导致的包校验不稳定问题，现固定集成测试为串行执行
+- 修复 pre-push 验证收据漂移测试受 CI 环境固定 worker 数量影响的问题，确保使用不同值以正确验证指纹失效场景
+
 ## [0.28.12] - 2026-08-06
 
 ### 重点更新
@@ -157,26 +205,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/executors/dag-pi-executor.js

@@ -8,6 +8,8 @@ import { cleanupPlaywrightCliDefaultSession, createPlaywrightCliTool, PI_COMMAND
 import { dagCommandPolicyAllows, resolveDagCommandPolicy, } from "../workflows/dag/types.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
 import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { isWriterEmptyDiffRetryCandidate, INCOMPLETE_WRITE_SET_RETRY_CATEGORY, WRITER_EMPTY_DIFF_RETRY_CATEGORY, } from "../workflows/dag/retry-policy.js";
+import { assessBackendTestMdWriterCompleteness, assessBackendTestPytestWriterCompleteness, classifyBackendTestWriterCompletenessFailure, isBackendTestCompletenessRetryCandidate, writeBackendTestWriterProgressArtifacts, } from "../workflows/dag/backend-test-writer-completeness.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 /** Bounded writer tools: no unrestricted bash; edit/write are policy-wrapped via SDK customTools. */
@@ -680,7 +682,39 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
             afterStatus: changeManifestAfterStatus ?? "",
         });
     }
-    if (writeGuardOk && !writerOutcomeViolation) {
+    let completenessFailure;
+    if (mapped.ok &&
+        writeGuardOk &&
+        !writerOutcomeViolation &&
+        isBackendTestCompletenessRetryCandidate(input.task)) {
+        try {
+            const progress = input.task.id === "generate-backend-pytest-pi"
+                ? await assessBackendTestPytestWriterCompleteness(input.cwd)
+                : await assessBackendTestMdWriterCompleteness(input.cwd);
+            await writeBackendTestWriterProgressArtifacts({
+                runDir: meta.runDir,
+                progress,
+                attempt: input.attempt ?? 1,
+                maxAttempts: input.task.retryPolicy?.maxAttempts ?? 3,
+            });
+            if (progress.status !== "PASS") {
+                const classified = classifyBackendTestWriterCompletenessFailure(progress);
+                completenessFailure = {
+                    failureCategory: classified.recoverable
+                        ? INCOMPLETE_WRITE_SET_RETRY_CATEGORY
+                        : "invalid-output",
+                    detail: `backend-test completeness gate ${progress.status}: targets=${progress.targetPaths.join(",") || "(none)"}; issues=${progress.issues.map((issue) => issue.detail).join("; ") || "none"}`,
+                };
+            }
+        }
+        catch (error) {
+            completenessFailure = {
+                failureCategory: "invalid-output",
+                detail: `backend-test completeness gate crashed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    if (writeGuardOk && !writerOutcomeViolation && !completenessFailure) {
         return mapped;
     }
     const stderrParts = [mapped.stderr];
@@ -690,6 +724,9 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     if (writerOutcomeViolation) {
         stderrParts.push(writerOutcomeViolation);
     }
+    if (completenessFailure) {
+        stderrParts.push(completenessFailure.detail);
+    }
     if (meta.writeGuardAttribution === "best-effort") {
         stderrParts.push("write guard note: concurrent rank writers use best-effort per-node attribution; keep same-rank writeSet entries disjoint");
     }
@@ -699,7 +736,13 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
         stderr: stderrParts.filter(Boolean).join("\n\n"),
         failureCategory: mapped.ok
             ? writeGuardOk
-                ? "invalid-output"
+                ? completenessFailure
+                    ? completenessFailure.failureCategory
+                    : changeManifestChangedFiles?.length === 0 &&
+                        isWriterEmptyDiffRetryCandidate(input.task) &&
+                        isChangedWriterImplementationOutcome(mapped.assistantText || mapped.stdout)
+                        ? WRITER_EMPTY_DIFF_RETRY_CATEGORY
+                        : "invalid-output"
                 : "write-guard"
             : mapped.failureCategory,
         durationMs: mapped.durationMs || Date.now() - started,
@@ -776,6 +819,10 @@ function parseWriterImplementationOutcome(text) {
 function isWriterImplementationOutcome(value) {
     return (value === "changed" || value === "already-satisfied" || value === "blocked");
 }
+function isChangedWriterImplementationOutcome(text) {
+    const parsed = parseWriterImplementationOutcome(text);
+    return parsed.kind === "valid" && parsed.outcome === "changed";
+}
 function writerOutcomeDiagnostics(text, parsed, changedFiles) {
     const firstNonEmpty = text
         .split(/\r?\n/)