@tea-agent/loop-agent 0.43.0-next.12 → 0.43.0-next.13

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
-  "version": "0.43.0-next.12",
-  "gitSha": "59f2e162841fbf8171ebaa6963c6cec95eb98512",
-  "builtAt": "2026-09-10T14:30:24.298Z"
+  "version": "0.43.0-next.13",
+  "gitSha": "4e92f5b2b1c43bc8971d9c9e6c21f76fa557189d",
+  "builtAt": "2026-09-11T00:55:37.486Z"
 }

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

@@ -94,48 +94,43 @@ const DAG_RUNS_PREFIX = ".harness/dag-runs/";
  * They are not product evidence and must not fail exclusive write guards.
  * Intentional report/product writes remain governed by writePolicy/writeSet.
  */
-export function isEphemeralToolCachePath(filePath) {
-    const normalized = normalizePath(filePath);
-    if (!normalized)
-        return false;
+const EPHEMERAL_CACHE_DIRS = [
     // CodeGraph extension sync side effect (plan 2026-08-21 D7): a loaded
     // pi-codegraph extension keeps an existing .codegraph/ index fresh at
     // session start; those index files are extension-owned run state, not
     // writer output, so they never count as write-guard violations.
-    if (normalized === ".codegraph" || normalized.startsWith(".codegraph/")) {
-        return true;
-    }
-    if (normalized === ".pytest_cache" ||
-        normalized.startsWith(".pytest_cache/")) {
-        return true;
-    }
-    if (normalized === ".mypy_cache" || normalized.startsWith(".mypy_cache/")) {
-        return true;
-    }
-    if (normalized === ".ruff_cache" || normalized.startsWith(".ruff_cache/")) {
-        return true;
-    }
+    ".codegraph",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".ruff_cache",
     // 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/")) {
-        return true;
-    }
-    if (normalized === ".coverage" || normalized.startsWith(".coverage.")) {
-        return true;
-    }
+    ".playwright-cli",
+];
+const EPHEMERAL_CACHE_DIR_PREFIXES = [
     // vite/vitest runtime caches live under node_modules/.vite (e.g.
     // node_modules/.vite/vitest/results.json). node_modules is the gitignored
     // dependency tree — tool cache writes there are never a writer's product
     // change and must not trip the write guard.
-    if (normalized.startsWith("node_modules/.vite/")) {
-        return true;
-    }
-    if (/(?:^|\/)__pycache__(?:\/|$)/.test(normalized))
-        return true;
-    if (/\.(?:pyc|pyo)$/.test(normalized))
-        return true;
-    return false;
+    "node_modules/.vite",
+];
+const EPHEMERAL_CACHE_FILES = new Set([".coverage"]);
+const EPHEMERAL_CACHE_PATH_PATTERNS = [
+    /(?:^|\/)__pycache__(?:\/|$)/,
+    /\.(?:pyc|pyo)$/,
+];
+function isExactOrChildPath(value, names) {
+    return names.some((name) => value === name || value.startsWith(`${name}/`));
+}
+export function isEphemeralToolCachePath(filePath) {
+    const normalized = normalizePath(filePath);
+    if (!normalized)
+        return false;
+    return (isExactOrChildPath(normalized, EPHEMERAL_CACHE_DIRS) ||
+        EPHEMERAL_CACHE_DIR_PREFIXES.some((prefix) => normalized.startsWith(`${prefix}/`)) ||
+        EPHEMERAL_CACHE_FILES.has(normalized) ||
+        normalized.startsWith(".coverage.") ||
+        EPHEMERAL_CACHE_PATH_PATTERNS.some((pattern) => pattern.test(normalized)));
 }
 /** MVP post-run guard: only paths that changed during the shell node are checked. */
 export function validateShellWriteGuard(input) {

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

@@ -24,6 +24,50 @@ export const frontendCommandCategorySchema = z.enum([
     "unit-test",
     "trace",
 ]);
+/**
+ * Ordered string-blob rules. Order is the contract: the first matching rule wins,
+ * so rules that share keywords keep their original precedence. `nodeIdIncludes`
+ * and `blobIncludes` are alternatives within one rule (logical OR).
+ */
+const BLOB_RULES = [
+    {
+        result: "contract",
+        nodeIdIncludes: ["contract"],
+        blobIncludes: ["contract mismatch", "source binding"],
+    },
+    { result: "trace", nodeIdIncludes: ["trace"], blobIncludes: ["trace:"] },
+    { result: "review", nodeIdIncludes: ["review"] },
+    {
+        result: "unit-test",
+        nodeIdIncludes: ["behavior"],
+        blobIncludes: ["vitest", "jest", "npm test"],
+    },
+    {
+        result: "typecheck",
+        blobIncludes: ["typecheck", "tsc"],
+        blobPatterns: [/error ts\d+/i],
+    },
+    { result: "lint", blobIncludes: ["eslint", "lint"] },
+    // "vite build"/"next build" are subsumed by "build".
+    { result: "build", blobIncludes: ["build"] },
+    {
+        result: "component-test",
+        blobIncludes: ["testing-library", "component", "render("],
+    },
+    {
+        result: "dependency",
+        blobIncludes: ["package.json", "unapproved dependency", "npm install"],
+    },
+    {
+        result: "credential",
+        blobIncludes: ["credential", "api key", "secret"],
+    },
+    { result: "deploy", blobIncludes: ["deploy", "production release"] },
+    {
+        result: "spec-unclear",
+        blobIncludes: ["spec unclear", "requirement ambiguous", "needs human"],
+    },
+];
 export function classifyFrontendFailure(input) {
     // AC-2: structured evidence takes priority over string-blob heuristics.
     if (input.failureCategory === "write-guard") {
@@ -39,86 +83,21 @@ export function classifyFrontendFailure(input) {
         return "trace";
     }
     if (input.commandCategory) {
-        switch (input.commandCategory) {
-            case "typecheck":
-                return "typecheck";
-            case "build":
-                return "build";
-            case "lint":
-                return "lint";
-            case "component-test":
-                return "component-test";
-            case "unit-test":
-                return "unit-test";
-        }
+        // "trace" already returned above, so the remaining categories map 1:1.
+        return input.commandCategory;
     }
-    // Fallback: string-blob heuristic, preserved in its original branch order so
-    // legacy assertions (error TS2304 → typecheck, write-guard → path, etc.) stay green.
+    // Fallback: ordered string-blob heuristics. Only the shell executor's
+    // structured category proves a write-boundary failure, so blob text never
+    // overrides the structured checks above.
     const blob = `${input.nodeId}\n${input.failureCategory ?? ""}\n${input.stdout ?? ""}\n${input.stderr ?? ""}`.toLowerCase();
-    if (input.nodeId.includes("contract") ||
-        blob.includes("contract mismatch") ||
-        blob.includes("source binding")) {
-        return "contract";
-    }
-    // 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 (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)) {
-        return "typecheck";
-    }
-    if (blob.includes("eslint") || blob.includes("lint")) {
-        return "lint";
-    }
-    if (blob.includes("build") ||
-        blob.includes("vite build") ||
-        blob.includes("next build")) {
-        return "build";
-    }
-    if (blob.includes("testing-library") ||
-        blob.includes("component") ||
-        blob.includes("render(")) {
-        return "component-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";
+    for (const rule of BLOB_RULES) {
+        if (rule.nodeIdIncludes?.some((keyword) => input.nodeId.includes(keyword)) ||
+            rule.blobIncludes?.some((keyword) => blob.includes(keyword)) ||
+            rule.blobPatterns?.some((pattern) => pattern.test(blob))) {
+            return rule.result;
+        }
     }
     if (input.failureCategory === "invalid-output")
         return "contract";
-    if (input.failureCategory === "write-guard")
-        return "path";
     return "unknown";
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.43.0-next.12",
+  "version": "0.43.0-next.13",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",
@@ -98,10 +98,13 @@
   },
   "devDependencies": {
     "@remixicon/react": "^4.9.0",
+    "@stryker-mutator/core": "^10.0.0",
+    "@stryker-mutator/vitest-runner": "^10.0.0",
     "@types/node": "^24.6.0",
     "@types/react": "^19.1.8",
     "@types/react-dom": "^19.1.6",
     "@types/semver": "^7.7.1",
+    "@vitest/coverage-v8": "^4.1.11",
     "react": "^19.1.0",
     "react-dom": "^19.1.0",
     "react-markdown": "^10.1.0",