@organizaone/o1-code 0.4.0 → 0.5.1

package/chunks/{chunk-S2LBLNBW.js → chunk-CMZHL55Y.js}

@@ -1,16 +1,22 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  isUnverifiableIdentityError,
+  openNoFollow
+} from "./chunk-DJOP5LOE.js";
 import {
   isCommandAvailable
-} from "./chunk-J5BDFZYA.js";
+} from "./chunk-V23Q4GBY.js";
 import {
   NO_EXEC_CONFIG,
-  NO_EXEC_CONFIG_SETTINGS
+  NO_EXEC_CONFIG_SETTINGS,
+  findGitRoot,
+  readFirstLineNoFollow
 } from "./chunk-IO32UWHY.js";
 import {
   fileExists,
   isWithinRoot
-} from "./chunk-E4BNWSC7.js";
+} from "./chunk-H5L5E5NI.js";
 import {
   atomicWriteFile,
   atomicWriteJSON
@@ -121,11 +127,1963 @@ __name(isFiniteInteger, "isFiniteInteger");
 // packages/core/src/services/gitWorktreeService.ts
 init_esbuild_shims();
 import nodeFs from "node:fs";
-import * as fs2 from "node:fs/promises";
-import * as path2 from "node:path";
+import * as fs4 from "node:fs/promises";
+import * as path5 from "node:path";
 import { randomBytes, randomInt } from "node:crypto";
-import { execFile, execSync } from "node:child_process";
+import { execFile as execFile3, execSync } from "node:child_process";
+import { promisify as promisify3 } from "node:util";
+
+// packages/core/src/utils/git-branches.ts
+init_esbuild_shims();
+import { execFile as execFile2 } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// packages/core/src/utils/gitDirect.ts
+init_esbuild_shims();
+import * as fs2 from "node:fs";
+import * as fsPromises from "node:fs/promises";
+import * as path3 from "node:path";
+
+// packages/core/src/utils/gitDiff.ts
+init_esbuild_shims();
+import { execFile } from "node:child_process";
+import { access, lstat, open, readFile as readFile2, stat } from "node:fs/promises";
+import * as path2 from "node:path";
 import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var GIT_TIMEOUT_MS = 5e3;
+var MAX_FILES = 50;
+var MAX_DIFF_SIZE_BYTES = 1e6;
+var MAX_LINES_PER_FILE = 400;
+var MAX_FILES_FOR_DETAILS = 500;
+var EMPTY_STATS = {
+  filesCount: 0,
+  linesAdded: 0,
+  linesRemoved: 0
+};
+var UNTRACKED_READ_CAP_BYTES = MAX_DIFF_SIZE_BYTES;
+var UNTRACKED_READ_CHUNK_BYTES = 64 * 1024;
+var BINARY_SNIFF_BYTES = 8 * 1024;
+async function openUntrackedForDiffRead(absPath) {
+  try {
+    return await openNoFollow(absPath);
+  } catch (error) {
+    if (!isUnverifiableIdentityError(error)) return void 0;
+  }
+  try {
+    return await open(absPath);
+  } catch {
+    return void 0;
+  }
+}
+__name(openUntrackedForDiffRead, "openUntrackedForDiffRead");
+async function fetchGitDiff(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  if (await isInTransientGitState(gitRoot)) return null;
+  const [shortstatOut, untrackedOut] = await Promise.all([
+    runGit(
+      [
+        "--no-optional-locks",
+        "diff",
+        "--no-ext-diff",
+        "--no-textconv",
+        "HEAD",
+        "--shortstat"
+      ],
+      gitRoot
+    ),
+    runGit(
+      [
+        "--no-optional-locks",
+        "ls-files",
+        "-z",
+        "--others",
+        "--exclude-standard"
+      ],
+      gitRoot
+    )
+  ]);
+  const untrackedCount = countNulDelimited(untrackedOut);
+  const quickStats = shortstatOut != null && parseShortstat(shortstatOut) || EMPTY_STATS;
+  if (quickStats.filesCount + untrackedCount > MAX_FILES_FOR_DETAILS) {
+    return {
+      stats: {
+        ...quickStats,
+        filesCount: quickStats.filesCount + untrackedCount
+      },
+      perFileStats: /* @__PURE__ */ new Map()
+    };
+  }
+  const [numstatOut, nameStatusOut] = await Promise.all([
+    runGit(
+      [
+        "--no-optional-locks",
+        "diff",
+        "--no-ext-diff",
+        "--no-textconv",
+        "HEAD",
+        "--numstat",
+        "-z"
+      ],
+      gitRoot
+    ),
+    runGit(
+      [
+        "--no-optional-locks",
+        "diff",
+        "--no-ext-diff",
+        "--no-textconv",
+        "HEAD",
+        "--name-status",
+        "-z"
+      ],
+      gitRoot
+    )
+  ]);
+  if (numstatOut == null) return null;
+  const { stats, perFileStats } = parseGitNumstat(numstatOut);
+  const deletedPaths = nameStatusOut != null ? parseDeletedFromNameStatus(nameStatusOut) : null;
+  if (deletedPaths && deletedPaths.size > 0) {
+    for (const [filename, s] of perFileStats) {
+      if (deletedPaths.has(filename)) s.isDeleted = true;
+    }
+  }
+  if (untrackedCount > 0) {
+    stats.filesCount += untrackedCount;
+    const untrackedPaths = splitNulDelimited(untrackedOut);
+    const lineStats = await mapWithConcurrency(
+      untrackedPaths,
+      MAX_FILES,
+      (relPath) => countUntrackedLines(path2.join(gitRoot, relPath))
+    );
+    for (const s of lineStats) stats.linesAdded += s.added;
+    const remainingSlots = Math.max(0, MAX_FILES - perFileStats.size);
+    const visibleCount = Math.min(remainingSlots, untrackedPaths.length);
+    for (let i = 0; i < visibleCount; i++) {
+      const relPath = untrackedPaths[i] ?? "";
+      const u = lineStats[i] ?? {
+        added: 0,
+        isBinary: false,
+        truncated: false
+      };
+      perFileStats.set(relPath, {
+        added: u.added,
+        removed: 0,
+        isBinary: u.isBinary,
+        isUntracked: true,
+        truncated: u.truncated
+      });
+    }
+  }
+  return { stats, perFileStats };
+}
+__name(fetchGitDiff, "fetchGitDiff");
+async function fetchGitDiffHunks(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return /* @__PURE__ */ new Map();
+  if (await isInTransientGitState(gitRoot)) return /* @__PURE__ */ new Map();
+  const diffOut = await runGit(
+    ["--no-optional-locks", "diff", "--no-ext-diff", "--no-textconv", "HEAD"],
+    gitRoot
+  );
+  if (diffOut == null) return /* @__PURE__ */ new Map();
+  return parseGitDiff(diffOut);
+}
+__name(fetchGitDiffHunks, "fetchGitDiffHunks");
+async function fetchGitDiffHunksForFile(cwd, filePath, oldPath) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const relPath = toRepoRelativePath(gitRoot, filePath);
+  if (relPath === null) return null;
+  if (await isInTransientGitState(gitRoot)) return null;
+  const oldRelPath = oldPath != null ? toRepoRelativePath(gitRoot, oldPath) : null;
+  const diffArgs = [
+    "--no-optional-locks",
+    "diff",
+    "--no-ext-diff",
+    "--no-textconv"
+  ];
+  if (oldRelPath != null) diffArgs.push("-M");
+  diffArgs.push("HEAD", "--");
+  if (oldRelPath != null) diffArgs.push(oldRelPath);
+  diffArgs.push(relPath);
+  const diffOut = await runGit(diffArgs, gitRoot);
+  if (diffOut == null) return null;
+  const truncatedPaths = /* @__PURE__ */ new Set();
+  const parsed = parseGitDiff(diffOut, truncatedPaths);
+  if (parsed.size > 0) {
+    const [key, hunks] = parsed.entries().next().value;
+    return { hunks: hunks ?? [], truncated: truncatedPaths.has(key) };
+  }
+  const untrackedOut = await runGit(
+    [
+      "--no-optional-locks",
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "--",
+      relPath
+    ],
+    gitRoot
+  );
+  if (untrackedOut && untrackedOut.trim().length > 0) {
+    return synthesizeUntrackedHunk(gitRoot, relPath);
+  }
+  return null;
+}
+__name(fetchGitDiffHunksForFile, "fetchGitDiffHunksForFile");
+function toRepoRelativePath(gitRoot, filePath) {
+  if (!path2.isAbsolute(filePath)) {
+    if (filePath.length === 0) return null;
+    if (filePath.startsWith("/") || filePath.startsWith("\\")) return null;
+    if (/^[A-Za-z]:/.test(filePath)) return null;
+    if (filePath.split(/[\\/]/).some((segment) => segment === ".."))
+      return null;
+    return filePath;
+  }
+  const rel = path2.relative(gitRoot, filePath);
+  if (rel === "" || rel === ".." || rel.startsWith(`..${path2.sep}`) || path2.isAbsolute(rel))
+    return null;
+  return rel;
+}
+__name(toRepoRelativePath, "toRepoRelativePath");
+async function synthesizeUntrackedHunk(gitRoot, filePath) {
+  const absPath = path2.join(gitRoot, filePath);
+  try {
+    const lst = await lstat(absPath);
+    if (!lst.isFile()) return null;
+  } catch {
+    return null;
+  }
+  const fh = await openUntrackedForDiffRead(absPath);
+  if (!fh) return null;
+  try {
+    const st = await fh.stat();
+    if (!st.isFile()) return null;
+    const cap = Math.min(st.size, MAX_DIFF_SIZE_BYTES);
+    const buf = Buffer.allocUnsafe(cap);
+    let offset = 0;
+    while (offset < cap) {
+      const { bytesRead } = await fh.read(buf, offset, cap - offset, offset);
+      if (bytesRead === 0) break;
+      offset += bytesRead;
+    }
+    const sniffEnd = Math.min(offset, BINARY_SNIFF_BYTES);
+    for (let i = 0; i < sniffEnd; i++) {
+      if (buf[i] === 0) return null;
+    }
+    const lines = buf.toString("utf8", 0, offset).split("\n");
+    if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+    const capped = lines.slice(0, MAX_LINES_PER_FILE);
+    const truncated = st.size > MAX_DIFF_SIZE_BYTES || lines.length > capped.length;
+    if (capped.length === 0) return { hunks: [], truncated };
+    return {
+      hunks: [
+        {
+          oldStart: 0,
+          oldLines: 0,
+          newStart: 1,
+          newLines: capped.length,
+          lines: capped.map((line) => "+" + line)
+        }
+      ],
+      truncated
+    };
+  } catch {
+    return null;
+  } finally {
+    await fh.close().catch(() => {
+    });
+  }
+}
+__name(synthesizeUntrackedHunk, "synthesizeUntrackedHunk");
+function forEachNumstatEntry(stdout, visit) {
+  const tokens = stdout.split("\0");
+  if (tokens.length > 0 && tokens[tokens.length - 1] === "") tokens.pop();
+  let pending = null;
+  let renameOld = null;
+  for (const token of tokens) {
+    if (pending) {
+      if (renameOld === null) {
+        renameOld = token;
+        continue;
+      }
+      visit({ ...pending, path: token, oldPath: renameOld });
+      pending = null;
+      renameOld = null;
+      continue;
+    }
+    const firstTab = token.indexOf("	");
+    if (firstTab < 0) continue;
+    const secondTab = token.indexOf("	", firstTab + 1);
+    if (secondTab < 0) continue;
+    const addStr = token.slice(0, firstTab);
+    const remStr = token.slice(firstTab + 1, secondTab);
+    const path6 = token.slice(secondTab + 1);
+    const isBinary = addStr === "-" || remStr === "-";
+    const added = isBinary ? 0 : parseInt(addStr, 10) || 0;
+    const removed = isBinary ? 0 : parseInt(remStr, 10) || 0;
+    if (path6 === "") {
+      pending = { added, removed, isBinary };
+      continue;
+    }
+    visit({ path: path6, added, removed, isBinary });
+  }
+}
+__name(forEachNumstatEntry, "forEachNumstatEntry");
+function parseGitNumstat(stdout) {
+  let added = 0;
+  let removed = 0;
+  let validFileCount = 0;
+  const perFileStats = /* @__PURE__ */ new Map();
+  forEachNumstatEntry(stdout, (entry) => {
+    commitEntry(
+      entry.path,
+      entry.added,
+      entry.removed,
+      entry.isBinary,
+      entry.oldPath
+    );
+  });
+  function commitEntry(filePath, fileAdded, fileRemoved, isBinary, oldPath) {
+    validFileCount++;
+    added += fileAdded;
+    removed += fileRemoved;
+    if (perFileStats.size < MAX_FILES) {
+      perFileStats.set(filePath, {
+        added: fileAdded,
+        removed: fileRemoved,
+        isBinary,
+        ...oldPath ? { oldPath } : {}
+      });
+    }
+  }
+  __name(commitEntry, "commitEntry");
+  return {
+    stats: {
+      filesCount: validFileCount,
+      linesAdded: added,
+      linesRemoved: removed
+    },
+    perFileStats
+  };
+}
+__name(parseGitNumstat, "parseGitNumstat");
+function parseGitDiff(stdout, truncatedPaths) {
+  const result = /* @__PURE__ */ new Map();
+  if (!stdout.trim()) return result;
+  const fileDiffs = stdout.split(/^diff --git /m).filter(Boolean);
+  for (const fileDiff of fileDiffs) {
+    if (result.size >= MAX_FILES) break;
+    if (Buffer.byteLength(fileDiff, "utf8") > MAX_DIFF_SIZE_BYTES) continue;
+    const lines = fileDiff.split("\n");
+    const filePath = extractFilePath(lines);
+    if (filePath === null) continue;
+    const fileHunks = [];
+    let currentHunk = null;
+    let lineCount = 0;
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i] ?? "";
+      const hunkMatch = line.match(
+        /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/
+      );
+      if (hunkMatch) {
+        if (currentHunk) fileHunks.push(currentHunk);
+        currentHunk = {
+          oldStart: parseInt(hunkMatch[1] ?? "0", 10),
+          oldLines: parseInt(hunkMatch[2] ?? "1", 10),
+          newStart: parseInt(hunkMatch[3] ?? "0", 10),
+          newLines: parseInt(hunkMatch[4] ?? "1", 10),
+          lines: []
+        };
+        continue;
+      }
+      if (!currentHunk) {
+        continue;
+      }
+      if (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ")) {
+        if (lineCount >= MAX_LINES_PER_FILE) {
+          truncatedPaths?.add(filePath);
+          break;
+        }
+        currentHunk.lines.push("" + line);
+        lineCount++;
+      } else if (line.startsWith("\\")) {
+        currentHunk.lines.push("" + line);
+      }
+    }
+    if (currentHunk) fileHunks.push(currentHunk);
+    if (fileHunks.length > 0) result.set(filePath, fileHunks);
+  }
+  return result;
+}
+__name(parseGitDiff, "parseGitDiff");
+function unquoteCStylePath(s) {
+  if (!s.startsWith('"') || !s.endsWith('"') || s.length < 2) return s;
+  const inner = s.slice(1, -1);
+  const bytes = [];
+  let i = 0;
+  while (i < inner.length) {
+    const c = inner.charCodeAt(i);
+    if (c !== 92) {
+      const cp = inner.codePointAt(i);
+      if (cp === void 0) {
+        i++;
+        continue;
+      }
+      const ch = String.fromCodePoint(cp);
+      bytes.push(...Buffer.from(ch, "utf8"));
+      i += ch.length;
+      continue;
+    }
+    const next = inner[i + 1];
+    if (next === void 0) {
+      bytes.push(92);
+      i++;
+      continue;
+    }
+    switch (next) {
+      case "a":
+        bytes.push(7);
+        i += 2;
+        break;
+      case "b":
+        bytes.push(8);
+        i += 2;
+        break;
+      case "f":
+        bytes.push(12);
+        i += 2;
+        break;
+      case "v":
+        bytes.push(11);
+        i += 2;
+        break;
+      case "t":
+        bytes.push(9);
+        i += 2;
+        break;
+      case "n":
+        bytes.push(10);
+        i += 2;
+        break;
+      case "r":
+        bytes.push(13);
+        i += 2;
+        break;
+      case '"':
+        bytes.push(34);
+        i += 2;
+        break;
+      case "\\":
+        bytes.push(92);
+        i += 2;
+        break;
+      default:
+        if (next >= "0" && next <= "7") {
+          let octal = "";
+          while (octal.length < 3 && i + 1 + octal.length < inner.length && (inner[i + 1 + octal.length] ?? "") >= "0" && (inner[i + 1 + octal.length] ?? "") <= "7") {
+            octal += inner[i + 1 + octal.length];
+          }
+          bytes.push(parseInt(octal, 8) & 255);
+          i += 1 + octal.length;
+        } else {
+          bytes.push(...Buffer.from(next, "utf8"));
+          i += 2;
+        }
+    }
+  }
+  return Buffer.from(bytes).toString("utf8");
+}
+__name(unquoteCStylePath, "unquoteCStylePath");
+function extractFilePath(lines) {
+  let plus = null;
+  let minus = null;
+  let renameTo = null;
+  let copyTo = null;
+  for (const line of lines) {
+    if (line.startsWith("@@ ")) break;
+    if (line.startsWith("+++ ")) plus = line.slice(4);
+    else if (line.startsWith("--- ")) minus = line.slice(4);
+    else if (line.startsWith("rename to ")) renameTo = line.slice(10);
+    else if (line.startsWith("copy to ")) copyTo = line.slice(8);
+  }
+  const stripTab = /* @__PURE__ */ __name((s) => {
+    const t = s.indexOf("	");
+    return t >= 0 ? s.slice(0, t) : s;
+  }, "stripTab");
+  const normalize = /* @__PURE__ */ __name((s) => unquoteCStylePath(stripTab(s)), "normalize");
+  if (renameTo !== null) return normalize(renameTo);
+  if (copyTo !== null) return normalize(copyTo);
+  if (plus !== null) {
+    const p = normalize(plus);
+    if (p !== "/dev/null" && p.startsWith("b/")) return p.slice(2);
+    if (minus !== null) {
+      const m = normalize(minus);
+      if (m !== "/dev/null" && m.startsWith("a/")) return m.slice(2);
+    }
+    return null;
+  }
+  if (minus !== null) {
+    const m = normalize(minus);
+    if (m !== "/dev/null" && m.startsWith("a/")) return m.slice(2);
+  }
+  return null;
+}
+__name(extractFilePath, "extractFilePath");
+function parseShortstat(stdout) {
+  const match = stdout.match(
+    /^ ?(\d{1,10}) files? changed(?:, (\d{1,10}) insertions?\(\+\))?(?:, (\d{1,10}) deletions?\(-\))?$/m
+  );
+  if (!match) return null;
+  return {
+    filesCount: parseInt(match[1] ?? "0", 10),
+    linesAdded: parseInt(match[2] ?? "0", 10),
+    linesRemoved: parseInt(match[3] ?? "0", 10)
+  };
+}
+__name(parseShortstat, "parseShortstat");
+async function getWorkingTreeLineStats(cwd) {
+  const stdout = await runGit(
+    ["diff-index", "--no-ext-diff", "--no-textconv", "--shortstat", "HEAD"],
+    cwd
+  );
+  if (stdout === null) return null;
+  const stats = parseShortstat(stdout);
+  return {
+    linesAdded: stats?.linesAdded ?? 0,
+    linesRemoved: stats?.linesRemoved ?? 0
+  };
+}
+__name(getWorkingTreeLineStats, "getWorkingTreeLineStats");
+function parseDeletedFromNameStatus(stdout) {
+  const tokens = stdout.split("\0");
+  if (tokens.length > 0 && tokens[tokens.length - 1] === "") tokens.pop();
+  const deleted = /* @__PURE__ */ new Set();
+  let i = 0;
+  while (i < tokens.length) {
+    const status = tokens[i] ?? "";
+    i++;
+    if (status === "") continue;
+    const head = status[0];
+    if (head === "R" || head === "C") {
+      i += 2;
+      continue;
+    }
+    const path6 = tokens[i] ?? "";
+    i++;
+    if (head === "D" && path6 !== "") deleted.add(path6);
+  }
+  return deleted;
+}
+__name(parseDeletedFromNameStatus, "parseDeletedFromNameStatus");
+function countNulDelimited(stdout) {
+  if (!stdout) return 0;
+  let count = 0;
+  for (let i = 0; i < stdout.length; i++) {
+    if (stdout.charCodeAt(i) === 0) count++;
+  }
+  return count;
+}
+__name(countNulDelimited, "countNulDelimited");
+function splitNulDelimited(stdout) {
+  if (!stdout) return [];
+  return stdout.split("\0").filter(Boolean);
+}
+__name(splitNulDelimited, "splitNulDelimited");
+async function countUntrackedLines(absPath) {
+  let st;
+  try {
+    st = await lstat(absPath);
+  } catch {
+    return { added: 0, isBinary: true, truncated: false };
+  }
+  if (!st.isFile()) {
+    return { added: 0, isBinary: true, truncated: false };
+  }
+  const fh = await openUntrackedForDiffRead(absPath);
+  if (!fh) {
+    return { added: 0, isBinary: true, truncated: false };
+  }
+  try {
+    const buf = Buffer.allocUnsafe(UNTRACKED_READ_CHUNK_BYTES);
+    let totalRead = 0;
+    let lines = 0;
+    let lastByte = -1;
+    let sniffedBytes = 0;
+    while (totalRead < UNTRACKED_READ_CAP_BYTES) {
+      const remaining = UNTRACKED_READ_CAP_BYTES - totalRead;
+      const toRead = Math.min(buf.length, remaining);
+      const { bytesRead } = await fh.read(buf, 0, toRead, totalRead);
+      if (bytesRead === 0) break;
+      if (sniffedBytes < BINARY_SNIFF_BYTES) {
+        const sniffEnd = Math.min(bytesRead, BINARY_SNIFF_BYTES - sniffedBytes);
+        for (let i = 0; i < sniffEnd; i++) {
+          if (buf[i] === 0) {
+            return { added: 0, isBinary: true, truncated: false };
+          }
+        }
+        sniffedBytes += sniffEnd;
+      }
+      for (let i = 0; i < bytesRead; i++) {
+        if (buf[i] === 10) lines++;
+      }
+      lastByte = buf[bytesRead - 1] ?? -1;
+      totalRead += bytesRead;
+    }
+    if (totalRead === 0) {
+      return { added: 0, isBinary: false, truncated: false };
+    }
+    let truncated = false;
+    if (totalRead >= UNTRACKED_READ_CAP_BYTES) {
+      const { size } = await fh.stat();
+      truncated = size > totalRead;
+    }
+    if (!truncated && lastByte !== 10) lines++;
+    return { added: lines, isBinary: false, truncated };
+  } catch {
+    return { added: 0, isBinary: true, truncated: false };
+  } finally {
+    await fh.close().catch(() => {
+    });
+  }
+}
+__name(countUntrackedLines, "countUntrackedLines");
+async function resolveGitDir(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  return resolveGitDirFromRoot(gitRoot);
+}
+__name(resolveGitDir, "resolveGitDir");
+async function resolveGitDirFromRoot(gitRoot) {
+  const dotGit = path2.join(gitRoot, ".git");
+  try {
+    const s = await stat(dotGit);
+    if (s.isDirectory()) return dotGit;
+    if (!s.isFile()) return null;
+    const content = await readFile2(dotGit, "utf8");
+    const match = content.match(/^gitdir:\s*(.+?)\s*$/m);
+    if (!match || !match[1]) return null;
+    const raw = match[1];
+    return path2.isAbsolute(raw) ? raw : path2.resolve(gitRoot, raw);
+  } catch {
+    return null;
+  }
+}
+__name(resolveGitDirFromRoot, "resolveGitDirFromRoot");
+async function isInTransientGitState(gitRoot) {
+  const gitDir = await resolveGitDirFromRoot(gitRoot);
+  if (!gitDir) return false;
+  const transientPaths = [
+    "MERGE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD",
+    "rebase-merge",
+    "rebase-apply"
+  ];
+  const results = await Promise.all(
+    transientPaths.map(
+      (name) => access(path2.join(gitDir, name)).then(() => true).catch(() => false)
+    )
+  );
+  return results.some(Boolean);
+}
+__name(isInTransientGitState, "isInTransientGitState");
+async function mapWithConcurrency(items, limit, fn) {
+  if (items.length === 0) return [];
+  const effective = Math.max(1, limit);
+  const results = new Array(items.length);
+  for (let i = 0; i < items.length; i += effective) {
+    const slice = items.slice(i, i + effective);
+    const batch = await Promise.all(slice.map((item) => fn(item)));
+    for (let j = 0; j < batch.length; j++) {
+      results[i + j] = batch[j];
+    }
+  }
+  return results;
+}
+__name(mapWithConcurrency, "mapWithConcurrency");
+async function runGit(args, cwd) {
+  const fullArgs = ["-c", "core.quotepath=false", ...NO_EXEC_CONFIG, ...args];
+  try {
+    const { stdout } = await execFileAsync("git", fullArgs, {
+      cwd,
+      timeout: GIT_TIMEOUT_MS,
+      maxBuffer: 64 * 1024 * 1024,
+      windowsHide: true,
+      encoding: "utf8"
+    });
+    return stdout;
+  } catch {
+    return null;
+  }
+}
+__name(runGit, "runGit");
+async function getGitWorkingTreeStatus(cwd) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const stdout = await runGit(
+    ["--no-optional-locks", "status", "--porcelain=v1", "--branch", "-z"],
+    gitRoot
+  );
+  if (stdout == null) return null;
+  const tokens = stdout.split("\0");
+  if (tokens.length > 0 && tokens[tokens.length - 1] === "") tokens.pop();
+  const head = tokens.shift() ?? "";
+  const branch = parseStatusBranchLine(head);
+  const counts = parseStatusEntries(tokens);
+  const [stashCount, operation] = await Promise.all([
+    countStashEntries(gitRoot),
+    detectGitOperation(gitRoot)
+  ]);
+  return {
+    ...branch,
+    ...counts,
+    stashCount,
+    ...operation ? { operation } : {}
+  };
+}
+__name(getGitWorkingTreeStatus, "getGitWorkingTreeStatus");
+var NO_BRANCH = {
+  branch: null,
+  detached: false,
+  hasUpstream: false,
+  ahead: 0,
+  behind: 0
+};
+function parseStatusBranchLine(line) {
+  if (!line.startsWith("## ")) return { ...NO_BRANCH };
+  let desc = line.slice(3);
+  if (desc.startsWith("HEAD (no branch)")) {
+    return { ...NO_BRANCH, detached: true };
+  }
+  const unborn = desc.match(/^(?:No commits yet|Initial commit) on (.+)$/);
+  if (unborn) {
+    return { ...NO_BRANCH, branch: unborn[1] ?? null };
+  }
+  let ahead = 0;
+  let behind = 0;
+  const bracket = desc.match(/ \[([^\]]*)\]$/);
+  if (bracket) {
+    const inner = bracket[1] ?? "";
+    const aheadMatch = inner.match(/ahead (\d+)/);
+    const behindMatch = inner.match(/behind (\d+)/);
+    ahead = aheadMatch ? Number(aheadMatch[1]) : 0;
+    behind = behindMatch ? Number(behindMatch[1]) : 0;
+    desc = desc.slice(0, bracket.index).trimEnd();
+  }
+  const hasUpstream = desc.includes("...");
+  const sepIndex = desc.lastIndexOf("...");
+  const branch = sepIndex >= 0 ? desc.slice(0, sepIndex) : desc;
+  return {
+    branch: branch || null,
+    detached: false,
+    hasUpstream,
+    ahead,
+    behind
+  };
+}
+__name(parseStatusBranchLine, "parseStatusBranchLine");
+function isUnmergedEntry(x, y) {
+  if (x === "U" || y === "U") return true;
+  if (x === "D" && y === "D") return true;
+  if (x === "A" && y === "A") return true;
+  return false;
+}
+__name(isUnmergedEntry, "isUnmergedEntry");
+function parseStatusEntries(tokens) {
+  let staged = 0;
+  let unstaged = 0;
+  let untracked = 0;
+  let conflicted = 0;
+  for (let i = 0; i < tokens.length; i++) {
+    const tok = tokens[i] ?? "";
+    if (tok.length < 3 || tok[2] !== " ") continue;
+    const x = tok[0];
+    const y = tok[1];
+    if (x === "?" && y === "?") {
+      untracked++;
+      continue;
+    }
+    if (x === "!" && y === "!") continue;
+    if (isUnmergedEntry(x, y)) {
+      conflicted++;
+      continue;
+    }
+    if (x !== " " && x !== "?") staged++;
+    if (y !== " " && y !== "?") unstaged++;
+    if (x === "R" || x === "C" || y === "R" || y === "C") i++;
+  }
+  return { staged, unstaged, untracked, conflicted };
+}
+__name(parseStatusEntries, "parseStatusEntries");
+async function detectGitOperation(gitRoot) {
+  const gitDir = await resolveGitDirFromRoot(gitRoot);
+  if (!gitDir) return void 0;
+  const checks = [
+    ["rebase-merge", "rebase"],
+    ["rebase-apply", "rebase"],
+    ["MERGE_HEAD", "merge"],
+    ["CHERRY_PICK_HEAD", "cherry-pick"],
+    ["REVERT_HEAD", "revert"],
+    ["BISECT_LOG", "bisect"]
+  ];
+  for (const [name, op] of checks) {
+    try {
+      await access(path2.join(gitDir, name));
+      return op;
+    } catch {
+    }
+  }
+  return void 0;
+}
+__name(detectGitOperation, "detectGitOperation");
+async function resolveCommonGitDir(gitDir) {
+  const raw = (await readFirstLineNoFollow(path2.join(gitDir, "commondir")))?.trim();
+  if (!raw) return gitDir;
+  return path2.isAbsolute(raw) ? raw : path2.resolve(gitDir, raw);
+}
+__name(resolveCommonGitDir, "resolveCommonGitDir");
+async function countStashEntries(gitRoot) {
+  const gitDir = await resolveGitDirFromRoot(gitRoot);
+  if (!gitDir) return 0;
+  const commonDir = await resolveCommonGitDir(gitDir);
+  const stashLog = path2.join(commonDir, "logs", "refs", "stash");
+  try {
+    const st = await lstat(stashLog);
+    if (!st.isFile()) return 0;
+  } catch {
+    return 0;
+  }
+  try {
+    const content = await readFile2(stashLog, "utf8");
+    return content.split("\n").filter((line) => line.trim().length > 0).length;
+  } catch {
+    return 0;
+  }
+}
+__name(countStashEntries, "countStashEntries");
+var MAX_LOG_LIMIT = 200;
+var DEFAULT_LOG_LIMIT = 50;
+var LOG_FORMAT = "%H%x00%h%x00%an%x00%ae%x00%at%x00%s%x00%D%x00%P%x00%ct";
+var LOG_FIELDS = 9;
+var LOG_DETAIL_FORMAT = "%H%x00%h%x00%an%x00%ae%x00%at%x00%s%x00%D%x00%P%x00%b";
+function parseLogFields(parts) {
+  if (parts.length !== LOG_FIELDS) return null;
+  return {
+    sha: parts[0],
+    shortSha: parts[1],
+    authorName: parts[2],
+    authorEmail: parts[3],
+    authorDate: parseInt(parts[4], 10) || 0,
+    subject: parts[5],
+    refs: parts[6],
+    parents: parts[7] ? parts[7].split(" ").filter(Boolean) : [],
+    commitDate: parseInt(parts[8], 10) || 0
+  };
+}
+__name(parseLogFields, "parseLogFields");
+var LOG_ALL_REVISIONS = ["HEAD", "--branches", "--tags", "--remotes"];
+function isSafeLogRange(range) {
+  return !range.startsWith("-") && !range.startsWith("..") && /^[A-Za-z0-9_./~^-]+$/.test(range);
+}
+__name(isSafeLogRange, "isSafeLogRange");
+function parseLogRecords(stdout) {
+  const fields = stdout.split("\0");
+  if (fields.at(-1) === "") fields.pop();
+  const entries = [];
+  for (let i = 0; i + LOG_FIELDS <= fields.length; i += LOG_FIELDS) {
+    const entry = parseLogFields(fields.slice(i, i + LOG_FIELDS));
+    if (entry) entries.push(entry);
+  }
+  return entries;
+}
+__name(parseLogRecords, "parseLogRecords");
+async function fetchGitLog(cwd, options) {
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const limit = Math.min(
+    Math.max(options?.limit ?? DEFAULT_LOG_LIMIT, 1),
+    MAX_LOG_LIMIT
+  );
+  const skip = Math.max(options?.skip ?? 0, 0);
+  const revisions = options?.all ? LOG_ALL_REVISIONS : options?.range && isSafeLogRange(options.range) ? [options.range] : [];
+  const search = options?.search?.trim();
+  if (search) {
+    return searchGitLog(gitRoot, revisions, search, limit, skip);
+  }
+  const stdout = await runGit(
+    [
+      "--no-optional-locks",
+      "log",
+      "-z",
+      `--format=${LOG_FORMAT}`,
+      "--date-order",
+      "-n",
+      String(limit + 1),
+      ...skip > 0 ? ["--skip", String(skip)] : [],
+      ...revisions,
+      "--"
+    ],
+    gitRoot
+  );
+  if (stdout === null) {
+    const head = await runGit(["rev-parse", "--verify", "HEAD"], gitRoot);
+    return head === null ? { entries: [], hasMore: false } : null;
+  }
+  const entries = parseLogRecords(stdout);
+  return { entries: entries.slice(0, limit), hasMore: entries.length > limit };
+}
+__name(fetchGitLog, "fetchGitLog");
+async function searchGitLog(gitRoot, revisions, query, limit, skip) {
+  const window = String(skip + limit + 1);
+  const walk = /* @__PURE__ */ __name((filter) => runGit(
+    [
+      "--no-optional-locks",
+      "log",
+      "-z",
+      `--format=${LOG_FORMAT}`,
+      "--date-order",
+      "-i",
+      "--fixed-strings",
+      filter,
+      "-n",
+      window,
+      ...revisions,
+      "--"
+    ],
+    gitRoot
+  ), "walk");
+  const runs = [walk(`--grep=${query}`), walk(`--author=${query}`)];
+  if (/^[0-9a-f]{4,40}$/i.test(query)) {
+    runs.push(
+      runGit(
+        [
+          "rev-parse",
+          "--verify",
+          "--quiet",
+          "--end-of-options",
+          `${query}^{commit}`
+        ],
+        gitRoot
+      ).then(
+        (sha) => sha ? runGit(
+          [
+            "--no-optional-locks",
+            "log",
+            "-z",
+            `--format=${LOG_FORMAT}`,
+            "--no-walk",
+            sha.trim(),
+            "--"
+          ],
+          gitRoot
+        ) : null
+      )
+    );
+  }
+  const bySha = /* @__PURE__ */ new Map();
+  for (const stdout of await Promise.all(runs)) {
+    for (const entry of parseLogRecords(stdout ?? "")) {
+      if (!bySha.has(entry.sha))
+        bySha.set(entry.sha, { entry, rank: bySha.size });
+    }
+  }
+  const entries = [...bySha.values()].sort((a, b) => b.entry.commitDate - a.entry.commitDate || a.rank - b.rank).map((item) => item.entry);
+  return {
+    entries: entries.slice(skip, skip + limit),
+    hasMore: entries.length > skip + limit
+  };
+}
+__name(searchGitLog, "searchGitLog");
+async function fetchGitCommitDetail(cwd, sha) {
+  if (!/^[0-9a-f]{7,40}$/i.test(sha)) return null;
+  const gitRoot = findGitRoot(cwd);
+  if (!gitRoot) return null;
+  const metaRaw = await runGit(
+    [
+      "--no-optional-locks",
+      "log",
+      "-1",
+      "-z",
+      `--format=${LOG_DETAIL_FORMAT}`,
+      sha
+    ],
+    gitRoot
+  );
+  if (metaRaw === null) return null;
+  const parts = metaRaw.split("\0");
+  if (parts.at(-1) === "") parts.pop();
+  if (parts.length !== 9) return null;
+  const parents = parts[7] ? parts[7].split(" ").filter(Boolean) : [];
+  const diffTreeArgs = parents.length > 1 ? [
+    "--no-optional-locks",
+    "diff-tree",
+    "--no-commit-id",
+    "--numstat",
+    // Detect renames so `git mv` counts as one file (by its new path),
+    // matching the main `git diff` path — diff-tree is plumbing and does
+    // NOT honour diff.renames, so without -M a rename splits into a
+    // delete + add pair. The three-token `-z` rename sequence it then
+    // emits is handled by the pending-rename state machine below.
+    "-M",
+    "-r",
+    "-z",
+    `${sha}^1`,
+    sha
+  ] : [
+    "--no-optional-locks",
+    "diff-tree",
+    "--no-commit-id",
+    "--numstat",
+    // Detect renames so `git mv` counts as one file (by its new path),
+    // matching the main `git diff` path — diff-tree is plumbing and does
+    // NOT honour diff.renames, so without -M a rename splits into a
+    // delete + add pair. The three-token `-z` rename sequence it then
+    // emits is handled by the pending-rename state machine below.
+    "-M",
+    "-r",
+    "-z",
+    "--root",
+    sha
+  ];
+  const numstatRaw = await runGit(diffTreeArgs, gitRoot);
+  const files = [];
+  let filesCount = 0;
+  let linesAdded = 0;
+  let linesRemoved = 0;
+  if (numstatRaw) {
+    forEachNumstatEntry(numstatRaw, (entry) => {
+      filesCount++;
+      linesAdded += entry.added;
+      linesRemoved += entry.removed;
+      if (files.length < MAX_FILES) {
+        files.push({
+          path: entry.path,
+          added: entry.added,
+          removed: entry.removed,
+          isBinary: entry.isBinary
+        });
+      }
+    });
+  }
+  return {
+    sha: parts[0],
+    shortSha: parts[1],
+    authorName: parts[2],
+    authorEmail: parts[3],
+    authorDate: parseInt(parts[4], 10) || 0,
+    subject: parts[5],
+    refs: parts[6],
+    parents,
+    body: parts[8].replace(/\n$/, ""),
+    files,
+    filesCount,
+    linesAdded,
+    linesRemoved,
+    hiddenCount: Math.max(filesCount - files.length, 0)
+  };
+}
+__name(fetchGitCommitDetail, "fetchGitCommitDetail");
+
+// packages/core/src/utils/gitDirect.ts
+var SHORT_SHA_LENGTH = 7;
+var debug = createDebugLogger("gitDirect");
+var MAX_REF_COMPONENT_LENGTH = 255;
+var INVALID_REF_CHARS = /[\x00-\x20\x7f-\x9f\u200b-\u200d\u2028\u2029\u202a-\u202e\u2066-\u2069\ufeff~^:?*[\\]/;
+function isValidRefName(name) {
+  if (!name || name === "HEAD") return false;
+  if (name.startsWith("/") || name.endsWith("/")) return false;
+  if (name.startsWith(".") || name.endsWith(".")) return false;
+  if (name.endsWith(".lock")) return false;
+  if (name.includes("..") || name.includes("//")) return false;
+  if (name.includes("/.") || name.includes("./") || name.includes(".lock/")) {
+    return false;
+  }
+  if (name.includes("@{")) return false;
+  if (INVALID_REF_CHARS.test(name)) return false;
+  if (name.split("/").some((c) => c.length > MAX_REF_COMPONENT_LENGTH)) {
+    return false;
+  }
+  return true;
+}
+__name(isValidRefName, "isValidRefName");
+function isValidGitSha(value) {
+  return /^[0-9a-f]{40}$/.test(value) || /^[0-9a-f]{64}$/.test(value);
+}
+__name(isValidGitSha, "isValidGitSha");
+var gitDirCache = /* @__PURE__ */ new Map();
+async function isDir(p) {
+  try {
+    return (await fsPromises.stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+__name(isDir, "isDir");
+async function hasGitStore(dir) {
+  const [objects, refs] = await Promise.all([
+    isDir(path3.join(dir, "objects")),
+    isDir(path3.join(dir, "refs"))
+  ]);
+  return objects && refs;
+}
+__name(hasGitStore, "hasGitStore");
+async function isRealGitDir(gitDir) {
+  if (await hasGitStore(gitDir)) return true;
+  const rel = await readFirstLineNoFollow(path3.join(gitDir, "commondir"));
+  if (!rel) return false;
+  return hasGitStore(path3.resolve(gitDir, rel.trim()));
+}
+__name(isRealGitDir, "isRealGitDir");
+async function resolveTrustedGitDir(cwd) {
+  const gitDir = await resolveGitDir(cwd);
+  if (!gitDir) return null;
+  return await isRealGitDir(gitDir) ? gitDir : null;
+}
+__name(resolveTrustedGitDir, "resolveTrustedGitDir");
+async function getCachedGitDir(cwd) {
+  const key = path3.resolve(cwd);
+  const cached = gitDirCache.get(key);
+  if (cached !== void 0) return cached;
+  const gitDir = await resolveTrustedGitDir(key);
+  if (gitDir !== null) gitDirCache.set(key, gitDir);
+  return gitDir;
+}
+__name(getCachedGitDir, "getCachedGitDir");
+async function readGitHead(gitDir) {
+  const firstLine = await readFirstLineNoFollow(path3.join(gitDir, "HEAD"));
+  if (firstLine === null) return null;
+  const content = firstLine.trim();
+  if (content.startsWith("ref:")) {
+    const ref = content.slice(4).trim();
+    if (!ref.startsWith("refs/heads/")) return null;
+    const name = ref.slice("refs/heads/".length);
+    if (!isValidRefName(name)) return null;
+    return { type: "branch", name };
+  }
+  if (isValidGitSha(content)) {
+    return { type: "detached", name: content };
+  }
+  return null;
+}
+__name(readGitHead, "readGitHead");
+async function resolveBranchName(cwd) {
+  const gitDir = await getCachedGitDir(cwd);
+  if (!gitDir) return void 0;
+  const head = await readGitHead(gitDir);
+  if (!head) return void 0;
+  return head.type === "branch" ? head.name : head.name.slice(0, SHORT_SHA_LENGTH);
+}
+__name(resolveBranchName, "resolveBranchName");
+var repoBranchWatches = /* @__PURE__ */ new Map();
+async function watchRepoBranch(cwd, onChange) {
+  const gitDir = await getCachedGitDir(cwd);
+  if (!gitDir) return () => {
+  };
+  let entry = repoBranchWatches.get(gitDir);
+  if (!entry) {
+    const logsHeadPath = path3.join(gitDir, "logs", "HEAD");
+    try {
+      await fsPromises.access(logsHeadPath, fs2.constants?.F_OK ?? 0);
+      if ((await fsPromises.lstat(logsHeadPath)).isSymbolicLink()) {
+        return () => {
+        };
+      }
+    } catch {
+      return () => {
+      };
+    }
+    const existing = repoBranchWatches.get(gitDir);
+    if (existing) {
+      entry = existing;
+    } else {
+      let watcher;
+      try {
+        watcher = fs2.watch(logsHeadPath, (eventType) => {
+          if (eventType === "change" || eventType === "rename") {
+            repoBranchWatches.get(gitDir)?.subscribers.forEach((cb) => {
+              try {
+                cb();
+              } catch {
+              }
+            });
+          }
+        });
+      } catch (err) {
+        debug.warn(`failed to watch reflog for ${gitDir}: ${err}`);
+        return () => {
+        };
+      }
+      watcher.on("error", (err) => {
+        debug.warn(
+          `reflog watcher error for ${gitDir}; branch will no longer auto-update: ${err?.message}`
+        );
+        const current = repoBranchWatches.get(gitDir);
+        if (current?.watcher === watcher) {
+          try {
+            watcher.close();
+          } catch {
+          }
+          repoBranchWatches.delete(gitDir);
+        }
+      });
+      entry = { watcher, subscribers: /* @__PURE__ */ new Set() };
+      repoBranchWatches.set(gitDir, entry);
+    }
+  }
+  entry.subscribers.add(onChange);
+  let disposed = false;
+  return () => {
+    if (disposed) return;
+    disposed = true;
+    const e = repoBranchWatches.get(gitDir);
+    if (!e) return;
+    e.subscribers.delete(onChange);
+    if (e.subscribers.size === 0) {
+      e.watcher.close();
+      repoBranchWatches.delete(gitDir);
+    }
+  };
+}
+__name(watchRepoBranch, "watchRepoBranch");
+
+// packages/core/src/utils/git-branches.ts
+var debugLogger = createDebugLogger("GIT_BRANCHES");
+var execFileAsync2 = promisify2(execFile2);
+var GIT_TIMEOUT_MS2 = 3e4;
+var MAX_RECENT_BRANCHES = 20;
+var MAX_REFLOG_ENTRIES = 200;
+var GIT_ENV_VARS_TO_CLEAR = [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_COMMON_DIR",
+  "GIT_INDEX_FILE",
+  "GIT_CONFIG_GLOBAL",
+  "GIT_CONFIG_SYSTEM",
+  "GIT_CONFIG_NOSYSTEM",
+  // Repository selectors that an inherited daemon environment could use to
+  // redirect a trusted-workspace git/gh invocation to a different repository
+  // or object database despite the resolved cwd.
+  "GH_REPO",
+  "GIT_CONFIG_COUNT",
+  "GIT_CONFIG_PARAMETERS",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES"
+];
+var GIT_ENV_PREFIXES_TO_CLEAR = ["GIT_CONFIG_KEY_", "GIT_CONFIG_VALUE_"];
+var HELPER_PROTOCOLS = /* @__PURE__ */ new Set(["ext", "fd"]);
+function gitEnv(base) {
+  const env = { ...base ?? process.env };
+  for (const key of GIT_ENV_VARS_TO_CLEAR) {
+    delete env[key];
+  }
+  for (const key of Object.keys(env)) {
+    if (GIT_ENV_PREFIXES_TO_CLEAR.some((prefix) => key.startsWith(prefix))) {
+      delete env[key];
+    }
+  }
+  const inheritedAllow = env["GIT_ALLOW_PROTOCOL"];
+  if (inheritedAllow !== void 0) {
+    env["GIT_ALLOW_PROTOCOL"] = inheritedAllow.split(":").filter((p) => !HELPER_PROTOCOLS.has(p.trim().toLowerCase())).join(":");
+  }
+  env["LC_ALL"] = "C";
+  env["LANG"] = "C";
+  return env;
+}
+__name(gitEnv, "gitEnv");
+function runGit2(cwd, args, env) {
+  return execFileAsync2("git", args, {
+    cwd,
+    timeout: GIT_TIMEOUT_MS2,
+    maxBuffer: 10 * 1024 * 1024,
+    env: gitEnv(env)
+  }).then(({ stdout }) => stdout);
+}
+__name(runGit2, "runGit");
+var SEPARATOR = "\0";
+async function fetchGitBranches(cwd, env) {
+  await runGit2(cwd, ["rev-parse", "--git-dir"], env);
+  const [localRaw, remoteRaw, tagsRaw, headRaw, reflogRaw] = await Promise.all([
+    runGit2(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
+        "refs/heads/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit2(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(HEAD)%00%(upstream:short)%00%(upstream:track,nobracket)%00%(committerdate:unix)%00%(subject)%00%(symref)%00%(push:short)%00%(push:track,nobracket)",
+        "refs/remotes/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit2(
+      cwd,
+      [
+        "for-each-ref",
+        "--format=%(refname:short)%00%(creatordate:unix)%00%(subject)",
+        "--sort=-creatordate",
+        "refs/tags/"
+      ],
+      env
+    ).catch(() => ""),
+    runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env).catch(() => ""),
+    runGit2(
+      cwd,
+      ["reflog", "show", "--format=%gs", `-${MAX_REFLOG_ENTRIES}`],
+      env
+    ).catch(() => "")
+  ]);
+  const local = parseBranchLines(localRaw);
+  const remote = parseBranchLines(remoteRaw);
+  const tags = parseTagLines(tagsRaw);
+  const recent = parseRecentBranches(reflogRaw, headRaw.trim());
+  const headTrimmed = headRaw.trim();
+  const detached = !headTrimmed;
+  return {
+    local,
+    remote,
+    tags,
+    recent,
+    head: headTrimmed || await getDetachedHead(cwd, env),
+    detached
+  };
+}
+__name(fetchGitBranches, "fetchGitBranches");
+function parseBranchLines(raw) {
+  if (!raw.trim()) return [];
+  return raw.trim().split("\n").filter(Boolean).filter((line) => {
+    const parts = line.split(SEPARATOR);
+    return !(parts[6] ?? "");
+  }).map((line) => {
+    const parts = line.split(SEPARATOR);
+    const name = parts[0] ?? "";
+    const isHead = parts[1] === "*";
+    const upstream = parts[2] || void 0;
+    const track = parts[3] ?? "";
+    const commitDate = parseInt(parts[4] ?? "0", 10) || 0;
+    const commitSubject = parts[5] ?? "";
+    let ahead = 0;
+    let behind = 0;
+    const aheadMatch = /ahead (\d+)/.exec(track);
+    const behindMatch = /behind (\d+)/.exec(track);
+    if (aheadMatch) ahead = parseInt(aheadMatch[1], 10);
+    if (behindMatch) behind = parseInt(behindMatch[1], 10);
+    const upstreamGone = upstream !== void 0 && /\bgone\b/.test(track);
+    const pushTarget = parts[7] || void 0;
+    const pushTrack = parts[8] ?? "";
+    const pushGone = pushTarget !== void 0 && /\bgone\b/.test(pushTrack);
+    let pushAhead;
+    let pushBehind;
+    if (pushTarget !== void 0 && !pushGone) {
+      const pa = /ahead (\d+)/.exec(pushTrack);
+      const pb = /behind (\d+)/.exec(pushTrack);
+      pushAhead = pa ? parseInt(pa[1], 10) : 0;
+      pushBehind = pb ? parseInt(pb[1], 10) : 0;
+    }
+    return {
+      name,
+      isHead,
+      upstream,
+      ...upstreamGone ? { upstreamGone } : {},
+      ahead,
+      behind,
+      ...pushTarget !== void 0 ? { pushTarget } : {},
+      ...pushAhead !== void 0 ? { pushAhead } : {},
+      ...pushBehind !== void 0 ? { pushBehind } : {},
+      ...pushGone ? { pushGone } : {},
+      commitDate,
+      commitSubject
+    };
+  });
+}
+__name(parseBranchLines, "parseBranchLines");
+function parseTagLines(raw) {
+  if (!raw.trim()) return [];
+  return raw.trim().split("\n").filter(Boolean).map((line) => {
+    const parts = line.split(SEPARATOR);
+    return {
+      name: parts[0] ?? "",
+      date: parseInt(parts[1] ?? "0", 10) || 0,
+      subject: parts[2] ?? ""
+    };
+  });
+}
+__name(parseTagLines, "parseTagLines");
+function parseRecentBranches(reflogRaw, currentHead) {
+  if (!reflogRaw.trim()) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const line of reflogRaw.trim().split("\n")) {
+    if (!line.startsWith("checkout: moving from ")) continue;
+    const idx = line.indexOf(" to ");
+    if (idx === -1) continue;
+    const branch = line.slice(idx + 4);
+    if (branch && !seen.has(branch) && branch !== currentHead && !/^[0-9a-f]{7,40}$/.test(branch)) {
+      seen.add(branch);
+      result.push(branch);
+      if (result.length >= MAX_RECENT_BRANCHES) break;
+    }
+  }
+  return result;
+}
+__name(parseRecentBranches, "parseRecentBranches");
+async function getDetachedHead(cwd, env) {
+  try {
+    const sha = await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env);
+    return sha.trim();
+  } catch {
+    return "";
+  }
+}
+__name(getDetachedHead, "getDetachedHead");
+function isValidCheckoutRef(value) {
+  const ref = value.trim();
+  if (!ref || ref.startsWith("-")) return false;
+  if (ref === "HEAD") return true;
+  return isValidRefName(ref) || isValidGitSha(ref);
+}
+__name(isValidCheckoutRef, "isValidCheckoutRef");
+async function gitCheckout(cwd, ref, env) {
+  if (!isValidCheckoutRef(ref)) {
+    throw new Error(`invalid checkout ref: ${ref}`);
+  }
+  const isRemoteTracking = await runGit2(
+    cwd,
+    ["show-ref", "--verify", "--quiet", `refs/remotes/${ref}`],
+    env
+  ).then(() => true).catch(() => false);
+  if (isRemoteTracking) {
+    const localName = ref.slice(ref.indexOf("/") + 1);
+    if (!isValidCheckoutRef(localName)) {
+      throw new Error(
+        `invalid local branch name derived from remote ref: ${localName}`
+      );
+    }
+    const hasLocal = await runGit2(
+      cwd,
+      ["show-ref", "--verify", "--quiet", `refs/heads/${localName}`],
+      env
+    ).then(() => true).catch(() => false);
+    if (hasLocal) {
+      await runGit2(cwd, ["checkout", localName, "--"], env);
+    } else {
+      await runGit2(cwd, ["checkout", "--track", ref], env);
+    }
+    const head = (await runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
+    return { branch: head, detached: false };
+  }
+  await runGit2(cwd, ["checkout", ref, "--"], env);
+  const headRaw = await runGit2(
+    cwd,
+    ["symbolic-ref", "--short", "HEAD"],
+    env
+  ).catch(() => "");
+  const trimmed = headRaw.trim();
+  if (trimmed) {
+    return { branch: trimmed, detached: false };
+  }
+  const sha = await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env);
+  return { branch: sha.trim(), detached: true };
+}
+__name(gitCheckout, "gitCheckout");
+async function gitCreateBranch(cwd, name, startPoint, env) {
+  if (!isValidRefName(name) || name.startsWith("-")) {
+    throw new Error(`invalid branch name: ${name}`);
+  }
+  const args = ["checkout", "-b", name];
+  if (startPoint) {
+    if (!isValidCheckoutRef(startPoint)) {
+      throw new Error(`invalid start point: ${startPoint}`);
+    }
+    args.push(startPoint);
+  }
+  args.push("--");
+  const originalRef = (await runGit2(
+    cwd,
+    ["symbolic-ref", "--quiet", "--short", "HEAD"],
+    env
+  ).catch(() => "")).trim();
+  const originalCommit = originalRef ? "" : (await runGit2(cwd, ["rev-parse", "HEAD"], env).catch(() => "")).trim();
+  const startCommit = (await runGit2(
+    cwd,
+    ["rev-parse", "--verify", `${startPoint || "HEAD"}^{commit}`],
+    env
+  ).catch(() => "")).trim();
+  try {
+    await runGit2(cwd, args, env);
+  } catch (err) {
+    const nowOn = (await runGit2(
+      cwd,
+      ["symbolic-ref", "--quiet", "--short", "HEAD"],
+      env
+    ).catch(() => "")).trim();
+    if (nowOn === name) {
+      if (originalRef) {
+        await runGit2(cwd, ["checkout", originalRef, "--"], env).catch(() => {
+        });
+      } else if (originalCommit) {
+        await runGit2(
+          cwd,
+          ["checkout", "--detach", originalCommit, "--"],
+          env
+        ).catch(() => {
+        });
+      }
+      const newHead = (await runGit2(cwd, ["rev-parse", `refs/heads/${name}`], env).catch(
+        () => ""
+      )).trim();
+      if (newHead && newHead !== startCommit) {
+        debugLogger.warn(
+          `gitCreateBranch: keeping branch "${name}" because it contains commits created after checkout (likely by a failing post-checkout hook)`
+        );
+      } else {
+        await runGit2(cwd, ["branch", "-D", name], env).catch(() => {
+        });
+      }
+    }
+    throw err;
+  }
+  return { branch: name, detached: false };
+}
+__name(gitCreateBranch, "gitCreateBranch");
+async function gitPush(cwd, opts, env) {
+  const args = ["push"];
+  if (opts?.force) args.push("--force-with-lease");
+  if (opts?.setUpstream) {
+    let branch;
+    try {
+      branch = (await runGit2(cwd, ["symbolic-ref", "--short", "HEAD"], env)).trim();
+    } catch {
+      throw new Error(
+        "cannot push with --set-upstream in detached HEAD state; check out a branch first"
+      );
+    }
+    const hasUpstream = await runGit2(
+      cwd,
+      ["rev-parse", "--abbrev-ref", `${branch}@{u}`],
+      env
+    ).catch(() => "");
+    if (hasUpstream.trim()) {
+      const output2 = await runGit2(cwd, args, env);
+      return { success: true, output: output2.trim() };
+    }
+    let remote = (await runGit2(cwd, ["config", `branch.${branch}.pushRemote`], env).catch(
+      () => ""
+    )).trim();
+    if (!remote) {
+      remote = (await runGit2(cwd, ["config", "remote.pushDefault"], env).catch(() => "")).trim();
+    }
+    if (!remote) {
+      remote = (await runGit2(cwd, ["config", `branch.${branch}.remote`], env).catch(
+        () => ""
+      )).trim();
+    }
+    if (!remote) {
+      const remotes = (await runGit2(cwd, ["remote"], env).catch(() => "")).trim();
+      const remoteList = remotes ? remotes.split("\n") : [];
+      remote = remoteList.length === 1 ? remoteList[0] ?? "origin" : "origin";
+    }
+    args.push("--set-upstream", remote, branch);
+  }
+  const output = await runGit2(cwd, args, env);
+  return { success: true, output: output.trim() };
+}
+__name(gitPush, "gitPush");
+var GitPullFailure = class extends Error {
+  static {
+    __name(this, "GitPullFailure");
+  }
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "GitPullFailure";
+    this.code = code;
+  }
+};
+var AUTO_STASH_MESSAGE = "o1-code: auto-stash before pull";
+var OPERATION_STATE_PATHS = [
+  ["MERGE_HEAD", "merge"],
+  ["CHERRY_PICK_HEAD", "cherry-pick"],
+  ["REVERT_HEAD", "revert"],
+  ["rebase-merge", "rebase"],
+  ["rebase-apply", "rebase or am"]
+];
+function gitDetail(err) {
+  if (err && typeof err === "object" && ("stdout" in err || "stderr" in err)) {
+    const e = err;
+    const detail = `${e.stdout ?? ""}
+${e.stderr ?? ""}`.trim();
+    if (detail) return detail;
+    return "git exited without diagnostic output; a stale lock file (e.g. .git/index.lock) or another git process is the usual cause";
+  }
+  return err instanceof Error ? err.message : String(err);
+}
+__name(gitDetail, "gitDetail");
+function exitCode(err) {
+  const code = err?.code;
+  return typeof code === "number" ? code : void 0;
+}
+__name(exitCode, "exitCode");
+function pullExitCode(err) {
+  const code = exitCode(err);
+  if (code !== void 0) return code;
+  const e = err;
+  if (e && (e.killed === true || typeof e.signal === "string")) return 1;
+  return void 0;
+}
+__name(pullExitCode, "pullExitCode");
+async function gitPaths(cwd, names, env) {
+  const args = ["rev-parse"];
+  for (const name of names) args.push("--git-path", name);
+  return (await runGit2(cwd, args, env)).trim().split("\n").map((line) => path4.resolve(cwd, line));
+}
+__name(gitPaths, "gitPaths");
+async function operationInProgress(cwd, env) {
+  const paths = await gitPaths(
+    cwd,
+    OPERATION_STATE_PATHS.map(([statePath]) => statePath),
+    env
+  );
+  for (let i = 0; i < OPERATION_STATE_PATHS.length; i++) {
+    if (fs3.existsSync(paths[i])) return OPERATION_STATE_PATHS[i][1];
+  }
+  return void 0;
+}
+__name(operationInProgress, "operationInProgress");
+async function refuseOperationInProgress(cwd, env) {
+  const operation = await operationInProgress(cwd, env);
+  if (operation) {
+    throw new GitPullFailure(
+      "operation_in_progress",
+      `cannot update: a ${operation} is in progress; finish or abort it from a terminal first`
+    );
+  }
+}
+__name(refuseOperationInProgress, "refuseOperationInProgress");
+async function upstreamSha(cwd, env, ref = "") {
+  try {
+    return (await runGit2(
+      cwd,
+      ["rev-parse", "--verify", "--quiet", `${ref}@{upstream}`],
+      env
+    )).trim();
+  } catch {
+    return "";
+  }
+}
+__name(upstreamSha, "upstreamSha");
+function readTrimmed(file) {
+  try {
+    return fs3.readFileSync(file, "utf8").trim();
+  } catch {
+    return "";
+  }
+}
+__name(readTrimmed, "readTrimmed");
+async function abortOwnPullState(cwd, pullExitCode2, env) {
+  if (pullExitCode2 !== 1) return;
+  try {
+    const [mergeHead, rebaseMergeDir, rebaseApplyDir] = await gitPaths(
+      cwd,
+      ["MERGE_HEAD", "rebase-merge", "rebase-apply"],
+      env
+    );
+    if (fs3.existsSync(mergeHead)) {
+      const upstream = await upstreamSha(cwd, env);
+      if (upstream && readTrimmed(mergeHead) === upstream) {
+        await runGit2(cwd, ["merge", "--abort"], env);
+      }
+      return;
+    }
+    for (const dir of [rebaseMergeDir, rebaseApplyDir]) {
+      if (!fs3.existsSync(dir)) continue;
+      const headName = readTrimmed(path4.join(dir, "head-name")).replace(
+        /^refs\/heads\//,
+        ""
+      );
+      const upstream = headName ? await upstreamSha(cwd, env, headName) : "";
+      if (upstream && readTrimmed(path4.join(dir, "onto")) === upstream) {
+        await runGit2(cwd, ["rebase", "--abort"], env);
+      }
+      return;
+    }
+  } catch {
+  }
+}
+__name(abortOwnPullState, "abortOwnPullState");
+async function stashEntries(cwd, env) {
+  const raw = await runGit2(cwd, ["stash", "list", "--format=%H%x00%s"], env);
+  return raw.split("\n").filter((line) => line.includes("\0")).map((line) => {
+    const [sha, subject] = line.split("\0");
+    return { sha, subject: subject ?? "" };
+  });
+}
+__name(stashEntries, "stashEntries");
+function parseDroppedStashSha(output) {
+  const match = /\(([0-9a-f]{40,64})\)\s*$/m.exec(output.trim());
+  return match?.[1];
+}
+__name(parseDroppedStashSha, "parseDroppedStashSha");
+async function restoreStash(cwd, sha, env) {
+  let output = "";
+  try {
+    await runGit2(cwd, ["stash", "apply", sha], env);
+  } catch (err) {
+    return { restored: false, output: gitDetail(err) };
+  }
+  let entries;
+  try {
+    entries = await stashEntries(cwd, env);
+  } catch (err) {
+    return {
+      restored: true,
+      output: `restored, but stash entry ${sha} was kept because the stash could not be listed:
+${gitDetail(err)}`
+    };
+  }
+  const index = entries.findIndex((entry) => entry.sha === sha);
+  if (index === -1) return { restored: true, output };
+  const slot = `stash@{${index}}`;
+  let dropped;
+  try {
+    dropped = parseDroppedStashSha(
+      await runGit2(cwd, ["stash", "drop", slot], env)
+    );
+  } catch (err) {
+    return {
+      restored: true,
+      output: `restored, but stash entry ${slot} (${sha}) could not be dropped:
+${gitDetail(err)}`
+    };
+  }
+  if (dropped !== void 0 && dropped !== sha) {
+    const subject = (await runGit2(cwd, ["log", "-1", "--format=%s", dropped], env).catch(
+      () => ""
+    )).trim();
+    const storeArgs = ["stash", "store", "--quiet"];
+    if (subject) storeArgs.push("-m", subject);
+    storeArgs.push(dropped);
+    const stored = await runGit2(cwd, storeArgs, env).then(() => true).catch(() => false);
+    output = stored ? `restored; stash entry ${sha} was kept because the stash changed while dropping it` : `restored; stash entry ${sha} was kept because the stash changed while dropping it, and the displaced entry ${dropped} could not be stored back \u2014 recover it with: git stash store ${dropped}`;
+  }
+  return { restored: true, output };
+}
+__name(restoreStash, "restoreStash");
+function pullArgs(opts) {
+  const args = ["pull"];
+  if (opts?.rebase) args.push("--rebase");
+  return args;
+}
+__name(pullArgs, "pullArgs");
+async function validatedUpstream(cwd, env) {
+  const sha = await upstreamSha(cwd, env);
+  if (sha) return sha;
+  let branch;
+  try {
+    branch = (await runGit2(cwd, ["symbolic-ref", "--quiet", "--short", "HEAD"], env)).trim();
+  } catch {
+    throw new GitPullFailure(
+      "pull_failed",
+      "cannot update: HEAD is detached; check out a branch from a terminal first"
+    );
+  }
+  const configured = (await runGit2(
+    cwd,
+    ["for-each-ref", "--format=%(upstream)", `refs/heads/${branch}`],
+    env
+  ).catch(() => "")).trim();
+  if (configured) {
+    throw new GitPullFailure(
+      "pull_failed",
+      "cannot update: the upstream branch no longer exists on the remote; nothing was changed"
+    );
+  }
+  await runGit2(cwd, ["rev-parse", "--abbrev-ref", "@{upstream}"], env);
+  throw new GitPullFailure(
+    "pull_failed",
+    "cannot update: the upstream branch could not be resolved; nothing was changed"
+  );
+}
+__name(validatedUpstream, "validatedUpstream");
+async function pushAutoStash(cwd, env) {
+  const before = new Set((await stashEntries(cwd, env)).map((e) => e.sha));
+  await refuseOperationInProgress(cwd, env);
+  try {
+    await runGit2(
+      cwd,
+      ["stash", "push", "--include-untracked", "-m", AUTO_STASH_MESSAGE],
+      env
+    );
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `cannot stash the local changes, so the update was not attempted:
+${gitDetail(err)}`
+    );
+  }
+  let after;
+  try {
+    after = await stashEntries(cwd, env);
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `cannot identify the auto-stash entry, so the update was not attempted; your changes are in the entry labelled "${AUTO_STASH_MESSAGE}" in git stash list:
+${gitDetail(err)}`
+    );
+  }
+  const created = after.filter(
+    (e) => !before.has(e.sha) && e.subject.endsWith(AUTO_STASH_MESSAGE)
+  );
+  return created.length > 0 ? created[created.length - 1].sha : void 0;
+}
+__name(pushAutoStash, "pushAutoStash");
+async function stashPull(cwd, opts, env) {
+  await refuseOperationInProgress(cwd, env);
+  await runGit2(cwd, ["fetch", "--prune"], env);
+  await validatedUpstream(cwd, env);
+  const stashed = await pushAutoStash(cwd, env);
+  let output;
+  try {
+    output = (await runGit2(cwd, pullArgs(opts), env)).trim();
+  } catch (err) {
+    const detail = gitDetail(err);
+    await abortOwnPullState(cwd, pullExitCode(err), env);
+    if (stashed === void 0) {
+      throw new GitPullFailure("pull_failed", `update failed:
+${detail}`);
+    }
+    const restore2 = await restoreStash(cwd, stashed, env);
+    throw new GitPullFailure(
+      "pull_failed",
+      restore2.restored ? `update failed; your local changes were restored${restore2.output ? ` (${restore2.output})` : ""}:
+${detail}` : `update failed and your local changes could not be restored automatically; they are kept in stash entry ${stashed}:
+${restore2.output}
+${detail}`
+    );
+  }
+  if (stashed === void 0) return { success: true, output };
+  const restore = await restoreStash(cwd, stashed, env);
+  if (restore.restored) {
+    if (restore.output === "") return { success: true, output };
+    return {
+      success: true,
+      stashKept: true,
+      stashSha: stashed,
+      output: `${output}
+${restore.output}`.trim()
+    };
+  }
+  return {
+    success: true,
+    stashRestoreConflict: true,
+    stashSha: stashed,
+    output: `${output}
+restoring your local changes failed; they are kept in stash entry ${stashed}:
+${restore.output}`.trim()
+  };
+}
+__name(stashPull, "stashPull");
+async function forcePull(cwd, env) {
+  await refuseOperationInProgress(cwd, env);
+  const toplevel = (await runGit2(cwd, ["rev-parse", "--show-toplevel"], env)).trim();
+  if (await fs3.promises.realpath(cwd) !== await fs3.promises.realpath(toplevel)) {
+    throw new GitPullFailure(
+      "force_unsupported",
+      "cannot discard changes: the workspace is a subdirectory of its repository, so discarding would also reset changes outside the workspace; resolve them from a terminal"
+    );
+  }
+  await runGit2(cwd, ["fetch", "--prune"], env);
+  const validated = await validatedUpstream(cwd, env);
+  try {
+    await runGit2(cwd, ["merge-base", "--is-ancestor", "HEAD", validated], env);
+  } catch (err) {
+    if (exitCode(err) === 1) {
+      throw new GitPullFailure(
+        "diverged",
+        "cannot discard and update: the branch has diverged from its upstream; merge or rebase the local commits from a terminal first"
+      );
+    }
+    throw err;
+  }
+  await refuseOperationInProgress(cwd, env);
+  await runGit2(cwd, ["reset", "--hard"], env);
+  await runGit2(cwd, ["clean", "-fd"], env);
+  let output;
+  try {
+    output = await runGit2(cwd, ["merge", "--ff-only", validated], env);
+  } catch (err) {
+    throw new GitPullFailure(
+      "pull_failed",
+      `discard applied, but the update failed:
+${gitDetail(err)}`
+    );
+  }
+  return { success: true, output: output.trim() };
+}
+__name(forcePull, "forcePull");
+async function gitPull(cwd, opts, env) {
+  if (opts?.stash && opts?.force) {
+    throw new Error("stash and force are mutually exclusive");
+  }
+  if (opts?.fetchOnly && (opts?.stash || opts?.force)) {
+    throw new Error("fetchOnly cannot be combined with stash or force");
+  }
+  if (opts?.fetchOnly) {
+    const output2 = await runGit2(cwd, ["fetch", "--all", "--prune"], env);
+    return { success: true, output: output2.trim() };
+  }
+  if (opts?.force) return forcePull(cwd, env);
+  if (opts?.stash) return stashPull(cwd, opts, env);
+  const output = await runGit2(cwd, pullArgs(opts), env);
+  return { success: true, output: output.trim() };
+}
+__name(gitPull, "gitPull");
+async function gitCommit(cwd, message, opts, env) {
+  let savedIndex = null;
+  if (opts?.all) {
+    const tree = (await runGit2(cwd, ["write-tree"], env).catch(() => "")).trim();
+    if (tree) {
+      savedIndex = tree;
+    } else {
+      const unmerged = (await runGit2(cwd, ["ls-files", "--unmerged"], env)).trim();
+      if (unmerged) {
+        throw new Error(
+          "cannot stage all changes: unresolved merge conflicts in the index"
+        );
+      }
+      throw new Error(
+        "cannot stage all changes: failed to snapshot index (write-tree failed)"
+      );
+    }
+  }
+  try {
+    if (opts?.all) {
+      await runGit2(cwd, ["add", "-A"], env);
+    }
+    await runGit2(cwd, ["commit", "-m", message], env);
+  } catch (err) {
+    if (savedIndex) {
+      await runGit2(cwd, ["read-tree", savedIndex], env).catch((rollbackErr) => {
+        console.error("git index rollback failed:", rollbackErr);
+      });
+    }
+    throw err;
+  }
+  const sha = (await runGit2(cwd, ["rev-parse", "--short", "HEAD"], env)).trim();
+  const subject = (await runGit2(cwd, ["log", "-1", "--format=%s"], env)).trim();
+  return { sha, subject };
+}
+__name(gitCommit, "gitCommit");
 
 // packages/core/src/utils/load-simple-git.ts
 init_esbuild_shims();
@@ -173,8 +2131,8 @@ async function initRepositoryWithMainBranch(git) {
 __name(initRepositoryWithMainBranch, "initRepositoryWithMainBranch");
 
 // packages/core/src/services/gitWorktreeService.ts
-var execFileAsync = promisify(execFile);
-var debugLogger = createDebugLogger("GIT_WORKTREE_SERVICE");
+var execFileAsync3 = promisify3(execFile3);
+var debugLogger2 = createDebugLogger("GIT_WORKTREE_SERVICE");
 var WORKTREE_BRANCH_PREFIX = "worktree-";
 function worktreeBranchForSlug(slug) {
   return `${WORKTREE_BRANCH_PREFIX}${slug}`;
@@ -182,38 +2140,85 @@ function worktreeBranchForSlug(slug) {
 __name(worktreeBranchForSlug, "worktreeBranchForSlug");
 var WORKTREE_SESSION_FILE = ".o1-code-session";
 var WORKTREE_SESSION_MARKER_MAX_BYTES = 512;
+var DISPOSABLE_IGNORED_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", "coverage"]);
+async function worktreeHasWork(worktreePath) {
+  try {
+    await fs4.access(path5.join(worktreePath, ".git"));
+    const { stdout } = await execFileAsync3(
+      "git",
+      [
+        ...NO_EXEC_CONFIG,
+        "--no-optional-locks",
+        "status",
+        "--porcelain",
+        "-z",
+        "--untracked-files=normal",
+        "--ignored=matching"
+      ],
+      {
+        cwd: worktreePath,
+        env: gitEnv(),
+        encoding: "utf8",
+        maxBuffer: 10 * 1024 * 1024,
+        timeout: 3e4
+      }
+    );
+    for (const record of stdout.split("\0")) {
+      if (record.length === 0) continue;
+      const status = record.slice(0, 2);
+      const entry = record.slice(3);
+      if (status !== "??" && status !== "!!") return true;
+      if (entry === WORKTREE_SESSION_FILE) continue;
+      if (status === "!!" && entry.split("/").some((segment) => DISPOSABLE_IGNORED_DIRS.has(segment))) {
+        continue;
+      }
+      const stats = await fs4.lstat(
+        path5.join(worktreePath, entry.replace(/\/$/, ""))
+      );
+      if (stats.isSymbolicLink()) continue;
+      return true;
+    }
+    return false;
+  } catch (error) {
+    debugLogger2.warn(
+      `worktreeHasWork: cannot inspect ${worktreePath}, keeping it: ${error}`
+    );
+    return true;
+  }
+}
+__name(worktreeHasWork, "worktreeHasWork");
 var NO_EXEC_DIFF_FLAGS = ["--no-ext-diff", "--no-textconv"];
 async function addWorktreeSessionMarkerExclude(worktreePath) {
   try {
     const { simpleGit } = await loadSimpleGit();
     const wtGit = simpleGit(worktreePath);
     const commonDir = (await wtGit.revparse(["--git-common-dir"])).trim();
-    const excludePath = path2.isAbsolute(commonDir) ? path2.join(commonDir, "info", "exclude") : path2.join(worktreePath, commonDir, "info", "exclude");
-    await fs2.mkdir(path2.dirname(excludePath), { recursive: true });
+    const excludePath = path5.isAbsolute(commonDir) ? path5.join(commonDir, "info", "exclude") : path5.join(worktreePath, commonDir, "info", "exclude");
+    await fs4.mkdir(path5.dirname(excludePath), { recursive: true });
     let existing = "";
     try {
-      existing = await fs2.readFile(excludePath, "utf8");
+      existing = await fs4.readFile(excludePath, "utf8");
     } catch {
     }
     const rules = [WORKTREE_SESSION_FILE, `${WORKTREE_SESSION_FILE}.*.tmp`];
     let next = existing;
     for (const rule of rules) {
       if (!next.split(/\r?\n/).includes(rule)) {
-        const sep = next.length === 0 || next.endsWith("\n") ? "" : "\n";
-        next = `${next}${sep}${rule}
+        const sep2 = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+        next = `${next}${sep2}${rule}
 `;
       }
     }
     if (next !== existing) {
-      await fs2.writeFile(excludePath, next, "utf8");
+      await fs4.writeFile(excludePath, next, "utf8");
     }
   } catch {
   }
 }
 __name(addWorktreeSessionMarkerExclude, "addWorktreeSessionMarkerExclude");
 async function writeWorktreeSessionMarker(worktreePath, sessionId) {
-  await fs2.writeFile(
-    path2.join(worktreePath, WORKTREE_SESSION_FILE),
+  await fs4.writeFile(
+    path5.join(worktreePath, WORKTREE_SESSION_FILE),
     sessionId,
     "utf8"
   );
@@ -236,10 +2241,10 @@ var WorktreeMarkerCommittedError = class extends Error {
 };
 async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
   assertValidWorktreeSessionMarkerOwner(sessionId);
-  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const markerPath = path5.join(worktreePath, WORKTREE_SESSION_FILE);
   const stagedPath = `${markerPath}.${randomBytes(6).toString("hex")}.tmp`;
   const flags = nodeFs.constants.O_WRONLY | nodeFs.constants.O_CREAT | nodeFs.constants.O_EXCL | (nodeFs.constants.O_NOFOLLOW ?? 0);
-  const handle = await fs2.open(stagedPath, flags, 384);
+  const handle = await fs4.open(stagedPath, flags, 384);
   let stagedDev = 0;
   let stagedIno = 0;
   try {
@@ -253,20 +2258,20 @@ async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
     await handle.sync();
     const [after, pathStats] = await Promise.all([
       handle.stat(),
-      fs2.lstat(stagedPath)
+      fs4.lstat(stagedPath)
     ]);
     if (!after.isFile() || after.nlink !== 1 || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== before.dev || after.ino !== before.ino || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
       throw new Error("Worktree session marker identity changed");
     }
-    await fs2.link(stagedPath, markerPath);
+    await fs4.link(stagedPath, markerPath);
   } catch (error) {
     await handle.close().catch(() => {
     });
     if (stagedIno !== 0) {
       try {
-        const current = await fs2.lstat(stagedPath);
+        const current = await fs4.lstat(stagedPath);
         if (current.dev === stagedDev && current.ino === stagedIno) {
-          await fs2.unlink(stagedPath);
+          await fs4.unlink(stagedPath);
         }
       } catch {
       }
@@ -274,7 +2279,7 @@ async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
     throw error;
   }
   try {
-    await fs2.unlink(stagedPath);
+    await fs4.unlink(stagedPath);
     await handle.close();
   } catch (error) {
     await handle.close().catch(() => {
@@ -291,12 +2296,12 @@ function assertValidWorktreeSessionMarkerOwner(sessionId) {
 }
 __name(assertValidWorktreeSessionMarkerOwner, "assertValidWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarkerStrict(worktreePath) {
-  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const markerPath = path5.join(worktreePath, WORKTREE_SESSION_FILE);
   let handle;
   let observedMarker = false;
   try {
     const flags = nodeFs.constants.O_RDONLY | (nodeFs.constants.O_NOFOLLOW ?? 0) | (nodeFs.constants.O_NONBLOCK ?? 0);
-    const before = await fs2.lstat(markerPath);
+    const before = await fs4.lstat(markerPath);
     observedMarker = true;
     if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1) {
       return { state: "invalid", reason: "unsafe marker file type" };
@@ -304,7 +2309,7 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
     if (before.ino === 0 || before.size > WORKTREE_SESSION_MARKER_MAX_BYTES) {
       return { state: "invalid", reason: "unsafe marker size or identity" };
     }
-    handle = await fs2.open(markerPath, flags);
+    handle = await fs4.open(markerPath, flags);
     const opened = await handle.stat();
     if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== before.dev || opened.ino !== before.ino) {
       return {
@@ -329,7 +2334,7 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
     }
     const raw = markerBuffer.subarray(0, bytesRead).toString("utf8");
     const after = await handle.stat();
-    const pathStats = await fs2.lstat(markerPath);
+    const pathStats = await fs4.lstat(markerPath);
     if (!after.isFile() || after.nlink !== 1 || after.size !== bytesRead || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== opened.dev || after.ino !== opened.ino || !pathStats.isFile() || pathStats.nlink !== 1 || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
       return {
         state: "invalid",
@@ -362,7 +2367,7 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
 }
 __name(readWorktreeSessionMarkerStrict, "readWorktreeSessionMarkerStrict");
 function readWorktreeSessionMarkerStrictSync(worktreePath) {
-  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const markerPath = path5.join(worktreePath, WORKTREE_SESSION_FILE);
   let fd;
   let observedMarker = false;
   try {
@@ -463,7 +2468,7 @@ async function transferWorktreeSessionMarkerOwner(worktreePath, expectedOwner, n
   if (euid !== void 0 && opening.uid !== null && opening.uid !== euid) {
     throw new Error("Worktree marker is owned by a different uid");
   }
-  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const markerPath = path5.join(worktreePath, WORKTREE_SESSION_FILE);
   await atomicWriteFile(markerPath, newOwner, {
     mode: 384,
     noFollow: true,
@@ -478,14 +2483,14 @@ async function transferWorktreeSessionMarkerOwner(worktreePath, expectedOwner, n
 }
 __name(transferWorktreeSessionMarkerOwner, "transferWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarker(worktreePath) {
-  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const markerPath = path5.join(worktreePath, WORKTREE_SESSION_FILE);
   try {
-    const raw = await fs2.readFile(markerPath, "utf8");
+    const raw = await fs4.readFile(markerPath, "utf8");
     const trimmed = raw.trim();
     return trimmed.length > 0 ? trimmed : null;
   } catch (error) {
     if (error.code !== "ENOENT") {
-      debugLogger.warn(
+      debugLogger2.warn(
         `readWorktreeSessionMarker: cannot read ${markerPath}: ${error}`
       );
     }
@@ -517,7 +2522,7 @@ var GitWorktreeService = class _GitWorktreeService {
   gitPromise;
   customBaseDir;
   constructor(sourceRepoPath, customBaseDir) {
-    this.sourceRepoPath = path2.resolve(sourceRepoPath);
+    this.sourceRepoPath = path5.resolve(sourceRepoPath);
     this.customBaseDir = customBaseDir;
   }
   getGit() {
@@ -532,23 +2537,23 @@ var GitWorktreeService = class _GitWorktreeService {
    */
   static getBaseDir(customDir) {
     if (customDir) {
-      return path2.resolve(customDir);
+      return path5.resolve(customDir);
     }
-    return path2.join(Storage.getGlobalO1CodeDir(), WORKTREES_DIR);
+    return path5.join(Storage.getGlobalO1CodeDir(), WORKTREES_DIR);
   }
   /**
    * Gets the directory for a specific session.
    * @param customBaseDir - Optional custom base directory override
    */
   static getSessionDir(sessionId, customBaseDir) {
-    return path2.join(_GitWorktreeService.getBaseDir(customBaseDir), sessionId);
+    return path5.join(_GitWorktreeService.getBaseDir(customBaseDir), sessionId);
   }
   /**
    * Gets the worktrees directory for a specific session.
    * @param customBaseDir - Optional custom base directory override
    */
   static getWorktreesDir(sessionId, customBaseDir) {
-    return path2.join(
+    return path5.join(
       _GitWorktreeService.getSessionDir(sessionId, customBaseDir),
       WORKTREES_DIR
     );
@@ -589,7 +2594,7 @@ var GitWorktreeService = class _GitWorktreeService {
       const top = out.replace(/\n$/, "");
       return top.length > 0 ? top : null;
     } catch (error) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `getRepoTopLevel failed at ${this.sourceRepoPath}: ${error}`
       );
       return null;
@@ -634,7 +2639,7 @@ var GitWorktreeService = class _GitWorktreeService {
       if (mainPath.length === 0) return null;
       const realpathOr = /* @__PURE__ */ __name(async (p) => {
         try {
-          return await fs2.realpath(p);
+          return await fs4.realpath(p);
         } catch {
           return p;
         }
@@ -645,14 +2650,14 @@ var GitWorktreeService = class _GitWorktreeService {
         simpleGit(mainPath).raw(["rev-parse", "--git-common-dir"])
       ]);
       const ourCommonDir = await realpathOr(
-        path2.resolve(this.sourceRepoPath, ourRaw.trim())
+        path5.resolve(this.sourceRepoPath, ourRaw.trim())
       );
       const anchorCommonDir = await realpathOr(
-        path2.resolve(mainPath, anchorRaw.trim())
+        path5.resolve(mainPath, anchorRaw.trim())
       );
       return ourCommonDir === anchorCommonDir ? mainPath : null;
     } catch (error) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `getMainWorktreePath failed at ${this.sourceRepoPath}: ${error}`
       );
       return null;
@@ -749,9 +2754,9 @@ var GitWorktreeService = class _GitWorktreeService {
         sessionId,
         this.customBaseDir
       );
-      await fs2.mkdir(worktreesDir, { recursive: true });
+      await fs4.mkdir(worktreesDir, { recursive: true });
       const sanitizedName = this.sanitizeName(name);
-      const worktreePath = path2.join(worktreesDir, sanitizedName);
+      const worktreePath = path5.join(worktreesDir, sanitizedName);
       const exists = await this.pathExists(worktreePath);
       if (exists) {
         return {
@@ -831,8 +2836,8 @@ var GitWorktreeService = class _GitWorktreeService {
       config.sessionId,
       this.customBaseDir
     );
-    await fs2.mkdir(sessionDir, { recursive: true });
-    const configPath = path2.join(sessionDir, "config.json");
+    await fs4.mkdir(sessionDir, { recursive: true });
+    const configPath = path5.join(sessionDir, "config.json");
     const configFile = {
       sessionId: config.sessionId,
       sourceRepoPath: config.sourceRepoPath,
@@ -841,7 +2846,7 @@ var GitWorktreeService = class _GitWorktreeService {
       createdAt: Date.now(),
       ...config.metadata
     };
-    await fs2.writeFile(configPath, JSON.stringify(configFile, null, 2));
+    await fs4.writeFile(configPath, JSON.stringify(configFile, null, 2));
     let dirtyStateSnapshot = "";
     try {
       dirtyStateSnapshot = (await (await this.getGit()).stash(["create"])).trim();
@@ -894,10 +2899,10 @@ var GitWorktreeService = class _GitWorktreeService {
         }
         for (const relPath of untrackedFiles) {
           try {
-            const src = path2.join(this.sourceRepoPath, relPath);
-            const dst = path2.join(worktree.path, relPath);
-            await fs2.mkdir(path2.dirname(dst), { recursive: true });
-            await fs2.copyFile(src, dst);
+            const src = path5.join(this.sourceRepoPath, relPath);
+            const dst = path5.join(worktree.path, relPath);
+            await fs4.mkdir(path5.dirname(dst), { recursive: true });
+            await fs4.copyFile(src, dst);
           } catch {
           }
         }
@@ -922,11 +2927,11 @@ var GitWorktreeService = class _GitWorktreeService {
       this.customBaseDir
     );
     try {
-      const entries = await fs2.readdir(worktreesDir, { withFileTypes: true });
+      const entries = await fs4.readdir(worktreesDir, { withFileTypes: true });
       const worktrees = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const worktreePath = path2.join(worktreesDir, entry.name);
+          const worktreePath = path5.join(worktreesDir, entry.name);
           let branchName = "";
           try {
             branchName = execSync("git rev-parse --abbrev-ref HEAD", {
@@ -938,7 +2943,7 @@ var GitWorktreeService = class _GitWorktreeService {
           }
           let createdAt = Date.now();
           try {
-            const stats = await fs2.stat(worktreePath);
+            const stats = await fs4.stat(worktreePath);
             createdAt = stats.birthtimeMs;
           } catch {
           }
@@ -978,7 +2983,7 @@ var GitWorktreeService = class _GitWorktreeService {
       return { success: true };
     } catch (error) {
       try {
-        await fs2.rm(worktreePath, { recursive: true, force: true });
+        await fs4.rm(worktreePath, { recursive: true, force: true });
         await git.raw(["worktree", "prune"]);
         return { success: true };
       } catch (_rmError) {
@@ -1019,7 +3024,7 @@ var GitWorktreeService = class _GitWorktreeService {
       this.customBaseDir
     );
     try {
-      await fs2.rm(sessionDir, { recursive: true, force: true });
+      await fs4.rm(sessionDir, { recursive: true, force: true });
     } catch (error) {
       result.errors.push(
         `Failed to remove session directory: ${error instanceof Error ? error.message : "Unknown error"}`
@@ -1084,17 +3089,17 @@ var GitWorktreeService = class _GitWorktreeService {
       if (!patch.trim()) {
         return { success: true };
       }
-      const patchFile = path2.join(
+      const patchFile = path5.join(
         this.getBaseDirForInstance(),
         `.worktree-apply-${Date.now()}-${Math.random().toString(16).slice(2)}.patch`
       );
-      await fs2.mkdir(path2.dirname(patchFile), { recursive: true });
-      await fs2.writeFile(patchFile, patch, "utf-8");
+      await fs4.mkdir(path5.dirname(patchFile), { recursive: true });
+      await fs4.writeFile(patchFile, patch, "utf-8");
       try {
         const applyArgs = hasBaseline ? ["apply", "--whitespace=nowarn", patchFile] : ["apply", "--3way", "--whitespace=nowarn", patchFile];
         await targetGit.raw(applyArgs);
       } finally {
-        await fs2.rm(patchFile, { force: true });
+        await fs4.rm(patchFile, { force: true });
       }
       return { success: true };
     } catch (error) {
@@ -1111,17 +3116,17 @@ var GitWorktreeService = class _GitWorktreeService {
     const baseDir = _GitWorktreeService.getBaseDir(customBaseDir);
     const sessions = [];
     try {
-      const entries = await fs2.readdir(baseDir, { withFileTypes: true });
+      const entries = await fs4.readdir(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const configPath = path2.join(baseDir, entry.name, "config.json");
+          const configPath = path5.join(baseDir, entry.name, "config.json");
           try {
-            const configContent = await fs2.readFile(configPath, "utf-8");
+            const configContent = await fs4.readFile(configPath, "utf-8");
             const config = JSON.parse(configContent);
-            const worktreesDir = path2.join(baseDir, entry.name, WORKTREES_DIR);
+            const worktreesDir = path5.join(baseDir, entry.name, WORKTREES_DIR);
             let worktreeCount = 0;
             try {
-              const worktreeEntries = await fs2.readdir(worktreesDir);
+              const worktreeEntries = await fs4.readdir(worktreesDir);
               worktreeCount = worktreeEntries.length;
             } catch {
             }
@@ -1175,7 +3180,7 @@ var GitWorktreeService = class _GitWorktreeService {
   }
   async pathExists(p) {
     try {
-      await fs2.access(p);
+      await fs4.access(p);
       return true;
     } catch {
       return false;
@@ -1192,13 +3197,13 @@ var GitWorktreeService = class _GitWorktreeService {
    * repo: `<projectRoot>/.o1-code/worktrees`.
    */
   getUserWorktreesDir() {
-    return path2.join(this.sourceRepoPath, ".o1-code", WORKTREES_DIR);
+    return path5.join(this.sourceRepoPath, ".o1-code", WORKTREES_DIR);
   }
   /**
    * Returns the absolute worktree path for a given slug.
    */
   getUserWorktreePath(slug) {
-    return path2.join(this.getUserWorktreesDir(), slug);
+    return path5.join(this.getUserWorktreesDir(), slug);
   }
   /**
    * Generates an auto-slug `{adj}-{noun}-{6hex}` for an unnamed worktree.
@@ -1295,9 +3300,9 @@ var GitWorktreeService = class _GitWorktreeService {
   async getRegisteredWorktreeBranch(worktreePath) {
     let resolvedWorktreePath;
     try {
-      const stat2 = await fs2.stat(worktreePath);
-      if (!stat2.isDirectory()) return null;
-      resolvedWorktreePath = await fs2.realpath(worktreePath);
+      const stat4 = await fs4.stat(worktreePath);
+      if (!stat4.isDirectory()) return null;
+      resolvedWorktreePath = await fs4.realpath(worktreePath);
     } catch {
       return null;
     }
@@ -1320,27 +3325,27 @@ var GitWorktreeService = class _GitWorktreeService {
           "--show-toplevel"
         ])
       ]);
-      ourCommonDir = path2.resolve(this.sourceRepoPath, ourRaw.trim());
+      ourCommonDir = path5.resolve(this.sourceRepoPath, ourRaw.trim());
       const lines = probeRaw.split("\n").map((l) => l.trim()).filter((l) => l.length > 0);
       if (lines.length < 4) return null;
       headCommit = lines[0];
       branch = lines[1];
-      probeCommonDir = path2.resolve(worktreePath, lines[2]);
-      probeToplevel = path2.resolve(lines[3]);
+      probeCommonDir = path5.resolve(worktreePath, lines[2]);
+      probeToplevel = path5.resolve(lines[3]);
     } catch (error) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `getRegisteredWorktreeBranch: probe at ${worktreePath} failed: ${error}`
       );
       return null;
     }
     if (probeCommonDir !== ourCommonDir) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `getRegisteredWorktreeBranch: ${worktreePath} belongs to a different repo (common-dir=${probeCommonDir}, expected ${ourCommonDir})`
       );
       return null;
     }
     if (probeToplevel !== resolvedWorktreePath) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `getRegisteredWorktreeBranch: ${worktreePath} is not a registered worktree (toplevel=${probeToplevel}, expected ${resolvedWorktreePath})`
       );
       return null;
@@ -1385,34 +3390,34 @@ var GitWorktreeService = class _GitWorktreeService {
   async isRegisteredLinkedWorktree(worktreePath) {
     const realpathOr = /* @__PURE__ */ __name(async (p) => {
       try {
-        return await fs2.realpath(p);
+        return await fs4.realpath(p);
       } catch {
-        return path2.resolve(p);
+        return path5.resolve(p);
       }
     }, "realpathOr");
     try {
-      const target = await fs2.realpath(worktreePath);
-      const ourCommonDir = path2.resolve(
+      const target = await fs4.realpath(worktreePath);
+      const ourCommonDir = path5.resolve(
         this.sourceRepoPath,
         (await (await this.getGit()).raw(["rev-parse", "--git-common-dir"])).trim()
       );
-      const worktreesDir = path2.join(ourCommonDir, "worktrees");
+      const worktreesDir = path5.join(ourCommonDir, "worktrees");
       let entryNames;
       try {
-        entryNames = await fs2.readdir(worktreesDir);
+        entryNames = await fs4.readdir(worktreesDir);
       } catch {
         return false;
       }
       let entryGitDir = null;
       for (const name of entryNames) {
-        const entry = path2.join(worktreesDir, name);
+        const entry = path5.join(worktreesDir, name);
         let pointer;
         try {
-          pointer = (await fs2.readFile(path2.join(entry, "gitdir"), "utf8")).trim();
+          pointer = (await fs4.readFile(path5.join(entry, "gitdir"), "utf8")).trim();
         } catch {
           continue;
         }
-        if (await realpathOr(path2.dirname(pointer)) === target) {
+        if (await realpathOr(path5.dirname(pointer)) === target) {
           entryGitDir = entry;
           break;
         }
@@ -1420,10 +3425,10 @@ var GitWorktreeService = class _GitWorktreeService {
       if (!entryGitDir) return false;
       const { simpleGit } = await loadSimpleGit();
       const rawGitDir = (await simpleGit(target).raw(["rev-parse", "--git-dir"])).trim();
-      const probeGitDir = await realpathOr(path2.resolve(target, rawGitDir));
+      const probeGitDir = await realpathOr(path5.resolve(target, rawGitDir));
       return probeGitDir === await realpathOr(entryGitDir);
     } catch (error) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `isRegisteredLinkedWorktree: probe at ${worktreePath} failed: ${error}`
       );
       return false;
@@ -1468,7 +3473,7 @@ var GitWorktreeService = class _GitWorktreeService {
     }
     const refspec = `pull/${prNumberStr}/head`;
     try {
-      await execFileAsync(
+      await execFileAsync3(
         "git",
         ["fetch", "--end-of-options", "origin", refspec],
         {
@@ -1502,7 +3507,7 @@ var GitWorktreeService = class _GitWorktreeService {
       }
       const firstLine = stderr.split("\n").find((l) => l.trim().length > 0);
       const detail = firstLine ? ` (${firstLine.trim()})` : "";
-      debugLogger.warn(
+      debugLogger2.warn(
         `fetchPullRequestRef: git fetch pull/${prNumber}/head failed: ${error}`
       );
       return {
@@ -1565,18 +3570,18 @@ var GitWorktreeService = class _GitWorktreeService {
       options?.prBacked === true ? { allowPrBackedShape: true } : void 0
     );
     if (validationError) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `createUserWorktree: invalid slug ${slug}: ${validationError}`
       );
       return { success: false, error: validationError };
     }
     try {
       const worktreesDir = this.getUserWorktreesDir();
-      await fs2.mkdir(worktreesDir, { recursive: true });
-      const worktreePath = path2.join(worktreesDir, slug);
+      await fs4.mkdir(worktreesDir, { recursive: true });
+      const worktreePath = path5.join(worktreesDir, slug);
       if (await fileExists(worktreePath)) {
         const error = `Worktree already exists at ${worktreePath}`;
-        debugLogger.warn(`createUserWorktree: ${error}`);
+        debugLogger2.warn(`createUserWorktree: ${error}`);
         return { success: false, error };
       }
       await this.ensureWorktreesGitignored();
@@ -1585,12 +3590,12 @@ var GitWorktreeService = class _GitWorktreeService {
       const branchExists = await this.localBranchExists(branchName);
       if (branchExists) {
         const error = `Cannot create worktree "${slug}": branch ${branchName} already exists. Choose a different name, or delete the branch first (e.g. \`git branch -d ${branchName}\`).`;
-        debugLogger.warn(`createUserWorktree: ${error}`);
+        debugLogger2.warn(`createUserWorktree: ${error}`);
         return { success: false, error };
       }
       await (await this.getGit()).raw(["worktree", "add", "-b", branchName, worktreePath, base]);
       await this.configureHooksPath(worktreePath).catch((error) => {
-        debugLogger.warn(
+        debugLogger2.warn(
           `createUserWorktree: failed to configure core.hooksPath for ${slug}: ${error}`
         );
       });
@@ -1600,7 +3605,7 @@ var GitWorktreeService = class _GitWorktreeService {
           worktreePath,
           symlinkPaths
         ).catch((error) => {
-          debugLogger.warn(
+          debugLogger2.warn(
             `createUserWorktree: symlinkConfiguredDirectories failed for ${slug}: ${error}`
           );
         });
@@ -1616,7 +3621,7 @@ var GitWorktreeService = class _GitWorktreeService {
       return { success: true, worktree };
     } catch (error) {
       const message = `Failed to create worktree "${slug}": ${error instanceof Error ? error.message : "Unknown error"}`;
-      debugLogger.warn(`createUserWorktree: ${message}`);
+      debugLogger2.warn(`createUserWorktree: ${message}`);
       return { success: false, error: message };
     }
   }
@@ -1635,14 +3640,14 @@ var GitWorktreeService = class _GitWorktreeService {
    * creation so the extra ~14ms isn't worth the file-parsing complexity).
    */
   async configureHooksPath(worktreePath) {
-    const huskyPath = path2.join(this.sourceRepoPath, ".husky");
+    const huskyPath = path5.join(this.sourceRepoPath, ".husky");
     let hooksPath = null;
     try {
-      await fs2.stat(huskyPath);
+      await fs4.stat(huskyPath);
       hooksPath = huskyPath;
     } catch (error) {
       if (!(isNodeError(error) && error.code === "ENOENT")) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `configureHooksPath: cannot stat ${huskyPath}: ${error}`
         );
       }
@@ -1650,13 +3655,13 @@ var GitWorktreeService = class _GitWorktreeService {
     if (!hooksPath) {
       try {
         const commonDir = (await (await this.getGit()).raw(["rev-parse", "--git-common-dir"])).trim();
-        const resolvedCommonDir = path2.isAbsolute(commonDir) ? commonDir : path2.resolve(this.sourceRepoPath, commonDir);
-        const candidate = path2.join(resolvedCommonDir, "hooks");
-        await fs2.stat(candidate);
+        const resolvedCommonDir = path5.isAbsolute(commonDir) ? commonDir : path5.resolve(this.sourceRepoPath, commonDir);
+        const candidate = path5.join(resolvedCommonDir, "hooks");
+        await fs4.stat(candidate);
         hooksPath = candidate;
       } catch (error) {
         if (!(isNodeError(error) && error.code === "ENOENT")) {
-          debugLogger.warn(
+          debugLogger2.warn(
             `configureHooksPath: cannot resolve git common hooks dir: ${error}`
           );
         }
@@ -1675,7 +3680,7 @@ var GitWorktreeService = class _GitWorktreeService {
     if (existing === "") {
       await worktreeGit.raw(["config", "core.hooksPath", hooksPath]);
     } else if (existing !== hooksPath) {
-      debugLogger.debug(
+      debugLogger2.debug(
         `configureHooksPath: preserving existing core.hooksPath=${existing} (o1-code would have set it to ${hooksPath})`
       );
     }
@@ -1707,70 +3712,70 @@ var GitWorktreeService = class _GitWorktreeService {
   async symlinkConfiguredDirectories(worktreePath, configured) {
     let repoRootAbs;
     try {
-      repoRootAbs = await fs2.realpath(this.sourceRepoPath);
+      repoRootAbs = await fs4.realpath(this.sourceRepoPath);
     } catch {
-      debugLogger.warn(
+      debugLogger2.warn(
         `symlinkConfiguredDirectories: cannot realpath sourceRepoPath "${this.sourceRepoPath}", skipping all entries`
       );
       return;
     }
-    const gitDirAbs = path2.join(repoRootAbs, ".git");
-    const o1codeDirAbs = path2.join(repoRootAbs, ".o1-code");
-    const realWorktreePath = await fs2.realpath(worktreePath).catch(() => worktreePath);
+    const gitDirAbs = path5.join(repoRootAbs, ".git");
+    const o1codeDirAbs = path5.join(repoRootAbs, ".o1-code");
+    const realWorktreePath = await fs4.realpath(worktreePath).catch(() => worktreePath);
     for (const raw of configured) {
       if (typeof raw !== "string" || raw.length === 0) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: skipping non-string / empty entry: ${JSON.stringify(raw)}`
         );
         continue;
       }
-      if (path2.isAbsolute(raw)) {
-        debugLogger.warn(
+      if (path5.isAbsolute(raw)) {
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing absolute path "${raw}"`
         );
         continue;
       }
       if (raw.split(/[\\/]/).includes("..")) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 contains '..' segment`
         );
         continue;
       }
-      const sourceAbs = path2.resolve(repoRootAbs, raw);
+      const sourceAbs = path5.resolve(repoRootAbs, raw);
       if (sourceAbs === repoRootAbs) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing empty / repo-root path "${raw}"`
         );
         continue;
       }
       if (!isWithinRoot(sourceAbs, repoRootAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 resolves outside repo root (${sourceAbs} vs ${repoRootAbs})`
         );
         continue;
       }
       if (isWithinRoot(sourceAbs, gitDirAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing git-internal path "${raw}"`
         );
         continue;
       }
       if (isWithinRoot(sourceAbs, o1codeDirAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 the .o1-code tree is CLI-managed; symlinking any of it could create a worktrees-inside-worktrees loop or alias CLI metadata.`
         );
         continue;
       }
       let sourceStat = null;
       try {
-        sourceStat = await fs2.stat(sourceAbs);
+        sourceStat = await fs4.stat(sourceAbs);
       } catch (error) {
         if (isNodeError(error) && error.code === "ENOENT") {
-          debugLogger.debug(
+          debugLogger2.debug(
             `symlinkConfiguredDirectories: source missing, skipping: ${sourceAbs}`
           );
         } else {
-          debugLogger.warn(
+          debugLogger2.warn(
             `symlinkConfiguredDirectories: cannot stat ${sourceAbs}: ${error}`
           );
         }
@@ -1778,68 +3783,68 @@ var GitWorktreeService = class _GitWorktreeService {
       }
       let realSource;
       try {
-        realSource = await fs2.realpath(sourceAbs);
+        realSource = await fs4.realpath(sourceAbs);
       } catch (error) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: cannot realpath source "${sourceAbs}": ${error}`
         );
         continue;
       }
       if (!isWithinRoot(realSource, repoRootAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 real source ${realSource} escapes repo root ${repoRootAbs}`
         );
         continue;
       }
       if (isWithinRoot(realSource, gitDirAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 real source ${realSource} resolves inside .git`
         );
         continue;
       }
       if (isWithinRoot(realSource, o1codeDirAbs)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 real source ${realSource} resolves inside .o1-code`
         );
         continue;
       }
-      const destAbs = path2.join(worktreePath, raw);
+      const destAbs = path5.join(worktreePath, raw);
       try {
-        await fs2.mkdir(path2.dirname(destAbs), { recursive: true });
+        await fs4.mkdir(path5.dirname(destAbs), { recursive: true });
       } catch (error) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: cannot mkdir parent of ${destAbs}: ${error}`
         );
         continue;
       }
       let realDestParent;
       try {
-        realDestParent = await fs2.realpath(path2.dirname(destAbs));
+        realDestParent = await fs4.realpath(path5.dirname(destAbs));
       } catch (error) {
-        debugLogger.warn(
-          `symlinkConfiguredDirectories: cannot realpath dest parent for "${raw}" (${path2.dirname(destAbs)}): ${error}`
+        debugLogger2.warn(
+          `symlinkConfiguredDirectories: cannot realpath dest parent for "${raw}" (${path5.dirname(destAbs)}): ${error}`
         );
         continue;
       }
       if (!isWithinRoot(realDestParent, realWorktreePath)) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `symlinkConfiguredDirectories: refusing path "${raw}" \u2014 dest parent ${realDestParent} escapes worktree root ${realWorktreePath} (committed-symlink chain)`
         );
         continue;
       }
       try {
         const symlinkType = sourceStat.isDirectory() ? process.platform === "win32" ? "junction" : "dir" : "file";
-        await fs2.symlink(realSource, destAbs, symlinkType);
-        debugLogger.debug(
+        await fs4.symlink(realSource, destAbs, symlinkType);
+        debugLogger2.debug(
           `symlinkConfiguredDirectories: linked ${destAbs} \u2192 ${realSource} (${symlinkType})`
         );
       } catch (error) {
         if (isNodeError(error) && error.code === "EEXIST") {
-          debugLogger.debug(
+          debugLogger2.debug(
             `symlinkConfiguredDirectories: destination exists, skipping: ${destAbs}`
           );
         } else {
-          debugLogger.warn(
+          debugLogger2.warn(
             `symlinkConfiguredDirectories: failed to link ${destAbs} \u2192 ${realSource}: ${error}`
           );
         }
@@ -1870,7 +3875,7 @@ var GitWorktreeService = class _GitWorktreeService {
       ]);
       return out.trim().length > 0;
     } catch (error) {
-      debugLogger.warn(`localBranchExists failed for ${branchName}: ${error}`);
+      debugLogger2.warn(`localBranchExists failed for ${branchName}: ${error}`);
       return false;
     }
   }
@@ -1882,11 +3887,11 @@ var GitWorktreeService = class _GitWorktreeService {
    */
   async ensureWorktreesGitignored() {
     try {
-      const o1codeDir = path2.join(this.sourceRepoPath, ".o1-code");
-      await fs2.mkdir(o1codeDir, { recursive: true });
-      const gitignorePath = path2.join(o1codeDir, ".gitignore");
+      const o1codeDir = path5.join(this.sourceRepoPath, ".o1-code");
+      await fs4.mkdir(o1codeDir, { recursive: true });
+      const gitignorePath = path5.join(o1codeDir, ".gitignore");
       try {
-        await fs2.writeFile(
+        await fs4.writeFile(
           gitignorePath,
           `# Auto-generated by o1-code.
 ${WORKTREES_DIR}/
@@ -1900,7 +3905,7 @@ ${WORKTREES_DIR}/
         throw error;
       }
     } catch (error) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `ensureWorktreesGitignored failed (non-fatal): ${error}`
       );
     }
@@ -1930,7 +3935,7 @@ ${WORKTREES_DIR}/
       await git.branch(["-d", branchName]);
       return { success: true };
     } catch (error) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `removeUserWorktree: safe branch delete failed for ${branchName}: ${error}`
       );
     }
@@ -1939,7 +3944,7 @@ ${WORKTREES_DIR}/
         await git.branch(["-D", branchName]);
         return { success: true };
       } catch (error) {
-        debugLogger.warn(
+        debugLogger2.warn(
           `removeUserWorktree: force branch delete failed for ${branchName}: ${error}`
         );
       }
@@ -1973,7 +3978,7 @@ ${WORKTREES_DIR}/
       ])).split("\n").map((s) => s.trim()).filter((s) => s.length > 0 && s !== `refs/heads/${branchName}`);
       return refs.length === 0;
     } catch (error) {
-      debugLogger.warn(
+      debugLogger2.warn(
         `hasUnmergedWorktreeCommits failed for slug ${slug}: ${error}`
       );
       return true;
@@ -1989,7 +3994,7 @@ ${WORKTREES_DIR}/
    */
   async hasWorktreeChanges(worktreePath) {
     try {
-      const { stdout } = await execFileAsync(
+      const { stdout } = await execFileAsync3(
         "git",
         [
           ...NO_EXEC_CONFIG,
@@ -2015,7 +4020,7 @@ ${WORKTREES_DIR}/
    */
   async countWorktreeChanges(worktreePath) {
     try {
-      const { stdout } = await execFileAsync(
+      const { stdout } = await execFileAsync3(
         "git",
         [
           ...NO_EXEC_CONFIG,
@@ -2048,12 +4053,44 @@ ${WORKTREES_DIR}/
 };
 
 export {
+  MAX_FILES,
+  MAX_DIFF_SIZE_BYTES,
+  MAX_LINES_PER_FILE,
+  MAX_FILES_FOR_DETAILS,
+  fetchGitDiff,
+  fetchGitDiffHunks,
+  fetchGitDiffHunksForFile,
+  parseGitNumstat,
+  parseGitDiff,
+  unquoteCStylePath,
+  getWorkingTreeLineStats,
+  parseDeletedFromNameStatus,
+  getGitWorkingTreeStatus,
+  parseStatusBranchLine,
+  parseStatusEntries,
+  MAX_LOG_LIMIT,
+  DEFAULT_LOG_LIMIT,
+  fetchGitLog,
+  fetchGitCommitDetail,
   writeRuntimeStatus,
   readRuntimeStatus,
   clearRuntimeStatus,
+  isValidRefName,
+  resolveBranchName,
+  watchRepoBranch,
+  gitEnv,
+  runGit2 as runGit,
+  fetchGitBranches,
+  isValidCheckoutRef,
+  gitCheckout,
+  gitCreateBranch,
+  gitPush,
+  GitPullFailure,
+  gitPull,
+  gitCommit,
   loadSimpleGit,
   worktreeBranchForSlug,
-  WORKTREE_SESSION_FILE,
+  worktreeHasWork,
   writeWorktreeSessionMarker,
   WorktreeMarkerCommittedError,
   createWorktreeSessionMarkerExclusive,
@@ -2100,6 +4137,11 @@ export {
  * The schema is small and stable; external consumers should treat
  * unknown fields as forward-compatible additions.
  */
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2026 Qwen Team