@tea-agent/loop-agent 0.26.2 → 0.26.3

package/CHANGELOG.md

@@ -2,6 +2,29 @@
 
 ## [Unreleased]
 
+## [0.26.3] - 2026-08-02
+
+### 重点更新
+
+- DAG 无害工具副产物自动恢复
+- 提升前端验证命令的精确度与失败分类
+- 隔离测试固件与运行环境标记
+
+### 新增
+
+- DAG 无害工具副产物自动恢复：自动清理 Git Bash 误用 `> nul` / `2> nul` 在仓库根目录生成的普通非 symlink untracked `nul` 文件，避免其干扰 Git 状态复查与变更清单生成
+
+### 改进
+
+- 精确限定前端验证命令的作用域，提升验证执行的准确性
+- 更精准地分类前端验证失败原因，避免模糊报错
+- 将运行器标记与测试固件进行安全隔离，防止测试环境干扰
+
+### 修复
+
+- 修复配置验证目标错误处理符号引用的问题
+- 修复 DAG 执行中无害的根目录 nul 副产物导致流程异常的问题
+
 ## [0.26.2] - 2026-08-02
 
 ### 重点更新

package/dist/executors/dag-pi-executor.js

@@ -3,7 +3,7 @@ import { createHash } from "node:crypto";
 import { writeDagNodeJsonArtifact, writeTextArtifactFile, } from "../infrastructure/harness/artifact-store.js";
 import { executePiStep, } from "./pi-executor.js";
 import { redactPromptForLog, truncateOutput, } from "../shared/output-truncation.js";
-import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
+import { GitStatusUnavailableError, pathsChangedDuringRun, readGitStatusPorcelain, recoverRootNulArtifact, snapshotGitStatusPathFingerprints, snapshotGitStatusPorcelain, validateShellWriteGuard, } from "./shell-write-guard.js";
 import { redactSecrets, truncateUtf8Preview } from "../shared/preview.js";
 export const DAG_PI_READONLY_TOOLS = ["read", "grep", "find", "ls"];
 export const DAG_PI_WRITE_TOOLS = [
@@ -259,6 +259,7 @@ export async function writePiExecutorArtifacts(artifactsDir, input) {
 }
 const DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES = {
     readGitStatusPorcelain,
+    recoverRootNulArtifact,
 };
 export async function executeDagPiNode(input, meta, piStepFn = executePiStep, writeGuardDependencies = DEFAULT_DAG_PI_WRITE_GUARD_DEPENDENCIES) {
     const started = Date.now();
@@ -360,10 +361,105 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
     let changeManifestAfterStatus;
     let changeManifestChangedFiles;
     if (beforeStatus !== undefined) {
+        let recoveryEvidence;
+        let removalPendingRecheck;
         try {
-            const afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
-            const afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
-            const afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            let afterStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, { phase: "pi-writer-after" });
+            let afterSnapshot = snapshotGitStatusPorcelain(afterStatus);
+            let afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, afterSnapshot);
+            // Benign tool artifact recovery: a new untracked bounded regular file
+            // literally named `nul` at the repository root is removed with
+            // the Node file API, then git status is recaptured so the guard,
+            // outcome validation and change manifest only ever see the
+            // sanitized diff. Every non-matching candidate stays fail-closed.
+            if (afterSnapshot.has("nul")) {
+                const recoverRootNulArtifactFn = writeGuardDependencies.recoverRootNulArtifact ??
+                    recoverRootNulArtifact;
+                const recovery = await recoverRootNulArtifactFn({
+                    rootCwd: input.cwd,
+                    beforeSnapshot: snapshotGitStatusPorcelain(beforeStatus),
+                    afterSnapshot,
+                    afterPathFingerprints,
+                    candidateAuthorized: validateShellWriteGuardFromDiff({
+                        changedFiles: ["nul"],
+                        task: input.task,
+                        concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
+                    }).ok,
+                });
+                const beforeStatusSha256 = createHash("sha256")
+                    .update(beforeStatus)
+                    .digest("hex");
+                const afterStatusSha256 = createHash("sha256")
+                    .update(afterStatus)
+                    .digest("hex");
+                if (recovery.action === "removed") {
+                    const evidenceBase = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "recovered",
+                        result: "removed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        removedAt: recovery.removedAt,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                    };
+                    removalPendingRecheck = evidenceBase;
+                    const recheckedStatus = await writeGuardDependencies.readGitStatusPorcelain(input.cwd, {
+                        phase: "pi-writer-after-recheck",
+                    });
+                    const recheckedSnapshot = snapshotGitStatusPorcelain(recheckedStatus);
+                    afterStatus = recheckedStatus;
+                    afterSnapshot = recheckedSnapshot;
+                    afterPathFingerprints = await snapshotGitStatusPathFingerprints(input.cwd, recheckedSnapshot);
+                    recoveryEvidence = {
+                        ...evidenceBase,
+                        recheck: {
+                            statusSha256: createHash("sha256")
+                                .update(recheckedStatus)
+                                .digest("hex"),
+                            nulStillPresent: recheckedSnapshot.has("nul"),
+                        },
+                    };
+                    removalPendingRecheck = undefined;
+                }
+                else if (recovery.action === "skipped") {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "skipped",
+                        result: "kept",
+                        ...(recovery.observedSizeBytes === undefined
+                            ? {}
+                            : { observedSizeBytes: recovery.observedSizeBytes }),
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                }
+                else {
+                    recoveryEvidence = {
+                        candidatePath: "nul",
+                        reason: recovery.reason,
+                        action: "failed",
+                        result: "removal-failed",
+                        observedSizeBytes: recovery.observedSizeBytes,
+                        errorDetail: recovery.errorDetail,
+                        beforeStatusSha256,
+                        afterStatusSha256,
+                        recheck: {
+                            statusSha256: afterStatusSha256,
+                            nulStillPresent: true,
+                        },
+                    };
+                    writeGuardOk = false;
+                    writeGuardViolations = [
+                        `nul artifact removal failed: ${recovery.errorDetail}`,
+                    ];
+                }
+            }
             const changedFiles = pathsChangedDuringRun(snapshotGitStatusPorcelain(beforeStatus), afterSnapshot, beforePathFingerprints, afterPathFingerprints);
             changeManifestAfterStatus = afterStatus;
             changeManifestChangedFiles = changedFiles;
@@ -372,16 +468,35 @@ export async function executeDagPiNode(input, meta, piStepFn = executePiStep, wr
                 task: input.task,
                 concurrentSiblingWriteSets: meta.concurrentSiblingWriteSets,
             });
-            writeGuardOk = guard.ok;
-            writeGuardViolations = guard.violations;
+            writeGuardOk = writeGuardOk && guard.ok;
+            writeGuardViolations = [...writeGuardViolations, ...guard.violations];
         }
         catch (error) {
             await persistGitWriteGuardDiagnostics(meta.runDir, input.task.id, error);
+            if (removalPendingRecheck) {
+                // The artifact was already deleted but the recheck read failed:
+                // record the recovery facts with the recheck failure so the
+                // evidence trail stays complete while the node remains failed.
+                recoveryEvidence = {
+                    ...removalPendingRecheck,
+                    recheck: {
+                        failed: true,
+                        errorDetail: boundedRecoveryErrorDetail(error),
+                    },
+                };
+            }
             writeGuardOk = false;
             writeGuardViolations = [
                 `git status unavailable: ${error instanceof Error ? error.message : String(error)}`,
             ];
         }
+        if (recoveryEvidence) {
+            await persistBenignToolArtifactRecovery({
+                runDir: meta.runDir,
+                nodeId: input.task.id,
+                evidence: recoveryEvidence,
+            });
+        }
     }
     let writerOutcomeViolation;
     if (mapped.ok && input.task.writerOutcomePolicy) {
@@ -624,9 +739,7 @@ async function persistWriterGitBaseline(input) {
         nodeId: input.nodeId,
         phase: "pi-writer-before",
         capturedAt: new Date().toISOString(),
-        statusSha256: createHash("sha256")
-            .update(input.beforeStatus)
-            .digest("hex"),
+        statusSha256: createHash("sha256").update(input.beforeStatus).digest("hex"),
         dirtyPaths: [...input.beforeSnapshot.keys()].sort(),
         pathFingerprintsSha256: createHash("sha256")
             .update(JSON.stringify(fingerprintEntries))
@@ -639,6 +752,40 @@ async function persistGitWriteGuardDiagnostics(runDir, nodeId, error) {
         return;
     await writeDagNodeJsonArtifact(runDir, nodeId, "git-write-guard-diagnostics.json", error.diagnostics);
 }
+function boundedRecoveryErrorDetail(error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    return detail.length <= 1000
+        ? detail
+        : `${detail.slice(0, 1000)}...[truncated]`;
+}
+/**
+ * Persist bounded run-owned evidence for a recognized repository-root `nul`
+ * candidate: candidate path, reason, action, result and recheck facts plus
+ * status hashes. Never records environment variables or secrets.
+ */
+async function persistBenignToolArtifactRecovery(input) {
+    const artifact = {
+        schemaVersion: 1,
+        nodeId: input.nodeId,
+        candidatePath: input.evidence.candidatePath,
+        reason: input.evidence.reason,
+        action: input.evidence.action,
+        result: input.evidence.result,
+        ...(input.evidence.observedSizeBytes === undefined
+            ? {}
+            : { observedSizeBytes: input.evidence.observedSizeBytes }),
+        ...(input.evidence.errorDetail
+            ? { errorDetail: input.evidence.errorDetail }
+            : {}),
+        ...(input.evidence.removedAt
+            ? { removedAt: input.evidence.removedAt }
+            : {}),
+        beforeStatusSha256: input.evidence.beforeStatusSha256,
+        afterStatusSha256: input.evidence.afterStatusSha256,
+        recheck: input.evidence.recheck,
+    };
+    await writeDagNodeJsonArtifact(input.runDir, input.nodeId, "benign-tool-artifact-recovery.json", artifact);
+}
 /**
  * Validate the writer's observed diff against its declared write boundary.
  * Inlined mirror of runPostRunWriteGuard that reuses the already-computed diff

package/dist/executors/shell-write-guard.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
 import { constants, createReadStream } from "node:fs";
-import { access, lstat, readlink } from "node:fs/promises";
+import { access, lstat, readlink, unlink } from "node:fs/promises";
 import path from "node:path";
 import { pathMatchesPattern } from "../shared/git-progress.js";
 async function sha256File(filePath) {
@@ -58,8 +58,7 @@ export async function snapshotGitStatusPathFingerprints(cwd, status) {
     const entries = await Promise.all([...status.keys()].map(async (filePath) => {
         const candidate = path.resolve(root, filePath);
         const relative = path.relative(root, candidate);
-        if (relative.startsWith("..") ||
-            path.isAbsolute(relative)) {
+        if (relative.startsWith("..") || path.isAbsolute(relative)) {
             return [filePath, "outside-repository"];
         }
         try {
@@ -72,10 +71,7 @@ export async function snapshotGitStatusPathFingerprints(cwd, status) {
                 ];
             }
             if (info.isFile()) {
-                return [
-                    filePath,
-                    `file:${await sha256File(candidate)}`,
-                ];
+                return [filePath, `file:${await sha256File(candidate)}`];
             }
             return [
                 filePath,
@@ -101,7 +97,8 @@ export function isEphemeralToolCachePath(filePath) {
     const normalized = normalizePath(filePath);
     if (!normalized)
         return false;
-    if (normalized === ".pytest_cache" || normalized.startsWith(".pytest_cache/")) {
+    if (normalized === ".pytest_cache" ||
+        normalized.startsWith(".pytest_cache/")) {
         return true;
     }
     if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
@@ -112,7 +109,8 @@ export function isEphemeralToolCachePath(filePath) {
     }
     // playwright-cli default session dumps (console/page/network) under repo cwd.
     // Real browser case evidence must still be written under testcase/** explicitly.
-    if (normalized === ".playwright-cli" || normalized.startsWith(".playwright-cli/")) {
+    if (normalized === ".playwright-cli" ||
+        normalized.startsWith(".playwright-cli/")) {
         return true;
     }
     if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
@@ -164,6 +162,136 @@ export function validateShellWriteGuard(input) {
     }
     return { ok: violations.length === 0, violations };
 }
+/** SHA-256 of an empty file, retained for fingerprint tests and diagnostics. */
+export const EMPTY_FILE_SHA256 = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+/**
+ * A mistaken Git Bash `> nul` / `2> nul` target may contain bounded command
+ * output. Keep the recovery cap small enough that a material product artifact
+ * cannot be silently discarded while covering ordinary tool diagnostics.
+ */
+export const MAX_BENIGN_ROOT_NUL_BYTES = 1024 * 1024;
+/**
+ * Decide whether the exact repository-root `nul` entry is a benign tool
+ * artifact that may be removed. Every proof must hold: absent from the before
+ * snapshot, brand-new untracked (`??`) in the after snapshot, outside the
+ * writer's declared boundary, and currently inspected as a regular file no
+ * larger than {@link MAX_BENIGN_ROOT_NUL_BYTES}. Nested keys such as `src/nul`
+ * never match the exact root key; missing or unreadable facts stay fail-closed.
+ */
+export function evaluateRootNulCandidate(input) {
+    if (!input.afterSnapshot.has("nul")) {
+        return { action: "skip", candidatePath: "nul", reason: "nested-path" };
+    }
+    if (input.beforeSnapshot.has("nul")) {
+        return { action: "skip", candidatePath: "nul", reason: "pre-existing" };
+    }
+    if (input.afterSnapshot.get("nul") !== "??") {
+        return {
+            action: "skip",
+            candidatePath: "nul",
+            reason: "not-new-untracked",
+        };
+    }
+    if (input.candidateAuthorized === true) {
+        return {
+            action: "skip",
+            candidatePath: "nul",
+            reason: "authorized-by-write-boundary",
+        };
+    }
+    const fingerprint = input.afterPathFingerprints?.get("nul");
+    if (!fingerprint || fingerprint.startsWith("unreadable:")) {
+        return {
+            action: "skip",
+            candidatePath: "nul",
+            reason: "unreadable",
+        };
+    }
+    if (input.candidateIsRegularFile === false ||
+        !fingerprint.startsWith("file:")) {
+        return {
+            action: "skip",
+            candidatePath: "nul",
+            reason: "not-regular-file",
+        };
+    }
+    const observedSizeBytes = input.candidateSizeBytes ??
+        (fingerprint === `file:${EMPTY_FILE_SHA256}` ? 0 : undefined);
+    if (observedSizeBytes === undefined ||
+        !Number.isSafeInteger(observedSizeBytes) ||
+        observedSizeBytes < 0) {
+        return { action: "skip", candidatePath: "nul", reason: "unreadable" };
+    }
+    if (observedSizeBytes > MAX_BENIGN_ROOT_NUL_BYTES) {
+        return { action: "skip", candidatePath: "nul", reason: "too-large" };
+    }
+    return {
+        action: "remove",
+        candidatePath: "nul",
+        reason: "new-untracked-bounded-regular-file",
+        observedSizeBytes,
+    };
+}
+/**
+ * Remove a benign repository-root `nul` artifact with the Node file API only.
+ * On win32 libuv addresses the literal name through the `\\?\` NT path form, so
+ * a file literally named `nul` can be stat/unlink'ed precisely without shell
+ * redirection or `rm`. Non-matching candidates are left untouched; unlink
+ * failures surface as a bounded `failed` result so callers stay fail-closed.
+ */
+export async function recoverRootNulArtifact(input) {
+    let candidateSizeBytes;
+    let candidateIsRegularFile;
+    if (input.afterSnapshot.has("nul") &&
+        !input.beforeSnapshot.has("nul") &&
+        input.afterSnapshot.get("nul") === "??" &&
+        input.candidateAuthorized !== true) {
+        try {
+            const info = await lstat(path.resolve(input.rootCwd, "nul"));
+            candidateSizeBytes = info.size;
+            candidateIsRegularFile = info.isFile() && !info.isSymbolicLink();
+        }
+        catch {
+            candidateIsRegularFile = undefined;
+        }
+    }
+    const evaluation = evaluateRootNulCandidate({
+        beforeSnapshot: input.beforeSnapshot,
+        afterSnapshot: input.afterSnapshot,
+        afterPathFingerprints: input.afterPathFingerprints,
+        candidateSizeBytes,
+        candidateIsRegularFile,
+        candidateAuthorized: input.candidateAuthorized,
+    });
+    if (evaluation.action === "skip") {
+        return {
+            action: "skipped",
+            candidatePath: "nul",
+            reason: evaluation.reason,
+            ...(candidateSizeBytes === undefined ? {} : { observedSizeBytes: candidateSizeBytes }),
+        };
+    }
+    const removeFile = input.removeFile ?? ((filePath) => unlink(filePath));
+    try {
+        await removeFile(path.resolve(input.rootCwd, "nul"));
+        return {
+            action: "removed",
+            candidatePath: "nul",
+            reason: evaluation.reason,
+            observedSizeBytes: evaluation.observedSizeBytes,
+            removedAt: new Date().toISOString(),
+        };
+    }
+    catch (error) {
+        return {
+            action: "failed",
+            candidatePath: "nul",
+            reason: "removal-failed",
+            observedSizeBytes: evaluation.observedSizeBytes,
+            errorDetail: boundedErrorDetail(error),
+        };
+    }
+}
 export class GitStatusUnavailableError extends Error {
     diagnostics;
     constructor(input) {
@@ -179,7 +307,8 @@ export class GitStatusUnavailableError extends Error {
             cwd: path.resolve(input.cwd),
             platform: input.platform ?? process.platform,
             executableCandidates: input.executableCandidates ?? [],
-            requiredWindowsEnvironment: input.requiredWindowsEnvironment ?? requiredWindowsEnvironment(process.env),
+            requiredWindowsEnvironment: input.requiredWindowsEnvironment ??
+                requiredWindowsEnvironment(process.env),
             attempts: input.attempts,
         };
     }
@@ -216,11 +345,15 @@ function formatWindowsExitCode(exitCode) {
     return `0x${(exitCode >>> 0).toString(16).padStart(8, "0").toUpperCase()}`;
 }
 function isWindowsDllInitializationFailure(platform, exitCode) {
-    return platform === "win32" && exitCode !== undefined && (exitCode >>> 0) === 0xc0000142;
+    return (platform === "win32" &&
+        exitCode !== undefined &&
+        exitCode >>> 0 === 0xc0000142);
 }
 function boundedErrorDetail(error) {
     const detail = error instanceof Error ? error.message : String(error);
-    return detail.length <= 1000 ? detail : `${detail.slice(0, 1000)}...[truncated]`;
+    return detail.length <= 1000
+        ? detail
+        : `${detail.slice(0, 1000)}...[truncated]`;
 }
 export function deriveSameInstallationGitCandidates(primary) {
     const normalized = path.win32.normalize(primary);

package/dist/workflows/dag/frontend-repair.js

@@ -34,43 +34,31 @@ export function isFrontendRepairable(failureClass) {
 }
 export function classifyFrontendFailure(input) {
     const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
-    const failureDiagnosticBlob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
     if (input.nodeId.includes("contract") ||
         blob.includes("contract mismatch") ||
         blob.includes("source binding")) {
         return "contract";
     }
-    if (input.failureCategory === "write-guard" ||
-        failureDiagnosticBlob.includes("forbidden") ||
-        failureDiagnosticBlob.includes("write guard") ||
-        failureDiagnosticBlob.includes("write-set") ||
-        failureDiagnosticBlob.includes("writeset")) {
+    // Shell verification may contain test-runner logs from unrelated tests. Only
+    // the shell executor's structured category proves a write-boundary failure.
+    if (input.failureCategory === "write-guard") {
         return "path";
     }
-    if (blob.includes("package.json") ||
-        blob.includes("unapproved dependency") ||
-        blob.includes("npm install")) {
-        return "dependency";
-    }
-    if (blob.includes("credential") ||
-        blob.includes("api key") ||
-        blob.includes("secret")) {
-        return "credential";
-    }
-    if (blob.includes("deploy") || blob.includes("production release")) {
-        return "deploy";
-    }
-    if (blob.includes("spec unclear") ||
-        blob.includes("requirement ambiguous") ||
-        blob.includes("needs human")) {
-        return "spec-unclear";
-    }
     if (input.nodeId.includes("trace") || blob.includes("trace:")) {
         return "trace";
     }
     if (input.nodeId.includes("review")) {
         return "review";
     }
+    // Classify the failed verification command before inspecting its output.
+    // Full test output includes unrelated passing-test titles such as
+    // "secret-shaped" and "write-guard failure".
+    if (blob.includes("vitest") ||
+        blob.includes("jest") ||
+        blob.includes("npm test") ||
+        input.nodeId.includes("behavior")) {
+        return "unit-test";
+    }
     if (blob.includes("typecheck") ||
         blob.includes("tsc") ||
         /error ts\d+/i.test(blob)) {
@@ -89,11 +77,23 @@ export function classifyFrontendFailure(input) {
         blob.includes("render(")) {
         return "component-test";
     }
-    if (blob.includes("vitest") ||
-        blob.includes("jest") ||
-        blob.includes("npm test") ||
-        input.nodeId.includes("behavior")) {
-        return "unit-test";
+    if (blob.includes("package.json") ||
+        blob.includes("unapproved dependency") ||
+        blob.includes("npm install")) {
+        return "dependency";
+    }
+    if (blob.includes("credential") ||
+        blob.includes("api key") ||
+        blob.includes("secret")) {
+        return "credential";
+    }
+    if (blob.includes("deploy") || blob.includes("production release")) {
+        return "deploy";
+    }
+    if (blob.includes("spec unclear") ||
+        blob.includes("requirement ambiguous") ||
+        blob.includes("needs human")) {
+        return "spec-unclear";
     }
     if (input.failureCategory === "invalid-output")
         return "contract";

package/dist/workflows/dag/frontend-verification-trace.js

@@ -37,6 +37,9 @@ function symbolEvidenceCandidates(symbol) {
         return [symbol, describeTitle, "describe("];
     return [symbol];
 }
+function isConfigurationVerificationFile(file) {
+    return /(?:^|\/)(?:package\.json|tsconfig(?:\.[^/]+)?\.json|(?:vite|webpack|rollup|docusaurus)\.config\.[cm]?[jt]s)$/.test(file.replace(/\\/g, "/"));
+}
 async function assertFileAndSymbol(input) {
     const issues = [];
     const absolute = path.resolve(input.workspaceRoot, input.file);
@@ -94,6 +97,7 @@ export async function runFrontendVerificationTraceGate(input) {
             .join("; ")}`);
     }
     const contract = parsed.data;
+    const requiresBehaviorVerification = contract.verificationTargets.some((target) => target.type !== "static");
     // Prefer post-repair reverify nodes when present (M3); else initial verify nodes (M2).
     const staticCandidates = [
         "frontend-static-reverify-shell",
@@ -146,7 +150,8 @@ export async function runFrontendVerificationTraceGate(input) {
         if (input.evidence.static.commandLabels.length === 0) {
             throw new Error("trace: no successful static verification commands in current run");
         }
-        if (input.evidence.behavior.commandLabels.length === 0) {
+        if (requiresBehaviorVerification &&
+            input.evidence.behavior.commandLabels.length === 0) {
             throw new Error("trace: no successful behavior verification commands in current run");
         }
     }
@@ -181,7 +186,12 @@ export async function runFrontendVerificationTraceGate(input) {
         const fileIssues = await assertFileAndSymbol({
             workspaceRoot: input.workspaceRoot,
             file: target.file,
-            symbol: target.symbol,
+            // Configuration files prove that the command's entrypoint exists;
+            // they do not expose source symbols. LLMs sometimes derive a
+            // filename fragment such as "build" from tsconfig.build.json.
+            symbol: isConfigurationVerificationFile(target.file)
+                ? undefined
+                : target.symbol,
         });
         issues.push(...fileIssues);
         const status = issues.length ? "failed" : "ok";

package/dist/workflows/dag/governance-profile.js

@@ -106,7 +106,7 @@ function writeSetMatchesAnyPattern(writeSet, patterns) {
 function shellCommandLooksDeterministic(command) {
     const normalized = command.replace(/["']/g, "");
     return (/\bnpx vitest run\b/.test(normalized) ||
-        /\bnpm (?:run )?(?:lint|typecheck|test)\b/.test(normalized) ||
+        /\bnpm(?:\s+--prefix\s+\S+)*\s+(?:run\s+)?(?:lint|typecheck|test|build)\b/.test(normalized) ||
         /check-repo\.sh/.test(normalized) ||
         /\bshell\.preset\b/.test(normalized) ||
         /loop-agent-standard-verify/.test(normalized));

package/dist/workflows/dag/init-hybrid.js

@@ -890,7 +890,9 @@ function chooseFrontendVerifyCommands(input) {
     if (input.parsedCommands.length > 0) {
         return { commands: input.parsedCommands, commandSource: "inline" };
     }
-    if (input.adapterCommands && input.adapterCommands.length > 0) {
+    if (input.allowAdapter !== false &&
+        input.adapterCommands &&
+        input.adapterCommands.length > 0) {
         return { commands: input.adapterCommands, commandSource: "adapter" };
     }
     return { commandSource: "inline" };
@@ -2158,7 +2160,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         "Frontend planning must consume the read-only Mock assessment strategy produced after scouting; MOCK_STRATEGY: blocked must not pass the deterministic Mock contract gate.",
         "Mock implementations must preserve the real request path as the default, require explicit test/dev activation, and never rely on commenting out the real request.",
         "Mock-backed behavior evidence proves only the documented frontend contract, never real API integration.",
-        "frontend-implementation DAGs must complete deterministic static verification and behavior verification before final review.",
+        "frontend-implementation DAGs must complete deterministic static verification before final review. Behavior verification is also required when the task declares a behavior entrypoint or the implementation contract contains a non-static verification target; static-only contracts must map every target to the declared static entrypoint.",
         "frontend review must block closeout unless review verdict is exactly VERDICT: pass.",
         `Frontend risk classification: ${frontendRisk.selectedRisk} — ${frontendRisk.reason}`,
         frontendRisk.forceFullGates
@@ -2183,6 +2185,10 @@ async function buildFrontendHybridDagFromTask(sources) {
         ...explicitFrontendVerifyCommands.behaviorCommands,
     ].map(verifyCommandKey));
     const adapterVerifyCommands = (sources.verifyCommands?.final ?? []).filter((command) => !explicitCommandKeys.has(verifyCommandKey(command)));
+    const hasDeclaredFrontendVerification = explicitFrontendVerifyCommands.staticCommands.length > 0 ||
+        explicitFrontendVerifyCommands.behaviorCommands.length > 0 ||
+        parsedFrontendVerifyCommands.staticCommands.length > 0 ||
+        parsedFrontendVerifyCommands.behaviorCommands.length > 0;
     const staticVerifyCommands = chooseFrontendVerifyCommands({
         explicitCommands: explicitFrontendVerifyCommands.staticCommands,
         parsedCommands: parsedFrontendVerifyCommands.staticCommands,
@@ -2197,6 +2203,9 @@ async function buildFrontendHybridDagFromTask(sources) {
         explicitCommands: explicitFrontendVerifyCommands.behaviorCommands,
         parsedCommands: parsedFrontendVerifyCommands.behaviorCommands,
         adapterCommands: adapterVerifyCommands,
+        // A declared task verifier owns this task's verification boundary. A
+        // static-only task must not inherit unrelated root-level test commands.
+        allowAdapter: !hasDeclaredFrontendVerification,
     });
     const staticShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
@@ -2211,8 +2220,13 @@ async function buildFrontendHybridDagFromTask(sources) {
     const behaviorShellCommands = buildVerifyShellCommands({
         repoRoot: sources.repoRoot,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: hasDeclaredFrontendVerification
+            ? []
+            : behaviorFallbackCommands,
     });
+    const effectiveBehaviorFallbackCommands = hasDeclaredFrontendVerification
+        ? []
+        : behaviorFallbackCommands;
     const staticVerifyEvidence = buildVerifyEvidence({
         phase: "intermediate",
         quota: strategy.intermediateQuota ?? "full",
@@ -2238,7 +2252,7 @@ async function buildFrontendHybridDagFromTask(sources) {
         quota: "full",
         commandSource: behaviorVerifyCommands.commandSource,
         commands: behaviorVerifyCommands.commands,
-        fallbackCommands: behaviorFallbackCommands,
+        fallbackCommands: effectiveBehaviorFallbackCommands,
         commandTexts: behaviorShellCommands,
         finalFullRequired: true,
         commandTimeoutMs: DEFAULT_VERIFY_TIMEOUT_MS,
@@ -2352,7 +2366,7 @@ async function buildFrontendHybridDagFromTask(sources) {
                 subtask_prompt: [
                     "Audit the frontend plan before implementation.",
                     "First non-empty line must be exactly VERDICT: pass or VERDICT: request-revision.",
-                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for the selected strategy. Mock strategies require Mock-backed evidence. not-needed requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
+                    "Request revision when the Mock strategy is MOCK_STRATEGY: blocked, missing, unsupported by repository evidence, inconsistent with the API contract, outside authorized paths/dependencies, unable to prove production-default-off behavior with the fixed production/default-real-path static check, or missing deterministic behavior verification for a declared behavior target or selected Mock strategy. Mock strategies require Mock-backed evidence. A static-only contract is allowed only when every verification target is static and maps to a declared static entrypoint. not-needed otherwise requires applicable real/no-remote behavior evidence unless auto mode explicitly skipped Mock because no project Mock capability exists; in that case the plan must preserve the real request path and record the Real Integration Gap.",
                     "Also request revision for missing applicable UI states, unsupported dependency additions, design-system drift without reason, weak interaction coverage, broad scope, inline fake data, schema drift, or missing deterministic verification commands.",
                     "Read-only: do not modify repository files.",
                     fixedVerificationContext,

package/dist/workflows/dag/types.js

@@ -163,7 +163,7 @@ export const dagFrontendVerificationBundleSchema = z
     mockCommands: z.array(z.string()).default([]),
     lintCommands: z.array(z.string().min(1)).optional(),
     staticCommands: z.array(z.string()).min(1),
-    behaviorCommands: z.array(z.string()).min(1),
+    behaviorCommands: z.array(z.string()).default([]),
     mockEvidence: dagShellVerifyEvidenceSchema.optional(),
     lintEvidence: dagShellVerifyEvidenceSchema.optional(),
     staticEvidence: dagShellVerifyEvidenceSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.26.2",
+  "version": "0.26.3",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",