@atlasharness/atlascode 0.1.82 → 0.1.83

package/dist/cli.js

@@ -33374,6 +33374,7 @@ var init_load = __esm(() => {
 import {
   appendFile as fsAppendFile,
   mkdir,
+  open as fsOpen2,
   stat as stat2
 } from "fs/promises";
 import { appendFileSync, closeSync as closeSync2, fstatSync, mkdirSync as mkdirSync2, openSync as openSync2, readSync as readSync2 } from "fs";
@@ -33524,11 +33525,14 @@ class Project {
   }
   async appendToFile(filePath, data) {
     try {
+      const needsSeparator = await transcriptTailNeedsSeparator(filePath);
+      const payload = needsSeparator ? `
+` + data : data;
       try {
-        await fsAppendFile(filePath, data, { mode: 384 });
+        await fsAppendFile(filePath, payload, { mode: 384 });
       } catch {
         await mkdir(dirname6(filePath), { recursive: true, mode: 448 });
-        await fsAppendFile(filePath, data, { mode: 384 });
+        await fsAppendFile(filePath, payload, { mode: 384 });
       }
     } catch (err) {
       const code = err?.code;
@@ -33865,11 +33869,13 @@ class Project {
 function appendEntryToFile(fullPath, entry) {
   const line = jsonStringify(entry) + `
 `;
+  const payload = transcriptTailNeedsSeparatorSync(fullPath) ? `
+` + line : line;
   try {
-    appendFileSync(fullPath, line, { mode: 384 });
+    appendFileSync(fullPath, payload, { mode: 384 });
   } catch {
     mkdirSync2(dirname6(fullPath), { mode: 448 });
-    appendFileSync(fullPath, line, { mode: 384 });
+    appendFileSync(fullPath, payload, { mode: 384 });
   }
 }
 function readFileTailSync(fullPath) {
@@ -33891,6 +33897,42 @@ function readFileTailSync(fullPath) {
     }
   }
 }
+async function transcriptTailNeedsSeparator(fullPath) {
+  let fh;
+  try {
+    const st = await stat2(fullPath);
+    if (!st.isFile() || st.size === 0)
+      return false;
+    fh = await fsOpen2(fullPath, "r");
+    const buf = Buffer.alloc(1);
+    const { bytesRead } = await fh.read(buf, 0, 1, st.size - 1);
+    return bytesRead === 1 && buf[0] !== 10;
+  } catch {
+    return false;
+  } finally {
+    await fh?.close().catch(() => {});
+  }
+}
+function transcriptTailNeedsSeparatorSync(fullPath) {
+  let fd;
+  try {
+    fd = openSync2(fullPath, "r");
+    const st = fstatSync(fd);
+    if (st.size === 0)
+      return false;
+    const buf = Buffer.alloc(1);
+    const bytesRead = readSync2(fd, buf, 0, 1, st.size - 1);
+    return bytesRead === 1 && buf[0] !== 10;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync2(fd);
+      } catch {}
+    }
+  }
+}
 function projectInstance() {
   return getProject();
 }
@@ -75904,6 +75946,16 @@ async function resolveGitDir(startPath) {
       if (content.startsWith("gitdir:")) {
         const rawDir = content.slice("gitdir:".length).trim();
         const resolved = resolve13(root, rawDir);
+        try {
+          const dirStat = await stat6(resolved);
+          if (!dirStat.isDirectory()) {
+            resolveGitDirCache.set(cwd, null);
+            return null;
+          }
+        } catch {
+          resolveGitDirCache.set(cwd, null);
+          return null;
+        }
         resolveGitDirCache.set(cwd, resolved);
         return resolved;
       }
@@ -75925,6 +75977,9 @@ function isSafeRefName(name) {
   if (name.split("/").some((c) => c === "." || c === "")) {
     return false;
   }
+  if (name.split("/").some((c) => c.startsWith(".") || c.endsWith(".lock"))) {
+    return false;
+  }
   if (!/^[a-zA-Z0-9/._+@-]+$/.test(name)) {
     return false;
   }
@@ -75934,6 +75989,16 @@ function isValidGitSha(s) {
   return /^[0-9a-f]{40}$/.test(s) || /^[0-9a-f]{64}$/.test(s);
 }
 async function readGitHead(gitDir) {
+  const head = await readGitHeadFromFiles(gitDir);
+  if (head) {
+    return head;
+  }
+  if (await isReftableStorage(gitDir)) {
+    return readGitHeadViaGit(gitDir);
+  }
+  return null;
+}
+async function readGitHeadFromFiles(gitDir) {
   try {
     const content = (await readFile9(join29(gitDir, "HEAD"), "utf-8")).trim();
     if (content.startsWith("ref:")) {
@@ -75959,6 +76024,43 @@ async function readGitHead(gitDir) {
     return null;
   }
 }
+async function isReftableStorage(gitDir) {
+  const dirs = [gitDir];
+  const commonDir = await getCommonDir(gitDir);
+  if (commonDir && commonDir !== gitDir) {
+    dirs.push(commonDir);
+  }
+  for (const dir of dirs) {
+    if (await parseGitConfigValue(dir, "extensions", null, "refstorage") === "reftable") {
+      return true;
+    }
+  }
+  return false;
+}
+async function readGitHeadViaGit(gitDir) {
+  const sym = await execFileNoThrowWithCwd(gitExe(), ["--git-dir", gitDir, "symbolic-ref", "-q", "HEAD"], { stdin: "ignore", env: { ...process.env, ...GIT_NO_PROMPT_ENV } });
+  if (sym.code === 0) {
+    const ref = sym.stdout.trim();
+    if (ref.startsWith("refs/heads/")) {
+      const name = ref.slice("refs/heads/".length);
+      return isSafeRefName(name) ? { type: "branch", name } : null;
+    }
+    if (!isSafeRefName(ref)) {
+      return null;
+    }
+    const sha = await resolveRef(gitDir, ref);
+    return sha ? { type: "detached", sha } : { type: "detached", sha: "" };
+  }
+  if (sym.code !== 1) {
+    return null;
+  }
+  const rev = await execFileNoThrowWithCwd(gitExe(), ["--git-dir", gitDir, "rev-parse", "--verify", "--quiet", "HEAD"], { stdin: "ignore", env: { ...process.env, ...GIT_NO_PROMPT_ENV } });
+  if (rev.code !== 0) {
+    return null;
+  }
+  const sha = rev.stdout.trim();
+  return isValidGitSha(sha) ? { type: "detached", sha } : null;
+}
 async function resolveRef(gitDir, ref) {
   const result = await resolveRefInDir(gitDir, ref);
   if (result) {
@@ -75966,7 +76068,18 @@ async function resolveRef(gitDir, ref) {
   }
   const commonDir = await getCommonDir(gitDir);
   if (commonDir && commonDir !== gitDir) {
-    return resolveRefInDir(commonDir, ref);
+    const common = await resolveRefInDir(commonDir, ref);
+    if (common) {
+      return common;
+    }
+  }
+  if (await isReftableStorage(gitDir) && isSafeRefName(ref)) {
+    const rev = await execFileNoThrowWithCwd(gitExe(), ["--git-dir", gitDir, "rev-parse", "--verify", "--quiet", ref], { stdin: "ignore", env: { ...process.env, ...GIT_NO_PROMPT_ENV } });
+    if (rev.code !== 0) {
+      return null;
+    }
+    const sha = rev.stdout.trim();
+    return isValidGitSha(sha) ? sha : null;
   }
   return null;
 }
@@ -76032,6 +76145,20 @@ async function readWorktreeHeadSha(worktreePath) {
   }
   return head.sha;
 }
+async function readCheckoutHeadSha(checkoutPath) {
+  const gitDir = await resolveGitDir(checkoutPath);
+  if (!gitDir) {
+    return null;
+  }
+  const head = await readGitHead(gitDir);
+  if (!head) {
+    return null;
+  }
+  if (head.type === "branch") {
+    return resolveRef(gitDir, `refs/heads/${head.name}`);
+  }
+  return head.sha;
+}
 function parseWorktreeListPorcelain(out) {
   const entries = [];
   let current = null;
@@ -76299,11 +76426,14 @@ var init_git = __esm(() => {
 // src/engine/worktree/worktree.ts
 import {
   copyFile,
+  lstat,
   mkdir as mkdir10,
   readdir as readdir4,
+  readFile as readFile10,
   realpath as realpath2,
   stat as stat7,
   symlink as symlink2,
+  unlink as unlink5,
   utimes
 } from "fs/promises";
 import { basename as basename7, dirname as dirname16, join as join30, resolve as resolve14 } from "path";
@@ -76368,11 +76498,61 @@ function generateTmuxSessionName(repoPath, branch) {
   const combined = `${repoName}_${branch}`;
   return combined.replace(/[/.]/g, "_");
 }
+async function isRegisteredWorktreeTarget(worktreePath) {
+  try {
+    const ptr = (await readFile10(join30(worktreePath, ".git"), "utf-8")).trim();
+    if (!ptr.startsWith("gitdir:"))
+      return false;
+    const gitDir = resolve14(worktreePath, ptr.slice("gitdir:".length).trim());
+    const backlink = (await readFile10(join30(gitDir, "gitdir"), "utf-8")).trim();
+    return resolve14(dirname16(backlink)) === resolve14(worktreePath);
+  } catch {
+    return false;
+  }
+}
+async function inspectWorktreeTarget(worktreePath) {
+  let entries;
+  try {
+    const st = await stat7(worktreePath);
+    if (!st.isDirectory())
+      return "occupied";
+    entries = await readdir4(worktreePath);
+  } catch (e) {
+    return getErrnoCode(e) === "ENOENT" ? "clear" : "occupied";
+  }
+  if (entries.length === 0)
+    return "clear";
+  if (entries.length > 1 || entries[0] !== ".git")
+    return "occupied";
+  const dotGit = join30(worktreePath, ".git");
+  try {
+    const st = await lstat(dotGit);
+    if (!st.isFile())
+      return "occupied";
+  } catch {
+    return "occupied";
+  }
+  let content;
+  try {
+    content = (await readFile10(dotGit, "utf-8")).trim();
+  } catch {
+    return "occupied";
+  }
+  if (!content.startsWith("gitdir:"))
+    return "occupied";
+  const gitdirTarget = resolve14(worktreePath, content.slice("gitdir:".length).trim());
+  try {
+    await stat7(gitdirTarget);
+    return "occupied";
+  } catch {
+    return "repair-dangling-pointer";
+  }
+}
 async function getOrCreateWorktree(repoRoot, slug, options) {
   const worktreePath = worktreePathFor(repoRoot, slug);
   const worktreeBranch = worktreeBranchName(slug);
   const existingHead = await readWorktreeHeadSha(worktreePath);
-  if (existingHead) {
+  if (existingHead && await isRegisteredWorktreeTarget(worktreePath)) {
     return {
       worktreePath,
       worktreeBranch,
@@ -76380,6 +76560,20 @@ async function getOrCreateWorktree(repoRoot, slug, options) {
       existed: true
     };
   }
+  const targetState = await inspectWorktreeTarget(worktreePath);
+  if (targetState === "repair-dangling-pointer") {
+    await unlink5(join30(worktreePath, ".git"));
+  } else if (targetState === "occupied") {
+    throw new Error(`Worktree path "${worktreePath}" already exists and is not a safe-to-repair worktree leftover; refusing to overwrite it (data preserved)`);
+  }
+  let sourceCheckout = options?.sourceCheckout ?? null;
+  if (!sourceCheckout && resolve14(process.cwd()) !== resolve14(repoRoot)) {
+    const callingCwd = process.cwd();
+    const headCommit = await readCheckoutHeadSha(callingCwd);
+    if (headCommit) {
+      sourceCheckout = { cwd: callingCwd, headCommit };
+    }
+  }
   await mkdir10(worktreesDir(repoRoot), { recursive: true });
   const fetchEnv = { ...process.env, ...GIT_NO_PROMPT_ENV };
   let baseBranch;
@@ -76406,22 +76600,35 @@ async function getOrCreateWorktree(repoRoot, slug, options) {
     }
   }
   if (!baseSha) {
-    const { stdout, code: shaCode } = await execFileNoThrowWithCwd(gitExe(), ["rev-parse", baseBranch], { cwd: repoRoot });
-    if (shaCode !== 0) {
-      throw new Error(`Failed to resolve base branch "${baseBranch}": git rev-parse failed`);
+    if (baseBranch === "HEAD" && sourceCheckout) {
+      const { code: verifyCode } = await execFileNoThrowWithCwd(gitExe(), ["rev-parse", "--verify", `${sourceCheckout.headCommit}^{commit}`], { cwd: repoRoot });
+      if (verifyCode !== 0) {
+        throw new Error(`Failed to resolve source checkout HEAD ${sourceCheckout.headCommit} as a commit in the repository; refusing to silently fall back to the canonical HEAD`);
+      }
+      baseSha = sourceCheckout.headCommit;
+    } else {
+      const { stdout, code: shaCode } = await execFileNoThrowWithCwd(gitExe(), ["rev-parse", "--verify", `${baseBranch}^{commit}`], { cwd: repoRoot });
+      if (shaCode !== 0) {
+        throw new Error(`Failed to resolve base branch "${baseBranch}": git rev-parse failed`);
+      }
+      baseSha = stdout.trim();
     }
-    baseSha = stdout.trim();
   }
   const sparsePaths = getWorktreeSettings().sparsePaths;
   const addArgs = ["worktree", "add"];
   if (sparsePaths?.length) {
     addArgs.push("--no-checkout");
   }
-  addArgs.push("-B", worktreeBranch, worktreePath, baseBranch);
+  addArgs.push("-B", worktreeBranch, worktreePath, `${baseSha}^{commit}`);
   const { code: createCode, stderr: createStderr } = await execFileNoThrowWithCwd(gitExe(), addArgs, { cwd: repoRoot });
   if (createCode !== 0) {
     throw new Error(`Failed to create worktree: ${createStderr}`);
   }
+  const actualHead = await readWorktreeHeadSha(worktreePath);
+  if (actualHead !== baseSha) {
+    await execFileNoThrowWithCwd(gitExe(), ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
+    throw new Error(`Worktree base divergence: created worktree HEAD ${actualHead ?? "<unreadable>"} does not match the selected base ${baseSha}; the worktree was removed`);
+  }
   if (sparsePaths?.length) {
     const tearDown = async (msg) => {
       await execFileNoThrowWithCwd(gitExe(), ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
@@ -76810,7 +77017,7 @@ function memoize2(fn, resolver) {
 
 // src/engine/skill/markdownLoader.ts
 import { statSync as statSync5 } from "fs";
-import { lstat, readdir as readdir5, readFile as readFile10, stat as stat8, realpath as realpath3 } from "fs/promises";
+import { lstat as lstat2, readdir as readdir5, readFile as readFile11, stat as stat8, realpath as realpath3 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { dirname as dirname17, join as join31, resolve as resolve15 } from "path";
 function extractDescriptionFromMarkdown(content, defaultDescription = "Custom item") {
@@ -76857,7 +77064,7 @@ function parseSlashCommandToolsFromFrontmatter(toolsValue) {
 }
 async function getFileIdentity(filePath) {
   try {
-    const stats = await lstat(filePath, { bigint: true });
+    const stats = await lstat2(filePath, { bigint: true });
     if (stats.dev === 0n && stats.ino === 0n) {
       return null;
     }
@@ -76969,7 +77176,7 @@ async function loadMarkdownFiles(dir) {
   }
   const results = await Promise.all(files.map(async (filePath) => {
     try {
-      const rawContent = await readFile10(filePath, { encoding: "utf-8" });
+      const rawContent = await readFile11(filePath, { encoding: "utf-8" });
       const { frontmatter, content } = parseFrontmatter(rawContent, filePath);
       return {
         filePath,
@@ -78679,10 +78886,10 @@ var init_mcpJsonRpc = __esm(() => {
 });
 
 // src/mcp/mcpConfig.ts
-import { readFile as readFile11 } from "node:fs/promises";
+import { readFile as readFile12 } from "node:fs/promises";
 async function loadProjectMcpJson(path) {
   try {
-    const raw = await readFile11(path, "utf8");
+    const raw = await readFile12(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) {
       return parsed;
@@ -80097,7 +80304,13 @@ var init_enterWorktreeTool = __esm(() => {
         throw new Error("Already in a worktree session");
       }
       const mainRepoRoot = findCanonicalGitRoot(getCwdState());
+      let sourceCheckout;
       if (mainRepoRoot && mainRepoRoot !== getCwdState()) {
+        const callingCwd = getCwdState();
+        const headCommit = await readCheckoutHeadSha(callingCwd);
+        if (headCommit) {
+          sourceCheckout = { cwd: callingCwd, headCommit };
+        }
         process.chdir(mainRepoRoot);
         setCwd(mainRepoRoot);
       }
@@ -80116,7 +80329,7 @@ var init_enterWorktreeTool = __esm(() => {
         };
       }
       const slug = input.name ?? randomUUID15();
-      const worktreeSession = await createWorktreeForSession(getSessionId(), slug);
+      const worktreeSession = await createWorktreeForSession(getSessionId(), slug, undefined, sourceCheckout ? { sourceCheckout } : undefined);
       process.chdir(worktreeSession.worktreePath);
       setCwd(worktreeSession.worktreePath);
       setOriginalCwd(getCwdState());
@@ -87395,7 +87608,7 @@ var init_headlessSessionEnd = __esm(() => {
 
 // src/cli/print.ts
 import { randomUUID as randomUUID21 } from "crypto";
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 import { join as join37, resolve as resolve16 } from "path";
 function bridgeMcpToolClientLocal(client) {
   return {
@@ -87468,7 +87681,7 @@ async function parseMcpConfigItemsLocal(items) {
       object = JSON.parse(trimmed);
     } catch {
       try {
-        const raw = await readFile12(resolve16(trimmed), "utf8");
+        const raw = await readFile13(resolve16(trimmed), "utf8");
         object = JSON.parse(raw);
       } catch {
         object = null;
@@ -88416,7 +88629,7 @@ async function updateHandler(options = {}) {
 var init_update = () => {};
 
 // src/cli/mcpConfigWrite.ts
-import { chmod, open as open5, rename, stat as stat11, unlink as unlink5 } from "node:fs/promises";
+import { chmod, open as open5, rename, stat as stat11, unlink as unlink6 } from "node:fs/promises";
 import { join as join39 } from "node:path";
 function scopeToSettingsSource(scope) {
   return scope === "local" ? "localSettings" : "userSettings";
@@ -88575,7 +88788,7 @@ async function writeMcpjsonFile(config) {
     await rename(tempPath, mcpJsonPath);
   } catch (e) {
     try {
-      await unlink5(tempPath);
+      await unlink6(tempPath);
     } catch {}
     throw e;
   }
@@ -100631,11 +100844,11 @@ var init_execFileNoThrow2 = __esm(() => {
 });
 
 // src/tui/utils/git/gitConfigParser.ts
-import { readFile as readFile15 } from "fs/promises";
+import { readFile as readFile16 } from "fs/promises";
 import { join as join46 } from "path";
 async function parseGitConfigValue2(gitDir, section, subsection, key) {
   try {
-    const config = await readFile15(join46(gitDir, "config"), "utf-8");
+    const config = await readFile16(join46(gitDir, "config"), "utf-8");
     return parseConfigString2(config, section, subsection, key);
   } catch {
     return null;
@@ -100801,8 +101014,11 @@ var init_gitConfigParser = () => {};
 
 // src/tui/utils/git/gitFilesystem.ts
 import { unwatchFile, watchFile } from "fs";
-import { readdir as readdir7, readFile as readFile16, stat as stat13 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile17, stat as stat13 } from "fs/promises";
 import { join as join47, resolve as resolve18 } from "path";
+function gitExePath() {
+  return process.env.ATLAS_GIT_EXE ?? "git";
+}
 function clearResolveGitDirCache() {
   resolveGitDirCache2.clear();
 }
@@ -100821,10 +101037,20 @@ async function resolveGitDir2(startPath) {
   try {
     const st = await stat13(gitPath);
     if (st.isFile()) {
-      const content = (await readFile16(gitPath, "utf-8")).trim();
+      const content = (await readFile17(gitPath, "utf-8")).trim();
       if (content.startsWith("gitdir:")) {
         const rawDir = content.slice("gitdir:".length).trim();
         const resolved = resolve18(root, rawDir);
+        try {
+          const dirStat = await stat13(resolved);
+          if (!dirStat.isDirectory()) {
+            resolveGitDirCache2.set(cwd, null);
+            return null;
+          }
+        } catch {
+          resolveGitDirCache2.set(cwd, null);
+          return null;
+        }
         resolveGitDirCache2.set(cwd, resolved);
         return resolved;
       }
@@ -100846,6 +101072,9 @@ function isSafeRefName2(name) {
   if (name.split("/").some((c) => c === "." || c === "")) {
     return false;
   }
+  if (name.split("/").some((c) => c.startsWith(".") || c.endsWith(".lock"))) {
+    return false;
+  }
   if (!/^[a-zA-Z0-9/._+@-]+$/.test(name)) {
     return false;
   }
@@ -100855,8 +101084,18 @@ function isValidGitSha2(s) {
   return /^[0-9a-f]{40}$/.test(s) || /^[0-9a-f]{64}$/.test(s);
 }
 async function readGitHead2(gitDir) {
+  const head = await readGitHeadFromFiles2(gitDir);
+  if (head) {
+    return head;
+  }
+  if (await isReftableStorage2(gitDir)) {
+    return readGitHeadViaGit2(gitDir);
+  }
+  return null;
+}
+async function readGitHeadFromFiles2(gitDir) {
   try {
-    const content = (await readFile16(join47(gitDir, "HEAD"), "utf-8")).trim();
+    const content = (await readFile17(join47(gitDir, "HEAD"), "utf-8")).trim();
     if (content.startsWith("ref:")) {
       const ref = content.slice("ref:".length).trim();
       if (ref.startsWith("refs/heads/")) {
@@ -100880,6 +101119,43 @@ async function readGitHead2(gitDir) {
     return null;
   }
 }
+async function isReftableStorage2(gitDir) {
+  const dirs = [gitDir];
+  const commonDir = await getCommonDir2(gitDir);
+  if (commonDir && commonDir !== gitDir) {
+    dirs.push(commonDir);
+  }
+  for (const dir of dirs) {
+    if (await parseGitConfigValue2(dir, "extensions", null, "refstorage") === "reftable") {
+      return true;
+    }
+  }
+  return false;
+}
+async function readGitHeadViaGit2(gitDir) {
+  const sym = await execFileNoThrow3(gitExePath(), ["--git-dir", gitDir, "symbolic-ref", "-q", "HEAD"], { stdin: "ignore", useCwd: false, env: { ...process.env, ...GIT_NO_PROMPT_ENV2 } });
+  if (sym.code === 0) {
+    const ref = sym.stdout.trim();
+    if (ref.startsWith("refs/heads/")) {
+      const name = ref.slice("refs/heads/".length);
+      return isSafeRefName2(name) ? { type: "branch", name } : null;
+    }
+    if (!isSafeRefName2(ref)) {
+      return null;
+    }
+    const sha = await resolveRef2(gitDir, ref);
+    return sha ? { type: "detached", sha } : { type: "detached", sha: "" };
+  }
+  if (sym.code !== 1) {
+    return null;
+  }
+  const rev = await execFileNoThrow3(gitExePath(), ["--git-dir", gitDir, "rev-parse", "--verify", "--quiet", "HEAD"], { stdin: "ignore", useCwd: false, env: { ...process.env, ...GIT_NO_PROMPT_ENV2 } });
+  if (rev.code !== 0) {
+    return null;
+  }
+  const sha = rev.stdout.trim();
+  return isValidGitSha2(sha) ? { type: "detached", sha } : null;
+}
 async function resolveRef2(gitDir, ref) {
   const result = await resolveRefInDir2(gitDir, ref);
   if (result) {
@@ -100887,13 +101163,24 @@ async function resolveRef2(gitDir, ref) {
   }
   const commonDir = await getCommonDir2(gitDir);
   if (commonDir && commonDir !== gitDir) {
-    return resolveRefInDir2(commonDir, ref);
+    const common = await resolveRefInDir2(commonDir, ref);
+    if (common) {
+      return common;
+    }
+  }
+  if (await isReftableStorage2(gitDir) && isSafeRefName2(ref)) {
+    const rev = await execFileNoThrow3(gitExePath(), ["--git-dir", gitDir, "rev-parse", "--verify", "--quiet", ref], { stdin: "ignore", useCwd: false, env: { ...process.env, ...GIT_NO_PROMPT_ENV2 } });
+    if (rev.code !== 0) {
+      return null;
+    }
+    const sha = rev.stdout.trim();
+    return isValidGitSha2(sha) ? sha : null;
   }
   return null;
 }
 async function resolveRefInDir2(dir, ref) {
   try {
-    const content = (await readFile16(join47(dir, ref), "utf-8")).trim();
+    const content = (await readFile17(join47(dir, ref), "utf-8")).trim();
     if (content.startsWith("ref:")) {
       const target = content.slice("ref:".length).trim();
       if (!isSafeRefName2(target)) {
@@ -100907,7 +101194,7 @@ async function resolveRefInDir2(dir, ref) {
     return content;
   } catch {}
   try {
-    const packed = await readFile16(join47(dir, "packed-refs"), "utf-8");
+    const packed = await readFile17(join47(dir, "packed-refs"), "utf-8");
     for (const line of packed.split(`
 `)) {
       if (line.startsWith("#") || line.startsWith("^")) {
@@ -100927,7 +101214,7 @@ async function resolveRefInDir2(dir, ref) {
 }
 async function getCommonDir2(gitDir) {
   try {
-    const content = (await readFile16(join47(gitDir, "commondir"), "utf-8")).trim();
+    const content = (await readFile17(join47(gitDir, "commondir"), "utf-8")).trim();
     return resolve18(gitDir, content);
   } catch {
     return null;
@@ -100935,7 +101222,7 @@ async function getCommonDir2(gitDir) {
 }
 async function readRawSymref2(gitDir, refPath, branchPrefix) {
   try {
-    const content = (await readFile16(join47(gitDir, refPath), "utf-8")).trim();
+    const content = (await readFile17(join47(gitDir, refPath), "utf-8")).trim();
     if (content.startsWith("ref:")) {
       const target = content.slice("ref:".length).trim();
       if (target.startsWith(branchPrefix)) {
@@ -100981,6 +101268,11 @@ class GitFileWatcher {
     this.watchPath(join47(this.commonDir ?? this.gitDir, "config"), () => {
       this.invalidate();
     });
+    if (await isReftableStorage2(this.gitDir)) {
+      this.watchPath(join47(this.commonDir ?? this.gitDir, "reftable"), () => {
+        this.invalidate();
+      });
+    }
     await this.watchCurrentBranchRef();
     registerCleanup3(async () => {
       this.stopWatching();
@@ -101144,7 +101436,7 @@ async function getHeadForDir(cwd) {
 async function readWorktreeHeadSha2(worktreePath) {
   let gitDir;
   try {
-    const ptr = (await readFile16(join47(worktreePath, ".git"), "utf-8")).trim();
+    const ptr = (await readFile17(join47(worktreePath, ".git"), "utf-8")).trim();
     if (!ptr.startsWith("gitdir:")) {
       return null;
     }
@@ -101161,6 +101453,20 @@ async function readWorktreeHeadSha2(worktreePath) {
   }
   return head.sha;
 }
+async function readCheckoutHeadSha2(checkoutPath) {
+  const gitDir = await resolveGitDir2(checkoutPath);
+  if (!gitDir) {
+    return null;
+  }
+  const head = await readGitHead2(gitDir);
+  if (!head) {
+    return null;
+  }
+  if (head.type === "branch") {
+    return resolveRef2(gitDir, `refs/heads/${head.name}`);
+  }
+  return head.sha;
+}
 async function getRemoteUrlForDir(cwd) {
   const gitDir = await resolveGitDir2(cwd);
   if (!gitDir) {
@@ -101189,13 +101495,18 @@ async function getWorktreeCountFromFs() {
     return 1;
   }
 }
-var resolveGitDirCache2, WATCH_INTERVAL_MS = 1000, gitWatcher;
+var GIT_NO_PROMPT_ENV2, resolveGitDirCache2, WATCH_INTERVAL_MS = 1000, gitWatcher;
 var init_gitFilesystem = __esm(() => {
   init_bootstrapState();
   init_cleanupRegistry3();
   init_cwd3();
+  init_execFileNoThrow2();
   init_git2();
   init_gitConfigParser();
+  GIT_NO_PROMPT_ENV2 = {
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: ""
+  };
   resolveGitDirCache2 = new Map;
   gitWatcher = new GitFileWatcher;
 });
@@ -102221,7 +102532,7 @@ var init_git2 = __esm(() => {
 });
 
 // src/tui/utils/platform.ts
-import { readdir as readdir8, readFile as readFile17 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile18 } from "fs/promises";
 import { release as osRelease } from "os";
 var SUPPORTED_PLATFORMS2, getPlatform3, getWslVersion, getLinuxDistroInfo;
 var init_platform3 = __esm(() => {
@@ -102283,7 +102594,7 @@ var init_platform3 = __esm(() => {
       linuxKernel: osRelease()
     };
     try {
-      const content = await readFile17("/etc/os-release", "utf8");
+      const content = await readFile18("/etc/os-release", "utf8");
       for (const line of content.split(`
 `)) {
         const match = line.match(/^(ID|VERSION_ID)=(.*)$/);
@@ -102419,7 +102730,7 @@ var init_getWorktreePathsPortable = __esm(() => {
 });
 
 // src/tui/utils/sessionStoragePortable.ts
-import { open as fsOpen2, readdir as readdir9, realpath as realpath5, stat as stat14 } from "fs/promises";
+import { open as fsOpen3, readdir as readdir9, realpath as realpath5, stat as stat14 } from "fs/promises";
 function validateUuid(maybeUuid) {
   if (typeof maybeUuid !== "string")
     return null;
@@ -102484,7 +102795,7 @@ function extractLastJsonStringField2(text, key) {
 }
 async function readHeadAndTail(filePath, fileSize, buf) {
   try {
-    const fh = await fsOpen2(filePath, "r");
+    const fh = await fsOpen3(filePath, "r");
     try {
       const headResult = await fh.read(buf, 0, LITE_READ_BUF_SIZE2, 0);
       if (headResult.bytesRead === 0)
@@ -102511,7 +102822,7 @@ async function scanMidForSessionTitle(filePath, fileSize) {
   if (scanLen <= 0)
     return;
   try {
-    const fh = await fsOpen2(filePath, "r");
+    const fh = await fsOpen3(filePath, "r");
     try {
       const buf = Buffer.allocUnsafe(scanLen);
       const result = await fh.read(buf, 0, scanLen, scanStart);
@@ -102711,7 +103022,7 @@ async function readTranscriptForLoad2(filePath, fileSize) {
     straddleSnapTailEnd: 0
   };
   const chunk = Buffer.allocUnsafe(CHUNK_SIZE);
-  const fd = await fsOpen2(filePath, "r");
+  const fd = await fsOpen3(filePath, "r");
   try {
     let filePos = 0;
     while (filePos < fileSize) {
@@ -121761,7 +122072,7 @@ function stripBOM2(content) {
 var UTF8_BOM = "\uFEFF";
 
 // src/tui/utils/json.ts
-import { open as open6, readFile as readFile18, stat as stat15 } from "fs/promises";
+import { open as open6, readFile as readFile19, stat as stat15 } from "fs/promises";
 function parseJSONUncached(json, shouldLogError) {
   try {
     return { ok: true, value: JSON.parse(stripBOM2(json)) };
@@ -121863,7 +122174,7 @@ async function readJSONLFile(filePath) {
   try {
     const { size } = await stat15(filePath);
     if (size <= MAX_JSONL_READ_BYTES) {
-      return parseJSONL2(await readFile18(filePath));
+      return parseJSONL2(await readFile19(filePath));
     }
     const fd = __using(__stack, await open6(filePath, "r"), 1);
     const buf = Buffer.allocUnsafe(MAX_JSONL_READ_BYTES);
@@ -124781,7 +125092,7 @@ var init_file = __esm(() => {
 });
 
 // src/tui/utils/git/gitignore.ts
-import { appendFile as appendFile2, mkdir as mkdir14, readFile as readFile19, writeFile as writeFile10 } from "fs/promises";
+import { appendFile as appendFile2, mkdir as mkdir14, readFile as readFile20, writeFile as writeFile10 } from "fs/promises";
 import { homedir as homedir21 } from "os";
 import { dirname as dirname31, join as join58 } from "path";
 async function isPathGitignored2(filePath, cwd) {
@@ -124808,7 +125119,7 @@ async function addFileGlobRuleToGitignore(filename, cwd = getCwd()) {
     const configGitDir = dirname31(globalGitignorePath);
     await mkdir14(configGitDir, { recursive: true });
     try {
-      const content = await readFile19(globalGitignorePath, { encoding: "utf-8" });
+      const content = await readFile20(globalGitignorePath, { encoding: "utf-8" });
       if (content.includes(gitignoreEntry)) {
         return;
       }
@@ -127387,7 +127698,7 @@ function peekForStdinData2(stream, ms) {
 }
 
 // src/tui/utils/debug.ts
-import { appendFile as appendFile3, mkdir as mkdir15, symlink as symlink3, unlink as unlink6 } from "fs/promises";
+import { appendFile as appendFile3, mkdir as mkdir15, symlink as symlink3, unlink as unlink7 } from "fs/promises";
 import { dirname as dirname34, join as join62 } from "path";
 function enableDebugLogging() {
   const wasActive = isDebugMode() || isAtlasDev();
@@ -127540,7 +127851,7 @@ var init_debug = __esm(() => {
       const debugLogPath = getDebugLogPath();
       const debugLogsDir = dirname34(debugLogPath);
       const latestSymlinkPath = join62(debugLogsDir, "latest");
-      await unlink6(latestSymlinkPath).catch(() => {});
+      await unlink7(latestSymlinkPath).catch(() => {});
       await symlink3(debugLogPath, latestSymlinkPath);
     } catch {}
   });
@@ -165110,7 +165421,7 @@ var init_mailbox3 = __esm(() => {
 });
 
 // node_modules/readdirp/index.js
-import { lstat as lstat2, readdir as readdir10, realpath as realpath7, stat as stat18 } from "node:fs/promises";
+import { lstat as lstat3, readdir as readdir10, realpath as realpath7, stat as stat18 } from "node:fs/promises";
 import { join as pjoin, resolve as presolve, sep as psep } from "node:path";
 import { Readable as Readable6 } from "node:stream";
 function readdirp(root, options = {}) {
@@ -165207,7 +165518,7 @@ var init_readdirp = __esm(() => {
       const type = opts.type ?? defaultOptions.type;
       this._fileFilter = normalizeFilter(opts.fileFilter);
       this._directoryFilter = normalizeFilter(opts.directoryFilter);
-      const statMethod = opts.lstat ? lstat2 : stat18;
+      const statMethod = opts.lstat ? lstat3 : stat18;
       if (wantBigintFsStats) {
         this._stat = (path) => statMethod(path, { bigint: true });
       } else {
@@ -165334,7 +165645,7 @@ var init_readdirp = __esm(() => {
       const full = entry.fullPath;
       try {
         const entryRealPath = await realpath7(full);
-        const entryRealPathStats = await lstat2(entryRealPath);
+        const entryRealPathStats = await lstat3(entryRealPath);
         if (entryRealPathStats.isFile()) {
           return "file";
         }
@@ -165362,7 +165673,7 @@ var init_readdirp = __esm(() => {
 
 // node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile as unwatchFile3, watchFile as watchFile3 } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat3, open as open8, stat as stat19 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat4, open as open8, stat as stat19 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
 function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
@@ -165790,7 +166101,7 @@ var init_handler = __esm(() => {
     ERROR: "error"
   };
   EV = EVENTS;
-  statMethods = { lstat: lstat3, stat: stat19 };
+  statMethods = { lstat: lstat4, stat: stat19 };
   HANDLER_KEYS = [KEY_LISTENERS, KEY_ERR, KEY_RAW];
   binaryExtensions = new Set([
     "3dm",
@@ -167313,7 +167624,7 @@ var init_pluginOnlyPolicy = __esm(() => {
 
 // src/tui/utils/markdownConfigLoader.ts
 import { statSync as statSync9 } from "fs";
-import { lstat as lstat4, readdir as readdir12, readFile as readFile20, realpath as realpath8, stat as stat22 } from "fs/promises";
+import { lstat as lstat5, readdir as readdir12, readFile as readFile21, realpath as realpath8, stat as stat22 } from "fs/promises";
 import { homedir as homedir23 } from "os";
 import { dirname as dirname40, join as join67, resolve as resolve30, sep as sep14 } from "path";
 function extractDescriptionFromMarkdown2(content, defaultDescription = "Custom item") {
@@ -167370,7 +167681,7 @@ function parseSlashCommandToolsFromFrontmatter2(toolsValue) {
 }
 async function getFileIdentity3(filePath) {
   try {
-    const stats = await lstat4(filePath, { bigint: true });
+    const stats = await lstat5(filePath, { bigint: true });
     if (stats.dev === 0n && stats.ino === 0n) {
       return null;
     }
@@ -167497,7 +167808,7 @@ async function loadMarkdownFiles2(dir) {
   }
   const results = await Promise.all(files.map(async (filePath) => {
     try {
-      const rawContent = await readFile20(filePath, { encoding: "utf-8" });
+      const rawContent = await readFile21(filePath, { encoding: "utf-8" });
       const { frontmatter, content } = parseFrontmatter2(rawContent, filePath);
       return {
         filePath,
@@ -171687,7 +171998,7 @@ var init_agentColorManager = __esm(() => {
 });
 
 // src/tui/tools/AgentTool/agentMemorySnapshot.ts
-import { mkdir as mkdir16, readdir as readdir14, readFile as readFile21, unlink as unlink7, writeFile as writeFile11 } from "fs/promises";
+import { mkdir as mkdir16, readdir as readdir14, readFile as readFile22, unlink as unlink8, writeFile as writeFile11 } from "fs/promises";
 import { join as join72 } from "path";
 function getSnapshotDirForAgent(agentType) {
   return join72(getCwd(), getConfigDirName2(), SNAPSHOT_BASE, agentType);
@@ -171700,7 +172011,7 @@ function getSyncedJsonPath(agentType, scope) {
 }
 async function readJsonFile(path, schema) {
   try {
-    const content = await readFile21(path, { encoding: "utf-8" });
+    const content = await readFile22(path, { encoding: "utf-8" });
     const result = schema.safeParse(jsonParse2(content));
     return result.success ? result.data : null;
   } catch {
@@ -171716,7 +172027,7 @@ async function copySnapshotToLocal(agentType, scope) {
     for (const dirent of files) {
       if (!dirent.isFile() || dirent.name === SNAPSHOT_JSON)
         continue;
-      const content = await readFile21(join72(snapshotMemDir, dirent.name), {
+      const content = await readFile22(join72(snapshotMemDir, dirent.name), {
         encoding: "utf-8"
       });
       await writeFile11(join72(localMemDir, dirent.name), content);
@@ -180408,14 +180719,16 @@ var installPrepareCommitMsgHook = () => ({});
 // src/tui/utils/worktree.ts
 import {
   copyFile as copyFile2,
+  lstat as lstat6,
   mkdir as mkdir17,
   readdir as readdir15,
-  readFile as readFile22,
+  readFile as readFile23,
   stat as stat24,
   symlink as symlink4,
+  unlink as unlink9,
   utimes as utimes2
 } from "fs/promises";
-import { basename as basename17, dirname as dirname42, join as join73 } from "path";
+import { basename as basename17, dirname as dirname42, join as join73, resolve as resolve32 } from "path";
 function validateWorktreeSlug2(slug) {
   if (slug.length > MAX_WORKTREE_SLUG_LENGTH2) {
     throw new Error(`Invalid worktree name: must be ${MAX_WORKTREE_SLUG_LENGTH2} characters or fewer (got ${slug.length})`);
@@ -180474,11 +180787,61 @@ function worktreeBranchName2(slug) {
 function worktreePathFor2(repoRoot, slug) {
   return join73(worktreesDir2(repoRoot), flattenSlug2(slug));
 }
+async function isRegisteredWorktreeTarget2(worktreePath) {
+  try {
+    const ptr = (await readFile23(join73(worktreePath, ".git"), "utf-8")).trim();
+    if (!ptr.startsWith("gitdir:"))
+      return false;
+    const gitDir = resolve32(worktreePath, ptr.slice("gitdir:".length).trim());
+    const backlink = (await readFile23(join73(gitDir, "gitdir"), "utf-8")).trim();
+    return resolve32(dirname42(backlink)) === resolve32(worktreePath);
+  } catch {
+    return false;
+  }
+}
+async function inspectWorktreeTarget2(worktreePath) {
+  let entries;
+  try {
+    const st = await stat24(worktreePath);
+    if (!st.isDirectory())
+      return "occupied";
+    entries = await readdir15(worktreePath);
+  } catch (e) {
+    return getErrnoCode2(e) === "ENOENT" ? "clear" : "occupied";
+  }
+  if (entries.length === 0)
+    return "clear";
+  if (entries.length > 1 || entries[0] !== ".git")
+    return "occupied";
+  const dotGit = join73(worktreePath, ".git");
+  try {
+    const st = await lstat6(dotGit);
+    if (!st.isFile())
+      return "occupied";
+  } catch {
+    return "occupied";
+  }
+  let content;
+  try {
+    content = (await readFile23(dotGit, "utf-8")).trim();
+  } catch {
+    return "occupied";
+  }
+  if (!content.startsWith("gitdir:"))
+    return "occupied";
+  const gitdirTarget = resolve32(worktreePath, content.slice("gitdir:".length).trim());
+  try {
+    await stat24(gitdirTarget);
+    return "occupied";
+  } catch {
+    return "repair-dangling-pointer";
+  }
+}
 async function getOrCreateWorktree2(repoRoot, slug, options) {
   const worktreePath = worktreePathFor2(repoRoot, slug);
   const worktreeBranch = worktreeBranchName2(slug);
   const existingHead = await readWorktreeHeadSha2(worktreePath);
-  if (existingHead) {
+  if (existingHead && await isRegisteredWorktreeTarget2(worktreePath)) {
     return {
       worktreePath,
       worktreeBranch,
@@ -180486,8 +180849,22 @@ async function getOrCreateWorktree2(repoRoot, slug, options) {
       existed: true
     };
   }
+  const targetState = await inspectWorktreeTarget2(worktreePath);
+  if (targetState === "repair-dangling-pointer") {
+    await unlink9(join73(worktreePath, ".git"));
+  } else if (targetState === "occupied") {
+    throw new Error(`Worktree path "${worktreePath}" already exists and is not a safe-to-repair worktree leftover; refusing to overwrite it (data preserved)`);
+  }
+  let sourceCheckout = options?.sourceCheckout ?? null;
+  if (!sourceCheckout && resolve32(getCwd()) !== resolve32(repoRoot)) {
+    const callingCwd = getCwd();
+    const headCommit = await readCheckoutHeadSha2(callingCwd);
+    if (headCommit) {
+      sourceCheckout = { cwd: callingCwd, headCommit };
+    }
+  }
   await mkdir17(worktreesDir2(repoRoot), { recursive: true });
-  const fetchEnv = { ...process.env, ...GIT_NO_PROMPT_ENV2 };
+  const fetchEnv = { ...process.env, ...GIT_NO_PROMPT_ENV3 };
   let baseBranch;
   let baseSha = null;
   if (options?.prNumber) {
@@ -180512,22 +180889,35 @@ async function getOrCreateWorktree2(repoRoot, slug, options) {
     }
   }
   if (!baseSha) {
-    const { stdout, code: shaCode } = await execFileNoThrowWithCwd2(gitExe2(), ["rev-parse", baseBranch], { cwd: repoRoot });
-    if (shaCode !== 0) {
-      throw new Error(`Failed to resolve base branch "${baseBranch}": git rev-parse failed`);
+    if (baseBranch === "HEAD" && sourceCheckout) {
+      const { code: verifyCode } = await execFileNoThrowWithCwd2(gitExe2(), ["rev-parse", "--verify", `${sourceCheckout.headCommit}^{commit}`], { cwd: repoRoot });
+      if (verifyCode !== 0) {
+        throw new Error(`Failed to resolve source checkout HEAD ${sourceCheckout.headCommit} as a commit in the repository; refusing to silently fall back to the canonical HEAD`);
+      }
+      baseSha = sourceCheckout.headCommit;
+    } else {
+      const { stdout, code: shaCode } = await execFileNoThrowWithCwd2(gitExe2(), ["rev-parse", "--verify", `${baseBranch}^{commit}`], { cwd: repoRoot });
+      if (shaCode !== 0) {
+        throw new Error(`Failed to resolve base branch "${baseBranch}": git rev-parse failed`);
+      }
+      baseSha = stdout.trim();
     }
-    baseSha = stdout.trim();
   }
   const sparsePaths = getInitialSettings2().worktree?.sparsePaths;
   const addArgs = ["worktree", "add"];
   if (sparsePaths?.length) {
     addArgs.push("--no-checkout");
   }
-  addArgs.push("-B", worktreeBranch, worktreePath, baseBranch);
+  addArgs.push("-B", worktreeBranch, worktreePath, `${baseSha}^{commit}`);
   const { code: createCode, stderr: createStderr } = await execFileNoThrowWithCwd2(gitExe2(), addArgs, { cwd: repoRoot });
   if (createCode !== 0) {
     throw new Error(`Failed to create worktree: ${createStderr}`);
   }
+  const actualHead = await readWorktreeHeadSha2(worktreePath);
+  if (actualHead !== baseSha) {
+    await execFileNoThrowWithCwd2(gitExe2(), ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
+    throw new Error(`Worktree base divergence: created worktree HEAD ${actualHead ?? "<unreadable>"} does not match the selected base ${baseSha}; the worktree was removed`);
+  }
   if (sparsePaths?.length) {
     const tearDown = async (msg) => {
       await execFileNoThrowWithCwd2(gitExe2(), ["worktree", "remove", "--force", worktreePath], { cwd: repoRoot });
@@ -180553,7 +180943,7 @@ async function getOrCreateWorktree2(repoRoot, slug, options) {
 async function copyWorktreeIncludeFiles(repoRoot, worktreePath) {
   let includeContent;
   try {
-    includeContent = await readFile22(join73(repoRoot, ".worktreeinclude"), "utf-8");
+    includeContent = await readFile23(join73(repoRoot, ".worktreeinclude"), "utf-8");
   } catch {
     return [];
   }
@@ -180933,7 +181323,7 @@ async function cleanupStaleAgentWorktrees2(cutoffDate) {
   }
   return removed;
 }
-var import_ignore, VALID_WORKTREE_SLUG_SEGMENT2, MAX_WORKTREE_SLUG_LENGTH2 = 64, currentWorktreeSession2 = null, GIT_NO_PROMPT_ENV2, EPHEMERAL_WORKTREE_PATTERNS2;
+var import_ignore, VALID_WORKTREE_SLUG_SEGMENT2, MAX_WORKTREE_SLUG_LENGTH2 = 64, currentWorktreeSession2 = null, GIT_NO_PROMPT_ENV3, EPHEMERAL_WORKTREE_PATTERNS2;
 var init_worktree4 = __esm(() => {
   init_shared();
   init_configDir();
@@ -180952,7 +181342,7 @@ var init_worktree4 = __esm(() => {
   init_detection2();
   import_ignore = __toESM(require_ignore(), 1);
   VALID_WORKTREE_SLUG_SEGMENT2 = /^[a-zA-Z0-9._-]+$/;
-  GIT_NO_PROMPT_ENV2 = {
+  GIT_NO_PROMPT_ENV3 = {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: ""
   };
@@ -189857,7 +190247,7 @@ var init_validate2 = __esm(() => {
 
 // src/tui/keybindings/loadUserBindings.ts
 import { readFileSync as readFileSync18 } from "fs";
-import { readFile as readFile23, stat as stat26 } from "fs/promises";
+import { readFile as readFile24, stat as stat26 } from "fs/promises";
 import { dirname as dirname43, join as join75 } from "path";
 function isKeybindingCustomizationEnabled() {
   return getFeatureValue_CACHED_MAY_BE_STALE("atlas_keybinding_customization_release", false);
@@ -189890,7 +190280,7 @@ async function loadKeybindings() {
   }
   const userPath = getKeybindingsPath();
   try {
-    const content = await readFile23(userPath, "utf-8");
+    const content = await readFile24(userPath, "utf-8");
     const parsed = jsonParse2(content);
     let userBlocks;
     if (typeof parsed === "object" && parsed !== null && "bindings" in parsed) {
@@ -194792,7 +195182,7 @@ var init_common2 = __esm(() => {
 });
 
 // src/tui/services/mcp/config.ts
-import { chmod as chmod2, open as open9, rename as rename2, stat as stat27, unlink as unlink8 } from "fs/promises";
+import { chmod as chmod2, open as open9, rename as rename2, stat as stat27, unlink as unlink10 } from "fs/promises";
 import { dirname as dirname44, join as join77, parse as parse9 } from "path";
 function getEnterpriseMcpFilePath() {
   return join77(getManagedFilePath(), "managed-mcp.json");
@@ -194836,7 +195226,7 @@ async function writeMcpjsonFile2(config) {
     await rename2(tempPath, mcpJsonPath);
   } catch (e) {
     try {
-      await unlink8(tempPath);
+      await unlink10(tempPath);
     } catch {}
     throw e;
   }
@@ -200539,7 +200929,7 @@ var init_IdeOnboardingDialog = __esm(() => {
 
 // src/tui/utils/ide.ts
 import { createConnection } from "net";
-import { basename as basename19, join as join84, sep as pathSeparator, resolve as resolve32 } from "path";
+import { basename as basename19, join as join84, sep as pathSeparator, resolve as resolve33 } from "path";
 function isProcessRunning3(pid) {
   try {
     process.kill(pid, 0);
@@ -200681,7 +201071,7 @@ async function getIdeLockfilesPaths() {
   if (windowsHome) {
     const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME);
     const wslPath = converter.toLocalPath(windowsHome);
-    paths.push(resolve32(wslPath, getConfigDirName2(), "ide"));
+    paths.push(resolve33(wslPath, getConfigDirName2(), "ide"));
   }
   try {
     const usersDir = "/mnt/c/Users";
@@ -200823,14 +201213,14 @@ async function detectIDEs(includeInvalid) {
             if (!checkWSLDistroMatch(idePath, process.env.WSL_DISTRO_NAME)) {
               return false;
             }
-            const resolvedOriginal = resolve32(localPath).normalize("NFC");
+            const resolvedOriginal = resolve33(localPath).normalize("NFC");
             if (cwd === resolvedOriginal || cwd.startsWith(resolvedOriginal + pathSeparator)) {
               return true;
             }
             const converter = new WindowsToWSLConverter(process.env.WSL_DISTRO_NAME);
             localPath = converter.toLocalPath(idePath);
           }
-          const resolvedPath = resolve32(localPath).normalize("NFC");
+          const resolvedPath = resolve33(localPath).normalize("NFC");
           if (getPlatform3() === "windows") {
             const normalizedCwd = cwd.replace(/^[a-zA-Z]:/, (match) => match.toUpperCase());
             const normalizedResolvedPath = resolvedPath.replace(/^[a-zA-Z]:/, (match) => match.toUpperCase());
@@ -206335,7 +206725,7 @@ var init_ComputerUseApproval = __esm(() => {
 });
 
 // src/tui/utils/computerUse/computerUseLock.ts
-import { mkdir as mkdir21, readFile as readFile24, unlink as unlink9, writeFile as writeFile14 } from "fs/promises";
+import { mkdir as mkdir21, readFile as readFile25, unlink as unlink11, writeFile as writeFile14 } from "fs/promises";
 import { join as join87 } from "path";
 function isComputerUseLock(value) {
   if (typeof value !== "object" || value === null)
@@ -206347,7 +206737,7 @@ function getLockPath2() {
 }
 async function readLock2() {
   try {
-    const raw = await readFile24(getLockPath2(), "utf8");
+    const raw = await readFile25(getLockPath2(), "utf8");
     const parsed = jsonParse2(raw);
     return isComputerUseLock(parsed) ? parsed : undefined;
   } catch {
@@ -206388,7 +206778,7 @@ async function checkComputerUseLock() {
     return { kind: "blocked", by: existing.sessionId };
   }
   logForDebugging3(`Recovering stale computer-use lock from session ${existing.sessionId} (PID ${existing.pid})`);
-  await unlink9(getLockPath2()).catch(() => {});
+  await unlink11(getLockPath2()).catch(() => {});
   return { kind: "free" };
 }
 async function tryAcquireComputerUseLock() {
@@ -206405,7 +206795,7 @@ async function tryAcquireComputerUseLock() {
   }
   const existing = await readLock2();
   if (!existing) {
-    await unlink9(getLockPath2()).catch(() => {});
+    await unlink11(getLockPath2()).catch(() => {});
     if (await tryCreateExclusive2(lock)) {
       registerLockCleanup2();
       return FRESH;
@@ -206418,7 +206808,7 @@ async function tryAcquireComputerUseLock() {
     return { kind: "blocked", by: existing.sessionId };
   }
   logForDebugging3(`Recovering stale computer-use lock from session ${existing.sessionId} (PID ${existing.pid})`);
-  await unlink9(getLockPath2()).catch(() => {});
+  await unlink11(getLockPath2()).catch(() => {});
   if (await tryCreateExclusive2(lock)) {
     registerLockCleanup2();
     return FRESH;
@@ -206432,7 +206822,7 @@ async function releaseComputerUseLock() {
   if (!existing || existing.sessionId !== getSessionId())
     return false;
   try {
-    await unlink9(getLockPath2());
+    await unlink11(getLockPath2());
     logForDebugging3("Released computer-use lock");
     return true;
   } catch {
@@ -210444,7 +210834,7 @@ function createLinkedTransportPair() {
 }
 
 // src/tui/services/mcp/client.ts
-import { mkdir as mkdir22, readFile as readFile25, unlink as unlink10, writeFile as writeFile15 } from "fs/promises";
+import { mkdir as mkdir22, readFile as readFile26, unlink as unlink12, writeFile as writeFile15 } from "fs/promises";
 import { dirname as dirname45, join as join88 } from "path";
 function isMcpSessionExpiredError(error) {
   const httpStatus = "code" in error ? error.code : undefined;
@@ -210466,7 +210856,7 @@ function getMcpAuthCachePath() {
 }
 function getMcpAuthCache() {
   if (!authCachePromise) {
-    authCachePromise = readFile25(getMcpAuthCachePath(), "utf-8").then((data) => jsonParse2(data)).catch(() => ({}));
+    authCachePromise = readFile26(getMcpAuthCachePath(), "utf-8").then((data) => jsonParse2(data)).catch(() => ({}));
   }
   return authCachePromise;
 }
@@ -210490,7 +210880,7 @@ function setMcpAuthCacheEntry(serverId) {
 }
 function clearMcpAuthCache() {
   authCachePromise = null;
-  unlink10(getMcpAuthCachePath()).catch(() => {});
+  unlink12(getMcpAuthCachePath()).catch(() => {});
 }
 function handleRemoteAuthFailure(name, serverRef, transportType) {
   const label = {
@@ -212396,13 +212786,13 @@ var init_LSPDiagnosticRegistry = __esm(() => {
 });
 
 // src/tui/utils/plugins/lspPluginIntegration.ts
-import { readFile as readFile26 } from "fs/promises";
-import { join as join89, relative as relative10, resolve as resolve33 } from "path";
+import { readFile as readFile27 } from "fs/promises";
+import { join as join89, relative as relative10, resolve as resolve34 } from "path";
 function validatePathWithinPlugin(pluginPath, relativePath) {
-  const resolvedPluginPath = resolve33(pluginPath);
-  const resolvedFilePath = resolve33(pluginPath, relativePath);
+  const resolvedPluginPath = resolve34(pluginPath);
+  const resolvedFilePath = resolve34(pluginPath, relativePath);
   const rel = relative10(resolvedPluginPath, resolvedFilePath);
-  if (rel.startsWith("..") || resolve33(rel) === rel) {
+  if (rel.startsWith("..") || resolve34(rel) === rel) {
     return null;
   }
   return resolvedFilePath;
@@ -212411,7 +212801,7 @@ async function loadPluginLspServers(plugin, errors = []) {
   const servers = {};
   const lspJsonPath = join89(plugin.path, ".lsp.json");
   try {
-    const content = await readFile26(lspJsonPath, "utf-8");
+    const content = await readFile27(lspJsonPath, "utf-8");
     const parsed = jsonParse2(content);
     const result = record(string2(), LspServerConfigSchema()).safeParse(parsed);
     if (result.success) {
@@ -212468,7 +212858,7 @@ async function loadLspServersFromManifest(declaration, pluginPath, pluginName, e
         continue;
       }
       try {
-        const content = await readFile26(validatedPath, "utf-8");
+        const content = await readFile27(validatedPath, "utf-8");
         const parsed = jsonParse2(content);
         const result = record(string2(), LspServerConfigSchema()).safeParse(parsed);
         if (result.success) {
@@ -217515,9 +217905,9 @@ import {
   copyFile as copyFile3,
   link as link2,
   mkdir as mkdir23,
-  readFile as readFile27,
+  readFile as readFile28,
   stat as stat29,
-  unlink as unlink11
+  unlink as unlink13
 } from "fs/promises";
 import { dirname as dirname46, isAbsolute as isAbsolute19, join as join90, relative as relative11 } from "path";
 import { inspect as inspect3 } from "util";
@@ -217791,7 +218181,7 @@ async function applySnapshot(state, targetSnapshot) {
       }
       if (backupFileName === null) {
         try {
-          await unlink11(filePath);
+          await unlink13(filePath);
           logForDebugging3(`FileHistory: [Rewind] Deleted ${filePath}`);
           filesChanged.push(filePath);
         } catch (e) {
@@ -217832,8 +218222,8 @@ async function checkOriginFileChanged(originalFile, backupFileName, originalStat
   return compareStatsAndContent(originalStats, backupStats, async () => {
     try {
       const [originalContent, backupContent] = await Promise.all([
-        readFile27(originalFile, "utf-8"),
-        readFile27(backupPath, "utf-8")
+        readFile28(originalFile, "utf-8"),
+        readFile28(backupPath, "utf-8")
       ]);
       return originalContent !== backupContent;
     } catch {
@@ -218094,7 +218484,7 @@ async function notifyVscodeSnapshotFilesUpdated(oldState, newState) {
 }
 async function readFileAsyncOrNull(path) {
   try {
-    return await readFile27(path, "utf-8");
+    return await readFile28(path, "utf-8");
   } catch {
     return null;
   }
@@ -218204,13 +218594,13 @@ var init_detectRepository = __esm(() => {
 });
 
 // src/tui/utils/gitDiff.ts
-import { access, readFile as readFile28 } from "fs/promises";
+import { access, readFile as readFile29 } from "fs/promises";
 import { dirname as dirname47, join as join91, relative as relative12, sep as sep17 } from "path";
 async function fetchGitDiff() {
   const isGit = await getIsGit();
   if (!isGit)
     return null;
-  if (await isInTransientGitState()) {
+  if (await checkTransientGitState() !== "none") {
     return null;
   }
   const { stdout: shortstatOut, code: shortstatCode } = await execFileNoThrow3(gitExe2(), ["--no-optional-locks", "diff", "HEAD", "--shortstat"], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
@@ -218244,7 +218634,7 @@ async function fetchGitDiffHunks() {
   const isGit = await getIsGit();
   if (!isGit)
     return new Map;
-  if (await isInTransientGitState()) {
+  if (await checkTransientGitState() !== "none") {
     return new Map;
   }
   const { stdout: diffOut, code: diffCode } = await execFileNoThrow3(gitExe2(), ["--no-optional-locks", "diff", "HEAD"], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
@@ -218346,18 +218736,19 @@ function parseGitDiff(stdout) {
   }
   return result;
 }
-async function isInTransientGitState() {
+async function checkTransientGitState() {
   const gitDir = await getGitDir(getCwd());
-  if (!gitDir)
-    return false;
-  const transientFiles = [
-    "MERGE_HEAD",
-    "REBASE_HEAD",
-    "CHERRY_PICK_HEAD",
-    "REVERT_HEAD"
-  ];
-  const results = await Promise.all(transientFiles.map((file) => access(join91(gitDir, file)).then(() => true).catch(() => false)));
-  return results.some(Boolean);
+  if (gitDir) {
+    const fileHits = await Promise.all(TRANSIENT_GIT_REFS.map((file) => access(join91(gitDir, file)).then(() => true).catch(() => false)));
+    if (fileHits.some(Boolean))
+      return "transient";
+  }
+  const outcomes = await Promise.all(TRANSIENT_GIT_REFS.map((ref) => execFileNoThrow3(gitExe2(), ["--no-optional-locks", "rev-parse", "--verify", "--quiet", ref], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false }).then((result) => result.code === 0 ? "transient" : result.code === 1 ? "none" : "unknown").catch(() => "unknown")));
+  if (outcomes.some((o) => o === "transient"))
+    return "transient";
+  if (outcomes.some((o) => o === "unknown"))
+    return "unknown";
+  return "none";
 }
 async function fetchUntrackedFiles(maxFiles) {
   const { stdout, code } = await execFileNoThrow3(gitExe2(), ["--no-optional-locks", "ls-files", "--others", "--exclude-standard"], { timeout: GIT_TIMEOUT_MS, preserveOutputOnError: false });
@@ -218455,7 +218846,7 @@ async function generateSyntheticDiff(gitPath, absoluteFilePath) {
     if (!isFileWithinReadSizeLimit2(absoluteFilePath, MAX_DIFF_SIZE_BYTES)) {
       return null;
     }
-    const content = await readFile28(absoluteFilePath, "utf-8");
+    const content = await readFile29(absoluteFilePath, "utf-8");
     const lines = content.split(`
 `);
     if (lines.length > 0 && lines.at(-1) === "") {
@@ -218478,13 +218869,19 @@ ${addedLines}`;
     return null;
   }
 }
-var GIT_TIMEOUT_MS = 5000, MAX_FILES = 50, MAX_DIFF_SIZE_BYTES = 1e6, MAX_LINES_PER_FILE = 400, MAX_FILES_FOR_DETAILS = 500, SINGLE_FILE_DIFF_TIMEOUT_MS = 3000;
+var GIT_TIMEOUT_MS = 5000, MAX_FILES = 50, MAX_DIFF_SIZE_BYTES = 1e6, MAX_LINES_PER_FILE = 400, MAX_FILES_FOR_DETAILS = 500, TRANSIENT_GIT_REFS, SINGLE_FILE_DIFF_TIMEOUT_MS = 3000;
 var init_gitDiff = __esm(() => {
   init_cwd3();
   init_detectRepository();
   init_execFileNoThrow2();
   init_file();
   init_git2();
+  TRANSIENT_GIT_REFS = [
+    "MERGE_HEAD",
+    "REBASE_HEAD",
+    "CHERRY_PICK_HEAD",
+    "REVERT_HEAD"
+  ];
 });
 
 // src/tui/memdir/memoryTypes.ts
@@ -254038,7 +254435,7 @@ var init_readEditContext = __esm(() => {
 });
 
 // src/tui/tools/FileWriteTool/UI.tsx
-import { isAbsolute as isAbsolute20, relative as relative14, resolve as resolve35 } from "path";
+import { isAbsolute as isAbsolute20, relative as relative14, resolve as resolve36 } from "path";
 function countLines(content) {
   const parts = content.split(EOL);
   return content.endsWith(EOL) ? parts.length - 1 : parts.length;
@@ -254362,7 +254759,7 @@ function WriteRejectionBody(t0) {
 }
 async function loadRejectionDiff(filePath, content) {
   try {
-    const fullFilePath = isAbsolute20(filePath) ? filePath : resolve35(getCwd(), filePath);
+    const fullFilePath = isAbsolute20(filePath) ? filePath : resolve36(getCwd(), filePath);
     const handle = await openForScan(fullFilePath);
     if (handle === null)
       return {
@@ -256409,7 +256806,7 @@ var init_teammate2 = __esm(() => {
 });
 
 // src/tui/utils/tasks.ts
-import { mkdir as mkdir24, readdir as readdir16, readFile as readFile29, unlink as unlink12, writeFile as writeFile16 } from "fs/promises";
+import { mkdir as mkdir24, readdir as readdir16, readFile as readFile30, unlink as unlink14, writeFile as writeFile16 } from "fs/promises";
 import { join as join94 } from "path";
 function setLeaderTeamName2(teamName) {
   if (leaderTeamName2 === teamName)
@@ -256434,7 +256831,7 @@ function getHighWaterMarkPath2(taskListId) {
 async function readHighWaterMark2(taskListId) {
   const path = getHighWaterMarkPath2(taskListId);
   try {
-    const content = (await readFile29(path, "utf-8")).trim();
+    const content = (await readFile30(path, "utf-8")).trim();
     const value = parseInt(content, 10);
     return isNaN(value) ? 0 : value;
   } catch {
@@ -256474,7 +256871,7 @@ async function resetTaskList2(taskListId) {
       if (file.endsWith(".json") && !file.startsWith(".")) {
         const filePath = join94(dir, file);
         try {
-          await unlink12(filePath);
+          await unlink14(filePath);
         } catch {}
       }
     }
@@ -256558,7 +256955,7 @@ async function createTask2(taskListId, taskData) {
 async function getTask2(taskListId, taskId) {
   const path = getTaskPath2(taskListId, taskId);
   try {
-    const content = await readFile29(path, "utf-8");
+    const content = await readFile30(path, "utf-8");
     const data = jsonParse2(content);
     const parsed = TaskSchema2().safeParse(data);
     if (!parsed.success) {
@@ -256612,7 +257009,7 @@ async function deleteTask2(taskListId, taskId) {
       }
     }
     try {
-      await unlink12(path);
+      await unlink14(path);
     } catch (e) {
       const code = getErrnoCode2(e);
       if (code === "ENOENT") {
@@ -258915,7 +259312,7 @@ var init_outputLimits2 = __esm(() => {
 });
 
 // src/tui/utils/task/TaskOutput.ts
-import { unlink as unlink13 } from "fs/promises";
+import { unlink as unlink15 } from "fs/promises";
 var DEFAULT_MAX_MEMORY2, POLL_INTERVAL_MS3 = 1000, PROGRESS_TAIL_BYTES2 = 4096, TaskOutput3;
 var init_TaskOutput2 = __esm(() => {
   init_debug();
@@ -259144,7 +259541,7 @@ Output truncated (${sizeKB}KB total). Full output saved to: ${this.path}`;
     }
     async deleteOutputFile() {
       try {
-        await unlink13(this.path);
+        await unlink15(this.path);
       } catch {}
     }
     clear() {
@@ -259160,7 +259557,7 @@ Output truncated (${sizeKB}KB total). Full output saved to: ${this.path}`;
 });
 
 // src/tui/utils/sessionEnvironment.ts
-import { mkdir as mkdir25, readdir as readdir17, readFile as readFile30, writeFile as writeFile17 } from "fs/promises";
+import { mkdir as mkdir25, readdir as readdir17, readFile as readFile31, writeFile as writeFile17 } from "fs/promises";
 import { join as join95 } from "path";
 async function getSessionEnvDirPath() {
   const sessionEnvDir = join95(getAtlasConfigHomeDir3(), "session-env", getSessionId());
@@ -259199,7 +259596,7 @@ async function getSessionEnvironmentScript() {
   const envFile = process.env.ATLAS_SESSION_ENV_FILE;
   if (envFile) {
     try {
-      const envScript = (await readFile30(envFile, "utf8")).trim();
+      const envScript = (await readFile31(envFile, "utf8")).trim();
       if (envScript) {
         scripts.push(envScript);
         logForDebugging3(`Session environment loaded from ATLAS_SESSION_ENV_FILE: ${envFile} (${envScript.length} chars)`);
@@ -259218,7 +259615,7 @@ async function getSessionEnvironmentScript() {
     for (const file of hookFiles) {
       const filePath = join95(sessionEnvDir, file);
       try {
-        const content = (await readFile30(filePath, "utf8")).trim();
+        const content = (await readFile31(filePath, "utf8")).trim();
         if (content) {
           scripts.push(content);
         }
@@ -260259,7 +260656,7 @@ var init_powershellProvider = __esm(() => {
 import { execFileSync as execFileSync4, spawn as spawn9 } from "child_process";
 import { constants as fsConstants5, readFileSync as readFileSync19, unlinkSync as unlinkSync3 } from "fs";
 import { mkdir as mkdir27, open as open12, realpath as realpath10 } from "fs/promises";
-import { isAbsolute as isAbsolute25, resolve as resolve36 } from "path";
+import { isAbsolute as isAbsolute25, resolve as resolve37 } from "path";
 import { join as posixJoin3 } from "path/posix";
 import { accessSync as accessSync2 } from "fs";
 function isExecutable2(shellPath) {
@@ -260448,7 +260845,7 @@ async function exec3(command, abortSignal, shellType, options) {
   }
 }
 function setCwd2(path, relativeTo) {
-  const resolved = isAbsolute25(path) ? path : resolve36(relativeTo || getFsImplementation2().cwd(), path);
+  const resolved = isAbsolute25(path) ? path : resolve37(relativeTo || getFsImplementation2().cwd(), path);
   let physicalPath;
   try {
     physicalPath = getFsImplementation2().realpathSync(resolved);
@@ -260503,7 +260900,7 @@ var init_Shell2 = __esm(() => {
 });
 
 // src/tui/tools/BashTool/utils.ts
-import { readFile as readFile31, stat as stat33 } from "fs/promises";
+import { readFile as readFile32, stat as stat33 } from "fs/promises";
 function stripEmptyLines2(content) {
   const lines = content.split(`
 `);
@@ -260555,7 +260952,7 @@ async function resizeShellImageOutput2(stdout, outputFilePath, outputFileSize) {
     const size = outputFileSize ?? (await stat33(outputFilePath)).size;
     if (size > MAX_IMAGE_FILE_SIZE2)
       return null;
-    source = await readFile31(outputFilePath, "utf8");
+    source = await readFile32(outputFilePath, "utf8");
   }
   const parsed = parseDataUri2(source);
   if (!parsed)
@@ -261049,7 +261446,7 @@ var init_UI8 = __esm(() => {
 });
 
 // src/tui/tools/NotebookEditTool/NotebookEditTool.ts
-import { extname as extname13, isAbsolute as isAbsolute26, resolve as resolve37 } from "path";
+import { extname as extname13, isAbsolute as isAbsolute26, resolve as resolve38 } from "path";
 var inputSchema12, outputSchema10, NotebookEditTool2;
 var init_NotebookEditTool = __esm(() => {
   init_shared();
@@ -261163,7 +261560,7 @@ var init_NotebookEditTool = __esm(() => {
     renderToolUseErrorMessage: renderToolUseErrorMessage5,
     renderToolResultMessage: renderToolResultMessage8,
     async validateInput({ notebook_path, cell_type, cell_id, edit_mode = "replace" }, toolUseContext) {
-      const fullPath = isAbsolute26(notebook_path) ? notebook_path : resolve37(getCwd(), notebook_path);
+      const fullPath = isAbsolute26(notebook_path) ? notebook_path : resolve38(getCwd(), notebook_path);
       if (fullPath.startsWith("\\\\") || fullPath.startsWith("//")) {
         return { result: true };
       }
@@ -261262,7 +261659,7 @@ var init_NotebookEditTool = __esm(() => {
       cell_type,
       edit_mode: originalEditMode
     }, { readFileState, updateFileHistoryState }, _, parentMessage) {
-      const fullPath = isAbsolute26(notebook_path) ? notebook_path : resolve37(getCwd(), notebook_path);
+      const fullPath = isAbsolute26(notebook_path) ? notebook_path : resolve38(getCwd(), notebook_path);
       if (fileHistoryEnabled()) {
         await fileHistoryTrackEdit(updateFileHistoryState, fullPath, parentMessage.uuid);
       }
@@ -263179,7 +263576,7 @@ var init_fileStateCache = __esm(() => {
 });
 
 // src/tui/utils/hooks/hooksSettings.ts
-import { resolve as resolve38 } from "path";
+import { resolve as resolve39 } from "path";
 function isHookEqual(a, b) {
   if (a.type !== b.type)
     return false;
@@ -263230,7 +263627,7 @@ function getAllHooks(appState) {
     for (const source of sources) {
       const filePath = getSettingsFilePathForSource2(source);
       if (filePath) {
-        const resolvedPath = resolve38(filePath);
+        const resolvedPath = resolve39(filePath);
         if (seenFiles.has(resolvedPath)) {
           continue;
         }
@@ -267369,7 +267766,7 @@ __export(exports_teammateMailbox, {
   sendShutdownRequestToMailbox: () => sendShutdownRequestToMailbox2,
   writeToMailbox: () => writeToMailbox2
 });
-import { mkdir as mkdir28, readFile as readFile32, writeFile as writeFile18 } from "fs/promises";
+import { mkdir as mkdir28, readFile as readFile33, writeFile as writeFile18 } from "fs/promises";
 import { join as join100 } from "path";
 function getInboxPath2(agentName, teamName) {
   const team = teamName || getTeamName2() || "default";
@@ -267391,7 +267788,7 @@ async function readMailbox2(agentName, teamName) {
   const inboxPath = getInboxPath2(agentName, teamName);
   logForDebugging3(`[TeammateMailbox] readMailbox: path=${inboxPath}`);
   try {
-    const content = await readFile32(inboxPath, "utf-8");
+    const content = await readFile33(inboxPath, "utf-8");
     const messages = jsonParse2(content);
     logForDebugging3(`[TeammateMailbox] readMailbox: read ${messages.length} message(s)`);
     return messages;
@@ -295743,7 +296140,7 @@ var init_listSessionsImpl = __esm(() => {
 });
 
 // src/tui/services/autoDream/consolidationLock.ts
-import { mkdir as mkdir30, readFile as readFile33, stat as stat35, unlink as unlink14, utimes as utimes3, writeFile as writeFile20 } from "fs/promises";
+import { mkdir as mkdir30, readFile as readFile34, stat as stat35, unlink as unlink16, utimes as utimes3, writeFile as writeFile20 } from "fs/promises";
 import { join as join103 } from "path";
 function lockPath() {
   return join103(getAutoMemPath2(), LOCK_FILE);
@@ -295761,7 +296158,7 @@ async function tryAcquireConsolidationLock() {
   let mtimeMs;
   let holderPid;
   try {
-    const [s, raw] = await Promise.all([stat35(path), readFile33(path, "utf8")]);
+    const [s, raw] = await Promise.all([stat35(path), readFile34(path, "utf8")]);
     mtimeMs = s.mtimeMs;
     const parsed = parseInt(raw.trim(), 10);
     holderPid = Number.isFinite(parsed) ? parsed : undefined;
@@ -295776,7 +296173,7 @@ async function tryAcquireConsolidationLock() {
   await writeFile20(path, String(process.pid));
   let verify;
   try {
-    verify = await readFile33(path, "utf8");
+    verify = await readFile34(path, "utf8");
   } catch {
     return null;
   }
@@ -295788,7 +296185,7 @@ async function rollbackConsolidationLock(priorMtime) {
   const path = lockPath();
   try {
     if (priorMtime === 0) {
-      await unlink14(path);
+      await unlink16(path);
       return;
     }
     await writeFile20(path, "");
@@ -300223,6 +300620,7 @@ var init_EnterWorktreeTool = __esm(() => {
   init_memoryFiles();
   init_cwd3();
   init_git2();
+  init_gitFilesystem();
   init_plans();
   init_Shell2();
   init_sessionStorage();
@@ -300272,12 +300670,18 @@ var init_EnterWorktreeTool = __esm(() => {
         throw new Error("Already in a worktree session");
       }
       const mainRepoRoot = findCanonicalGitRoot2(getCwd());
+      let sourceCheckout;
       if (mainRepoRoot && mainRepoRoot !== getCwd()) {
+        const callingCwd = getCwd();
+        const headCommit = await readCheckoutHeadSha2(callingCwd);
+        if (headCommit) {
+          sourceCheckout = { cwd: callingCwd, headCommit };
+        }
         process.chdir(mainRepoRoot);
         setCwd2(mainRepoRoot);
       }
       const slug = input.name ?? getPlanSlug2();
-      const worktreeSession = await createWorktreeForSession2(getSessionId(), slug);
+      const worktreeSession = await createWorktreeForSession2(getSessionId(), slug, undefined, sourceCheckout ? { sourceCheckout } : undefined);
       process.chdir(worktreeSession.worktreePath);
       setCwd2(worktreeSession.worktreePath);
       setOriginalCwd(getCwd());
@@ -301198,7 +301602,7 @@ __export(exports_voice2, {
   stopRecording: () => stopRecording
 });
 import { spawn as spawn10, spawnSync as spawnSync3 } from "child_process";
-import { readFile as readFile34 } from "fs/promises";
+import { readFile as readFile35 } from "fs/promises";
 function loadAudioNapi() {
   audioNapiPromise ??= (async () => {
     const t0 = Date.now();
@@ -301253,7 +301657,7 @@ function _resetArecordProbeForTesting() {
   arecordProbe = null;
 }
 function linuxHasAlsaCards() {
-  linuxAlsaCardsMemo ??= readFile34("/proc/asound/cards", "utf8").then((cards) => {
+  linuxAlsaCardsMemo ??= readFile35("/proc/asound/cards", "utf8").then((cards) => {
     const c = cards.trim();
     return c !== "" && !c.includes("no soundcards");
   }, () => false);
@@ -311276,7 +311680,7 @@ var init_registry3 = __esm(() => {
 
 // src/tui/utils/swarm/teamHelpers.ts
 import { mkdirSync as mkdirSync7, readFileSync as readFileSync21, writeFileSync as writeFileSync6 } from "fs";
-import { mkdir as mkdir32, readFile as readFile35, rm as rm3, writeFile as writeFile23 } from "fs/promises";
+import { mkdir as mkdir32, readFile as readFile36, rm as rm3, writeFile as writeFile23 } from "fs/promises";
 import { join as join105 } from "path";
 function sanitizeName3(name) {
   return name.replace(/[^a-zA-Z0-9]/g, "-").toLowerCase();
@@ -311300,7 +311704,7 @@ function readTeamFile2(teamName) {
 }
 async function readTeamFileAsync2(teamName) {
   try {
-    const content = await readFile35(getTeamFilePath2(teamName), "utf-8");
+    const content = await readFile36(getTeamFilePath2(teamName), "utf-8");
     return jsonParse2(content);
   } catch (e) {
     if (getErrnoCode2(e) === "ENOENT")
@@ -311450,7 +311854,7 @@ async function destroyWorktree2(worktreePath) {
   const gitFilePath = join105(worktreePath, ".git");
   let mainRepoPath = null;
   try {
-    const gitFileContent = (await readFile35(gitFilePath, "utf-8")).trim();
+    const gitFileContent = (await readFile36(gitFilePath, "utf-8")).trim();
     const match = gitFileContent.match(/^gitdir:\s*(.+)$/);
     if (match && match[1]) {
       const worktreeGitDir = match[1];
@@ -313693,7 +314097,7 @@ var exports_SpecParser = {};
 __export(exports_SpecParser, {
   SpecParser: () => SpecParser2
 });
-import { readFile as readFile36 } from "fs/promises";
+import { readFile as readFile37 } from "fs/promises";
 var inputSchema42, outputSchema34, SpecParser2;
 var init_SpecParser = __esm(() => {
   init_v4();
@@ -313736,7 +314140,7 @@ var init_SpecParser = __esm(() => {
       let raw = inp.spec_source;
       let parsedFromFile = false;
       try {
-        const fileContent = await readFile36(inp.spec_source, "utf-8");
+        const fileContent = await readFile37(inp.spec_source, "utf-8");
         raw = fileContent;
         parsedFromFile = true;
       } catch {}
@@ -316879,7 +317283,7 @@ var init_parser7 = __esm(() => {
 });
 
 // src/tui/tools/PowerShellTool/gitSafety.ts
-import { basename as basename29, posix as posix7, resolve as resolve39, sep as sep23 } from "path";
+import { basename as basename29, posix as posix7, resolve as resolve40, sep as sep23 } from "path";
 function resolveCwdReentry(normalized) {
   if (!normalized.startsWith("../"))
     return normalized;
@@ -316927,7 +317331,7 @@ function normalizeGitPathArg(arg) {
 }
 function resolveEscapingPathToCwdRelative(n) {
   const cwd = getCwd();
-  const abs = resolve39(cwd, n);
+  const abs = resolve40(cwd, n);
   const cwdWithSep = cwd.endsWith(sep23) ? cwd : cwd + sep23;
   const absLower = abs.toLowerCase();
   const cwdLower = cwd.toLowerCase();
@@ -318167,7 +318571,7 @@ var init_modeValidation3 = __esm(() => {
 
 // src/tui/tools/PowerShellTool/pathValidation.ts
 import { homedir as homedir29 } from "os";
-import { isAbsolute as isAbsolute27, resolve as resolve40 } from "path";
+import { isAbsolute as isAbsolute27, resolve as resolve41 } from "path";
 function matchesParam(paramLower, paramList) {
   for (const p of paramList) {
     if (p === paramLower || paramLower.length > 1 && p.startsWith(paramLower)) {
@@ -318275,7 +318679,7 @@ function checkDenyRuleForGuessedPath(strippedPath, cwd, toolPermissionContext, o
   if (!strippedPath || strippedPath.includes("\x00"))
     return null;
   const tildeExpanded = expandTilde3(strippedPath);
-  const abs = isAbsolute27(tildeExpanded) ? tildeExpanded : resolve40(cwd, tildeExpanded);
+  const abs = isAbsolute27(tildeExpanded) ? tildeExpanded : resolve41(cwd, tildeExpanded);
   const { resolvedPath } = safeResolvePath3(getFsImplementation2(), abs);
   const permissionType = operationType === "read" ? "read" : "edit";
   const denyRule = matchingRuleForInput2(resolvedPath, toolPermissionContext, permissionType, "deny");
@@ -318365,7 +318769,7 @@ function validatePath3(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     if (containsPathTraversal2(normalizedPath)) {
-      const absolutePath = isAbsolute27(normalizedPath) ? normalizedPath : resolve40(cwd, normalizedPath);
+      const absolutePath = isAbsolute27(normalizedPath) ? normalizedPath : resolve41(cwd, normalizedPath);
       const { resolvedPath, isCanonical } = safeResolvePath3(getFsImplementation2(), absolutePath);
       const result = isPathAllowed2(resolvedPath, toolPermissionContext, operationType, isCanonical ? [resolvedPath] : undefined);
       return {
@@ -318375,7 +318779,7 @@ function validatePath3(filePath, cwd, toolPermissionContext, operationType) {
       };
     }
     const basePath = getGlobBaseDirectory2(normalizedPath);
-    const absoluteBasePath = isAbsolute27(basePath) ? basePath : resolve40(cwd, basePath);
+    const absoluteBasePath = isAbsolute27(basePath) ? basePath : resolve41(cwd, basePath);
     const { resolvedPath } = safeResolvePath3(getFsImplementation2(), absoluteBasePath);
     const permissionType = operationType === "read" ? "read" : "edit";
     const denyRule = matchingRuleForInput2(resolvedPath, toolPermissionContext, permissionType, "deny");
@@ -318395,7 +318799,7 @@ function validatePath3(filePath, cwd, toolPermissionContext, operationType) {
       }
     };
   }
-  const absolutePath = isAbsolute27(normalizedPath) ? normalizedPath : resolve40(cwd, normalizedPath);
+  const absolutePath = isAbsolute27(normalizedPath) ? normalizedPath : resolve41(cwd, normalizedPath);
   const { resolvedPath, isCanonical } = safeResolvePath3(getFsImplementation2(), absolutePath);
   const result = isPathAllowed2(resolvedPath, toolPermissionContext, operationType, isCanonical ? [resolvedPath] : undefined);
   return {
@@ -320309,7 +320713,7 @@ var init_powershellSecurity = __esm(() => {
 });
 
 // src/tui/tools/PowerShellTool/powershellPermissions.ts
-import { resolve as resolve41 } from "path";
+import { resolve as resolve42 } from "path";
 async function extractCommandName(command) {
   const trimmed = command.trim();
   if (!trimmed) {
@@ -320922,7 +321326,7 @@ async function powershellToolHasPermission(input, context) {
     const canonical = resolveToCanonical(element.name);
     if (canonical === "set-location" && element.args.length > 0) {
       const target = element.args.find((a) => a.length === 0 || !PS_TOKENIZER_DASH_CHARS.has(a[0]));
-      if (target && resolve41(getCwd(), target) === getCwd()) {
+      if (target && resolve42(getCwd(), target) === getCwd()) {
         return false;
       }
     }
@@ -327496,7 +327900,7 @@ var init_toolSearch = __esm(() => {
 
 // src/tui/services/vcr.ts
 import { createHash as createHash8, randomUUID as randomUUID33 } from "crypto";
-import { mkdir as mkdir34, readFile as readFile37, writeFile as writeFile24 } from "fs/promises";
+import { mkdir as mkdir34, readFile as readFile38, writeFile as writeFile24 } from "fs/promises";
 import { dirname as dirname57, join as join109 } from "path";
 function shouldUseVCR() {
   if (false) {}
@@ -327512,7 +327916,7 @@ async function withFixture(input, fixtureName, f) {
   const hash = createHash8("sha1").update(jsonStringify5(input)).digest("hex").slice(0, 12);
   const filename = join109(process.env.ATLAS_TEST_FIXTURES_ROOT ?? getCwd(), `fixtures/${fixtureName}-${hash}.json`);
   try {
-    const cached = jsonParse2(await readFile37(filename, { encoding: "utf8" }));
+    const cached = jsonParse2(await readFile38(filename, { encoding: "utf8" }));
     return cached;
   } catch (e) {
     const code = getErrnoCode2(e);
@@ -327734,7 +328138,7 @@ var init_tokenEstimation = __esm(() => {
 
 // src/tui/utils/pdf.ts
 import { randomUUID as randomUUID34 } from "crypto";
-import { mkdir as mkdir35, readdir as readdir19, readFile as readFile38 } from "fs/promises";
+import { mkdir as mkdir35, readdir as readdir19, readFile as readFile39 } from "fs/promises";
 import { join as join110 } from "path";
 async function readPDF2(filePath) {
   try {
@@ -327756,7 +328160,7 @@ async function readPDF2(filePath) {
         }
       };
     }
-    const fileBuffer = await readFile38(filePath);
+    const fileBuffer = await readFile39(filePath);
     const header = fileBuffer.subarray(0, 5).toString("ascii");
     if (!header.startsWith("%PDF-")) {
       return {
@@ -327931,7 +328335,7 @@ var init_pdf2 = __esm(() => {
 
 // src/tui/utils/readFileInRange.ts
 import { createReadStream as createReadStream3, fstat as fstat2 } from "fs";
-import { stat as fsStat3, readFile as readFile39 } from "fs/promises";
+import { stat as fsStat3, readFile as readFile40 } from "fs/promises";
 async function readFileInRange2(filePath, offset = 0, maxLines, maxBytes, signal, options) {
   signal?.throwIfAborted();
   const truncateOnByteLimit = options?.truncateOnByteLimit ?? false;
@@ -327943,7 +328347,7 @@ async function readFileInRange2(filePath, offset = 0, maxLines, maxBytes, signal
     if (!truncateOnByteLimit && maxBytes !== undefined && stats.size > maxBytes) {
       throw new FileTooLargeError2(stats.size, maxBytes);
     }
-    const text = await readFile39(filePath, { encoding: "utf8", signal });
+    const text = await readFile40(filePath, { encoding: "utf8", signal });
     return readFileInRangeFast2(text, stats.mtimeMs, offset, maxLines, truncateOnByteLimit ? maxBytes : undefined);
   }
   return readFileInRangeStreaming2(filePath, offset, maxLines, maxBytes, truncateOnByteLimit, signal);
@@ -329357,7 +329761,7 @@ var init_findRelevantMemories = __esm(() => {
 
 // src/tui/utils/attachments.ts
 import { readdir as readdir21, stat as stat37 } from "fs/promises";
-import { dirname as dirname58, parse as parse12, relative as relative21, resolve as resolve42 } from "path";
+import { dirname as dirname58, parse as parse12, relative as relative21, resolve as resolve43 } from "path";
 import { randomUUID as randomUUID35 } from "crypto";
 async function getAttachments(input, toolUseContext, ideSelection, queuedCommands, messages, querySource, options) {
   if (isEnvTruthy2(process.env.ATLAS_DISABLE_ATTACHMENTS) || isEnvTruthy2(process.env.ATLAS_SIMPLE)) {
@@ -329778,7 +330182,7 @@ async function getSelectedLinesFromIDE(ideSelection, toolUseContext) {
   ];
 }
 function getDirectoriesToProcess(targetPath, originalCwd) {
-  const targetDir = dirname58(resolve42(targetPath));
+  const targetDir = dirname58(resolve43(targetPath));
   const nestedDirs = [];
   let currentDir = targetDir;
   while (currentDir !== originalCwd && currentDir !== parse12(currentDir).root) {
@@ -330077,7 +330481,7 @@ async function getDynamicSkillAttachments(toolUseContext) {
         const candidates = entries.filter((e) => e.isDirectory() || e.isSymbolicLink()).map((e) => e.name);
         const checked = await Promise.all(candidates.map(async (name) => {
           try {
-            await stat37(resolve42(skillDir, name, "SKILL.md"));
+            await stat37(resolve43(skillDir, name, "SKILL.md"));
             return name;
           } catch {
             return null;
@@ -331504,9 +331908,9 @@ var init_zip = __esm(() => {
 import { randomBytes as randomBytes14 } from "crypto";
 import {
   chmod as chmod4,
-  lstat as lstat5,
+  lstat as lstat7,
   readdir as readdir22,
-  readFile as readFile40,
+  readFile as readFile41,
   rename as rename3,
   rm as rm5,
   stat as stat38,
@@ -331590,7 +331994,7 @@ async function collectFilesForZip(baseDir, relativePath, files, visited) {
     const relPath = relativePath ? `${relativePath}/${entry}` : entry;
     let fileStat;
     try {
-      fileStat = await lstat5(fullPath);
+      fileStat = await lstat7(fullPath);
     } catch {
       continue;
     }
@@ -331609,7 +332013,7 @@ async function collectFilesForZip(baseDir, relativePath, files, visited) {
       await collectFilesForZip(baseDir, relPath, files, visited);
     } else if (fileStat.isFile()) {
       try {
-        const content = await readFile40(fullPath);
+        const content = await readFile41(fullPath);
         files[relPath] = [
           new Uint8Array(content),
           { os: 3, attrs: (fileStat.mode & 65535) << 16 }
@@ -331655,7 +332059,7 @@ var init_zipCache = __esm(() => {
 });
 
 // src/tui/utils/plugins/cacheUtils.ts
-import { readdir as readdir23, rm as rm6, stat as stat39, unlink as unlink15, writeFile as writeFile26 } from "fs/promises";
+import { readdir as readdir23, rm as rm6, stat as stat39, unlink as unlink17, writeFile as writeFile26 } from "fs/promises";
 import { join as join115 } from "path";
 function clearAllPluginCaches() {
   clearPluginCache();
@@ -331716,7 +332120,7 @@ function getOrphanedAtPath(versionPath) {
 async function removeOrphanedAtMarker(versionPath) {
   const orphanedAtPath = getOrphanedAtPath(versionPath);
   try {
-    await unlink15(orphanedAtPath);
+    await unlink17(orphanedAtPath);
   } catch (error) {
     const code = getErrnoCode2(error);
     if (code === "ENOENT")
@@ -332143,11 +332547,11 @@ var init_marketplaceHelpers = __esm(() => {
 });
 
 // src/tui/utils/plugins/officialMarketplaceGcs.ts
-import { chmod as chmod5, mkdir as mkdir36, readFile as readFile41, rename as rename4, rm as rm7, writeFile as writeFile27 } from "fs/promises";
-import { dirname as dirname61, join as join116, resolve as resolve43, sep as sep24 } from "path";
+import { chmod as chmod5, mkdir as mkdir36, readFile as readFile42, rename as rename4, rm as rm7, writeFile as writeFile27 } from "fs/promises";
+import { dirname as dirname61, join as join116, resolve as resolve44, sep as sep24 } from "path";
 async function fetchOfficialMarketplaceFromGcs(installLocation, marketplacesCacheDir) {
-  const cacheDir = resolve43(marketplacesCacheDir);
-  const resolvedLoc = resolve43(installLocation);
+  const cacheDir = resolve44(marketplacesCacheDir);
+  const resolvedLoc = resolve44(installLocation);
   if (resolvedLoc !== cacheDir && !resolvedLoc.startsWith(cacheDir + sep24)) {
     logForDebugging3(`fetchOfficialMarketplaceFromGcs: refusing path outside cache dir: ${installLocation}`, { level: "error" });
     return null;
@@ -332168,7 +332572,7 @@ async function fetchOfficialMarketplaceFromGcs(installLocation, marketplacesCach
       throw new Error("latest pointer returned empty body");
     }
     const sentinelPath = join116(installLocation, ".gcs-sha");
-    const currentSha = await readFile41(sentinelPath, "utf8").then((s) => s.trim(), () => null);
+    const currentSha = await readFile42(sentinelPath, "utf8").then((s) => s.trim(), () => null);
     if (currentSha === sha) {
       outcome = "noop";
       return sha;
@@ -332281,7 +332685,7 @@ var init_ascendMarketplace = __esm(() => {
 });
 
 // src/tui/utils/plugins/orphanScanner.ts
-import { join as join117, resolve as resolve44, sep as sep25 } from "path";
+import { join as join117, resolve as resolve45, sep as sep25 } from "path";
 function normalizeRepoRef(ref) {
   let u = ref.trim();
   const ssh = u.match(/^git@([^:]+):(.+)$/);
@@ -332325,7 +332729,7 @@ async function readOrphanManifestName(dirPath) {
 }
 async function scanOrphanedMarketplaces() {
   const fs = getFsImplementation2();
-  const cacheDir = resolve44(getMarketplacesCacheDir());
+  const cacheDir = resolve45(getMarketplacesCacheDir());
   let entries;
   try {
     entries = await fs.readdir(cacheDir);
@@ -332333,8 +332737,8 @@ async function scanOrphanedMarketplaces() {
     return [];
   }
   const config = await loadKnownMarketplacesConfigSafe();
-  const registered = new Set(Object.values(config).map((e) => resolve44(e.installLocation)));
-  const seedDirs = getPluginSeedDirs().map((d) => resolve44(d));
+  const registered = new Set(Object.values(config).map((e) => resolve45(e.installLocation)));
+  const seedDirs = getPluginSeedDirs().map((d) => resolve45(d));
   const orphans = [];
   for (const entry of entries) {
     if (!entry.isDirectory())
@@ -332372,7 +332776,7 @@ var init_orphanScanner = __esm(() => {
 
 // src/tui/utils/plugins/marketplaceManager.ts
 import { writeFile as writeFile28 } from "fs/promises";
-import { basename as basename35, dirname as dirname62, isAbsolute as isAbsolute31, join as join118, resolve as resolve45, sep as sep26 } from "path";
+import { basename as basename35, dirname as dirname62, isAbsolute as isAbsolute31, join as join118, resolve as resolve46, sep as sep26 } from "path";
 function getKnownMarketplacesFile() {
   return join118(getPluginsDirectory(), "known_marketplaces.json");
 }
@@ -332578,7 +332982,7 @@ function getPluginGitTimeoutMs() {
 }
 async function gitPull(cwd, ref, options) {
   logForDebugging3(`git pull: cwd=${cwd} ref=${ref ?? "default"}`);
-  const env = { ...process.env, ...GIT_NO_PROMPT_ENV3 };
+  const env = { ...process.env, ...GIT_NO_PROMPT_ENV4 };
   const credentialArgs = options?.disableCredentialHelper ? ["-c", "credential.helper="] : [];
   if (ref) {
     const fetchResult = await execFileNoThrowWithCwd2(gitExe2(), [...credentialArgs, "fetch", "origin", ref], { cwd, timeout: getPluginGitTimeoutMs(), stdin: "ignore", env });
@@ -332726,7 +333130,7 @@ async function gitClone(gitUrl, targetPath, ref, sparsePaths) {
   const result = await execFileNoThrowWithCwd2(gitExe2(), args, {
     timeout: timeoutMs,
     stdin: "ignore",
-    env: { ...process.env, ...GIT_NO_PROMPT_ENV3 }
+    env: { ...process.env, ...GIT_NO_PROMPT_ENV4 }
   });
   const redacted = redactUrlCredentials(gitUrl);
   if (gitUrl !== redacted) {
@@ -332741,7 +333145,7 @@ async function gitClone(gitUrl, targetPath, ref, sparsePaths) {
         cwd: targetPath,
         timeout: timeoutMs,
         stdin: "ignore",
-        env: { ...process.env, ...GIT_NO_PROMPT_ENV3 }
+        env: { ...process.env, ...GIT_NO_PROMPT_ENV4 }
       });
       if (sparseResult.code !== 0) {
         return {
@@ -332753,7 +333157,7 @@ async function gitClone(gitUrl, targetPath, ref, sparsePaths) {
         cwd: targetPath,
         timeout: timeoutMs,
         stdin: "ignore",
-        env: { ...process.env, ...GIT_NO_PROMPT_ENV3 }
+        env: { ...process.env, ...GIT_NO_PROMPT_ENV4 }
       });
       if (checkoutResult.code !== 0) {
         return {
@@ -332845,7 +333249,7 @@ function safeCallProgress(onProgress, message) {
   }
 }
 async function reconcileSparseCheckout(cwd, sparsePaths) {
-  const env = { ...process.env, ...GIT_NO_PROMPT_ENV3 };
+  const env = { ...process.env, ...GIT_NO_PROMPT_ENV4 };
   if (sparsePaths && sparsePaths.length > 0) {
     return execFileNoThrowWithCwd2(gitExe2(), ["sparse-checkout", "set", "--cone", "--", ...sparsePaths], { cwd, timeout: getPluginGitTimeoutMs(), stdin: "ignore", env });
   }
@@ -333170,14 +333574,14 @@ async function loadAndCacheMarketplace(source, onProgress) {
         break;
       }
       case "file": {
-        const absPath = resolve45(source.path);
+        const absPath = resolve46(source.path);
         marketplacePath = absPath;
         temporaryCachePath = dirname62(dirname62(absPath));
         cleanupNeeded = false;
         break;
       }
       case "directory": {
-        const absPath = resolve45(source.path);
+        const absPath = resolve46(source.path);
         marketplacePath = findManifestInDir(absPath, "marketplace.json");
         temporaryCachePath = absPath;
         cleanupNeeded = false;
@@ -333209,8 +333613,8 @@ async function loadAndCacheMarketplace(source, onProgress) {
       throw new Error(`Failed to parse marketplace file at ${marketplacePath}: ${errorMessage2(e)}`);
     }
     const finalCachePath = join118(cacheDir, marketplace.name);
-    const resolvedFinal = resolve45(finalCachePath);
-    const resolvedCacheDir = resolve45(cacheDir);
+    const resolvedFinal = resolve46(finalCachePath);
+    const resolvedCacheDir = resolve46(cacheDir);
     if (!resolvedFinal.startsWith(resolvedCacheDir + sep26)) {
       throw new Error(`Marketplace name '${marketplace.name}' resolves to a path outside the cache directory`);
     }
@@ -333259,7 +333663,7 @@ async function captureResolvedSha(source, cachePath) {
 async function addMarketplaceSource(source, onProgress) {
   let resolvedSource = source;
   if (isLocalMarketplaceSource(source) && !isAbsolute31(source.path)) {
-    resolvedSource = { ...source, path: resolve45(source.path) };
+    resolvedSource = { ...source, path: resolve46(source.path) };
   }
   if (!isSourceAllowedByPolicy(resolvedSource)) {
     if (isSourceInBlocklist(resolvedSource)) {
@@ -333308,9 +333712,9 @@ Tip: The shorthand "${resolvedSource.repo}" assumes github.com. ` + `For interna
       }
       logForDebugging3(`Marketplace '${marketplace.name}' exists with different source — overwriting`);
       if (!isLocalMarketplaceSource(oldEntry.source)) {
-        const cacheDir = resolve45(getMarketplacesCacheDir());
-        const resolvedOld = resolve45(oldEntry.installLocation);
-        const resolvedNew = resolve45(cachePath);
+        const cacheDir = resolve46(getMarketplacesCacheDir());
+        const resolvedOld = resolve46(oldEntry.installLocation);
+        const resolvedNew = resolve46(cachePath);
         if (resolvedOld === resolvedNew) {} else if (resolvedOld === cacheDir || resolvedOld.startsWith(cacheDir + sep26)) {
           const fs = getFsImplementation2();
           await fs.rm(oldEntry.installLocation, { recursive: true, force: true });
@@ -333332,7 +333736,7 @@ Tip: The shorthand "${resolvedSource.repo}" assumes github.com. ` + `For interna
 }
 async function adoptOrphanMarketplace(dirName, overrideName) {
   const fs = getFsImplementation2();
-  const cacheDir = resolve45(getMarketplacesCacheDir());
+  const cacheDir = resolve46(getMarketplacesCacheDir());
   const dirPath = join118(cacheDir, dirName);
   if (!fs.existsSync(dirPath) || !fs.statSync(dirPath).isDirectory()) {
     throw new Error(`No marketplace directory named '${dirName}' in ${cacheDir}. ` + `Run \`plugin marketplace list\` to see unregistered directories.`);
@@ -333362,7 +333766,7 @@ async function adoptOrphanMarketplace(dirName, overrideName) {
   await updateKnownMarketplacesConfig((existing) => {
     const prior = existing[name];
     if (prior) {
-      if (resolve45(prior.installLocation) === resolve45(dirPath)) {
+      if (resolve46(prior.installLocation) === resolve46(dirPath)) {
         return;
       }
       throw new Error(`Marketplace name '${name}' is already registered at ` + `${prior.installLocation}. Remove it first ` + `(\`plugin marketplace remove ${name}\`) or adopt under a different name.`);
@@ -333593,8 +333997,8 @@ async function refreshMarketplace(name, onProgress, options) {
       throw new Error(`Marketplace '${name}' is seed-managed (${seedDir}) and its content is ` + `controlled by the seed image. To update: ask your admin to update the seed.`);
     }
     if (!isLocalMarketplaceSource(source)) {
-      const cacheDir = resolve45(getMarketplacesCacheDir());
-      const resolvedLoc = resolve45(installLocation);
+      const cacheDir = resolve46(getMarketplacesCacheDir());
+      const resolvedLoc = resolve46(installLocation);
       if (resolvedLoc !== cacheDir && !resolvedLoc.startsWith(cacheDir + sep26)) {
         throw new Error(`Marketplace '${name}' has a corrupted installLocation ` + `(${installLocation}) — expected a path inside ${cacheDir}. ` + `This can happen after cross-platform path writes or manual edits ` + `to known_marketplaces.json. ` + `Run: claude plugin marketplace remove "${name}" and re-add it.`);
       }
@@ -333701,7 +334105,7 @@ async function setMarketplaceAutoUpdate(name, autoUpdate) {
   }
   logForDebugging3(`Set autoUpdate=${autoUpdate} for marketplace: ${name}`);
 }
-var knownMarketplacesRmwChain, GIT_NO_PROMPT_ENV3, DEFAULT_PLUGIN_GIT_TIMEOUT_MS, GIT_SHA_RE, getMarketplace;
+var knownMarketplacesRmwChain, GIT_NO_PROMPT_ENV4, DEFAULT_PLUGIN_GIT_TIMEOUT_MS, GIT_SHA_RE, getMarketplace;
 var init_marketplaceManager = __esm(() => {
   init_axios2();
   init_configDir();
@@ -333732,7 +334136,7 @@ var init_marketplaceManager = __esm(() => {
   init_pluginOptionsStorage();
   init_schemas3();
   knownMarketplacesRmwChain = Promise.resolve();
-  GIT_NO_PROMPT_ENV3 = {
+  GIT_NO_PROMPT_ENV4 = {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: ""
   };
@@ -334344,7 +334748,7 @@ var init_mtimeAwareMemoize = () => {};
 
 // src/tui/utils/plugins/installCounts.ts
 import { randomBytes as randomBytes15 } from "crypto";
-import { readFile as readFile42, rename as rename5, unlink as unlink16, writeFile as writeFile29 } from "fs/promises";
+import { readFile as readFile43, rename as rename5, unlink as unlink18, writeFile as writeFile29 } from "fs/promises";
 import { join as join120 } from "path";
 function normalizeStatsBase(raw) {
   if (!raw)
@@ -334385,7 +334789,7 @@ function getInstallCountsCachePath() {
 async function loadInstallCountsCache() {
   const cachePath = getInstallCountsCachePath();
   try {
-    const content = await readFile42(cachePath, { encoding: "utf-8" });
+    const content = await readFile43(cachePath, { encoding: "utf-8" });
     const parsed = jsonParse2(content);
     if (typeof parsed !== "object" || parsed === null || !("version" in parsed) || !("entries" in parsed)) {
       logForDebugging3("Install counts cache has invalid structure");
@@ -334431,7 +334835,7 @@ async function saveInstallCountsCache(cache) {
   } catch (error) {
     logError3(error);
     try {
-      await unlink16(tempPath);
+      await unlink18(tempPath);
     } catch {}
   }
 }
@@ -334598,14 +335002,14 @@ var init_pluginVersioning = __esm(() => {
 // src/tui/utils/plugins/pluginInstallationHelpers.ts
 import { randomBytes as randomBytes16 } from "crypto";
 import { rename as rename6, rm as rm8 } from "fs/promises";
-import { dirname as dirname64, join as join121, resolve as resolve46, sep as sep27 } from "path";
+import { dirname as dirname64, join as join121, resolve as resolve47, sep as sep27 } from "path";
 function getCurrentTimestamp() {
   return new Date().toISOString();
 }
 function validatePathWithinBase(basePath, relativePath) {
-  const resolvedPath = resolve46(basePath, relativePath);
-  const normalizedBase = resolve46(basePath) + sep27;
-  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve46(basePath)) {
+  const resolvedPath = resolve47(basePath, relativePath);
+  const normalizedBase = resolve47(basePath) + sep27;
+  if (!resolvedPath.startsWith(normalizedBase) && resolvedPath !== resolve47(basePath)) {
     throw new Error(`Path traversal detected: "${relativePath}" would escape the base directory`);
   }
   return resolvedPath;
@@ -334837,7 +335241,7 @@ var init_pluginInstallationHelpers = __esm(() => {
 import {
   copyFile as copyFile6,
   readdir as readdir24,
-  readFile as readFile43,
+  readFile as readFile44,
   readlink,
   realpath as realpath12,
   rename as rename7,
@@ -334846,7 +335250,7 @@ import {
   stat as stat40,
   symlink as symlink5
 } from "fs/promises";
-import { basename as basename36, dirname as dirname65, join as join122, relative as relative22, resolve as resolve47, sep as sep28 } from "path";
+import { basename as basename36, dirname as dirname65, join as join122, relative as relative22, resolve as resolve48, sep as sep28 } from "path";
 function getPluginCachePath() {
   return join122(getPluginsDirectory(), "cache");
 }
@@ -335237,7 +335641,7 @@ async function cachePlugin(source, options) {
   let manifest;
   if (await pathExists2(manifestPath)) {
     try {
-      const content = await readFile43(manifestPath, { encoding: "utf-8" });
+      const content = await readFile44(manifestPath, { encoding: "utf-8" });
       const parsed = jsonParse2(content);
       const result = PluginManifestSchema().safeParse(parsed);
       if (result.success) {
@@ -335261,7 +335665,7 @@ async function cachePlugin(source, options) {
     }
   } else if (await pathExists2(legacyManifestPath)) {
     try {
-      const content = await readFile43(legacyManifestPath, {
+      const content = await readFile44(legacyManifestPath, {
         encoding: "utf-8"
       });
       const parsed = jsonParse2(content);
@@ -335311,7 +335715,7 @@ async function loadPluginManifest(manifestPath, pluginName, source) {
     };
   }
   try {
-    const content = await readFile43(manifestPath, { encoding: "utf-8" });
+    const content = await readFile44(manifestPath, { encoding: "utf-8" });
     const parsedJson = jsonParse2(content);
     const result = PluginManifestSchema().safeParse(parsedJson);
     if (result.success) {
@@ -335337,7 +335741,7 @@ async function loadPluginHooks2(hooksConfigPath, pluginName) {
   if (!await pathExists2(hooksConfigPath)) {
     throw new Error(`Hooks file not found at ${hooksConfigPath} for plugin ${pluginName}. If the manifest declares hooks, the file must exist.`);
   }
-  const content = await readFile43(hooksConfigPath, { encoding: "utf-8" });
+  const content = await readFile44(hooksConfigPath, { encoding: "utf-8" });
   const rawHooksConfig = jsonParse2(content);
   const validatedPluginHooks = PluginHooksSchema().parse(rawHooksConfig);
   return validatedPluginHooks.hooks;
@@ -335640,7 +336044,7 @@ function parsePluginSettings(raw) {
 async function loadPluginSettings(pluginPath, manifest) {
   const settingsJsonPath = join122(pluginPath, "settings.json");
   try {
-    const content = await readFile43(settingsJsonPath, { encoding: "utf-8" });
+    const content = await readFile44(settingsJsonPath, { encoding: "utf-8" });
     const parsed = jsonParse2(content);
     if (isRecord(parsed)) {
       const filtered = parsePluginSettings(parsed);
@@ -336200,7 +336604,7 @@ async function loadSessionOnlyPlugins(sessionPluginPaths) {
   const errors = [];
   for (const [index, pluginPath] of sessionPluginPaths.entries()) {
     try {
-      const resolvedPath = resolve47(pluginPath);
+      const resolvedPath = resolve48(pluginPath);
       if (!await pathExists2(resolvedPath)) {
         logForDebugging3(`Plugin path does not exist: ${resolvedPath}, skipping`, { level: "warn" });
         errors.push({
@@ -341339,7 +341743,7 @@ __export(exports_permissionSetup, {
   verifyAutoModeGateAccess: () => verifyAutoModeGateAccess
 });
 import { relative as relative23 } from "path";
-import { resolve as resolve48 } from "path";
+import { resolve as resolve49 } from "path";
 function isDangerousBashPermission(toolName, ruleContent) {
   if (toolName !== BASH_TOOL_NAME2) {
     return false;
@@ -341611,7 +342015,7 @@ function isSymlinkTo2({
   originalCwd
 }) {
   const { resolvedPath: resolvedProcessPwd, isSymlink: isProcessPwdSymlink } = safeResolvePath3(getFsImplementation2(), processPwd);
-  return isProcessPwdSymlink ? resolvedProcessPwd === resolve48(originalCwd) : false;
+  return isProcessPwdSymlink ? resolvedProcessPwd === resolve49(originalCwd) : false;
 }
 function initialPermissionModeFromCLI2({
   permissionModeCli,
@@ -342670,7 +343074,7 @@ __export(exports_terminalSetup, {
   shouldOfferTerminalSetup: () => shouldOfferTerminalSetup
 });
 import { randomBytes as randomBytes18 } from "crypto";
-import { copyFile as copyFile7, mkdir as mkdir37, readFile as readFile44, writeFile as writeFile30 } from "fs/promises";
+import { copyFile as copyFile7, mkdir as mkdir37, readFile as readFile45, writeFile as writeFile30 } from "fs/promises";
 import { homedir as homedir31, platform as platform3 } from "os";
 import { dirname as dirname66, join as join124 } from "path";
 import { pathToFileURL as pathToFileURL8 } from "url";
@@ -342816,7 +343220,7 @@ async function installBindingsForVSCodeTerminal(editor = "VSCode", theme) {
     let keybindings = [];
     let fileExists = false;
     try {
-      content = await readFile44(keybindingsPath, {
+      content = await readFile45(keybindingsPath, {
         encoding: "utf-8"
       });
       fileExists = true;
@@ -342963,7 +343367,7 @@ chars = "\\u001B\\r"`;
   let configExists = false;
   for (const path of configPaths) {
     try {
-      configContent = await readFile44(path, {
+      configContent = await readFile45(path, {
         encoding: "utf-8"
       });
       configPath = path;
@@ -343025,7 +343429,7 @@ async function installBindingsForZed(theme) {
     let keymapContent = "[]";
     let fileExists = false;
     try {
-      keymapContent = await readFile44(keymapPath, {
+      keymapContent = await readFile45(keymapPath, {
         encoding: "utf-8"
       });
       fileExists = true;
@@ -343097,7 +343501,7 @@ var init_terminalSetup = __esm(() => {
 
 // src/tui/utils/pasteStore.ts
 import { createHash as createHash10 } from "crypto";
-import { mkdir as mkdir38, readdir as readdir25, readFile as readFile45, stat as stat42, unlink as unlink17, writeFile as writeFile31 } from "fs/promises";
+import { mkdir as mkdir38, readdir as readdir25, readFile as readFile46, stat as stat42, unlink as unlink19, writeFile as writeFile31 } from "fs/promises";
 import { join as join125 } from "path";
 function getPasteStoreDir() {
   return join125(getAtlasConfigHomeDir3(), PASTE_STORE_DIR);
@@ -343122,7 +343526,7 @@ async function storePastedText(hash, content) {
 async function retrievePastedText(hash) {
   try {
     const pastePath = getPastePath(hash);
-    return await readFile45(pastePath, { encoding: "utf8" });
+    return await readFile46(pastePath, { encoding: "utf8" });
   } catch (error) {
     if (!isENOENT2(error)) {
       logForDebugging3(`Failed to retrieve paste ${hash}: ${error}`);
@@ -343147,7 +343551,7 @@ async function cleanupOldPastes(cutoffDate) {
     try {
       const stats = await stat42(filePath);
       if (stats.mtimeMs < cutoffTime) {
-        await unlink17(filePath);
+        await unlink19(filePath);
         logForDebugging3(`Cleaned up old paste: ${filePath}`);
       }
     } catch {}
@@ -347209,7 +347613,7 @@ var init_btw2 = __esm(() => {
 });
 
 // src/tui/components/Feedback.tsx
-import { readFile as readFile46, stat as stat43 } from "fs/promises";
+import { readFile as readFile47, stat as stat43 } from "fs/promises";
 function redactSensitiveInfo(text) {
   let redacted = text;
   redacted = redacted.replace(/"(sk-ant[^\s"']{24,})"/g, '"[REDACTED_API_KEY]"');
@@ -347248,7 +347652,7 @@ async function loadRawTranscriptJsonl() {
       });
       return null;
     }
-    return await readFile46(transcriptPath, "utf-8");
+    return await readFile47(transcriptPath, "utf-8");
   } catch {
     return null;
   }
@@ -351081,7 +351485,7 @@ var init_localInstaller = __esm(() => {
 });
 
 // src/tui/utils/shellConfig.ts
-import { open as open14, readFile as readFile47, stat as stat44 } from "fs/promises";
+import { open as open14, readFile as readFile48, stat as stat44 } from "fs/promises";
 import { homedir as osHomedir } from "os";
 import { join as join132 } from "path";
 function getShellConfigPaths(options) {
@@ -351116,7 +351520,7 @@ function filterAtlasAliases(lines) {
 }
 async function readFileLines(filePath) {
   try {
-    const content = await readFile47(filePath, { encoding: "utf8" });
+    const content = await readFile48(filePath, { encoding: "utf8" });
     return content.split(`
 `);
   } catch (e) {
@@ -351459,7 +351863,7 @@ var init_autoUpdater = __esm(() => {
 });
 
 // src/tui/utils/nativeInstaller/packageManagers.ts
-import { readFile as readFile48 } from "fs/promises";
+import { readFile as readFile49 } from "fs/promises";
 function isDistroFamily(osRelease, families) {
   return families.includes(osRelease.id) || osRelease.idLike.some((like) => families.includes(like));
 }
@@ -351517,7 +351921,7 @@ var init_packageManagers = __esm(() => {
   init_platform3();
   getOsRelease = memoize_default(async () => {
     try {
-      const content = await readFile48("/etc/os-release", "utf8");
+      const content = await readFile49("/etc/os-release", "utf8");
       const idMatch = content.match(/^ID=["']?(\S+?)["']?\s*$/m);
       const idLikeMatch = content.match(/^ID_LIKE=["']?(.+?)["']?\s*$/m);
       return {
@@ -351638,7 +352042,7 @@ var init_packageManagers = __esm(() => {
 });
 
 // src/tui/utils/doctorDiagnostic.ts
-import { readFile as readFile49, realpath as realpath13 } from "fs/promises";
+import { readFile as readFile50, realpath as realpath13 } from "fs/promises";
 import { homedir as homedir33 } from "os";
 import { delimiter as delimiter2, join as join134, posix as posix8, win32 as win322 } from "path";
 function getNormalizedPaths() {
@@ -351794,7 +352198,7 @@ async function detectMultipleInstallations() {
 async function detectConfigurationIssues(type) {
   const warnings = [];
   try {
-    const raw = await readFile49(join134(getManagedFilePath(), "managed-settings.json"), "utf-8");
+    const raw = await readFile50(join134(getManagedFilePath(), "managed-settings.json"), "utf-8");
     const parsed = jsonParse2(raw);
     const field = parsed && typeof parsed === "object" ? parsed.strictPluginOnlyCustomization : undefined;
     if (field !== undefined && typeof field !== "boolean") {
@@ -352293,7 +352697,7 @@ import {
   access as access5,
   chmod as chmod7,
   copyFile as copyFile8,
-  lstat as lstat6,
+  lstat as lstat8,
   mkdir as mkdir40,
   readdir as readdir26,
   readlink as readlink2,
@@ -352303,11 +352707,11 @@ import {
   rmdir as rmdir2,
   stat as stat45,
   symlink as symlink6,
-  unlink as unlink18,
+  unlink as unlink20,
   writeFile as writeFile36
 } from "fs/promises";
 import { homedir as homedir34 } from "os";
-import { basename as basename42, delimiter as delimiter3, dirname as dirname69, join as join137, resolve as resolve49 } from "path";
+import { basename as basename42, delimiter as delimiter3, dirname as dirname69, join as join137, resolve as resolve50 } from "path";
 function getPlatform4() {
   const os = env5.platform;
   const arch = process.arch === "x64" ? "x64" : process.arch === "arm64" ? "arm64" : null;
@@ -352435,7 +352839,7 @@ async function atomicMoveToInstallPath(stagedBinaryPath, installPath) {
     logForDebugging3(`Atomically installed binary to ${installPath}`);
   } catch (error) {
     try {
-      await unlink18(tempInstallPath);
+      await unlink20(tempInstallPath);
     } catch {}
     throw error;
   }
@@ -352610,7 +353014,7 @@ async function updateSymlink(symlinkPath, targetPath) {
         try {
           await copyFile8(targetPath, symlinkPath);
           try {
-            await unlink18(oldFileName);
+            await unlink20(oldFileName);
           } catch {}
         } catch (copyError) {
           try {
@@ -352655,13 +353059,13 @@ async function updateSymlink(symlinkPath, targetPath) {
     if (symlinkExists) {
       try {
         const currentTarget = await readlink2(symlinkPath);
-        const resolvedCurrentTarget = resolve49(dirname69(symlinkPath), currentTarget);
-        const resolvedTargetPath = resolve49(targetPath);
+        const resolvedCurrentTarget = resolve50(dirname69(symlinkPath), currentTarget);
+        const resolvedTargetPath = resolve50(targetPath);
         if (resolvedCurrentTarget === resolvedTargetPath) {
           return false;
         }
       } catch {}
-      await unlink18(symlinkPath);
+      await unlink20(symlinkPath);
     }
   } catch (error) {
     logError3(new Error(`Failed to check/remove existing symlink: ${error}`));
@@ -352674,7 +353078,7 @@ async function updateSymlink(symlinkPath, targetPath) {
     return true;
   } catch (error) {
     try {
-      await unlink18(tempSymlink);
+      await unlink20(tempSymlink);
     } catch {}
     logError3(new Error(`Failed to create symlink from ${symlinkPath} to ${targetPath}: ${error}`));
     return false;
@@ -352696,7 +353100,7 @@ async function checkInstall(force = false) {
   const dirs = getBaseDirectories();
   const messages = [];
   const localBinDir = dirname69(dirs.executable);
-  const resolvedLocalBinPath = resolve49(localBinDir);
+  const resolvedLocalBinPath = resolve50(localBinDir);
   const platform = getPlatform4();
   const isWindows = platform.startsWith("win32");
   try {
@@ -352719,7 +353123,7 @@ async function checkInstall(force = false) {
   } else {
     try {
       const target = await readlink2(dirs.executable);
-      const absoluteTarget = resolve49(dirname69(dirs.executable), target);
+      const absoluteTarget = resolve50(dirname69(dirs.executable), target);
       if (!await isPossibleClaudeBinary(absoluteTarget)) {
         messages.push({
           message: `AtlasCode symlink points to missing or invalid binary: ${target}`,
@@ -352747,7 +353151,7 @@ async function checkInstall(force = false) {
   }
   const isInCurrentPath = (process.env.PATH || "").split(delimiter3).some((entry) => {
     try {
-      const resolvedEntry = resolve49(entry);
+      const resolvedEntry = resolve50(entry);
       if (isWindows) {
         return resolvedEntry.toLowerCase() === resolvedLocalBinPath.toLowerCase();
       }
@@ -352826,7 +353230,7 @@ async function installLatestImpl(channelOrVersion, forceReinstall = false) {
 async function getVersionFromSymlink(symlinkPath) {
   try {
     const target = await readlink2(symlinkPath);
-    const absoluteTarget = resolve49(dirname69(symlinkPath), target);
+    const absoluteTarget = resolve50(dirname69(symlinkPath), target);
     if (await isPossibleClaudeBinary(absoluteTarget)) {
       return absoluteTarget;
     }
@@ -352842,7 +353246,7 @@ async function lockCurrentVersion() {
   if (!process.execPath.includes(dirs.versions)) {
     return;
   }
-  const versionPath = resolve49(process.execPath);
+  const versionPath = resolve50(process.execPath);
   try {
     const lockfilePath = getLockFilePathFromVersionPath(dirs, versionPath);
     await mkdir40(dirs.locks, { recursive: true });
@@ -352894,7 +353298,7 @@ async function forceRemoveLock(versionFilePath) {
   const dirs = getBaseDirectories();
   const lockfilePath = getLockFilePathFromVersionPath(dirs, versionFilePath);
   try {
-    await unlink18(lockfilePath);
+    await unlink20(lockfilePath);
     logForDebugging3(`Force-removed lock file at ${lockfilePath}`);
   } catch (error) {
     logForDebugging3(`Failed to force-remove lock file: ${errorMessage2(error)}`);
@@ -352913,7 +353317,7 @@ async function cleanupOldVersions() {
         if (!/atlas\.exe\.old\.\d+$/.test(file))
           continue;
         try {
-          await unlink18(join137(executableDir, file));
+          await unlink20(join137(executableDir, file));
           cleanedCount++;
         } catch {}
       }
@@ -352971,7 +353375,7 @@ async function cleanupOldVersions() {
       try {
         const stats = await stat45(entryPath);
         if (stats.mtime.getTime() < oneHourAgo) {
-          await unlink18(entryPath);
+          await unlink20(entryPath);
           tempFilesCleanedCount++;
           logForDebugging3(`Cleaned up orphaned temp install file: ${entry}`);
         }
@@ -352988,7 +353392,7 @@ async function cleanupOldVersions() {
       versionFiles.push({
         name: entry,
         path: entryPath,
-        resolvedPath: resolve49(entryPath),
+        resolvedPath: resolve50(entryPath),
         mtime: stats.mtime
       });
     } catch {}
@@ -353003,7 +353407,7 @@ async function cleanupOldVersions() {
     const currentBinaryPath = process.execPath;
     const protectedVersions = new Set;
     if (currentBinaryPath && currentBinaryPath.includes(dirs.versions)) {
-      protectedVersions.add(resolve49(currentBinaryPath));
+      protectedVersions.add(resolve50(currentBinaryPath));
     }
     const currentSymlinkVersion = await getVersionFromSymlink(dirs.executable);
     if (currentSymlinkVersion) {
@@ -353042,7 +353446,7 @@ async function cleanupOldVersions() {
     await Promise.all(versionsToDelete.map(async (version) => {
       try {
         const deleted = await tryWithVersionLock(version.path, async () => {
-          await unlink18(version.path);
+          await unlink20(version.path);
         });
         if (deleted) {
           deletedCount++;
@@ -353063,7 +353467,7 @@ async function cleanupOldVersions() {
 }
 async function isNpmSymlink(executablePath) {
   let targetPath = executablePath;
-  const stats = await lstat6(executablePath);
+  const stats = await lstat8(executablePath);
   if (stats.isSymbolicLink()) {
     targetPath = await realpath14(executablePath);
   }
@@ -353076,7 +353480,7 @@ async function removeInstalledSymlink() {
       logForDebugging3(`Skipping removal of ${dirs.executable} - appears to be npm-managed`);
       return;
     }
-    await unlink18(dirs.executable);
+    await unlink20(dirs.executable);
     logForDebugging3(`Removed atlas symlink at ${dirs.executable}`);
   } catch (error) {
     if (isENOENT2(error)) {
@@ -353131,7 +353535,7 @@ async function manualRemoveNpmPackage(packageName) {
     let manuallyRemoved = false;
     async function tryRemove(filePath, description) {
       try {
-        await unlink18(filePath);
+        await unlink20(filePath);
         logForDebugging3(`Manually removed ${description}: ${filePath}`);
         return true;
       } catch {
@@ -359487,7 +359891,7 @@ var init_useTurnDiffs = __esm(() => {
 });
 
 // src/tui/components/diff/DiffDetailView.tsx
-import { resolve as resolve50 } from "path";
+import { resolve as resolve51 } from "path";
 function DiffDetailView(t0) {
   const $ = import_compiler_runtime130.c(53);
   const {
@@ -359520,7 +359924,7 @@ function DiffDetailView(t0) {
     let content;
     let t2;
     if ($[1] !== filePath) {
-      const fullPath = resolve50(getCwd(), filePath);
+      const fullPath = resolve51(getCwd(), filePath);
       content = readFileSafe2(fullPath);
       t2 = content?.split(`
 `)[0] ?? null;
@@ -373034,7 +373438,7 @@ var init_mcp7 = __esm(() => {
 });
 
 // src/tui/utils/releaseNotes.ts
-import { mkdir as mkdir44, readFile as readFile50, writeFile as writeFile39 } from "fs/promises";
+import { mkdir as mkdir44, readFile as readFile51, writeFile as writeFile39 } from "fs/promises";
 import { dirname as dirname71, join as join140 } from "path";
 function getChangelogCachePath() {
   return join140(getAtlasConfigHomeDir3(), "cache", "changelog.md");
@@ -373084,7 +373488,7 @@ async function getStoredChangelog() {
   }
   const cachePath = getChangelogCachePath();
   try {
-    const content = await readFile50(cachePath, "utf-8");
+    const content = await readFile51(cachePath, "utf-8");
     changelogMemoryCache = content;
     return content;
   } catch {
@@ -391041,7 +391445,7 @@ __export(exports_thinkback, {
   call: () => call35,
   playAnimation: () => playAnimation
 });
-import { readFile as readFile51 } from "fs/promises";
+import { readFile as readFile52 } from "fs/promises";
 import { join as join143 } from "path";
 function getMarketplaceName() {
   return OFFICIAL_MARKETPLACE_NAME;
@@ -391070,7 +391474,7 @@ async function playAnimation(skillDir) {
   const dataPath = join143(skillDir, "year_in_review.js");
   const playerPath = join143(skillDir, "player.js");
   try {
-    await readFile51(dataPath);
+    await readFile52(dataPath);
   } catch (e) {
     if (isENOENT2(e)) {
       return {
@@ -391085,7 +391489,7 @@ async function playAnimation(skillDir) {
     };
   }
   try {
-    await readFile51(playerPath);
+    await readFile52(playerPath);
   } catch (e) {
     if (isENOENT2(e)) {
       return {
@@ -396164,7 +396568,7 @@ __export(exports_branch, {
   getUniqueForkName: () => getUniqueForkName
 });
 import { randomUUID as randomUUID39 } from "crypto";
-import { mkdir as mkdir45, readFile as readFile52, writeFile as writeFile40 } from "fs/promises";
+import { mkdir as mkdir45, readFile as readFile53, writeFile as writeFile40 } from "fs/promises";
 function deriveFirstPrompt(firstUserMessage) {
   const content = firstUserMessage?.message?.content;
   if (!content)
@@ -396183,7 +396587,7 @@ async function createFork(customTitle, target) {
   await mkdir45(projectDir, { recursive: true, mode: 448 });
   let transcriptContent;
   try {
-    transcriptContent = await readFile52(currentTranscriptPath);
+    transcriptContent = await readFile53(currentTranscriptPath);
   } catch {
     throw new Error("No conversation to branch");
   }
@@ -396505,7 +396909,7 @@ var init_types16 = __esm(() => {
 });
 
 // src/tui/components/agents/agentFileUtils.ts
-import { mkdir as mkdir46, open as open15, unlink as unlink19 } from "fs/promises";
+import { mkdir as mkdir46, open as open15, unlink as unlink21 } from "fs/promises";
 import { join as join145 } from "path";
 function formatAgentAsMarkdown(agentType, whenToUse, tools, systemPrompt, color, model, memory, effort) {
   const escapedWhenToUse = whenToUse.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\\\n");
@@ -396621,7 +397025,7 @@ async function deleteAgentFromFile(agent) {
   }
   const filePath = getActualAgentFilePath(agent);
   try {
-    await unlink19(filePath);
+    await unlink21(filePath);
   } catch (e) {
     const code = getErrnoCode2(e);
     if (code !== "ENOENT") {
@@ -402476,7 +402880,7 @@ var init_refresh = __esm(() => {
 
 // src/tui/utils/plugins/parseMarketplaceInput.ts
 import { homedir as homedir37 } from "os";
-import { resolve as resolve51 } from "path";
+import { resolve as resolve52 } from "path";
 function matchKnownGitHost(hostname) {
   const host = hostname.toLowerCase();
   for (const known of KNOWN_GIT_HOSTS) {
@@ -402528,7 +402932,7 @@ async function parseMarketplaceInput(input) {
   const isWindows = process.platform === "win32";
   const isWindowsPath = isWindows && (trimmed.startsWith(".\\") || trimmed.startsWith("..\\") || /^[a-zA-Z]:[/\\]/.test(trimmed));
   if (trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") || trimmed.startsWith("~") || isWindowsPath) {
-    const resolvedPath = resolve51(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir37()) : trimmed);
+    const resolvedPath = resolve52(trimmed.startsWith("~") ? trimmed.replace(/^~/, homedir37()) : trimmed);
     let stats;
     try {
       stats = await fs.stat(resolvedPath);
@@ -405493,7 +405897,7 @@ var init_DiscoverPlugins = __esm(() => {
 });
 
 // src/tui/utils/plugins/skillSearch.ts
-import { readdir as readdir27, readFile as readFile53, stat as stat46 } from "fs/promises";
+import { readdir as readdir27, readFile as readFile54, stat as stat46 } from "fs/promises";
 import { join as join146 } from "path";
 async function searchSkillsAcrossMarketplaces(query) {
   const config = await loadKnownMarketplacesConfig();
@@ -405541,7 +405945,7 @@ async function searchSkillsAcrossMarketplaces(query) {
           seen.add(skillFile);
           let content;
           try {
-            content = await readFile53(skillFile, { encoding: "utf-8" });
+            content = await readFile54(skillFile, { encoding: "utf-8" });
           } catch {
             continue;
           }
@@ -407036,7 +407440,7 @@ var init_ManageMarketplaces = __esm(() => {
 
 // src/tui/utils/plugins/pluginFlagging.ts
 import { randomBytes as randomBytes19 } from "crypto";
-import { readFile as readFile54, rename as rename10, unlink as unlink20, writeFile as writeFile41 } from "fs/promises";
+import { readFile as readFile55, rename as rename10, unlink as unlink22, writeFile as writeFile41 } from "fs/promises";
 import { join as join147 } from "path";
 function getFlaggedPluginsPath() {
   return join147(getPluginsDirectory(), FLAGGED_PLUGINS_FILENAME);
@@ -407063,7 +407467,7 @@ function parsePluginsData(content) {
 }
 async function readFromDisk() {
   try {
-    const content = await readFile54(getFlaggedPluginsPath(), {
+    const content = await readFile55(getFlaggedPluginsPath(), {
       encoding: "utf-8"
     });
     return parsePluginsData(content);
@@ -407086,7 +407490,7 @@ async function writeToDisk(plugins) {
   } catch (error) {
     logError3(error);
     try {
-      await unlink20(tempPath);
+      await unlink22(tempPath);
     } catch {}
   }
 }
@@ -410451,7 +410855,7 @@ async function createPluginReleaseTag(pluginId, explicitTag) {
       message: `Refusing to create tag '${resolved.got}': the plugin manifest declares version '${resolved.expected}'. Use 'plugin tag ${found.matchedId} --tag ${resolved.expected}' (or v${resolved.expected}).`
     };
   }
-  const gitEnv = { ...process.env, ...GIT_NO_PROMPT_ENV4 };
+  const gitEnv = { ...process.env, ...GIT_NO_PROMPT_ENV5 };
   const repoCheck = await execFileNoThrowWithCwd2(gitExe2(), ["rev-parse", "--git-dir"], {
     cwd: installPath,
     timeout: GIT_TIMEOUT_MS2,
@@ -410499,13 +410903,13 @@ async function createPluginReleaseTag(pluginId, explicitTag) {
     installPath
   };
 }
-var GIT_NO_PROMPT_ENV4, GIT_TIMEOUT_MS2 = 30000;
+var GIT_NO_PROMPT_ENV5, GIT_TIMEOUT_MS2 = 30000;
 var init_pluginTag = __esm(() => {
   init_fsOperations();
   init_git2();
   init_execFileNoThrow2();
   init_installedPluginsManager();
-  GIT_NO_PROMPT_ENV4 = {
+  GIT_NO_PROMPT_ENV5 = {
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: ""
   };
@@ -410579,7 +410983,7 @@ var init_TagPlugin = __esm(() => {
 });
 
 // src/tui/utils/plugins/validatePlugin.ts
-import { readdir as readdir29, readFile as readFile56, stat as stat48 } from "fs/promises";
+import { readdir as readdir29, readFile as readFile57, stat as stat48 } from "fs/promises";
 import * as path24 from "path";
 function detectManifestType(filePath) {
   const fileName = path24.basename(filePath);
@@ -410619,7 +411023,7 @@ async function validatePluginManifest(filePath) {
   const absolutePath = path24.resolve(filePath);
   let content;
   try {
-    content = await readFile56(absolutePath, { encoding: "utf-8" });
+    content = await readFile57(absolutePath, { encoding: "utf-8" });
   } catch (error) {
     const code = getErrnoCode2(error);
     let message;
@@ -410743,7 +411147,7 @@ async function validateMarketplaceManifest(filePath) {
   const absolutePath = path24.resolve(filePath);
   let content;
   try {
-    content = await readFile56(absolutePath, { encoding: "utf-8" });
+    content = await readFile57(absolutePath, { encoding: "utf-8" });
   } catch (error) {
     const code = getErrnoCode2(error);
     let message;
@@ -410829,7 +411233,7 @@ async function validateMarketplaceManifest(filePath) {
         const pluginJsonPath = findManifestInDir(path24.join(marketplaceRoot, entry.source), "plugin.json");
         let manifestVersion;
         try {
-          const raw = await readFile56(pluginJsonPath, { encoding: "utf-8" });
+          const raw = await readFile57(pluginJsonPath, { encoding: "utf-8" });
           const parsed = jsonParse2(raw);
           if (typeof parsed.version === "string") {
             manifestVersion = parsed.version;
@@ -410877,7 +411281,7 @@ async function validateMarketplaceManifest(filePath) {
         for (const skillFile of skillFiles) {
           let content;
           try {
-            content = await readFile56(skillFile, { encoding: "utf-8" });
+            content = await readFile57(skillFile, { encoding: "utf-8" });
           } catch (e) {
             if (isENOENT2(e))
               continue;
@@ -411004,7 +411408,7 @@ function validateComponentFile(filePath, content, fileType) {
 async function validateHooksJson(filePath) {
   let content;
   try {
-    content = await readFile56(filePath, { encoding: "utf-8" });
+    content = await readFile57(filePath, { encoding: "utf-8" });
   } catch (e) {
     const code = getErrnoCode2(e);
     if (code === "ENOENT") {
@@ -411097,7 +411501,7 @@ async function validatePluginContents(pluginDir) {
     for (const filePath of files) {
       let content;
       try {
-        content = await readFile56(filePath, { encoding: "utf-8" });
+        content = await readFile57(filePath, { encoding: "utf-8" });
       } catch (e) {
         if (isENOENT2(e))
           continue;
@@ -411166,7 +411570,7 @@ async function validateManifest(filePath) {
       return validateMarketplaceManifest(filePath);
     case "unknown": {
       try {
-        const content = await readFile56(absolutePath, { encoding: "utf-8" });
+        const content = await readFile57(absolutePath, { encoding: "utf-8" });
         const parsed = jsonParse2(content);
         if (Array.isArray(parsed.plugins)) {
           return validateMarketplaceManifest(filePath);
@@ -413301,7 +413705,7 @@ var init_rewind = __esm(() => {
 
 // src/tui/utils/heapDumpService.ts
 import { createWriteStream as createWriteStream3, writeFileSync as writeFileSync8 } from "fs";
-import { readdir as readdir30, readFile as readFile57, writeFile as writeFile42 } from "fs/promises";
+import { readdir as readdir30, readFile as readFile58, writeFile as writeFile42 } from "fs/promises";
 import { join as join152 } from "path";
 import { pipeline as pipeline2 } from "stream/promises";
 import {
@@ -413326,7 +413730,7 @@ async function captureMemoryDiagnostics(trigger, dumpNumber = 0) {
   } catch {}
   let smapsRollup;
   try {
-    smapsRollup = await readFile57("/proc/self/smaps_rollup", "utf8");
+    smapsRollup = await readFile58("/proc/self/smaps_rollup", "utf8");
   } catch {}
   const nativeMemory = usage.rss - usage.heapUsed;
   const bytesPerSecond = uptimeSeconds > 0 ? usage.rss / uptimeSeconds : 0;
@@ -414861,6 +415265,47 @@ var init_bundledSkills2 = __esm(() => {
   SAFE_WRITE_FLAGS2 = process.platform === "win32" ? "wx" : fsConstants8.O_WRONLY | fsConstants8.O_CREAT | fsConstants8.O_EXCL | O_NOFOLLOW3;
 });
 
+// src/tui/utils/worktreeChangeSummary.ts
+async function inspectWorktreeChanges(worktreePath, originalHeadCommit) {
+  try {
+    const status = await execFileNoThrow3(gitExe2(), [
+      "-C",
+      worktreePath,
+      "status",
+      "--porcelain"
+    ]);
+    if (status.code !== 0) {
+      return null;
+    }
+    const changedFiles = status.stdout.split(`
+`).filter((line) => line.trim() !== "").length;
+    if (!originalHeadCommit) {
+      return null;
+    }
+    const revList = await execFileNoThrow3(gitExe2(), [
+      "-C",
+      worktreePath,
+      "rev-list",
+      "--count",
+      `${originalHeadCommit}..HEAD`
+    ]);
+    if (revList.code !== 0) {
+      return null;
+    }
+    const commitsStr = revList.stdout.trim();
+    if (!/^\d+$/.test(commitsStr)) {
+      return null;
+    }
+    return { changedFiles, commits: parseInt(commitsStr, 10) };
+  } catch {
+    return null;
+  }
+}
+var init_worktreeChangeSummary = __esm(() => {
+  init_execFileNoThrow2();
+  init_git2();
+});
+
 // src/tui/components/WorktreeExitDialog.tsx
 function recordWorktreeExit() {
   (init_sessionStorage(), __toCommonJS(exports_sessionStorage)).saveWorktreeState(null);
@@ -414870,46 +415315,43 @@ function WorktreeExitDialog({
   onCancel
 }) {
   const [status, setStatus] = import_react166.useState("loading");
-  const [changes, setChanges] = import_react166.useState([]);
+  const [changedFiles, setChangedFiles] = import_react166.useState(0);
   const [commitCount, setCommitCount] = import_react166.useState(0);
+  const [stateUnknown, setStateUnknown] = import_react166.useState(false);
   const [resultMessage, setResultMessage] = import_react166.useState();
   const worktreeSession = getCurrentWorktreeSession2();
   import_react166.useEffect(() => {
     async function loadChanges() {
-      let changeLines = [];
-      const gitStatus = await execFileNoThrow3("git", ["status", "--porcelain"]);
-      if (gitStatus.stdout) {
-        changeLines = gitStatus.stdout.split(`
-`).filter((_) => _.trim() !== "");
-        setChanges(changeLines);
-      }
-      if (worktreeSession) {
-        const {
-          stdout: commitsStr
-        } = await execFileNoThrow3("git", ["rev-list", "--count", `${worktreeSession.originalHeadCommit}..HEAD`]);
-        const count = parseInt(commitsStr.trim()) || 0;
-        setCommitCount(count);
-        if (changeLines.length === 0 && count === 0) {
-          setStatus("removing");
-          cleanupWorktree2().then(() => {
-            process.chdir(worktreeSession.originalCwd);
-            setCwd2(worktreeSession.originalCwd);
-            recordWorktreeExit();
-            getPlansDirectory2.cache.clear?.();
-            setResultMessage("Worktree removed (no changes)");
-          }).catch((error) => {
-            logForDebugging3(`Failed to clean up worktree: ${error}`, {
-              level: "error"
-            });
-            setResultMessage("Worktree cleanup failed, exiting anyway");
-          }).then(() => {
-            setStatus("done");
+      if (!worktreeSession) {
+        return;
+      }
+      const summary = await inspectWorktreeChanges(worktreeSession.worktreePath, worktreeSession.originalHeadCommit);
+      if (summary === null) {
+        setStateUnknown(true);
+        setStatus("asking");
+        return;
+      }
+      setChangedFiles(summary.changedFiles);
+      setCommitCount(summary.commits);
+      if (summary.changedFiles === 0 && summary.commits === 0) {
+        setStatus("removing");
+        cleanupWorktree2().then(() => {
+          process.chdir(worktreeSession.originalCwd);
+          setCwd2(worktreeSession.originalCwd);
+          recordWorktreeExit();
+          getPlansDirectory2.cache.clear?.();
+          setResultMessage("Worktree removed (no changes)");
+        }).catch((error) => {
+          logForDebugging3(`Failed to clean up worktree: ${error}`, {
+            level: "error"
           });
-          return;
-        } else {
-          setStatus("asking");
-        }
+          setResultMessage("Worktree cleanup failed, exiting anyway");
+        }).then(() => {
+          setStatus("done");
+        });
+        return;
       }
+      setStatus("asking");
     }
     loadChanges();
   }, [worktreeSession]);
@@ -414976,11 +415418,13 @@ function WorktreeExitDialog({
         return;
       }
       const tmuxNote = hasTmux ? " Tmux session terminated." : "";
-      if (commitCount > 0 && changes.length > 0) {
+      if (stateUnknown) {
+        setResultMessage(`Worktree removed. Worktree state could not be verified before removal.${tmuxNote}`);
+      } else if (commitCount > 0 && changedFiles > 0) {
         setResultMessage(`Worktree removed. ${commitCount} ${commitCount === 1 ? "commit" : "commits"} and uncommitted changes were discarded.${tmuxNote}`);
       } else if (commitCount > 0) {
         setResultMessage(`Worktree removed. ${commitCount} ${commitCount === 1 ? "commit" : "commits"} on ${worktreeSession.worktreeBranch} ${commitCount === 1 ? "was" : "were"} discarded.${tmuxNote}`);
-      } else if (changes.length > 0) {
+      } else if (changedFiles > 0) {
         setResultMessage(`Worktree removed. Uncommitted changes were discarded.${tmuxNote}`);
       } else {
         setResultMessage(`Worktree removed.${tmuxNote}`);
@@ -415013,13 +415457,15 @@ function WorktreeExitDialog({
     }, undefined, true, undefined, this);
   }
   const branchName = worktreeSession.worktreeBranch;
-  const hasUncommitted = changes.length > 0;
+  const hasUncommitted = changedFiles > 0;
   const hasCommits = commitCount > 0;
   let subtitle = "";
-  if (hasUncommitted && hasCommits) {
-    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? "file" : "files"} and ${commitCount} ${commitCount === 1 ? "commit" : "commits"} on ${branchName}. All will be lost if you remove.`;
+  if (stateUnknown) {
+    subtitle = `Could not verify the worktree state at ${worktreeSession.worktreePath}. Keep it to stay safe, or remove it only if you are certain it holds no work.`;
+  } else if (hasUncommitted && hasCommits) {
+    subtitle = `You have ${changedFiles} uncommitted ${changedFiles === 1 ? "file" : "files"} and ${commitCount} ${commitCount === 1 ? "commit" : "commits"} on ${branchName}. All will be lost if you remove.`;
   } else if (hasUncommitted) {
-    subtitle = `You have ${changes.length} uncommitted ${changes.length === 1 ? "file" : "files"}. These will be lost if you remove the worktree.`;
+    subtitle = `You have ${changedFiles} uncommitted ${changedFiles === 1 ? "file" : "files"}. These will be lost if you remove the worktree.`;
   } else if (hasCommits) {
     subtitle = `You have ${commitCount} ${commitCount === 1 ? "commit" : "commits"} on ${branchName}. The branch will be deleted if you remove the worktree.`;
   } else {
@@ -415032,7 +415478,7 @@ function WorktreeExitDialog({
     }
     handleSelect("keep");
   }
-  const removeDescription = hasUncommitted || hasCommits ? "All changes and commits will be lost." : "Clean up the worktree directory.";
+  const removeDescription = stateUnknown ? "Unverified worktree — removal may discard work." : hasUncommitted || hasCommits ? "All changes and commits will be lost." : "Clean up the worktree directory.";
   const hasTmuxSession = Boolean(worktreeSession.tmuxSessionName);
   const options = hasTmuxSession ? [{
     label: "Keep worktree and tmux session",
@@ -415071,10 +415517,10 @@ var import_react166, jsx_dev_runtime303;
 var init_WorktreeExitDialog = __esm(() => {
   init_debug();
   init_ink2();
-  init_execFileNoThrow2();
   init_plans();
   init_Shell2();
   init_worktree4();
+  init_worktreeChangeSummary();
   init_select();
   init_Dialog();
   init_Spinner();
@@ -415133,7 +415579,7 @@ var init_ExitFlow = __esm(() => {
 });
 
 // src/tui/utils/concurrentSessions.ts
-import { chmod as chmod8, mkdir as mkdir48, readdir as readdir31, readFile as readFile58, unlink as unlink21, writeFile as writeFile43 } from "fs/promises";
+import { chmod as chmod8, mkdir as mkdir48, readdir as readdir31, readFile as readFile59, unlink as unlink23, writeFile as writeFile43 } from "fs/promises";
 import { join as join154 } from "path";
 function getSessionsDir() {
   return join154(getAtlasConfigHomeDir3(), "sessions");
@@ -415157,7 +415603,7 @@ async function registerSession2() {
   const pidFile = join154(dir, `${process.pid}.json`);
   registerCleanup3(async () => {
     try {
-      await unlink21(pidFile);
+      await unlink23(pidFile);
     } catch {}
   });
   try {
@@ -415189,7 +415635,7 @@ async function registerSession2() {
 async function updatePidFile(patch) {
   const pidFile = join154(getSessionsDir(), `${process.pid}.json`);
   try {
-    const data = jsonParse2(await readFile58(pidFile, "utf8"));
+    const data = jsonParse2(await readFile59(pidFile, "utf8"));
     await writeFile43(pidFile, jsonStringify5({ ...data, ...patch }));
   } catch (e) {
     logForDebugging3(`[concurrentSessions] updatePidFile failed: ${errorMessage2(e)}`);
@@ -415228,7 +415674,7 @@ async function countConcurrentSessions2() {
     if (isProcessRunning2(pid)) {
       count++;
     } else if (getPlatform3() !== "wsl") {
-      unlink21(join154(dir, file)).catch(() => {});
+      unlink23(join154(dir, file)).catch(() => {});
     }
   }
   return count;
@@ -417219,7 +417665,7 @@ var init_ansiToPng = __esm(() => {
 });
 
 // src/tui/utils/screenshotClipboard.ts
-import { mkdir as mkdir49, unlink as unlink22, writeFile as writeFile44 } from "fs/promises";
+import { mkdir as mkdir49, unlink as unlink24, writeFile as writeFile44 } from "fs/promises";
 import { tmpdir as tmpdir10 } from "os";
 import { join as join158 } from "path";
 async function copyAnsiToClipboard(ansiText, options) {
@@ -417231,7 +417677,7 @@ async function copyAnsiToClipboard(ansiText, options) {
     await writeFile44(pngPath, pngBuffer);
     const result = await copyPngToClipboard(pngPath);
     try {
-      await unlink22(pngPath);
+      await unlink24(pngPath);
     } catch {}
     return result;
   } catch (error) {
@@ -420344,8 +420790,8 @@ __export(exports_insights, {
 import {
   mkdir as mkdir50,
   readdir as readdir32,
-  readFile as readFile59,
-  unlink as unlink23,
+  readFile as readFile60,
+  unlink as unlink25,
   writeFile as writeFile45
 } from "fs/promises";
 import { extname as extname16, join as join160 } from "path";
@@ -420705,11 +421151,11 @@ async function formatTranscriptWithSummarization(log) {
 async function loadCachedFacets(sessionId) {
   const facetPath = join160(getFacetsDir(), `${sessionId}.json`);
   try {
-    const content = await readFile59(facetPath, { encoding: "utf-8" });
+    const content = await readFile60(facetPath, { encoding: "utf-8" });
     const parsed = jsonParse2(content);
     if (!isValidSessionFacets(parsed)) {
       try {
-        await unlink23(facetPath);
+        await unlink25(facetPath);
       } catch {}
       return null;
     }
@@ -420731,7 +421177,7 @@ async function saveFacets(facets) {
 async function loadCachedSessionMeta(sessionId) {
   const metaPath = join160(getSessionMetaDir(), `${sessionId}.json`);
   try {
-    const content = await readFile59(metaPath, { encoding: "utf-8" });
+    const content = await readFile60(metaPath, { encoding: "utf-8" });
     return jsonParse2(content);
   } catch {
     return null;
@@ -422787,12 +423233,12 @@ __export(exports_sessionStorage, {
 import { closeSync as closeSync7, fstatSync as fstatSync2, openSync as openSync7, readSync as readSync6 } from "fs";
 import {
   appendFile as fsAppendFile2,
-  open as fsOpen3,
+  open as fsOpen4,
   mkdir as mkdir51,
   readdir as readdir33,
-  readFile as readFile60,
+  readFile as readFile61,
   stat as stat49,
-  unlink as unlink24,
+  unlink as unlink26,
   writeFile as writeFile46
 } from "fs/promises";
 import { basename as basename48, dirname as dirname76, join as join161 } from "path";
@@ -422846,7 +423292,7 @@ async function writeAgentMetadata(agentId, metadata) {
 async function readAgentMetadata(agentId) {
   const path = getAgentMetadataPath(agentId);
   try {
-    const raw = await readFile60(path, "utf-8");
+    const raw = await readFile61(path, "utf-8");
     return JSON.parse(raw);
   } catch (e) {
     if (isFsInaccessible2(e))
@@ -422973,11 +423419,14 @@ class Project2 {
     }, this.FLUSH_INTERVAL_MS);
   }
   async appendToFile(filePath, data) {
+    const needsSeparator = await transcriptTailNeedsSeparator2(filePath);
+    const payload = needsSeparator ? `
+` + data : data;
     try {
-      await fsAppendFile2(filePath, data, { mode: 384 });
+      await fsAppendFile2(filePath, payload, { mode: 384 });
     } catch {
       await mkdir51(dirname76(filePath), { recursive: true, mode: 448 });
-      await fsAppendFile2(filePath, data, { mode: 384 });
+      await fsAppendFile2(filePath, payload, { mode: 384 });
     }
   }
   async drainWriteQueue() {
@@ -423140,7 +423589,7 @@ class Project2 {
         return;
       try {
         let fileSize = 0;
-        const fh = await fsOpen3(this.sessionFile, "r+");
+        const fh = await fsOpen4(this.sessionFile, "r+");
         try {
           const { size } = await fh.stat();
           fileSize = size;
@@ -423175,7 +423624,7 @@ class Project2 {
           logForDebugging3(`Skipping tombstone removal: session file too large (${formatFileSize3(fileSize)})`, { level: "warn" });
           return;
         }
-        const content = await readFile60(this.sessionFile, { encoding: "utf-8" });
+        const content = await readFile61(this.sessionFile, { encoding: "utf-8" });
         const lines = content.split(`
 `).filter((line) => {
           if (!line.trim())
@@ -423875,11 +424324,13 @@ function appendEntryToFile2(fullPath, entry) {
   const fs = getFsImplementation2();
   const line = jsonStringify5(entry) + `
 `;
+  const payload = transcriptTailNeedsSeparatorSync2(fullPath) ? `
+` + line : line;
   try {
-    fs.appendFileSync(fullPath, line, { mode: 384 });
+    fs.appendFileSync(fullPath, payload, { mode: 384 });
   } catch {
     fs.mkdirSync(dirname76(fullPath), { mode: 448 });
-    fs.appendFileSync(fullPath, line, { mode: 384 });
+    fs.appendFileSync(fullPath, payload, { mode: 384 });
   }
 }
 function readFileTailSync2(fullPath) {
@@ -423901,6 +424352,42 @@ function readFileTailSync2(fullPath) {
     }
   }
 }
+async function transcriptTailNeedsSeparator2(fullPath) {
+  let fh;
+  try {
+    const st = await stat49(fullPath);
+    if (!st.isFile() || st.size === 0)
+      return false;
+    fh = await fsOpen4(fullPath, "r");
+    const buf = Buffer.alloc(1);
+    const { bytesRead } = await fh.read(buf, 0, 1, st.size - 1);
+    return bytesRead === 1 && buf[0] !== 10;
+  } catch {
+    return false;
+  } finally {
+    await fh?.close().catch(() => {});
+  }
+}
+function transcriptTailNeedsSeparatorSync2(fullPath) {
+  let fd;
+  try {
+    fd = openSync7(fullPath, "r");
+    const st = fstatSync2(fd);
+    if (st.size === 0)
+      return false;
+    const buf = Buffer.alloc(1);
+    const bytesRead = readSync6(fd, buf, 0, 1, st.size - 1);
+    return bytesRead === 1 && buf[0] !== 10;
+  } catch {
+    return false;
+  } finally {
+    if (fd !== undefined) {
+      try {
+        closeSync7(fd);
+      } catch {}
+    }
+  }
+}
 async function saveCustomTitle(sessionId, customTitle, fullPath, source = "user") {
   const resolvedPath = fullPath ?? getTranscriptPathForSession3(sessionId);
   appendEntryToFile2(resolvedPath, {
@@ -424388,7 +424875,7 @@ async function loadTranscriptFile2(filePath, opts) {
         }
       }
     }
-    buf ??= await readFile60(filePath);
+    buf ??= await readFile61(filePath);
     if (!opts?.keepAllLeaves && !hasPreservedSegment && !isEnvTruthy2(process.env.ATLAS_DISABLE_PRECOMPACT_SKIP) && buf.length > SKIP_PRECOMPACT_THRESHOLD2) {
       buf = walkChainBeforeParse2(buf);
     }
@@ -425318,7 +425805,7 @@ var init_sessionStorage = __esm(() => {
 // src/tui/utils/plans.ts
 import { randomUUID as randomUUID40 } from "crypto";
 import { copyFile as copyFile9, writeFile as writeFile47 } from "fs/promises";
-import { join as join162, resolve as resolve54, sep as sep35 } from "path";
+import { join as join162, resolve as resolve55, sep as sep35 } from "path";
 function getPlanSlug2(sessionId) {
   const id = sessionId ?? getSessionId();
   const cache = getPlanSlugCache();
@@ -425528,7 +426015,7 @@ var init_plans = __esm(() => {
     let plansPath;
     if (settingsDir) {
       const cwd = getCwd();
-      const resolved = resolve54(cwd, settingsDir);
+      const resolved = resolve55(cwd, settingsDir);
       if (!resolved.startsWith(cwd + sep35) && resolved !== cwd) {
         logError3(new Error(`plansDirectory must be within project root: ${settingsDir}`));
         plansPath = join162(getAtlasConfigHomeDir3(), "plans");
@@ -425550,7 +426037,7 @@ var init_plans = __esm(() => {
 // src/tui/utils/permissions/filesystem.ts
 import { randomBytes as randomBytes21 } from "crypto";
 import { homedir as homedir38, tmpdir as tmpdir11 } from "os";
-import { join as join163, normalize as normalize15, posix as posix9, resolve as resolve55, sep as sep36 } from "path";
+import { join as join163, normalize as normalize15, posix as posix9, resolve as resolve56, sep as sep36 } from "path";
 function normalizeCaseForComparison2(path) {
   return path.toLowerCase();
 }
@@ -425778,7 +426265,7 @@ function isActiveWorktreeCwd2(cwd) {
     });
     const gitdirMatch = content.match(/^gitdir:\s*(.+)$/m);
     if (gitdirMatch?.[1]) {
-      const gitdir = resolve55(cwd, gitdirMatch[1].trim());
+      const gitdir = resolve56(cwd, gitdirMatch[1].trim());
       active = gitdir.lastIndexOf(sep36 + ".git" + sep36 + "worktrees" + sep36) > 0;
     }
   } catch {
@@ -426490,7 +426977,7 @@ import {
   open as open19,
   stat as stat50,
   symlink as symlink7,
-  unlink as unlink25
+  unlink as unlink27
 } from "fs/promises";
 import { join as join164 } from "path";
 function getTaskOutputDir2() {
@@ -426672,7 +427159,7 @@ function initTaskOutputAsSymlink(taskId, targetPath) {
       try {
         await symlink7(targetPath, outputPath);
       } catch {
-        await unlink25(outputPath);
+        await unlink27(outputPath);
         await symlink7(targetPath, outputPath);
       }
       return outputPath;
@@ -433908,7 +434395,7 @@ var init_summarizeFallback = __esm(() => {
 });
 
 // src/tui/services/SessionMemory/prompts.ts
-import { readFile as readFile61 } from "fs/promises";
+import { readFile as readFile62 } from "fs/promises";
 import { join as join165 } from "path";
 function getDefaultUpdatePrompt() {
   return `IMPORTANT: This message and these instructions are NOT part of the actual user conversation. Do NOT include any references to "note-taking", "session notes extraction", or these update instructions in the notes content.
@@ -433952,7 +434439,7 @@ REMEMBER: Use the Edit tool in parallel and stop. Do not continue after the edit
 async function loadSessionMemoryTemplate() {
   const templatePath = join165(getAtlasConfigHomeDir3(), "session-memory", "config", "template.md");
   try {
-    return await readFile61(templatePath, { encoding: "utf-8" });
+    return await readFile62(templatePath, { encoding: "utf-8" });
   } catch (e) {
     const code = getErrnoCode2(e);
     if (code === "ENOENT") {
@@ -433965,7 +434452,7 @@ async function loadSessionMemoryTemplate() {
 async function loadSessionMemoryPrompt() {
   const promptPath = join165(getAtlasConfigHomeDir3(), "session-memory", "config", "prompt.md");
   try {
-    return await readFile61(promptPath, { encoding: "utf-8" });
+    return await readFile62(promptPath, { encoding: "utf-8" });
   } catch (e) {
     const code = getErrnoCode2(e);
     if (code === "ENOENT") {
@@ -452165,7 +452652,7 @@ var init_useUpdateNotification = __esm(() => {
 });
 
 // src/tui/utils/updateCheck.ts
-import { mkdir as mkdir53, readFile as readFile62, writeFile as writeFile48 } from "node:fs/promises";
+import { mkdir as mkdir53, readFile as readFile63, writeFile as writeFile48 } from "node:fs/promises";
 import { homedir as homedir40 } from "node:os";
 import { join as join169 } from "node:path";
 function buildUpdateUpgradeCommand() {
@@ -452194,7 +452681,7 @@ function createDiskUpdateCache(dir) {
   return {
     async read() {
       try {
-        const raw = await readFile62(getUpdateCachePath(dir), "utf8");
+        const raw = await readFile63(getUpdateCachePath(dir), "utf8");
         const parsed = JSON.parse(raw);
         if ((parsed.latest === null || typeof parsed.latest === "string") && typeof parsed.checkedAtMs === "number") {
           return { latest: parsed.latest, checkedAtMs: parsed.checkedAtMs };
@@ -469379,7 +469866,7 @@ var init_coordinatorHandler = __esm(() => {
 });
 
 // src/tui/utils/permissions/sessionPermissionRules.ts
-import { mkdir as mkdir54, readFile as readFile63, rename as rename11, writeFile as writeFile49 } from "fs/promises";
+import { mkdir as mkdir54, readFile as readFile64, rename as rename11, writeFile as writeFile49 } from "fs/promises";
 import { dirname as dirname80, join as join173 } from "path";
 function sessionRulesPath(sessionId, projectDir) {
   return join173(projectDir, `${sessionId}${SESSION_RULES_FILE_SUFFIX}`);
@@ -469420,7 +469907,7 @@ function isSessionAddRules(u) {
 }
 async function readSessionPermissionRules(sessionId, projectDir) {
   try {
-    const raw = await readFile63(sessionRulesPath(sessionId, projectDir), "utf8");
+    const raw = await readFile64(sessionRulesPath(sessionId, projectDir), "utf8");
     return parseSessionRulesJson(raw);
   } catch (e) {
     logForDebugging3(`readSessionPermissionRules: no/corrupt sidecar for ${sessionId}: ${e}`);
@@ -473716,11 +474203,11 @@ var init_builtinMarketplaceSnapshots = __esm(() => {
 // src/tui/utils/plugins/marketplaceSnapshotFallback.ts
 import {
   mkdir as mkdir55,
-  readFile as readFile64,
+  readFile as readFile65,
   rm as rm11,
   writeFile as writeFile50
 } from "fs/promises";
-import { join as join175, resolve as resolve57, sep as sep41 } from "path";
+import { join as join175, resolve as resolve58, sep as sep41 } from "path";
 function getBuiltinSnapshotRoot() {
   return join175(getMarketplacesCacheDir(), "builtin-snapshots");
 }
@@ -473732,7 +474219,7 @@ function isBuiltinSnapshotEntry(entry) {
     return false;
   if (entry.source.source !== "directory")
     return false;
-  const root = resolve57(getBuiltinSnapshotRoot()) + sep41;
+  const root = resolve58(getBuiltinSnapshotRoot()) + sep41;
   return entry.installLocation.startsWith(root);
 }
 async function installBuiltinSnapshotFallback(marketplaceName) {
@@ -473778,7 +474265,7 @@ async function materializeSnapshot(snapshotDir, manifest) {
   await mkdir55(join175(snapshotDir, manifestDirName), { recursive: true });
   const content = jsonStringify5(manifest, null, 2);
   await writeFile50(manifestPath, content, { encoding: "utf-8" });
-  const roundTrip = JSON.parse(await readFile64(manifestPath, "utf-8"));
+  const roundTrip = JSON.parse(await readFile65(manifestPath, "utf-8"));
   PluginMarketplaceSchema().parse(roundTrip);
 }
 var init_marketplaceSnapshotFallback = __esm(() => {
@@ -476253,7 +476740,7 @@ var init_usePluginAutoupdateNotification = __esm(() => {
 });
 
 // src/tui/utils/plugins/reconciler.ts
-import { isAbsolute as isAbsolute34, resolve as resolve58 } from "path";
+import { isAbsolute as isAbsolute34, resolve as resolve59 } from "path";
 function diffMarketplaces(declared, materialized, opts) {
   const missing = [];
   const sourceChanged = [];
@@ -476366,7 +476853,7 @@ function normalizeSource(source, projectRoot) {
     const canonicalRoot = findCanonicalGitRoot2(base);
     return {
       ...source,
-      path: resolve58(canonicalRoot ?? base, source.path)
+      path: resolve59(canonicalRoot ?? base, source.path)
     };
   }
   return source;
@@ -479358,7 +479845,7 @@ var init_cronJitterConfig2 = __esm(() => {
 });
 
 // src/tui/utils/cronTasksLock.ts
-import { mkdir as mkdir56, readFile as readFile65, unlink as unlink26, writeFile as writeFile51 } from "fs/promises";
+import { mkdir as mkdir56, readFile as readFile66, unlink as unlink28, writeFile as writeFile51 } from "fs/promises";
 import { dirname as dirname83, join as join178 } from "path";
 function getLockPath3(dir) {
   return join178(dir ?? getProjectRoot(), LOCK_FILE_REL2);
@@ -479366,7 +479853,7 @@ function getLockPath3(dir) {
 async function readLock3(dir) {
   let raw;
   try {
-    raw = await readFile65(getLockPath3(dir), "utf8");
+    raw = await readFile66(getLockPath3(dir), "utf8");
   } catch {
     return;
   }
@@ -479435,7 +479922,7 @@ async function tryAcquireSchedulerLock2(opts) {
   if (existing) {
     logForDebugging3(`[ScheduledTasks] recovering stale scheduler lock from PID ${existing.pid}`);
   }
-  await unlink26(getLockPath3(dir)).catch(() => {});
+  await unlink28(getLockPath3(dir)).catch(() => {});
   if (await tryCreateExclusive3(lock, dir)) {
     lastBlockedBy2 = undefined;
     registerLockCleanup3(opts);
@@ -479453,7 +479940,7 @@ async function releaseSchedulerLock2(opts) {
   if (!existing || existing.sessionId !== sessionId)
     return;
   try {
-    await unlink26(getLockPath3(dir));
+    await unlink28(getLockPath3(dir));
     logForDebugging3("[ScheduledTasks] released scheduler lock");
   } catch {}
 }
@@ -490697,6 +491184,7 @@ async function setup(cwd, permissionMode, allowDangerouslySkipPermissions, workt
     }
     const slug = worktreePRNumber ? `pr-${worktreePRNumber}` : worktreeName ?? getPlanSlug2();
     let tmuxSessionName;
+    let sourceCheckout;
     if (inGit) {
       const mainRepoRoot = findCanonicalGitRoot2(getCwd());
       if (!mainRepoRoot) {
@@ -490705,6 +491193,11 @@ async function setup(cwd, permissionMode, allowDangerouslySkipPermissions, workt
         process.exit(1);
       }
       if (mainRepoRoot !== (findGitRoot2(getCwd()) ?? getCwd())) {
+        const callingCwd = getCwd();
+        const headCommit = await readCheckoutHeadSha2(callingCwd);
+        if (headCommit) {
+          sourceCheckout = { cwd: callingCwd, headCommit };
+        }
         logForDiagnosticsNoPII("info", "worktree_resolved_to_main_repo");
         process.chdir(mainRepoRoot);
         setCwd2(mainRepoRoot);
@@ -490715,7 +491208,10 @@ async function setup(cwd, permissionMode, allowDangerouslySkipPermissions, workt
     }
     let worktreeSession;
     try {
-      worktreeSession = await createWorktreeForSession2(getSessionId(), slug, tmuxSessionName, worktreePRNumber ? { prNumber: worktreePRNumber } : undefined);
+      worktreeSession = await createWorktreeForSession2(getSessionId(), slug, tmuxSessionName, worktreePRNumber || sourceCheckout ? {
+        ...worktreePRNumber ? { prNumber: worktreePRNumber } : {},
+        ...sourceCheckout ? { sourceCheckout } : {}
+      } : undefined);
     } catch (error) {
       process.stderr.write(source_default.red(`Error creating worktree: ${errorMessage2(error)}
 `));
@@ -490817,6 +491313,7 @@ var init_setup4 = __esm(() => {
   init_envUtils2();
   init_errors4();
   init_git2();
+  init_gitFilesystem();
   init_fileChangedWatcher();
   init_hooksConfigSnapshot();
   init_hooks7();
@@ -491656,7 +492153,7 @@ var init_mcp8 = __esm(() => {
 });
 
 // src/tui/utils/atlasDesktop.ts
-import { readdir as readdir34, readFile as readFile66, stat as stat55 } from "fs/promises";
+import { readdir as readdir34, readFile as readFile67, stat as stat55 } from "fs/promises";
 import { homedir as homedir48 } from "os";
 import { join as join185 } from "path";
 async function getDesktopConfigPath() {
@@ -491704,7 +492201,7 @@ async function readDesktopMcpServers() {
     const configPath = await getDesktopConfigPath();
     let configContent;
     try {
-      configContent = await readFile66(configPath, { encoding: "utf8" });
+      configContent = await readFile67(configPath, { encoding: "utf8" });
     } catch (e) {
       const code = getErrnoCode2(e);
       if (code === "ENOENT") {
@@ -492145,12 +492642,12 @@ var init_auth6 = __esm(() => {
 });
 
 // src/tui/utils/plugins/marketplacePublish.ts
-import { cp, mkdir as mkdir57, readFile as readFile67, rm as rm12, writeFile as writeFile54 } from "fs/promises";
+import { cp, mkdir as mkdir57, readFile as readFile68, rm as rm12, writeFile as writeFile54 } from "fs/promises";
 import {
   dirname as dirname87,
   join as join186,
   relative as relative38,
-  resolve as resolve59,
+  resolve as resolve60,
   sep as sep43
 } from "path";
 function git(marketplaceDir, args, timeoutMs = 2 * 60 * 1000) {
@@ -492163,8 +492660,8 @@ function gitFailureMessage(res) {
   return (res.stderr || res.error || `exit code ${res.code}`).trim();
 }
 async function publishPluginToMarketplace(opts) {
-  const pluginDir = resolve59(opts.pluginDir);
-  const marketplaceDir = resolve59(opts.marketplaceDir);
+  const pluginDir = resolve60(opts.pluginDir);
+  const marketplaceDir = resolve60(opts.marketplaceDir);
   const notes = [];
   if (pluginDir === marketplaceDir || pluginDir.startsWith(marketplaceDir + sep43)) {
     throw new Error(`Cannot publish "${pluginDir}": the plugin directory must not live inside the target marketplace (${marketplaceDir})`);
@@ -492172,7 +492669,7 @@ async function publishPluginToMarketplace(opts) {
   const pluginManifestPath = findManifestInDir(pluginDir, "plugin.json");
   let pluginManifestRaw;
   try {
-    pluginManifestRaw = await readFile67(pluginManifestPath, {
+    pluginManifestRaw = await readFile68(pluginManifestPath, {
       encoding: "utf-8"
     });
   } catch {
@@ -492197,7 +492694,7 @@ async function publishPluginToMarketplace(opts) {
   const marketplaceManifestPath = findManifestInDir(marketplaceDir, "marketplace.json");
   let marketplaceRaw;
   try {
-    marketplaceRaw = await readFile67(marketplaceManifestPath, {
+    marketplaceRaw = await readFile68(marketplaceManifestPath, {
       encoding: "utf-8"
     });
   } catch {
@@ -492295,9 +492792,9 @@ var init_marketplacePublish = __esm(() => {
 import { userInfo as userInfo2 } from "os";
 import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir58, writeFile as writeFile55 } from "fs/promises";
-import { dirname as dirname88, join as join187, resolve as resolve60 } from "path";
+import { dirname as dirname88, join as join187, resolve as resolve61 } from "path";
 async function scaffoldMarketplace(opts) {
-  const targetDir = resolve60(opts.targetDir);
+  const targetDir = resolve61(opts.targetDir);
   const name = opts.name.trim();
   const manifestDirName = getPluginManifestDirs()[0];
   const marketplaceManifestPath = join187(targetDir, manifestDirName, "marketplace.json");
@@ -492383,7 +492880,7 @@ var init_marketplaceScaffold = __esm(() => {
 });
 
 // src/tui/cli/handlers/plugins.ts
-import { basename as basename65, dirname as dirname89, resolve as resolve61 } from "path";
+import { basename as basename65, dirname as dirname89, resolve as resolve62 } from "path";
 function handleMarketplaceError(error, action) {
   logError3(error);
   cliError2(`${figures_default.cross} Failed to ${action}: ${errorMessage2(error)}`);
@@ -492735,7 +493232,7 @@ async function marketplaceUpdateHandler(name, options) {
 async function marketplaceScaffoldHandler(options) {
   if (options.cowork)
     setUseCoworkPlugins(true);
-  const targetDir = resolve61(options.target ?? process.cwd());
+  const targetDir = resolve62(options.target ?? process.cwd());
   try {
     const result = await scaffoldMarketplace({
       name: options.name,
@@ -492760,8 +493257,8 @@ async function marketplacePublishHandler(options) {
     setUseCoworkPlugins(true);
   try {
     const result = await publishPluginToMarketplace({
-      pluginDir: resolve61(options.plugin),
-      marketplaceDir: resolve61(options.marketplace),
+      pluginDir: resolve62(options.plugin),
+      marketplaceDir: resolve62(options.marketplace),
       version: options.version,
       push: options.push
     });
@@ -493979,7 +494476,7 @@ var init_update2 = __esm(() => {
 
 // src/tui/main.tsx
 import { readFileSync as readFileSync25 } from "fs";
-import { resolve as resolve62 } from "path";
+import { resolve as resolve63 } from "path";
 function logManagedSettings() {
   try {
     const policySettings = getSettingsForSource2("policySettings");
@@ -494556,12 +495053,12 @@ ${getTmuxInstallInstructions3()}
         process.exit(1);
       }
       try {
-        const filePath = resolve62(options.systemPromptFile);
+        const filePath = resolve63(options.systemPromptFile);
         systemPrompt = readFileSync25(filePath, "utf8");
       } catch (error) {
         const code = getErrnoCode2(error);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve62(options.systemPromptFile)}
+          process.stderr.write(source_default.red(`Error: System prompt file not found: ${resolve63(options.systemPromptFile)}
 `));
           process.exit(1);
         }
@@ -494578,12 +495075,12 @@ ${getTmuxInstallInstructions3()}
         process.exit(1);
       }
       try {
-        const filePath = resolve62(options.appendSystemPromptFile);
+        const filePath = resolve63(options.appendSystemPromptFile);
         appendSystemPrompt = readFileSync25(filePath, "utf8");
       } catch (error) {
         const code = getErrnoCode2(error);
         if (code === "ENOENT") {
-          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve62(options.appendSystemPromptFile)}
+          process.stderr.write(source_default.red(`Error: Append system prompt file not found: ${resolve63(options.appendSystemPromptFile)}
 `));
           process.exit(1);
         }
@@ -494633,7 +495130,7 @@ ${addendum}` : addendum;
             errors = result.errors;
           }
         } else {
-          const configPath = resolve62(configItem);
+          const configPath = resolve63(configItem);
           const result = parseMcpConfigFromFilePath({
             filePath: configPath,
             expandVars: true,
@@ -496280,7 +496777,7 @@ function createInMemorySandboxDeps() {
 // src/atlascode/adapters/sessionMemoryPortAdapter.ts
 init_engine();
 init_shared();
-import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile8 } from "fs/promises";
+import { mkdir as mkdir12, readFile as readFile14, writeFile as writeFile8 } from "fs/promises";
 import { dirname as dirname22, join as join41 } from "path";
 function sessionMemoryPath() {
   const env = getSessionEnv();
@@ -496290,7 +496787,7 @@ function createSessionMemoryPort() {
   return {
     async load() {
       try {
-        return await readFile13(sessionMemoryPath(), "utf-8");
+        return await readFile14(sessionMemoryPath(), "utf-8");
       } catch (e) {
         if (isFsInaccessible(e))
           return null;
@@ -496924,7 +497421,7 @@ function getAscendExecutor() {
   return _instance;
 }
 // src/ascend/tools/SpecParser.ts
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 
 // src/ascend/tools/constants.ts
 var SPEC_PARSER_TOOL_NAME = "AscendSpecParser";
@@ -496992,7 +497489,7 @@ var SpecParser = {
     let raw = inp.spec_source;
     let parsedFromFile = false;
     try {
-      const fileContent = await readFile14(inp.spec_source, "utf-8");
+      const fileContent = await readFile15(inp.spec_source, "utf-8");
       raw = fileContent;
       parsedFromFile = true;
     } catch {}