@tritard/waterbrother 0.16.111 → 0.16.112

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tritard/waterbrother",
-  "version": "0.16.111",
+  "version": "0.16.112",
   "description": "Waterbrother: bring-your-own-model coding CLI with local tools, sessions, operator modes, and approval controls",
   "type": "module",
   "bin": {

package/src/cli.js

@@ -1,5 +1,6 @@
 import { execFile, spawn } from "node:child_process";
 import fs from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
 import readline from "node:readline";
@@ -3244,47 +3245,54 @@ function formatTelegramVerificationSummary(result = {}) {
 
 async function runTelegramLocalVerification(cwd) {
   const planned = await planTelegramVerificationCommands(cwd);
+  const workspace = await resolveVerificationWorkspace(cwd);
   const commands = [];
   const startedAt = new Date().toISOString();
   const logs = [];
   let passedCount = 0;
-  for (const [bin, args, label] of planned) {
-    commands.push(label);
-    try {
-      await execFileAsync(bin, args, {
-        cwd,
-        env: { ...process.env },
-        maxBuffer: 8 * 1024 * 1024,
-        timeout: 10 * 60 * 1000
-      });
-      passedCount += 1;
-    } catch (error) {
-      const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
-      const extracted = combined
-        .split("\n")
-        .map((line) => String(line || "").trim())
-        .filter(Boolean)
-        .slice(0, 6);
-      logs.push(...extracted);
-      return {
-        outcome: error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed"),
-        summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
-        failedCommand: label,
-        commands,
-        startedAt,
-        completedAt: new Date().toISOString(),
-        logs
-      };
+  try {
+    for (const [bin, args, label] of planned) {
+      commands.push(label);
+      try {
+        await execFileAsync(bin, args, {
+          cwd: workspace.cwd,
+          env: { ...process.env },
+          maxBuffer: 8 * 1024 * 1024,
+          timeout: 10 * 60 * 1000
+        });
+        passedCount += 1;
+      } catch (error) {
+        const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
+        const extracted = combined
+          .split("\n")
+          .map((line) => String(line || "").trim())
+          .filter(Boolean)
+          .slice(0, 6);
+        logs.push(...extracted);
+        return {
+          outcome: error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed"),
+          summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
+          failedCommand: label,
+          isolation: workspace.isolation,
+          commands,
+          startedAt,
+          completedAt: new Date().toISOString(),
+          logs
+        };
+      }
     }
+    return {
+      outcome: "passed",
+      summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
+      isolation: workspace.isolation,
+      commands,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      logs
+    };
+  } finally {
+    await workspace.cleanup();
   }
-  return {
-    outcome: "passed",
-    summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
-    commands,
-    startedAt,
-    completedAt: new Date().toISOString(),
-    logs
-  };
 }
 
 async function chooseFromInteractiveMenu({ title, options, defaultIndex = 0 }) {
@@ -4843,6 +4851,91 @@ async function gitExec(args, { cwd, maxBuffer = 4 * 1024 * 1024, timeout = 30000
   return pfy(execFileCb)("git", args, { cwd, maxBuffer, timeout });
 }
 
+async function resolveVerificationWorkspace(cwd) {
+  const cleanup = async () => {};
+  let repoRoot = "";
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+      cwd,
+      maxBuffer: 256 * 1024,
+      timeout: 10000
+    });
+    repoRoot = String(stdout || "").trim();
+  } catch {
+    return { cwd, cleanup, isolation: "cwd" };
+  }
+  if (!repoRoot) {
+    return { cwd, cleanup, isolation: "cwd" };
+  }
+
+  const worktreeDir = await fs.mkdtemp(path.join(tmpdir(), "waterbrother-verify-"));
+  let attached = false;
+  const cleanupWorktree = async () => {
+    if (attached) {
+      try {
+        await execFileAsync("git", ["worktree", "remove", "--force", worktreeDir], {
+          cwd: repoRoot,
+          maxBuffer: 1024 * 1024,
+          timeout: 30000
+        });
+      } catch {}
+    }
+    await fs.rm(worktreeDir, { recursive: true, force: true }).catch(() => {});
+  };
+
+  try {
+    await execFileAsync("git", ["worktree", "add", "--detach", worktreeDir, "HEAD"], {
+      cwd: repoRoot,
+      maxBuffer: 1024 * 1024,
+      timeout: 30000
+    });
+    attached = true;
+
+    const copyRelativePath = async (relativePath) => {
+      const sourcePath = path.join(repoRoot, relativePath);
+      const targetPath = path.join(worktreeDir, relativePath);
+      await fs.mkdir(path.dirname(targetPath), { recursive: true });
+      await fs.cp(sourcePath, targetPath, { recursive: true, force: true });
+    };
+
+    const trackedChanged = await execFileAsync("git", ["diff", "--name-only", "-z", "HEAD"], {
+      cwd: repoRoot,
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 30000
+    }).catch(() => ({ stdout: "" }));
+    const deletedTracked = await execFileAsync("git", ["diff", "--name-only", "--diff-filter=D", "-z", "HEAD"], {
+      cwd: repoRoot,
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 30000
+    }).catch(() => ({ stdout: "" }));
+    const untracked = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+      cwd: repoRoot,
+      maxBuffer: 4 * 1024 * 1024,
+      timeout: 30000
+    }).catch(() => ({ stdout: "" }));
+
+    const deleted = new Set(String(deletedTracked.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean));
+    const tracked = String(trackedChanged.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean);
+    const extras = String(untracked.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean);
+
+    for (const relativePath of tracked) {
+      if (deleted.has(relativePath)) continue;
+      await copyRelativePath(relativePath);
+    }
+    for (const relativePath of extras) {
+      await copyRelativePath(relativePath);
+    }
+    for (const relativePath of deleted) {
+      await fs.rm(path.join(worktreeDir, relativePath), { recursive: true, force: true }).catch(() => {});
+    }
+
+    return { cwd: worktreeDir, cleanup: cleanupWorktree, isolation: "worktree" };
+  } catch {
+    await cleanupWorktree();
+    return { cwd, cleanup, isolation: "cwd" };
+  }
+}
+
 async function ensureGitRepo(cwd) {
   const check = await gitShell("git rev-parse --is-inside-work-tree", { cwd }).catch(() => null);
   if (!check || check.stdout.trim() !== "true") {

package/src/gateway.js

@@ -1,5 +1,6 @@
 import { execFile } from "node:child_process";
 import fs from "node:fs/promises";
+import { tmpdir } from "node:os";
 import path from "node:path";
 import process from "node:process";
 import { fileURLToPath } from "node:url";
@@ -589,6 +590,9 @@ function formatVerificationResultMarkup(result = {}, verifier = null) {
   if (result.failedCommand) {
     lines.push(`failed step: <code>${escapeTelegramHtml(String(result.failedCommand || ""))}</code>`);
   }
+  if (result.isolation) {
+    lines.push(`environment: <code>${escapeTelegramHtml(String(result.isolation || ""))}</code>`);
+  }
   if (Array.isArray(result.commands) && result.commands.length) {
     lines.push("commands:");
     for (const command of result.commands) {
@@ -3564,56 +3568,148 @@ class TelegramGateway {
     return commands;
   }
 
+  async resolveVerificationWorkspace(cwd) {
+    const cleanup = async () => {};
+    let repoRoot = "";
+    try {
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], {
+        cwd,
+        maxBuffer: 256 * 1024,
+        timeout: 10000
+      });
+      repoRoot = String(stdout || "").trim();
+    } catch {
+      return { cwd, cleanup, isolation: "cwd" };
+    }
+    if (!repoRoot) {
+      return { cwd, cleanup, isolation: "cwd" };
+    }
+
+    const worktreeDir = await fs.mkdtemp(path.join(tmpdir(), "waterbrother-verify-"));
+    let attached = false;
+    const cleanupWorktree = async () => {
+      if (attached) {
+        try {
+          await execFileAsync("git", ["worktree", "remove", "--force", worktreeDir], {
+            cwd: repoRoot,
+            maxBuffer: 1024 * 1024,
+            timeout: 30000
+          });
+        } catch {}
+      }
+      await fs.rm(worktreeDir, { recursive: true, force: true }).catch(() => {});
+    };
+
+    try {
+      await execFileAsync("git", ["worktree", "add", "--detach", worktreeDir, "HEAD"], {
+        cwd: repoRoot,
+        maxBuffer: 1024 * 1024,
+        timeout: 30000
+      });
+      attached = true;
+
+      const copyRelativePath = async (relativePath) => {
+        const sourcePath = path.join(repoRoot, relativePath);
+        const targetPath = path.join(worktreeDir, relativePath);
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.cp(sourcePath, targetPath, { recursive: true, force: true });
+      };
+
+      const trackedChanged = await execFileAsync("git", ["diff", "--name-only", "-z", "HEAD"], {
+        cwd: repoRoot,
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 30000
+      }).catch(() => ({ stdout: "" }));
+      const deletedTracked = await execFileAsync("git", ["diff", "--name-only", "--diff-filter=D", "-z", "HEAD"], {
+        cwd: repoRoot,
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 30000
+      }).catch(() => ({ stdout: "" }));
+      const untracked = await execFileAsync("git", ["ls-files", "--others", "--exclude-standard", "-z"], {
+        cwd: repoRoot,
+        maxBuffer: 4 * 1024 * 1024,
+        timeout: 30000
+      }).catch(() => ({ stdout: "" }));
+
+      const deleted = new Set(String(deletedTracked.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean));
+      const tracked = String(trackedChanged.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean);
+      const extras = String(untracked.stdout || "").split("\0").map((item) => item.trim()).filter(Boolean);
+
+      for (const relativePath of tracked) {
+        if (deleted.has(relativePath)) continue;
+        await copyRelativePath(relativePath);
+      }
+      for (const relativePath of extras) {
+        await copyRelativePath(relativePath);
+      }
+      for (const relativePath of deleted) {
+        await fs.rm(path.join(worktreeDir, relativePath), { recursive: true, force: true }).catch(() => {});
+      }
+
+      return { cwd: worktreeDir, cleanup: cleanupWorktree, isolation: "worktree" };
+    } catch {
+      await cleanupWorktree();
+      return { cwd, cleanup, isolation: "cwd" };
+    }
+  }
+
   async runLocalVerification(cwd, verifier = null) {
     const planned = await this.planVerificationCommands(cwd);
+    const workspace = await this.resolveVerificationWorkspace(cwd);
     const commands = [];
     const startedAt = new Date().toISOString();
     const logs = [];
     let passedCount = 0;
-    for (const [bin, args, label] of planned) {
-      commands.push(label);
-      try {
-        await execFileAsync(bin, args, {
-          cwd,
-          env: { ...process.env },
-          maxBuffer: 8 * 1024 * 1024,
-          timeout: 10 * 60 * 1000
-        });
-        passedCount += 1;
-      } catch (error) {
-        const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
-        const extracted = combined
-          .split("\n")
-          .map((line) => String(line || "").trim())
-          .filter(Boolean)
-          .slice(0, 6);
-        logs.push(...extracted);
-        const outcome = error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed");
-        return {
-          id: "",
-          workItemId: "",
-          verifierAgentId: String(verifier?.id || "").trim(),
-          outcome,
-          summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
-          failedCommand: label,
-          commands,
-          startedAt,
-          completedAt: new Date().toISOString(),
-          logs
-        };
+    try {
+      for (const [bin, args, label] of planned) {
+        commands.push(label);
+        try {
+          await execFileAsync(bin, args, {
+            cwd: workspace.cwd,
+            env: { ...process.env },
+            maxBuffer: 8 * 1024 * 1024,
+            timeout: 10 * 60 * 1000
+          });
+          passedCount += 1;
+        } catch (error) {
+          const combined = `${String(error?.stderr || "")}\n${String(error?.stdout || "")}`.trim();
+          const extracted = combined
+            .split("\n")
+            .map((line) => String(line || "").trim())
+            .filter(Boolean)
+            .slice(0, 6);
+          logs.push(...extracted);
+          const outcome = error?.killed || error?.signal === "SIGTERM" ? "timeout" : (passedCount > 0 ? "partial" : "failed");
+          return {
+            id: "",
+            workItemId: "",
+            verifierAgentId: String(verifier?.id || "").trim(),
+            outcome,
+            summary: `${label} failed${passedCount > 0 ? ` after ${passedCount} passing check${passedCount === 1 ? "" : "s"}` : ""}.`,
+            failedCommand: label,
+            isolation: workspace.isolation,
+            commands,
+            startedAt,
+            completedAt: new Date().toISOString(),
+            logs
+          };
+        }
       }
+      return {
+        id: "",
+        workItemId: "",
+        verifierAgentId: String(verifier?.id || "").trim(),
+        outcome: "passed",
+        summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
+        isolation: workspace.isolation,
+        commands,
+        startedAt,
+        completedAt: new Date().toISOString(),
+        logs: []
+      };
+    } finally {
+      await workspace.cleanup();
     }
-    return {
-      id: "",
-      workItemId: "",
-      verifierAgentId: String(verifier?.id || "").trim(),
-      outcome: "passed",
-      summary: `${commands.length} verification command${commands.length === 1 ? "" : "s"} passed.`,
-      commands,
-      startedAt,
-      completedAt: new Date().toISOString(),
-      logs: []
-    };
   }
 
   async startTypingLoop(chatId) {

package/src/shared-project.js

@@ -99,6 +99,7 @@ function normalizeVerificationResult(result = {}) {
     outcome: ["passed", "failed", "partial", "timeout"].includes(outcome) ? outcome : "failed",
     summary: String(result.summary || "").trim(),
     failedCommand: String(result.failedCommand || "").trim(),
+    isolation: String(result.isolation || "").trim(),
     commands,
     startedAt: String(result.startedAt || new Date().toISOString()).trim(),
     completedAt: String(result.completedAt || result.startedAt || new Date().toISOString()).trim(),