opencode-swarm 7.199.3 → 7.199.5

package/dist/cli/{index-4925h28w.js → index-xtda4xsn.js}

@@ -4,7 +4,7 @@ import {
   ensureTaskCheckpointReceipt,
   loadPlan,
   updateTaskCheckpointReceipt
-} from "./index-5jp79fag.js";
+} from "./index-gyz59cbh.js";
 import {
   tool
 } from "./index-9nyqt3kb.js";
@@ -14,16 +14,16 @@ import {
   isGitBinaryMissing,
   isSpawnCwdMissing,
   isSpawnCwdUnreadable
-} from "./index-g4fs6z4e.js";
+} from "./index-spggmr30.js";
 import {
   validateSwarmPath
-} from "./index-820pzqd6.js";
+} from "./index-b3ws03kp.js";
 import {
   readLedgerEvents
-} from "./index-ccpxq4yh.js";
+} from "./index-ybvnf7rt.js";
 import {
   appendCoreEventSync
-} from "./index-h349p91m.js";
+} from "./index-3mzc5rqc.js";
 import {
   derivePlanId,
   derivePlanIdentityHash
@@ -38,22 +38,27 @@ import {
 } from "./index-ejhxgyvm.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-ywb5er8g.js";
+} from "./index-270zfq1f.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-dgtvf04w.js";
+} from "./index-3ckvw3j2.js";
 import {
   init_git_executable,
-  resolveGitExecutable
-} from "./index-zxdawwc7.js";
+  resolveGitExecutable,
+  resolveGitExecutableAsync
+} from "./index-sp2cxpaq.js";
 import {
-  exports_external,
-  init_zod
-} from "./index-gknz3bv1.js";
+  bunSpawn,
+  init_bun_compat
+} from "./index-qbxk2rn6.js";
 import {
   init_logger,
   log
 } from "./index-zgwm4ryv.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
 
 // src/tools/checkpoint.ts
 init_zod();
@@ -62,12 +67,347 @@ import * as fs4 from "fs";
 import * as path5 from "path";
 
 // src/commands/destructive-purge.ts
-import { spawnSync } from "child_process";
 import { createHash, randomBytes } from "crypto";
 import * as fs from "fs";
-import * as path from "path";
-init_git_executable();
+import * as path2 from "path";
 init_logger();
+
+// src/commands/git-status-read.ts
+init_bun_compat();
+init_git_executable();
+var GIT_READ_DEFAULT_TIMEOUT_MS = 1e4;
+var GIT_READ_DEFAULT_MAX_BUFFER_BYTES = 1024 * 1024;
+var GIT_READ_STDERR_TAIL_MAX_CHARS = 200;
+var TRANSIENT_RETRY_CODES = new Set(["ETIMEDOUT", "EBUSY", "EPERM"]);
+function stderrTail(text) {
+  const tail = text.slice(-GIT_READ_STDERR_TAIL_MAX_CHARS);
+  return tail.replace(/[\x00-\x1f\x7f]+/g, " ").trim();
+}
+async function readBoundedOutput(stream, maxBytes) {
+  const reader = stream.getReader();
+  const chunks = [];
+  let totalBytes = 0;
+  let truncated = false;
+  try {
+    for (;; ) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (!value)
+        continue;
+      const remaining = maxBytes - totalBytes;
+      if (value.byteLength > remaining) {
+        if (remaining > 0)
+          chunks.push(value.slice(0, remaining));
+        truncated = true;
+        totalBytes += remaining;
+        continue;
+      }
+      chunks.push(value);
+      totalBytes += value.byteLength;
+    }
+    const joined = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      joined.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return { text: new TextDecoder().decode(joined), truncated };
+  } finally {
+    try {
+      reader.releaseLock();
+    } catch {}
+  }
+}
+async function readOnceDefault(args, cwd, timeoutMs, maxBufferBytes = GIT_READ_DEFAULT_MAX_BUFFER_BYTES, ignoreOutput = false) {
+  let proc;
+  let timer;
+  let resolutionTimer;
+  let childCompleted = false;
+  try {
+    const startedAt = Date.now();
+    const resolution = gitStatusReadInternals.resolveExecutable().then((executable2) => ({ kind: "resolved", executable: executable2 }));
+    resolution.catch(() => {});
+    const resolutionOutcome = await Promise.race([
+      resolution,
+      new Promise((resolve) => {
+        resolutionTimer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
+      })
+    ]);
+    if (resolutionTimer !== undefined) {
+      clearTimeout(resolutionTimer);
+      resolutionTimer = undefined;
+    }
+    if (resolutionOutcome.kind === "timeout") {
+      return { ok: false, code: "ETIMEDOUT", status: null, stderrTail: "" };
+    }
+    const executable = resolutionOutcome.executable;
+    const remainingMs = timeoutMs - (Date.now() - startedAt);
+    if (remainingMs <= 0) {
+      return { ok: false, code: "ETIMEDOUT", status: null, stderrTail: "" };
+    }
+    const options = {
+      cwd,
+      stdin: "ignore",
+      stdout: ignoreOutput ? "ignore" : "pipe",
+      stderr: ignoreOutput ? "ignore" : "pipe",
+      killProcessTree: true,
+      maxBuffer: ignoreOutput ? undefined : maxBufferBytes,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+    };
+    proc = gitStatusReadInternals.spawn([executable, ...args], options);
+    if (proc.spawnError) {
+      return {
+        ok: false,
+        code: proc.spawnError.code ?? null,
+        status: null,
+        stderrTail: ""
+      };
+    }
+    const completed = Promise.all([
+      proc.exited,
+      ignoreOutput ? Promise.resolve({ text: "", truncated: false }) : readBoundedOutput(proc.stdout, maxBufferBytes),
+      ignoreOutput ? Promise.resolve({ text: "", truncated: false }) : readBoundedOutput(proc.stderr, maxBufferBytes)
+    ]).then(([exitCode, stdout, stderr]) => ({
+      kind: "completed",
+      exitCode,
+      stdout,
+      stderr
+    }));
+    completed.catch(() => {});
+    const result = await Promise.race([
+      completed,
+      new Promise((resolve) => {
+        timer = setTimeout(() => resolve({ kind: "timeout" }), remainingMs);
+      })
+    ]);
+    if (result.kind === "timeout") {
+      return { ok: false, code: "ETIMEDOUT", status: null, stderrTail: "" };
+    }
+    childCompleted = true;
+    if (proc.spawnError) {
+      return {
+        ok: false,
+        code: proc.spawnError.code ?? null,
+        status: null,
+        stderrTail: stderrTail(result.stderr.text)
+      };
+    }
+    if (result.stdout.truncated || result.stderr.truncated) {
+      const partialStderr = stderrTail(result.stderr.text);
+      return {
+        ok: false,
+        code: "EOUTPUT",
+        status: null,
+        stderrTail: `output exceeded the ${maxBufferBytes}-byte bound${partialStderr ? `: ${partialStderr}` : ""}`
+      };
+    }
+    if (result.exitCode === null || result.exitCode === -1 || proc.signalCode != null) {
+      return {
+        ok: false,
+        code: "ESIGNAL",
+        status: null,
+        stderrTail: stderrTail(result.stderr.text)
+      };
+    }
+    if (result.exitCode !== 0) {
+      return {
+        ok: false,
+        code: null,
+        status: result.exitCode,
+        stderrTail: stderrTail(result.stderr.text)
+      };
+    }
+    return { ok: true, stdout: result.stdout.text };
+  } catch (err) {
+    return {
+      ok: false,
+      code: err?.code ?? null,
+      status: null,
+      stderrTail: ""
+    };
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+    if (resolutionTimer)
+      clearTimeout(resolutionTimer);
+    if (!childCompleted && proc && !proc.spawnError) {
+      try {
+        proc.kill("SIGKILL");
+      } catch {}
+      let reapTimer;
+      try {
+        await Promise.race([
+          proc.exited,
+          new Promise((resolve) => {
+            reapTimer = setTimeout(resolve, 2000);
+          })
+        ]);
+      } catch {} finally {
+        if (reapTimer)
+          clearTimeout(reapTimer);
+      }
+    }
+  }
+}
+var gitStatusReadInternals = {
+  readOnce: readOnceDefault,
+  resolveExecutable: () => resolveGitExecutableAsync(),
+  spawn: bunSpawn
+};
+async function readGitStatusAsync(args, cwd, opts) {
+  const timeoutMs = opts?.timeoutMs ?? GIT_READ_DEFAULT_TIMEOUT_MS;
+  const maxBufferBytes = opts?.maxBufferBytes ?? GIT_READ_DEFAULT_MAX_BUFFER_BYTES;
+  const first = await gitStatusReadInternals.readOnce(args, cwd, timeoutMs, maxBufferBytes);
+  if (first.ok || first.code === null)
+    return first;
+  if (!TRANSIENT_RETRY_CODES.has(first.code))
+    return first;
+  return gitStatusReadInternals.readOnce(args, cwd, timeoutMs, maxBufferBytes);
+}
+async function readGitRepositoryStatusAsync(cwd) {
+  const result = await gitStatusReadInternals.readOnce(["rev-parse", "--git-dir"], cwd, GIT_READ_DEFAULT_TIMEOUT_MS);
+  return result.ok;
+}
+
+// src/commands/rollback-gate.ts
+import * as fsSync from "fs";
+import * as path from "path";
+var ROLLBACK_GIT_KIND = "swarm-rollback-git";
+var ROLLBACK_PHASE_KIND = "swarm-rollback-phase";
+var GIT_LIST_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
+var _rollbackGateInternals = {
+  runGit: (args, cwd) => readGitStatusAsync(args, cwd),
+  runGitBuffered: (args, cwd) => readGitStatusAsync(args, cwd, {
+    maxBufferBytes: GIT_LIST_MAX_BUFFER_BYTES
+  })
+};
+async function readToString(raw) {
+  const value = await raw;
+  if (typeof value === "string")
+    return value;
+  if (value === null)
+    return null;
+  return value.ok ? value.stdout : null;
+}
+async function readFailureDetail(raw) {
+  const value = await raw;
+  if (value === null || typeof value === "string")
+    return null;
+  if (value.ok)
+    return null;
+  return {
+    code: value.code,
+    status: value.status,
+    stderrTail: value.stderrTail
+  };
+}
+function isRealGitRepository(directory) {
+  try {
+    if (fsSync.statSync(path.join(directory, ".git")).isFile())
+      return true;
+  } catch {
+    return false;
+  }
+  return fsSync.existsSync(path.join(directory, ".git", "HEAD"));
+}
+function parseTrackedDirtyPaths(statusOutput) {
+  const dirtyPaths = [];
+  const tokens = statusOutput.split("\x00");
+  for (let i = 0;i < tokens.length; i += 1) {
+    const token = tokens[i];
+    if (token === "" || token.length < 4)
+      continue;
+    const xy = token.slice(0, 2);
+    if (xy === "??")
+      continue;
+    const filePath = token.slice(3);
+    if (!filePath)
+      continue;
+    dirtyPaths.push(filePath);
+    if (/[RC]/.test(xy) && i + 1 < tokens.length && tokens[i + 1] !== "") {
+      dirtyPaths.push(tokens[i + 1]);
+      i += 1;
+    }
+  }
+  return dirtyPaths;
+}
+async function untrackedPathsInTargetTree(directory, targetSha) {
+  if (!isRealGitRepository(directory))
+    return [];
+  const targetTree = await readToString(await _rollbackGateInternals.runGitBuffered(["ls-tree", "-r", "-z", "--name-only", targetSha], directory));
+  const index = await readToString(await _rollbackGateInternals.runGitBuffered(["ls-files", "-z"], directory));
+  if (targetTree === null || index === null)
+    return [];
+  const indexed = new Set(index.split("\x00").filter((p) => p !== ""));
+  const inWay = [];
+  for (const rel of targetTree.split("\x00")) {
+    if (rel === "" || indexed.has(rel))
+      continue;
+    if (fsSync.existsSync(path.join(directory, rel)))
+      inWay.push(rel);
+  }
+  return inWay;
+}
+function trackedDirtyCandidates(directory, dirtyRelPaths) {
+  return dirtyRelPaths.map((rel) => ({
+    path: path.join(directory, rel),
+    reason: "uncommitted tracked change \u2014 destroyed by git reset --hard"
+  }));
+}
+function swarmOverwriteCandidates(directory, overwriteRelPaths) {
+  return overwriteRelPaths.map((rel) => ({
+    path: path.join(directory, ".swarm", rel),
+    reason: "live .swarm state replaced by the checkpoint copy"
+  }));
+}
+function describeUnreadableCause(measurement) {
+  if (measurement.code === "ETIMEDOUT") {
+    return "the read timed out (ETIMEDOUT) \u2014 the host may be unable to complete child spawns while loaded; restart the host and retry";
+  }
+  if (measurement.code === "EOUTPUT") {
+    return `the status output exceeded the read safety bound (${measurement.stderrTail ?? "output too large"}) \u2014 reduce the change footprint (commit or stash some work, or remove untracked bulk) and retry`;
+  }
+  if (measurement.code === "ESIGNAL") {
+    return "the git process was terminated before it answered (signal) \u2014 something external stopped it; retry, and inspect what terminates child processes if it recurs";
+  }
+  if (measurement.code === "ENOENT") {
+    return "the git executable was not found (ENOENT) \u2014 install git on PATH, or set git.binary in your USER-level config, and retry";
+  }
+  if (measurement.status !== null && measurement.status !== undefined) {
+    return `git status exited with status ${measurement.status}${measurement.stderrTail ? `: ${measurement.stderrTail}` : ""} \u2014 repair the repository state and retry`;
+  }
+  if (measurement.code) {
+    return `the read failed with code ${measurement.code} \u2014 retry, or inspect git status manually`;
+  }
+  return "retry, or inspect git status manually";
+}
+async function measureGitDestruction(directory, targetSha) {
+  if (!isRealGitRepository(directory)) {
+    return { kind: "ok", dirtyRelPaths: [] };
+  }
+  const raw = _rollbackGateInternals.runGit(["--no-optional-locks", "status", "--porcelain", "-z"], directory);
+  const status = await readToString(raw);
+  if (status === null) {
+    const failure = await readFailureDetail(raw);
+    return failure ? {
+      kind: "unreadable",
+      code: failure.code,
+      status: failure.status,
+      stderrTail: failure.stderrTail
+    } : { kind: "unreadable" };
+  }
+  const dirtyRelPaths = parseTrackedDirtyPaths(status);
+  if (targetSha) {
+    for (const rel of await untrackedPathsInTargetTree(directory, targetSha)) {
+      if (!dirtyRelPaths.includes(rel))
+        dirtyRelPaths.push(rel);
+    }
+  }
+  return { kind: "ok", dirtyRelPaths };
+}
+
+// src/commands/destructive-purge.ts
 var PENDING_PURGE_PATH = "pending-purge.json";
 var PENDING_PURGE_TTL_MS = 15 * 60 * 1000;
 var _internals = {
@@ -78,23 +418,26 @@ var _internals = {
   now: () => Date.now(),
   randomBytes,
   scopeDigest,
-  runGitStatus: runGitStatusSync
+  runGitStatus: (args, cwd) => readGitStatusAsync(args, cwd)
 };
-var GIT_STATUS_ARGS = ["status", "--porcelain"];
-function runGitStatusSync(args, cwd) {
-  const result = spawnSync(resolveGitExecutable(), args, {
-    cwd,
-    encoding: "utf8",
-    timeout: 1e4,
-    maxBuffer: 1024 * 1024,
-    windowsHide: true,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0)
+var GIT_STATUS_ARGS = [
+  "--no-optional-locks",
+  "status",
+  "--porcelain"
+];
+async function runGitStatusRead(args, cwd) {
+  const raw = await _internals.runGitStatus(args, cwd);
+  if (typeof raw === "string")
+    return { stdout: raw };
+  if (raw === null)
     return null;
-  return result.stdout ?? "";
+  if (raw.ok)
+    return { stdout: raw.stdout };
+  return {
+    cause: { code: raw.code, status: raw.status, stderrTail: raw.stderrTail }
+  };
 }
-function parseTrackedDirtyPaths(statusOutput) {
+function parseTrackedDirtyPaths2(statusOutput) {
   const dirtyPaths = [];
   for (const line of statusOutput.split(`
 `)) {
@@ -117,18 +460,20 @@ function parseTrackedDirtyPaths(statusOutput) {
   }
   return dirtyPaths;
 }
-function readTrackedDirtyPaths(directory) {
-  const statusOutput = _internals.runGitStatus(GIT_STATUS_ARGS, directory);
-  if (statusOutput === null)
+async function readTrackedDirtyPaths(directory) {
+  const read = await runGitStatusRead(GIT_STATUS_ARGS, directory);
+  if (read === null)
     return { ok: false };
-  return { ok: true, dirtyPaths: parseTrackedDirtyPaths(statusOutput) };
+  if ("cause" in read)
+    return { ok: false, failure: read.cause };
+  return { ok: true, dirtyPaths: parseTrackedDirtyPaths2(read.stdout) };
 }
-function recheckBeforeDestructive(directory, expectedDirtyPaths) {
-  const read = readTrackedDirtyPaths(directory);
+async function recheckBeforeDestructive(directory, expectedDirtyPaths) {
+  const read = await readTrackedDirtyPaths(directory);
   if (!read.ok) {
     return {
       ok: false,
-      reason: "git status could not be re-read before the destructive reset \u2014 the confirmed scope cannot be re-verified",
+      reason: `git status could not be re-read before the destructive reset \u2014 the confirmed scope cannot be re-verified${read.failure ? `. Cause: ${describeUnreadableCause(read.failure)}` : ""}`,
       newDirtyPaths: []
     };
   }
@@ -157,7 +502,7 @@ function resolveCandidates(scopeTarget, extra) {
 }
 function scopeDigest(kind, candidates) {
   const paths = candidates.map((c) => {
-    const resolved = path.resolve(c.path);
+    const resolved = path2.resolve(c.path);
     if (resolved.includes("\x00") || resolved.includes(`
 `)) {
       throw new Error(`Purge candidate path contains a NUL or newline separator character and cannot be scope-bound: ${JSON.stringify(resolved)}`);
@@ -289,12 +634,12 @@ function executeDestructivePurge(scopeTarget, projectRoot, token, extra) {
 
 // src/commands/reset-backup.ts
 import * as fs2 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
 var RESET_BACKUP_RETENTION = 5;
 function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
   const warnings = [];
   const copied = [];
-  const swarmDir = path2.join(directory, ".swarm");
+  const swarmDir = path3.join(directory, ".swarm");
   try {
     const stat = fs2.lstatSync(swarmDir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
@@ -306,8 +651,8 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
     return { backupDir: null, copied, warnings };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupsRoot = path2.join(swarmDir, opts?.backupsRoot ?? "reset-backups");
-  const backupDir = path2.join(backupsRoot, `${kind}-${timestamp}`);
+  const backupsRoot = path3.join(swarmDir, opts?.backupsRoot ?? "reset-backups");
+  const backupDir = path3.join(backupsRoot, `${kind}-${timestamp}`);
   let backupDirCreated = false;
   const ensureBackupDir = () => {
     if (!backupDirCreated) {
@@ -327,8 +672,8 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
       continue;
     try {
       ensureBackupDir();
-      const dest = path2.join(backupDir, rel);
-      fs2.mkdirSync(path2.dirname(dest), { recursive: true });
+      const dest = path3.join(backupDir, rel);
+      fs2.mkdirSync(path3.dirname(dest), { recursive: true });
       fs2.cpSync(src, dest, { recursive: true });
       copied.push(rel);
     } catch (err) {
@@ -343,7 +688,7 @@ function backupSwarmStateBeforeReset(directory, kind, relEntries, opts) {
     }
     return { backupDir: null, copied, warnings };
   }
-  pruneOldResetBackups(backupsRoot, warnings, path2.basename(backupDir));
+  pruneOldResetBackups(backupsRoot, warnings, path3.basename(backupDir));
   return { backupDir, copied, warnings };
 }
 var BACKUP_KIND_PREFIXES = [
@@ -367,7 +712,7 @@ function pruneOldResetBackups(backupsRoot, warnings, keepDirName) {
       if (stale.name === keepDirName)
         continue;
       try {
-        fs2.rmSync(path2.join(backupsRoot, stale.name), {
+        fs2.rmSync(path3.join(backupsRoot, stale.name), {
           recursive: true,
           force: true
         });
@@ -382,7 +727,7 @@ function pruneOldResetBackups(backupsRoot, warnings, keepDirName) {
 function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
   const warnings = [];
   const copied = [];
-  const swarmDir = path2.join(directory, ".swarm");
+  const swarmDir = path3.join(directory, ".swarm");
   try {
     const stat = fs2.lstatSync(swarmDir);
     if (stat.isSymbolicLink() || !stat.isDirectory()) {
@@ -394,8 +739,8 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
     return { backupDir: null, copied, warnings };
   }
   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
-  const backupsRoot = path2.join(swarmDir, "rollback-backups");
-  const backupDir = path2.join(backupsRoot, `rollback-git-${timestamp}`);
+  const backupsRoot = path3.join(swarmDir, "rollback-backups");
+  const backupDir = path3.join(backupsRoot, `rollback-git-${timestamp}`);
   let backupDirCreated = false;
   const ensureBackupDir = () => {
     if (!backupDirCreated) {
@@ -406,13 +751,13 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
   for (const rel of repoRelPaths) {
     if (!rel)
       continue;
-    const src = path2.join(directory, rel);
+    const src = path3.join(directory, rel);
     if (!fs2.existsSync(src))
       continue;
     try {
       ensureBackupDir();
-      const dest = path2.join(backupDir, "tracked", rel);
-      fs2.mkdirSync(path2.dirname(dest), { recursive: true });
+      const dest = path3.join(backupDir, "tracked", rel);
+      fs2.mkdirSync(path3.dirname(dest), { recursive: true });
       fs2.cpSync(src, dest, { recursive: true });
       copied.push(rel);
     } catch (err) {
@@ -427,123 +772,10 @@ function backupTrackedChangesBeforeRollback(directory, repoRelPaths) {
     }
     return { backupDir: null, copied, warnings };
   }
-  pruneOldResetBackups(backupsRoot, warnings, path2.basename(backupDir));
+  pruneOldResetBackups(backupsRoot, warnings, path3.basename(backupDir));
   return { backupDir, copied, warnings };
 }
 
-// src/commands/rollback-gate.ts
-init_git_executable();
-import { spawnSync as spawnSync2 } from "child_process";
-import * as fsSync from "fs";
-import * as path3 from "path";
-var ROLLBACK_GIT_KIND = "swarm-rollback-git";
-var ROLLBACK_PHASE_KIND = "swarm-rollback-phase";
-var GIT_STATUS_TIMEOUT_MS = 1e4;
-var GIT_LIST_MAX_BUFFER_BYTES = 32 * 1024 * 1024;
-var _rollbackGateInternals = {
-  runGit: (args, cwd) => {
-    const result = spawnSync2(resolveGitExecutable(), args, {
-      cwd,
-      encoding: "utf-8",
-      timeout: GIT_STATUS_TIMEOUT_MS,
-      windowsHide: true,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (result.error || result.status !== 0)
-      return null;
-    return result.stdout ?? "";
-  },
-  runGitBuffered: (args, cwd) => {
-    const result = spawnSync2(resolveGitExecutable(), args, {
-      cwd,
-      encoding: "utf-8",
-      timeout: GIT_STATUS_TIMEOUT_MS,
-      windowsHide: true,
-      maxBuffer: GIT_LIST_MAX_BUFFER_BYTES,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    if (result.error || result.status !== 0)
-      return null;
-    return result.stdout ?? "";
-  }
-};
-function isRealGitRepository(directory) {
-  try {
-    if (fsSync.statSync(path3.join(directory, ".git")).isFile())
-      return true;
-  } catch {
-    return false;
-  }
-  return fsSync.existsSync(path3.join(directory, ".git", "HEAD"));
-}
-function parseTrackedDirtyPaths2(statusOutput) {
-  const dirtyPaths = [];
-  const tokens = statusOutput.split("\x00");
-  for (let i = 0;i < tokens.length; i += 1) {
-    const token = tokens[i];
-    if (token === "" || token.length < 4)
-      continue;
-    const xy = token.slice(0, 2);
-    if (xy === "??")
-      continue;
-    const filePath = token.slice(3);
-    if (!filePath)
-      continue;
-    dirtyPaths.push(filePath);
-    if (/[RC]/.test(xy) && i + 1 < tokens.length && tokens[i + 1] !== "") {
-      dirtyPaths.push(tokens[i + 1]);
-      i += 1;
-    }
-  }
-  return dirtyPaths;
-}
-function untrackedPathsInTargetTree(directory, targetSha) {
-  if (!isRealGitRepository(directory))
-    return [];
-  const targetTree = _rollbackGateInternals.runGitBuffered(["ls-tree", "-r", "-z", "--name-only", targetSha], directory);
-  const index = _rollbackGateInternals.runGitBuffered(["ls-files", "-z"], directory);
-  if (targetTree === null || index === null)
-    return [];
-  const indexed = new Set(index.split("\x00").filter((p) => p !== ""));
-  const inWay = [];
-  for (const rel of targetTree.split("\x00")) {
-    if (rel === "" || indexed.has(rel))
-      continue;
-    if (fsSync.existsSync(path3.join(directory, rel)))
-      inWay.push(rel);
-  }
-  return inWay;
-}
-function trackedDirtyCandidates(directory, dirtyRelPaths) {
-  return dirtyRelPaths.map((rel) => ({
-    path: path3.join(directory, rel),
-    reason: "uncommitted tracked change \u2014 destroyed by git reset --hard"
-  }));
-}
-function swarmOverwriteCandidates(directory, overwriteRelPaths) {
-  return overwriteRelPaths.map((rel) => ({
-    path: path3.join(directory, ".swarm", rel),
-    reason: "live .swarm state replaced by the checkpoint copy"
-  }));
-}
-function measureGitDestruction(directory, targetSha) {
-  if (!isRealGitRepository(directory)) {
-    return { kind: "ok", dirtyRelPaths: [] };
-  }
-  const status = _rollbackGateInternals.runGit(["status", "--porcelain", "-z"], directory);
-  if (status === null) {
-    return { kind: "unreadable" };
-  }
-  const dirtyRelPaths = parseTrackedDirtyPaths2(status);
-  if (targetSha) {
-    for (const rel of untrackedPathsInTargetTree(directory, targetSha)) {
-      if (!dirtyRelPaths.includes(rel))
-        dirtyRelPaths.push(rel);
-    }
-  }
-  return { kind: "ok", dirtyRelPaths };
-}
-
 // src/tools/checkpoint.ts
 init_git_executable();
 
@@ -1214,7 +1446,7 @@ async function saveCheckpointRecord(label, directory) {
     })
   });
 }
-function handleRestore(label, directory, confirmToken) {
+async function handleRestore(label, directory, confirmToken) {
   try {
     const log2 = readCheckpointLog(directory);
     const checkpoint = log2.checkpoints.find((candidate) => candidate.label === label);
@@ -1224,11 +1456,12 @@ function handleRestore(label, directory, confirmToken) {
         error: `checkpoint not found: "${label}"`
       });
     }
-    const measurement = measureGitDestruction(directory, checkpoint.sha);
+    const measurement = await measureGitDestruction(directory, checkpoint.sha);
     if (measurement.kind === "unreadable") {
+      const cause = describeUnreadableCause(measurement);
       return serializeResult("restore", {
         success: false,
-        error: "cannot verify the working tree (git status unreadable) \u2014 refusing to restore without a preview. Retry, or inspect git status manually."
+        error: `cannot verify the working tree (git status unreadable; ${cause}) \u2014 refusing to restore without a preview.`
       });
     }
     if (measurement.dirtyRelPaths.length > 0) {
@@ -1509,7 +1742,7 @@ var checkpoint = createSwarmTool({
           action: "restore",
           directory,
           operationKey: `restore-${label}`,
-          run: async () => handleRestore(label, directory, confirmToken)
+          run: async () => await handleRestore(label, directory, confirmToken)
         });
       case "list":
         return handleList(directory);
@@ -1531,4 +1764,4 @@ var checkpoint = createSwarmTool({
   }
 });
 
-export { MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, GIT_STATUS_ARGS, parseTrackedDirtyPaths, recheckBeforeDestructive, previewDestructivePurge, issueConfirmToken, consumeConfirmToken, executeDestructivePurge, backupSwarmStateBeforeReset, ROLLBACK_GIT_KIND, ROLLBACK_PHASE_KIND, trackedDirtyCandidates, swarmOverwriteCandidates, measureGitDestruction, resolveWorkingDirectory, createSwarmTool, _internals2 as _internals, saveCheckpointRecord, checkpoint };
+export { MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, gitStatusReadInternals, readGitStatusAsync, readGitRepositoryStatusAsync, ROLLBACK_GIT_KIND, ROLLBACK_PHASE_KIND, trackedDirtyCandidates, swarmOverwriteCandidates, describeUnreadableCause, measureGitDestruction, GIT_STATUS_ARGS, parseTrackedDirtyPaths2 as parseTrackedDirtyPaths, recheckBeforeDestructive, previewDestructivePurge, issueConfirmToken, consumeConfirmToken, executeDestructivePurge, backupSwarmStateBeforeReset, resolveWorkingDirectory, createSwarmTool, _internals2 as _internals, saveCheckpointRecord, checkpoint };