@tea-agent/loop-agent 0.26.2 → 0.26.4

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/governance/document-index-closure.js

@@ -0,0 +1,164 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { pathMatchesPattern } from "../shared/git-progress.js";
+function normalizePath(value) {
+    return value.replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+$/, "");
+}
+function isConcreteRepoRelativePath(value) {
+    const normalized = normalizePath(value);
+    if (!normalized)
+        return false;
+    if (normalized === "." ||
+        normalized === "**" ||
+        normalized === "*" ||
+        normalized === "/*") {
+        return false;
+    }
+    if (normalized.includes("**") || normalized.includes("*"))
+        return false;
+    if (path.isAbsolute(normalized) || /^[A-Za-z]:\//.test(normalized))
+        return false;
+    if (normalized.split("/").some((segment) => segment === ".."))
+        return false;
+    return true;
+}
+function assertValidDirectoryIndexRule(rule, indexLabel) {
+    if (!rule || typeof rule !== "object" || Array.isArray(rule)) {
+        throw new Error(`document-index-closure: invalid completeDirectoryIndexes entry at ${indexLabel}`);
+    }
+    const record = rule;
+    if (typeof record.directory !== "string" ||
+        record.directory.trim().length === 0) {
+        throw new Error(`document-index-closure: completeDirectoryIndexes[${indexLabel}].directory must be a non-empty string`);
+    }
+    if (typeof record.index !== "string" || record.index.trim().length === 0) {
+        throw new Error(`document-index-closure: completeDirectoryIndexes[${indexLabel}].index must be a non-empty string`);
+    }
+    const directory = normalizePath(record.directory);
+    const index = normalizePath(record.index);
+    if (!isConcreteRepoRelativePath(directory)) {
+        throw new Error(`document-index-closure: completeDirectoryIndexes[${indexLabel}].directory must be a concrete repo-relative path (got "${record.directory}")`);
+    }
+    if (!isConcreteRepoRelativePath(index)) {
+        throw new Error(`document-index-closure: completeDirectoryIndexes[${indexLabel}].index must be a concrete repo-relative path without globs (got "${record.index}")`);
+    }
+    return { directory, index };
+}
+/**
+ * Load completeDirectoryIndexes from docs/document-catalog.json only.
+ * Does not hard-code a second directory table.
+ */
+export function loadCompleteDirectoryIndexes(repoRoot) {
+    const catalogPath = path.join(repoRoot, "docs", "document-catalog.json");
+    // The catalog is an opt-in governance surface. Projects that have not
+    // initialized it must still be able to generate DAGs for docs paths.
+    if (!existsSync(catalogPath))
+        return [];
+    let raw;
+    try {
+        raw = readFileSync(catalogPath, "utf-8");
+    }
+    catch (error) {
+        throw new Error(`document-index-closure: failed to read docs/document-catalog.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`document-index-closure: docs/document-catalog.json is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("document-index-closure: docs/document-catalog.json root must be an object");
+    }
+    const rulesRaw = parsed
+        .completeDirectoryIndexes;
+    if (rulesRaw === undefined) {
+        return [];
+    }
+    if (!Array.isArray(rulesRaw)) {
+        throw new Error("document-index-closure: completeDirectoryIndexes must be an array when present");
+    }
+    return rulesRaw.map((rule, index) => assertValidDirectoryIndexRule(rule, String(index)));
+}
+function candidateDirectoryPrefixes(candidatePath) {
+    const normalized = normalizePath(candidatePath);
+    if (!normalized)
+        return [];
+    // Treat trailing /** globs as directory roots for prefix matching.
+    const withoutGlob = normalized
+        .replace(/\/\*\*$/, "")
+        .replace(/\/\*$/, "")
+        .replace(/\*\*$/, "")
+        .replace(/\*$/, "");
+    const base = normalizePath(withoutGlob);
+    if (!base || base === "." || base === "**")
+        return [];
+    const segments = base.split("/").filter(Boolean);
+    const prefixes = [];
+    for (let i = segments.length; i >= 1; i -= 1) {
+        prefixes.push(segments.slice(0, i).join("/"));
+    }
+    return prefixes;
+}
+function longestMatchingRule(candidatePath, rules) {
+    const prefixes = new Set(candidateDirectoryPrefixes(candidatePath));
+    if (prefixes.size === 0)
+        return undefined;
+    let best;
+    for (const rule of rules) {
+        if (!prefixes.has(rule.directory) &&
+            !candidateUnderDirectory(candidatePath, rule.directory)) {
+            continue;
+        }
+        if (!best || rule.directory.length > best.directory.length) {
+            best = rule;
+        }
+    }
+    return best;
+}
+function candidateUnderDirectory(candidatePath, directory) {
+    const normalized = normalizePath(candidatePath)
+        .replace(/\/\*\*$/, "")
+        .replace(/\/\*$/, "");
+    const dir = normalizePath(directory);
+    return normalized === dir || normalized.startsWith(`${dir}/`);
+}
+/**
+ * Derive concrete companion index paths for candidate docs paths using catalog rules.
+ * Longest directory prefix wins. Throws fail-closed on forbidden conflicts.
+ */
+export function resolveDocumentIndexCompanions(input) {
+    const forbidden = input.forbiddenPaths ?? [];
+    const companions = new Set();
+    for (const candidate of input.candidatePaths) {
+        const rule = longestMatchingRule(candidate, input.rules);
+        if (!rule)
+            continue;
+        const indexPath = rule.index;
+        if (forbidden.some((pattern) => pathMatchesPattern(indexPath, pattern))) {
+            throw new Error(`document-index-closure: companion index "${indexPath}" for "${candidate}" conflicts with forbiddenPaths`);
+        }
+        companions.add(indexPath);
+    }
+    return [...companions].sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Convenience: load catalog and merge companion indexes into path lists.
+ */
+export function mergeDocumentIndexCompanions(input) {
+    const rules = loadCompleteDirectoryIndexes(input.repoRoot);
+    const companions = resolveDocumentIndexCompanions({
+        candidatePaths: input.paths,
+        rules,
+        forbiddenPaths: input.forbiddenPaths,
+    });
+    const merged = new Set(input.paths.map(normalizePath));
+    for (const companion of companions) {
+        merged.add(companion);
+    }
+    return {
+        paths: [...merged],
+        companions,
+    };
+}

package/dist/worker/observe/node-input.js

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import path from "node:path";
-import { redactSecrets, truncateUtf8Preview, } from "../../shared/preview.js";
+import { redactSecrets, truncateUtf8Preview } from "../../shared/preview.js";
 import { resolveDagNodeSkills } from "../../workflows/dag/skills.js";
 import { resolveDagNodePromptRedacted, resolveDagRunJson, } from "./dag-run-artifacts.js";
 export const NODE_INPUT_SCHEMA_VERSION = 1;
@@ -142,9 +142,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
         ? spec.defaults
         : undefined;
     const executorDeclared = typeof task.executor === "string";
-    const executor = executorDeclared
-        ? String(task.executor)
-        : "pi";
+    const executor = executorDeclared ? String(task.executor) : "pi";
     const executorSource = executorDeclared
         ? "task"
         : "schema-default";
@@ -190,7 +188,9 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
     const shellRaw = task.shell && typeof task.shell === "object" && !Array.isArray(task.shell)
         ? task.shell
         : null;
-    const staticRaw = task.static && typeof task.static === "object" && !Array.isArray(task.static)
+    const staticRaw = task.static &&
+        typeof task.static === "object" &&
+        !Array.isArray(task.static)
         ? task.static
         : null;
     let kind = "unknown";
@@ -206,9 +206,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             preset: typeof shellRaw.preset === "string"
                 ? redactSecrets(shellRaw.preset)
                 : null,
-            cwd: typeof shellRaw.cwd === "string"
-                ? redactSecrets(shellRaw.cwd)
-                : null,
+            cwd: typeof shellRaw.cwd === "string" ? redactSecrets(shellRaw.cwd) : null,
             timeoutMs: typeof shellRaw.timeoutMs === "number" &&
                 Number.isFinite(shellRaw.timeoutMs)
                 ? shellRaw.timeoutMs
@@ -216,6 +214,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             nonZeroExitPolicy: typeof shellRaw.nonZeroExitPolicy === "string"
                 ? shellRaw.nonZeroExitPolicy
                 : null,
+            failFast: typeof shellRaw.failFast === "boolean" ? shellRaw.failFast : null,
             gates: shellGateNames(shellRaw),
         }
         : null;
@@ -245,9 +244,7 @@ function projectTask(dagRunId, nodeId, lifecycle, spec, task, fingerprint, warni
             executor: redactString(executor),
             executorSource,
             role: typeof task.role === "string" ? redactSecrets(task.role) : null,
-            complexity: typeof task.complexity === "string"
-                ? task.complexity
-                : null,
+            complexity: typeof task.complexity === "string" ? task.complexity : null,
             writePolicy: writePolicy ? redactSecrets(writePolicy) : null,
             writePolicySource,
             toolProfile: typeof task.toolProfile === "string"

package/dist/workflows/dag/convergence/controller.js

@@ -1,4 +1,4 @@
-import { access, appendFile, cp, mkdir } from "node:fs/promises";
+import { access, appendFile, cp, mkdir, readFile } from "node:fs/promises";
 import path from "node:path";
 import { parseProcessVerdict } from "../node-execution.js";
 import { freshNodeRecord } from "../dynamic-runtime/shared.js";
@@ -120,7 +120,8 @@ export async function runConvergencePassController(input) {
         isLegitimateReviewRequestRevision(input.state)) {
         return handleReviewRequestRevision(input, reviewGate);
     }
-    if (reviewGate.status === "FINISHED") {
+    if (reviewGate.status === "FINISHED" &&
+        isLegitimateReviewPass(input.state)) {
         convergence.terminalReason = "review-pass";
         await appendConvergenceKnowledgePattern({
             cwd: input.cwd,
@@ -128,6 +129,9 @@ export async function runConvergencePassController(input) {
         });
         return { retry: false };
     }
+    if (reviewGate.status === "FINISHED") {
+        return handleReviewRequestRevision(input, reviewGate);
+    }
     // Compatibility: gates without routingAccept still ERROR on revision.
     if (reviewGate.status === "ERROR") {
         return handleReviewRequestRevision(input, reviewGate);
@@ -151,10 +155,14 @@ async function resolveNoRepairTerminal(input) {
             isLegitimateReviewRequestRevision(input.state)) {
             return handleReviewRequestRevision(input, reviewGate);
         }
-        if (reviewGate.status === "FINISHED") {
+        if (reviewGate.status === "FINISHED" &&
+            isLegitimateReviewPass(input.state)) {
             convergence.terminalReason = "review-pass";
             return { retry: false };
         }
+        if (reviewGate.status === "FINISHED") {
+            return handleReviewRequestRevision(input, reviewGate);
+        }
         if (reviewGate.status === "ERROR") {
             return handleReviewRequestRevision(input, reviewGate);
         }
@@ -178,10 +186,61 @@ async function resolveNoRepairTerminal(input) {
  * Hard verification failed. Apply the existing non-retry / regression /
  * max-passes guards, then reset the convergence chain for another pass.
  */
+function repairDispositionOf(artifact) {
+    return artifact?.disposition ?? "repairable";
+}
+function hardVerifyFailureFingerprint(input) {
+    return [
+        input.failureCategory ?? "unknown",
+        input.verifyPhase ?? "",
+        input.verifyQuota ?? "",
+        String(input.verifyCommandCount ?? ""),
+        (input.verifyCommandLabels ?? []).join("\n"),
+        (input.stderrExcerpt ?? "").slice(0, 500),
+    ].join("|");
+}
+function fingerprintFromHardVerify(hardVerify) {
+    const verifyEvidence = hardVerify.verifyEvidence;
+    // Keep fingerprint fields aligned with passHistory so consecutive passes
+    // compare the same identity (category + verifyEvidence command contract).
+    // stderr is intentionally excluded: pass history does not retain it, and
+    // empty repair manifests already prove no workspace progress.
+    return hardVerifyFailureFingerprint({
+        failureCategory: hardVerify.failureCategory,
+        verifyPhase: verifyEvidence?.phase,
+        verifyQuota: verifyEvidence?.quota,
+        verifyCommandCount: verifyEvidence?.commandCount,
+        verifyCommandLabels: verifyEvidence?.commandLabels,
+    });
+}
+function fingerprintFromPassHistory(pass) {
+    return hardVerifyFailureFingerprint({
+        failureCategory: pass.hardVerifyFailureCategory,
+        verifyPhase: pass.verifyPhase,
+        verifyQuota: pass.verifyQuota,
+        verifyCommandCount: pass.verifyCommandCount,
+        verifyCommandLabels: pass.verifyCommandLabels,
+    });
+}
+async function readRepairChangedFiles(runDir, repairNodeId = "repair-pi") {
+    try {
+        const raw = await readFile(path.join(runDir, repairNodeId, "change-manifest.json"), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed.changedFiles))
+            return [];
+        return parsed.changedFiles.filter((entry) => typeof entry === "string");
+    }
+    catch {
+        return undefined;
+    }
+}
 async function handleHardVerifyFailure(input, hardVerify) {
     const convergence = input.state.convergence;
     const currentPass = convergence.currentPass || 1;
     const hardFailure = hardVerify.failureCategory ?? "unknown";
+    const processSupervisor = input.state.nodes["process-supervisor-pi"];
+    const repairArtifact = processSupervisor?.repairArtifact;
+    const disposition = repairDispositionOf(repairArtifact);
     const passRecord = await buildConvergencePassRecord({
         pass: currentPass,
         status: "retrying",
@@ -198,6 +257,36 @@ async function handleHardVerifyFailure(input, hardVerify) {
         await input.persistState();
         return { retry: false };
     }
+    // AC-002: blocked-boundary stops re-entry of same-permission repair.
+    if (disposition === "blocked-boundary") {
+        passRecord.status = "terminal";
+        passRecord.reason = "blocked-boundary";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "blocked-boundary";
+        await input.persistState();
+        return { retry: false };
+    }
+    // AC-003: identical hard-verify failure fingerprint + empty repair
+    // change-manifest => no-progress early stop (does not exhaust maxFixLoops).
+    const currentFingerprint = fingerprintFromHardVerify(hardVerify);
+    const previousFailed = [...convergence.passHistory]
+        .reverse()
+        .find((pass) => pass.hardVerifyStatus === "ERROR");
+    const previousFingerprint = previousFailed
+        ? fingerprintFromPassHistory(previousFailed)
+        : undefined;
+    const changedFiles = await readRepairChangedFiles(input.runDir);
+    if (previousFingerprint !== undefined &&
+        previousFingerprint === currentFingerprint &&
+        changedFiles !== undefined &&
+        changedFiles.length === 0) {
+        passRecord.status = "terminal";
+        passRecord.reason = "no-progress";
+        convergence.passHistory.push(passRecord);
+        convergence.terminalReason = "no-progress";
+        await input.persistState();
+        return { retry: false };
+    }
     if (input.spec.convergence?.pauseOnRegression !== false &&
         detectConvergenceRegression(convergence.passHistory, passRecord)) {
         passRecord.status = "paused";
@@ -239,6 +328,14 @@ function isLegitimateReviewRequestRevision(state) {
         reviewVerdictNode?.status === "FINISHED" &&
         parseProcessVerdict(reviewVerdictNode) === "request-revision");
 }
+function isLegitimateReviewPass(state) {
+    const reviewNode = state.nodes["review-pi"];
+    const reviewVerdictNode = state.nodes[REVIEW_VERDICT_NODE_ID];
+    return (reviewNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewNode) === "pass" &&
+        reviewVerdictNode?.status === "FINISHED" &&
+        parseProcessVerdict(reviewVerdictNode) === "pass");
+}
 /**
  * Hard verification passed but the review path produced a legitimate
  * `request-revision`. With routingAccept the review gate finishes as a routing

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";