@tea-agent/loop-agent 0.39.0-next.2 → 0.39.0-next.3

package/dist/build-stamp.json

@@ -1,6 +1,6 @@
 {
   "schemaVersion": 1,
   "version": "0.37.0",
-  "gitSha": "4e502c40653f25c38302f1104e367d49bc950791",
-  "builtAt": "2026-08-17T08:09:21.899Z"
+  "gitSha": "944355b6e1204f12ebd4a7b0cc9c52fabff8ff97",
+  "builtAt": "2026-08-17T09:28:57.068Z"
 }

package/dist/commands/init-upgrade.js

@@ -938,6 +938,80 @@ function changedWorkspacePaths(before, after) {
         .filter((relativePath) => before[relativePath] !== after[relativePath])
         .sort();
 }
+/**
+ * Generated-output prefixes treated as verification noise when git ignore
+ * rules are unavailable (non-git target). In a git repo the authoritative
+ * filter is `.gitignore` via `git check-ignore`; this list only covers the
+ * common case where a verification command such as `npm run build` writes
+ * untracked artifacts (build/dist/coverage/...) into the workspace.
+ */
+const WORKSPACE_NOISE_PREFIXES = [
+    "node_modules/",
+    "build/",
+    "dist/",
+    "coverage/",
+    ".turbo/",
+    ".next/",
+    ".nuxt/",
+    ".cache/",
+    ".parcel-cache/",
+    ".vite/",
+    "out/",
+    "target/",
+    "__pycache__/",
+];
+function isWorkspaceNoisePath(relative) {
+    if (relative === ".git" || relative.startsWith(".git/"))
+        return true;
+    if (relative === RUN_ROOT || relative.startsWith(`${RUN_ROOT}/`))
+        return true;
+    return WORKSPACE_NOISE_PREFIXES.some((prefix) => relative === prefix.slice(0, -1) || relative.startsWith(prefix));
+}
+/**
+ * Filters changed workspace paths down to meaningful (non-generated) changes
+ * so a verification command that legitimately writes git-ignored artifacts is
+ * not misjudged as an unauthorized workspace mutation. Git ignore rules are
+ * authoritative when the target is a git repo; otherwise the built-in
+ * generated-output prefixes apply.
+ */
+async function filterWorkspaceNoise(repoRoot, relativePaths) {
+    const builtinFiltered = relativePaths.filter((relative) => !isWorkspaceNoisePath(relative));
+    if (builtinFiltered.length === 0)
+        return builtinFiltered;
+    const ignored = await gitIgnoredPaths(repoRoot, builtinFiltered);
+    if (ignored === null)
+        return builtinFiltered;
+    return builtinFiltered.filter((relative) => !ignored.has(relative));
+}
+/**
+ * Returns the subset of paths matched by git ignore rules, or null when the
+ * target is not a git repository (or git is unavailable), in which case the
+ * caller falls back to the built-in noise prefixes.
+ */
+async function gitIgnoredPaths(repoRoot, relativePaths) {
+    return await new Promise((resolve) => {
+        execFile("git", ["-C", repoRoot, "check-ignore", ...relativePaths], {
+            timeout: 15_000,
+            maxBuffer: 4 * 1024 * 1024,
+            windowsHide: true,
+        }, (error, stdout) => {
+            if (error) {
+                // `git check-ignore` exits 1 when no path is ignored: that is a
+                // successful lookup with an empty result set. Any other failure
+                // (e.g. 128 outside a repo) means the git filter is unavailable.
+                if (error.code === 1 && stdout.length === 0)
+                    resolve(new Set());
+                else
+                    resolve(null);
+                return;
+            }
+            resolve(new Set(stdout
+                .split("\n")
+                .filter(Boolean)
+                .map((entry) => entry.split(path.sep).join("/"))));
+        });
+    });
+}
 function isFrozenVerificationSurface(value) {
     return (isRecord(value) &&
         value.schemaVersion === 1 &&
@@ -1587,7 +1661,7 @@ async function validateContinueMerge(directory, state, anchor) {
         await assertSafeMergePath(state.repoRoot, allowedPath);
     }
     const current = await snapshotWorkspace(state.repoRoot);
-    const changed = changedWorkspacePaths(authoritativeGuard.baselineWorkspace, current);
+    const rawChanged = changedWorkspacePaths(authoritativeGuard.baselineWorkspace, current);
     const pending = await readPendingAcceptance({
         directory,
         state,
@@ -1602,6 +1676,10 @@ async function validateContinueMerge(directory, state, anchor) {
             pending,
         })
         : undefined;
+    // Only the out-of-bound drift check treats git-ignored/generated-output
+    // changes as noise; allowed-path changes are merge content and must stay
+    // intact even when the target is git-ignored (e.g. `.agents/skills/*`).
+    const changed = await filterWorkspaceNoise(state.repoRoot, rawChanged);
     const unexpected = changed.filter((relativePath) => {
         if (allowed.has(relativePath))
             return false;
@@ -1611,7 +1689,7 @@ async function validateContinueMerge(directory, state, anchor) {
     if (unexpected.length > 0) {
         throw new Error(`init upgrade merge write-guard blocked out-of-bound workspace changes: ${unexpected.join(", ")}`);
     }
-    const changedAllowed = changed.filter((relativePath) => allowed.has(relativePath));
+    const changedAllowed = rawChanged.filter((relativePath) => allowed.has(relativePath));
     if (changedAllowed.length === 0) {
         if (pending) {
             throw new Error("pending merge acceptance cannot authorize a merge without an allowed workspace change");
@@ -1834,16 +1912,8 @@ async function createVerificationWriteAudit(input) {
     const note = (scope, file) => {
         events.push(`${scope}=${file.split(path.sep).join("/")}`);
     };
-    const ignoredWorkspacePath = (candidate) => {
-        const relative = toRepoPath(canonicalRepoRoot, candidate);
-        return (relative === ".git" ||
-            relative.startsWith(".git/") ||
-            relative === "node_modules" ||
-            relative.startsWith("node_modules/") ||
-            relative === RUN_ROOT ||
-            relative.startsWith(`${RUN_ROOT}/`));
-    };
-    const install = async (scope, directory, ignore) => {
+    const ignoredWorkspacePath = (candidate) => isWorkspaceNoisePath(toRepoPath(canonicalRepoRoot, candidate));
+    const install = async (scope, directory, ignore, scopeRoot) => {
         const canonical = await realpath(directory);
         if (watched.has(canonical))
             return;
@@ -1867,11 +1937,11 @@ async function createVerificationWriteAudit(input) {
                 // 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) || ".");
+                    note(scope, path.relative(scopeRoot ?? 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) => {
+                void install(scope, candidate, ignore, scopeRoot).catch((error) => {
                     const code = error.code;
                     if (code !== "ENOENT" && code !== "ENOTDIR") {
                         failures.push(`watcher refresh failed for ${scope}: ${error instanceof Error ? error.message : String(error)}`);
@@ -1891,10 +1961,10 @@ async function createVerificationWriteAudit(input) {
             const child = path.join(canonical, entry.name);
             if (ignore?.(child) || !entry.isDirectory() || entry.isSymbolicLink())
                 continue;
-            await install(scope, child, ignore);
+            await install(scope, child, ignore, scopeRoot);
         }
     };
-    await install("workspace", canonicalRepoRoot, ignoredWorkspacePath);
+    await install("workspace", canonicalRepoRoot, ignoredWorkspacePath, canonicalRepoRoot);
     await install("controller", runRoot(input.repoRoot));
     await install("controller-anchor", anchor.anchorRoot);
     const piHomeEntry = await lstat(piHome).catch((error) => {
@@ -2194,17 +2264,25 @@ async function runVerificationCommand(input) {
         if (audit.failures.length)
             throw new Error(audit.failures.join("; "));
         await assertFrozenVerificationSurface(repoRoot, surface);
-        const changedWorkspace = changedWorkspacePaths(workspaceBefore, await snapshotWorkspace(repoRoot));
+        const changedWorkspace = await filterWorkspaceNoise(repoRoot, changedWorkspacePaths(workspaceBefore, await snapshotWorkspace(repoRoot)));
         const changedController = changedWorkspacePaths(controllerBefore, await snapshotDirectory(runRoot(repoRoot)));
         const changedAnchors = changedWorkspacePaths(anchorBefore, await controllerAnchorSnapshot(repoRoot, state));
         const changedPiHome = changedWorkspacePaths(piHomeBefore, await snapshotOptionalDirectory(path.join(os.homedir(), ".pi")));
-        if (descendantsObserved || audit.events.length || changedWorkspace.length || changedController.length || changedAnchors.length || changedPiHome.length) {
+        // Workspace watcher events are repo-root relative (see scopeRoot in
+        // createVerificationWriteAudit); drop git-ignored/generated-output noise
+        // before deciding whether the subprocess wrote the workspace.
+        const workspaceEvents = audit.events.filter((event) => event.startsWith("workspace="));
+        const remainingEvents = [
+            ...audit.events.filter((event) => !event.startsWith("workspace=")),
+            ...(await filterWorkspaceNoise(repoRoot, workspaceEvents.map((event) => event.slice("workspace=".length)))).map((relative) => `workspace=${relative}`),
+        ];
+        if (descendantsObserved || remainingEvents.length || changedWorkspace.length || changedController.length || changedAnchors.length || changedPiHome.length) {
             return {
                 ...result,
                 ok: false,
                 stderr: boundedOutput(`${result.stderr}\nverification write guard blocked changes: ${[
                     ...(descendantsObserved ? ["process-tree=descendant"] : []),
-                    ...(audit.events.length ? [`events=${audit.events.join(",")}`] : []),
+                    ...(remainingEvents.length ? [`events=${remainingEvents.join(",")}`] : []),
                     ...(changedWorkspace.length ? [`workspace=${changedWorkspace.join(",")}`] : []),
                     ...(changedController.length ? [`controller=${changedController.join(",")}`] : []),
                     ...(changedAnchors.length ? [`controller-anchor=${changedAnchors.join(",")}`] : []),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tea-agent/loop-agent",
-  "version": "0.39.0-next.2",
+  "version": "0.39.0-next.3",
   "type": "module",
   "bin": {
     "loop-agent": "bin/loop-agent.js",