agent-workbench 0.8.0 → 0.8.1

package/dist/server.js

@@ -3,7 +3,7 @@
 // packages/server/src/index.ts
 import { existsSync as existsSync4 } from "node:fs";
 import { createServer } from "node:http";
-import path73 from "node:path";
+import path75 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import express from "express";
 
@@ -144,20 +144,25 @@ var WORKTREE_COPY_MAX_FILES = 2e3;
 var WORKTREE_COPY_MAX_BYTES = 50 * 1024 * 1024;
 var WORKTREE_COPY_SAMPLE = 8;
 var WORKTREE_CREATE_MODES = ["new", "existing"];
+var WORKTREE_HOLDERS_MAX = 8;
 var WORKTREE_PLAN_PATHS_MAX = 20;
+var WORKTREE_UNTRACKED_MAX_FILES = 2e4;
 var WORKTREE_ROW_FILES_MAX = 8;
 var WORKTREE_CHANGES_COMMITS_MAX = 50;
 var WORKTREE_CHANGES_FILES_MAX = 2e3;
 function asCommitId(value) {
   return typeof value === "string" && /^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(value) ? value : null;
 }
+function asUntrackedStamp(value) {
+  return typeof value === "string" && /^[0-9a-f]{64}$/.test(value) ? value : null;
+}
 function parseSessionWorktree(value) {
   const record = asRecord(value);
   if (record === null) return null;
   const branch = asNonEmptyString(record["branch"]);
-  const exists6 = asBoolean(record["exists"]);
-  if (branch === null || exists6 === null) return null;
-  return { branch, exists: exists6, reopenable: record["reopenable"] === true };
+  const exists7 = asBoolean(record["exists"]);
+  if (branch === null || exists7 === null) return null;
+  return { branch, exists: exists7, reopenable: record["reopenable"] === true };
 }
 function parseWorktreeSource(value) {
   const record = asRecord(value);
@@ -172,6 +177,16 @@ function parseWorktreeSource(value) {
   }
   return null;
 }
+var HOLDER_TEXT_MAX = 255;
+function parseWorktreeHolder(value) {
+  const record = asRecord(value);
+  if (record === null) return null;
+  const pid = asPositiveInt(record["pid"]);
+  const name = asNonEmptyString(record["name"]);
+  if (pid === null || name === null || name.length > HOLDER_TEXT_MAX) return null;
+  const description = asString(record["description"])?.trim() ?? "";
+  return { pid, name, description: description.length > 0 && description.length <= HOLDER_TEXT_MAX ? description : null };
+}
 
 // packages/shared/src/models.ts
 var SESSION_TITLE_SOURCES = [
@@ -1326,7 +1341,10 @@ function parseClientMessage(raw) {
       const requestId = asNonEmptyString(record["requestId"]);
       const worktreeId = asNonEmptyString(record["worktreeId"]);
       const discardConflicts = asBoolean(record["discardConflicts"]);
-      return requestId === null || worktreeId === null || discardConflicts === null ? null : { type: "worktree.remove", requestId, worktreeId, discardConflicts };
+      if (requestId === null || worktreeId === null || discardConflicts === null) return null;
+      const message = { type: "worktree.remove", requestId, worktreeId, discardConflicts };
+      const discardUntracked = asUntrackedStamp(record["discardUntracked"]);
+      return discardUntracked === null ? message : { ...message, discardUntracked };
     }
     case "worktree.reopen": {
       const requestId = asNonEmptyString(record["requestId"]);
@@ -1364,8 +1382,8 @@ function parseClientMessage(raw) {
     case "worktree.changesDiff": {
       const requestId = asNonEmptyString(record["requestId"]);
       const worktreeId = asNonEmptyString(record["worktreeId"]);
-      const path74 = asNonEmptyString(record["path"]);
-      return requestId === null || worktreeId === null || path74 === null ? null : { type: "worktree.changesDiff", requestId, worktreeId, path: path74 };
+      const path76 = asNonEmptyString(record["path"]);
+      return requestId === null || worktreeId === null || path76 === null ? null : { type: "worktree.changesDiff", requestId, worktreeId, path: path76 };
     }
     case "worktree.requestReview": {
       const requestId = asNonEmptyString(record["requestId"]);
@@ -5962,18 +5980,18 @@ var BranchTracker = class {
   }
   /** La linea y todas las de las que cuelga. */
   pathFrom(leaf) {
-    const path74 = /* @__PURE__ */ new Set();
+    const path76 = /* @__PURE__ */ new Set();
     let current = leaf;
-    while (current !== null && !path74.has(current)) {
+    while (current !== null && !path76.has(current)) {
       const node = this.nodes.get(current);
       if (node === void 0) break;
-      path74.add(current);
+      path76.add(current);
       current = node.parent;
     }
-    return path74;
+    return path76;
   }
   recompute() {
-    const path74 = this.pathFrom(this.leaf());
+    const path76 = this.pathFrom(this.leaf());
     const children = /* @__PURE__ */ new Map();
     for (const [uuid, node] of this.nodes) {
       const key = node.parent !== null && this.nodes.has(node.parent) ? node.parent : null;
@@ -5982,9 +6000,9 @@ var BranchTracker = class {
       else list.push(uuid);
     }
     const roots = [];
-    for (const uuid of children.get(null) ?? []) if (!path74.has(uuid)) roots.push(uuid);
-    for (const uuid of path74) {
-      for (const child of children.get(uuid) ?? []) if (!path74.has(child)) roots.push(child);
+    for (const uuid of children.get(null) ?? []) if (!path76.has(uuid)) roots.push(uuid);
+    for (const uuid of path76) {
+      for (const child of children.get(uuid) ?? []) if (!path76.has(child)) roots.push(child);
     }
     const hidden = /* @__PURE__ */ new Set();
     for (const root of roots) {
@@ -19299,8 +19317,8 @@ function buildContinuationMessage(input) {
   }
   return sanitizeForPaste(lines.join("\n"));
 }
-function transcriptReferenceFor(path74, style) {
-  return style === "at-quoted" ? fileReference(path74, "at-quoted") : `"${path74}"`;
+function transcriptReferenceFor(path76, style) {
+  return style === "at-quoted" ? fileReference(path76, "at-quoted") : `"${path76}"`;
 }
 function planTranscript(input) {
   const turns = splitTurns(input.events);
@@ -21145,9 +21163,9 @@ function watchSessions(index, hub, agents, options = {}) {
     const probe = setInterval(() => {
       if (checking) return;
       checking = true;
-      void isDirectory3(root.path).then((exists6) => {
+      void isDirectory3(root.path).then((exists7) => {
         checking = false;
-        if (!exists6 || stopped || !probes.has(probe)) return;
+        if (!exists7 || stopped || !probes.has(probe)) return;
         clearInterval(probe);
         probes.delete(probe);
         watchRoot(agent, root, true);
@@ -21162,9 +21180,9 @@ function watchSessions(index, hub, agents, options = {}) {
         subscribeRoot(adapter.id, root, root.watch);
         continue;
       }
-      void isDirectory3(root.path).then((exists6) => {
+      void isDirectory3(root.path).then((exists7) => {
         if (stopped) return;
-        if (exists6) watchRoot(adapter.id, root, false);
+        if (exists7) watchRoot(adapter.id, root, false);
         else probeRoot(adapter.id, root);
       });
     }
@@ -22915,16 +22933,19 @@ async function searchFiles(cwd, query, folders, options = {}) {
     truncated: truncated || found.length > SEARCH_MAX_RESULTS
   };
 }
-async function existingFiles(cwd, relativePaths, folders) {
-  const existing = [];
+async function existingPaths(cwd, relativePaths, folders) {
+  const files = [];
+  const directories = [];
   for (const relativePath of relativePaths) {
     try {
       const absolute = await resolveForFiles(cwd, relativePath, folders);
-      if ((await stat37(absolute)).isFile()) existing.push(relativePath);
+      const info = await stat37(absolute);
+      if (info.isFile()) files.push(relativePath);
+      else if (info.isDirectory()) directories.push(relativePath);
     } catch {
     }
   }
-  return existing;
+  return { files, directories };
 }
 function contentHash(content) {
   return createHash4("sha256").update(content).digest("hex");
@@ -25055,12 +25076,12 @@ var VaultService = class {
 // packages/server/src/worktrees/service.ts
 import { randomBytes as randomBytes6, randomUUID as randomUUID7 } from "node:crypto";
 import { EventEmitter as EventEmitter7 } from "node:events";
-import { mkdir as mkdir22, rename as rename7, rm as rm9, rmdir, stat as stat44 } from "node:fs/promises";
-import path70 from "node:path";
+import { lstat as lstat5, mkdir as mkdir22, rename as rename7, rm as rm10, rmdir, stat as stat45 } from "node:fs/promises";
+import path72 from "node:path";
 
 // packages/server/src/worktrees/git.ts
 import { execFile as execFile6 } from "node:child_process";
-import { mkdtemp, rm as rm7 } from "node:fs/promises";
+import { mkdtemp, rm as rm7, stat as stat43 } from "node:fs/promises";
 import { tmpdir as tmpdir5 } from "node:os";
 import path65 from "node:path";
 var READ_TIMEOUT_MS = 15e3;
@@ -25073,7 +25094,7 @@ function run(cwd, args, options) {
   return new Promise((resolve, reject) => {
     const child = execFile6(
       "git",
-      ["-c", "core.quotepath=false", ...options.write ? [] : ["--no-optional-locks"], ...args],
+      ["-c", "core.quotepath=false", "-c", "core.longpaths=true", ...options.write ? [] : ["--no-optional-locks"], ...args],
       {
         cwd,
         timeout: options.write ? WRITE_TIMEOUT_MS : READ_TIMEOUT_MS,
@@ -25126,15 +25147,42 @@ async function localBranches(cwd) {
   return result.stdout.split(/\r?\n/).map((line) => branchOfRef(line.trim())).filter((branch) => branch !== null);
 }
 async function listWorktrees(cwd) {
+  return await readWorktreeList(cwd) ?? [];
+}
+async function readWorktreeList(cwd) {
   const result = await read(cwd, ["worktree", "list", "--porcelain", "-z"]);
-  return result.code === 0 ? parseWorktreeListZ(result.stdout) : [];
+  return result.code === 0 ? parseWorktreeListZ(result.stdout) : null;
 }
-async function uncommittedPaths(cwd) {
+async function uncommittedChanges(cwd) {
   const result = await read(cwd, ["status", "--porcelain=v2", "-z", "--untracked-files=normal"]);
   if (result.code !== 0) return null;
+  const parsed = parsePorcelainV2(result.stdout);
   const seen = /* @__PURE__ */ new Set();
-  for (const change of parsePorcelainV2(result.stdout).changes) seen.add(change.path);
-  return [...seen];
+  const untracked = [];
+  for (const change of parsed.changes) {
+    seen.add(change.path);
+    if (change.kind === "untracked") untracked.push(change.path);
+  }
+  return { paths: [...seen], untracked, complete: !parsed.truncated };
+}
+async function uncommittedPaths(cwd) {
+  return (await uncommittedChanges(cwd))?.paths ?? null;
+}
+async function hasLoadedSubmodule(cwd) {
+  const [modules, staged] = await Promise.all([read(cwd, ["rev-parse", "--git-path", "modules"]), read(cwd, ["ls-files", "--stage", "-z"])]);
+  if (modules.code !== 0 || staged.code !== 0) return null;
+  if (await isDirectory4(path65.resolve(cwd, modules.stdout.trim()))) return true;
+  const submodules = staged.stdout.split("\0").filter((line) => line.startsWith("160000 ")).map((line) => line.slice(line.indexOf("	") + 1));
+  for (const submodule of submodules) {
+    if (await exists4(path65.join(cwd, submodule, ".git"))) return true;
+  }
+  return false;
+}
+async function isDirectory4(candidate) {
+  return (await stat43(candidate).catch(() => null))?.isDirectory() === true;
+}
+async function exists4(candidate) {
+  return await stat43(candidate).catch(() => null) !== null;
 }
 async function isIntegrated(cwd, branch, base) {
   const result = await read(cwd, ["merge-base", "--is-ancestor", `refs/heads/${branch}`, `refs/heads/${base}`]);
@@ -25342,10 +25390,247 @@ function fastForward(baseFolder, target) {
   return run(baseFolder, fastForwardArgs(target), { write: true });
 }
 
+// packages/server/src/worktrees/holders.ts
+import { spawn as spawn4 } from "node:child_process";
+import path66 from "node:path";
+var SCAN_MAX_ENTRIES = 2e5;
+var SCAN_MAX_MS = 4e3;
+var HOLDERS_TIMEOUT_MS = 15e3;
+var OUTPUT_MAX_CHARS = 256 * 1024;
+var CSHARP = String.raw`
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+using Microsoft.Win32.SafeHandles;
+
+public static class AwFolderHolders {
+  [StructLayout(LayoutKind.Sequential)]
+  struct IoStatus { public IntPtr Status; public IntPtr Information; }
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct FindData {
+    public uint Attributes;
+    public uint Created1, Created2, Accessed1, Accessed2, Written1, Written2;
+    public uint SizeHigh, SizeLow, Reserved0, Reserved1;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string Name;
+    [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)] public string ShortName;
+  }
+
+  [DllImport("ntdll.dll")]
+  static extern int NtQueryInformationFile(SafeFileHandle file, out IoStatus status, IntPtr buffer, int length, int infoClass);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern SafeFileHandle CreateFileW(string name, uint access, uint share, IntPtr security, uint disposition, uint flags, IntPtr template);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern IntPtr FindFirstFileExW(string name, int level, out FindData data, int search, IntPtr filter, int flags);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool FindNextFileW(IntPtr find, out FindData data);
+  [DllImport("kernel32.dll")]
+  static extern bool FindClose(IntPtr find);
+  [DllImport("kernel32.dll", SetLastError = true)]
+  static extern IntPtr OpenProcess(uint access, bool inherit, int pid);
+  [DllImport("kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  static extern bool QueryFullProcessImageNameW(IntPtr process, int flags, StringBuilder name, ref int size);
+  [DllImport("kernel32.dll")]
+  static extern bool CloseHandle(IntPtr handle);
+
+  const uint ReadData = 0x1, ReadAttributes = 0x80, Delete = 0x10000, ShareAll = 7, OpenExisting = 3;
+  /* BACKUP_SEMANTICS abre carpetas; OPEN_REPARSE_POINT abre el enlace y no su destino. */
+  const uint OpenFlags = 0x02000000 | 0x00200000;
+  const int ProcessIdsUsingFile = 47, QueryLimited = 0x1000, MaxNamed = 32;
+  static readonly IntPtr NoFind = new IntPtr(-1);
+
+  static bool Taken(string path, bool top) {
+    using (SafeFileHandle file = CreateFileW(path, top ? Delete : ReadData, top ? ShareAll : 0, IntPtr.Zero, OpenExisting, OpenFlags, IntPtr.Zero)) {
+      if (!file.IsInvalid) return false;
+      int error = Marshal.GetLastWin32Error();
+      return error != 2 && error != 3;
+    }
+  }
+
+  static void Collect(string path, HashSet<int> seen, List<int> found, int self) {
+    using (SafeFileHandle file = CreateFileW(path, ReadAttributes, ShareAll, IntPtr.Zero, OpenExisting, OpenFlags, IntPtr.Zero)) {
+      if (file.IsInvalid) return;
+      for (int size = 4096; size <= 1 << 20; size *= 4) {
+        IntPtr buffer = Marshal.AllocHGlobal(size);
+        try {
+          IoStatus status;
+          int code = NtQueryInformationFile(file, out status, buffer, size, ProcessIdsUsingFile);
+          if (code == unchecked((int)0xC0000004) || code == unchecked((int)0x80000005)) continue;
+          if (code != 0) return;
+          int count = Marshal.ReadInt32(buffer);
+          if (IntPtr.Size * (count + 1) > size) continue;
+          for (int i = 0; i < count; i++) {
+            int pid = (int)Marshal.ReadIntPtr(buffer, IntPtr.Size * (i + 1)).ToInt64();
+            if (pid != self && seen.Add(pid)) found.Add(pid);
+          }
+          return;
+        } finally { Marshal.FreeHGlobal(buffer); }
+      }
+    }
+  }
+
+  static string Json(string value) {
+    if (value == null) return "null";
+    StringBuilder text = new StringBuilder("\"");
+    foreach (char c in value) {
+      if (c == '"' || c == '\\') text.Append('\\').Append(c);
+      else if (c < 0x20 || c > 0x7E) text.Append("\\u").Append(((int)c).ToString("x4"));
+      else text.Append(c);
+    }
+    return text.Append('"').ToString();
+  }
+
+  public static string Scan(string root, int maxEntries, int maxMs) {
+    Stopwatch clock = Stopwatch.StartNew();
+    int self = Process.GetCurrentProcess().Id;
+    HashSet<int> seen = new HashSet<int>();
+    List<int> found = new List<int>();
+    List<string> files = new List<string>();
+    Queue<string> dirs = new Queue<string>();
+    bool complete = true;
+    int entries = 0;
+    if (Taken(root, true)) Collect(root, seen, found, self);
+    dirs.Enqueue(root);
+    while (dirs.Count > 0) {
+      if (++entries > maxEntries || clock.ElapsedMilliseconds > maxMs) { complete = false; break; }
+      string dir = dirs.Dequeue();
+      if (dir != root && Taken(dir, false)) Collect(dir, seen, found, self);
+      FindData data;
+      IntPtr find = FindFirstFileExW(dir + "\\*", 1, out data, 0, IntPtr.Zero, 2);
+      if (find == NoFind) continue;
+      try {
+        do {
+          if (data.Name == "." || data.Name == "..") continue;
+          string child = dir + "\\" + data.Name;
+          if ((data.Attributes & 0x10) != 0 && (data.Attributes & 0x400) == 0) dirs.Enqueue(child);
+          else if (files.Count < maxEntries) files.Add(child);
+        } while (FindNextFileW(find, out data));
+      } finally { FindClose(find); }
+    }
+    if (complete) {
+      foreach (string file in files) {
+        if (++entries > maxEntries || clock.ElapsedMilliseconds > maxMs) { complete = false; break; }
+        if (Taken(file, false)) Collect(file, seen, found, self);
+      }
+    }
+    StringBuilder json = new StringBuilder("{\"complete\":");
+    json.Append(complete ? "true" : "false").Append(",\"ms\":").Append(clock.ElapsedMilliseconds).Append(",\"holders\":[");
+    int named = 0;
+    foreach (int pid in found) {
+      if (named >= MaxNamed) break;
+      string name = null, description = null;
+      IntPtr process = OpenProcess(QueryLimited, false, pid);
+      if (process != IntPtr.Zero) {
+        try {
+          StringBuilder image = new StringBuilder(32768);
+          int length = image.Capacity;
+          if (QueryFullProcessImageNameW(process, 0, image, ref length)) {
+            string full = image.ToString(0, length);
+            name = Path.GetFileName(full);
+            try { description = FileVersionInfo.GetVersionInfo(full).FileDescription; } catch { }
+          }
+        } finally { CloseHandle(process); }
+      }
+      if (name == null) {
+        try { name = pid == 4 ? "System" : Process.GetProcessById(pid).ProcessName + ".exe"; } catch { continue; }
+      }
+      json.Append(named++ == 0 ? "" : ",").Append("{\"pid\":").Append(pid).Append(",\"name\":").Append(Json(name))
+        .Append(",\"description\":").Append(Json(description)).Append('}');
+    }
+    return json.Append("]}").ToString();
+  }
+}
+`;
+function longPath(folder) {
+  const absolute = path66.win32.resolve(folder);
+  if (absolute.startsWith("\\\\?\\")) return absolute;
+  return absolute.startsWith("\\\\") ? `\\\\?\\UNC\\${absolute.slice(2)}` : `\\\\?\\${absolute}`;
+}
+function holdersScript(folder) {
+  const encoded = Buffer.from(longPath(folder), "utf8").toString("base64");
+  return [
+    "$ErrorActionPreference = 'Stop'",
+    `$source = @'
+${CSHARP}
+'@`,
+    "Add-Type -TypeDefinition $source",
+    `$root = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}'))`,
+    `[Console]::Out.WriteLine([AwFolderHolders]::Scan($root, ${SCAN_MAX_ENTRIES}, ${SCAN_MAX_MS}))`,
+    // Con `-Command -`, la última línea corre recién con la línea en blanco de después.
+    "",
+    ""
+  ].join("\n");
+}
+function parseHoldersOutput(output, selfPid) {
+  const line = output.split(/\r?\n/).map((candidate) => candidate.trim()).find((candidate) => candidate.startsWith('{"complete":'));
+  const record = line === void 0 ? null : asRecord(parseJson(line));
+  if (record === null || typeof record["complete"] !== "boolean" || !Array.isArray(record["holders"])) return null;
+  const holders = [];
+  let self = false;
+  for (const item of record["holders"]) {
+    const holder = parseWorktreeHolder(item);
+    if (holder === null || holders.some((other) => other.pid === holder.pid)) continue;
+    if (holder.pid === selfPid) self = true;
+    else if (holders.length < WORKTREE_HOLDERS_MAX) holders.push(holder);
+  }
+  return { holders, complete: record["complete"], self };
+}
+function powershellPath() {
+  const systemRoot = process.env["SystemRoot"] ?? process.env["windir"] ?? "C:\\Windows";
+  return path66.win32.join(systemRoot, "System32", "WindowsPowerShell", "v1.0", "powershell.exe");
+}
+function runPowerShell(script) {
+  return new Promise((resolve) => {
+    const child = spawn4(powershellPath(), ["-NoProfile", "-NonInteractive", "-Command", "-"], {
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    });
+    let output = "";
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(value);
+    };
+    const timer = setTimeout(() => {
+      child.kill();
+      finish(null);
+    }, HOLDERS_TIMEOUT_MS);
+    timer.unref();
+    child.stdout.setEncoding("utf8");
+    child.stdout.on("data", (chunk) => {
+      output += chunk;
+      if (output.length <= OUTPUT_MAX_CHARS) return;
+      child.kill();
+      finish(null);
+    });
+    child.on("error", () => finish(null));
+    child.on("close", () => finish(output));
+    child.stdin.on("error", () => void 0);
+    child.stdin.end(script);
+  });
+}
+async function folderHolders(folder) {
+  if (process.platform !== "win32") return [];
+  const output = await runPowerShell(holdersScript(folder));
+  const parsed = output === null ? null : parseHoldersOutput(output, process.pid);
+  if (parsed === null) {
+    console.warn(`[worktrees] couldn't tell which programs have ${folder} open`);
+    return [];
+  }
+  if (parsed.self) console.warn(`[worktrees] this server has ${folder} open`);
+  debugLog("worktrees", `holders of ${folder}: ${parsed.holders.length}, complete ${parsed.complete}`);
+  return parsed.holders;
+}
+
 // packages/server/src/worktrees/include.ts
 import { createHash as createHash6 } from "node:crypto";
 import { lstat as lstat3, mkdir as mkdir19, readdir as readdir19, readFile as readFile28, writeFile as writeFile11 } from "node:fs/promises";
-import path66 from "node:path";
+import path67 from "node:path";
 
 // packages/server/src/worktrees/merge-notes.ts
 var MERGE_MAX_EDITS = 2e3;
@@ -25521,7 +25806,7 @@ var CLI_CONFIG_DIRS = /* @__PURE__ */ new Set([".claude", ".codex", ".gemini", "
 var CLI_CONFIG_FILES = /* @__PURE__ */ new Set([".mcp.json", "opencode.json", "opencode.jsonc"]);
 var INCLUDE_FILE = ".worktreeinclude";
 var INCLUDE_FILE_MAX_BYTES = 64 * 1024;
-var toPosix2 = (value) => value.split(path66.sep).join("/");
+var toPosix2 = (value) => value.split(path67.sep).join("/");
 function hashOf(content) {
   return createHash6("sha256").update(content).digest("hex");
 }
@@ -25628,7 +25913,7 @@ async function copyToWorktree(mainRoot, folder, files, bases) {
       if (!info.isFile()) continue;
       content = await readFile28(source);
       const target = await resolveInside(folder, file.path);
-      await mkdir19(path66.dirname(target), { recursive: true });
+      await mkdir19(path67.dirname(target), { recursive: true });
       await writeFile11(target, content, { flag: "wx" });
       copied.push({ path: file.path, hash: hashOf(content) });
     } catch (error) {
@@ -25768,7 +26053,7 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
         result.skipped.push(file);
         continue;
       }
-      await mkdir19(path66.dirname(target), { recursive: true });
+      await mkdir19(path67.dirname(target), { recursive: true });
       await writeAtomically(target, outcome.content, {
         beforeRename: async () => {
           const now = await readInside(mainRoot, file);
@@ -25790,15 +26075,15 @@ async function returnNotes(mainRoot, folder, files, bases, options = {}) {
 }
 
 // packages/server/src/worktrees/names.ts
-import path67 from "node:path";
-function worktreeFolderFor(mainRoot, branch, pathApi = path67) {
+import path68 from "node:path";
+function worktreeFolderFor(mainRoot, branch, pathApi = path68) {
   const parent = pathApi.dirname(mainRoot);
   return pathApi.join(parent, worktreesDirName(pathApi.basename(mainRoot)), worktreeFolderName(branch));
 }
-function worktreesParentFor(mainRoot, pathApi = path67) {
+function worktreesParentFor(mainRoot, pathApi = path68) {
   return pathApi.join(pathApi.dirname(mainRoot), worktreesDirName(pathApi.basename(mainRoot)));
 }
-function mainRootFromShape(folder, pathApi = path67) {
+function mainRootFromShape(folder, pathApi = path68) {
   const parent = pathApi.dirname(folder);
   const parentName = pathApi.basename(parent);
   if (parentName.length > ".worktrees".length && parentName.toLowerCase().endsWith(".worktrees")) {
@@ -25813,8 +26098,8 @@ function mainRootFromShape(folder, pathApi = path67) {
 
 // packages/server/src/worktrees/note-bases.ts
 import { createHash as createHash7 } from "node:crypto";
-import { mkdir as mkdir20, readdir as readdir20, readFile as readFile29, rm as rm8, stat as stat43, utimes as utimes3 } from "node:fs/promises";
-import path68 from "node:path";
+import { mkdir as mkdir20, readdir as readdir20, readFile as readFile29, rm as rm8, stat as stat44, utimes as utimes3 } from "node:fs/promises";
+import path69 from "node:path";
 var TEXT_NOTE_EXTENSIONS = /* @__PURE__ */ new Set([".md", ".mdx", ".markdown", ".txt", ".rst", ".adoc"]);
 var NOTE_BASE_MAX_BYTES = 2 * 1024 * 1024;
 var PRUNE_GRACE_MS = 10 * 6e4;
@@ -25823,7 +26108,7 @@ function hashOf2(content) {
   return createHash7("sha256").update(content).digest("hex");
 }
 function keepsNoteBase(relative, content) {
-  return TEXT_NOTE_EXTENSIONS.has(path68.posix.extname(relative).toLowerCase()) && content.length <= NOTE_BASE_MAX_BYTES && !content.subarray(0, 8e3).includes(0);
+  return TEXT_NOTE_EXTENSIONS.has(path69.posix.extname(relative).toLowerCase()) && content.length <= NOTE_BASE_MAX_BYTES && !content.subarray(0, 8e3).includes(0);
 }
 var NoteBases = class {
   constructor(dir = worktreeNotesDir(), options = {}) {
@@ -25843,7 +26128,7 @@ var NoteBases = class {
   async save(relative, content) {
     if (!keepsNoteBase(relative, content)) return;
     const hash = hashOf2(content);
-    const file = path68.join(this.dir, hash);
+    const file = path69.join(this.dir, hash);
     const current = await readFile29(file).catch(() => null);
     if (current !== null && hashOf2(current) === hash) {
       const now = new Date(this.now());
@@ -25857,7 +26142,7 @@ var NoteBases = class {
   async load(hash) {
     if (!HASH.test(hash)) return null;
     try {
-      const content = await readFile29(path68.join(this.dir, hash));
+      const content = await readFile29(path69.join(this.dir, hash));
       return hashOf2(content) === hash ? content : null;
     } catch {
       return null;
@@ -25874,9 +26159,9 @@ var NoteBases = class {
     const now = this.now();
     for (const name of names) {
       if (!HASH.test(name) || keep.has(name)) continue;
-      const file = path68.join(this.dir, name);
+      const file = path69.join(this.dir, name);
       try {
-        const info = await stat43(file);
+        const info = await stat44(file);
         if (!info.isFile() || now - info.mtimeMs < this.graceMs) continue;
         await rm8(file, { force: true });
       } catch {
@@ -25929,7 +26214,7 @@ function catchUpPrompt(base, conflicts, uncommitted) {
 }
 function commitPrompt(files, count) {
   const more = count > files.length ? ` and ${count - files.length} more` : "";
-  return `This branch folder has uncommitted changes: ${files.join(", ")}${more}. Commit them with a clear message, or tell me first if any of them should be discarded instead. Don't push.`;
+  return `This branch folder has uncommitted changes: ${files.join(", ")}${more}. Commit them with a clear message. If any of them shouldn't be committed, leave it as it is and tell me which and why. Don't push.`;
 }
 function lastReplyText(events) {
   const textOf3 = (event2) => event2.parts.flatMap((part) => part.kind === "text" ? [part.text] : []).join("\n").trim();
@@ -25964,7 +26249,7 @@ function readVerdict(reply) {
 
 // packages/server/src/worktrees/store.ts
 import { mkdir as mkdir21, readFile as readFile30 } from "node:fs/promises";
-import path69 from "node:path";
+import path70 from "node:path";
 var STATE_VERSION5 = 1;
 var MAX_REMOVED = 300;
 var MAX_REVIEW_SESSIONS = 20;
@@ -26102,16 +26387,106 @@ var WorktreeStore = class {
     }
     const content = Buffer.from(JSON.stringify({ version: STATE_VERSION5, worktrees: this.records }, null, 2), "utf8");
     this.writing = this.writing.catch(() => void 0).then(async () => {
-      await mkdir21(path69.dirname(this.file), { recursive: true });
+      await mkdir21(path70.dirname(this.file), { recursive: true });
       await writeAtomically(this.file, content);
     });
     return this.writing;
   }
 };
 
+// packages/server/src/worktrees/untracked.ts
+import { createHash as createHash8 } from "node:crypto";
+import { lstat as lstat4, readdir as readdir21, realpath as realpath7, rm as rm9 } from "node:fs/promises";
+import path71 from "node:path";
+var sameName = (a, b) => a.toLowerCase() === b.toLowerCase();
+function cleanEntry(entry) {
+  const clean = entry.replace(/\/+$/, "");
+  if (clean.length === 0 || clean.includes("\\")) return null;
+  const parts = clean.split("/");
+  return parts.some((part) => part.length === 0 || part === "." || part === ".." || sameName(part, ".git")) ? null : clean;
+}
+async function scanUntracked(folder, entries, maxFiles = WORKTREE_UNTRACKED_MAX_FILES) {
+  const walk2 = { hash: createHash8("sha256"), files: 0, bytes: 0, max: maxFiles, blocked: null };
+  const targets = [];
+  for (const entry of [...entries].sort()) {
+    const clean = cleanEntry(entry);
+    if (clean === null) return null;
+    let target;
+    let real;
+    try {
+      const parent = await resolveInside(folder, path71.posix.dirname(clean), { mustExist: true });
+      target = path71.join(parent, path71.posix.basename(clean));
+      real = path71.join(await realpath7(parent), path71.posix.basename(clean));
+    } catch {
+      return null;
+    }
+    targets.push(target);
+    walk2.hash.update(`${clean}\0`);
+    await visit(target, real, clean, walk2);
+    if (walk2.blocked !== null) return { files: walk2.files, bytes: walk2.bytes, stamp: null, blocked: walk2.blocked, targets: [] };
+  }
+  return { files: walk2.files, bytes: walk2.bytes, stamp: walk2.hash.digest("hex"), blocked: null, targets };
+}
+async function visit(absolute, real, relative, walk2) {
+  if (walk2.files >= walk2.max) {
+    walk2.blocked = "too-many";
+    return;
+  }
+  let info;
+  try {
+    info = await lstat4(absolute);
+  } catch {
+    walk2.hash.update(`${relative}\0?
+`);
+    return;
+  }
+  const linked = !info.isDirectory() || !sameName(await realpath7(absolute).catch(() => ""), real);
+  if (linked) {
+    walk2.files += 1;
+    walk2.bytes += info.size;
+    walk2.hash.update(`${relative}\0${info.isSymbolicLink() || info.isDirectory() ? "l" : "f"}\0${info.size}\0${info.mtimeMs}
+`);
+    return;
+  }
+  walk2.hash.update(`${relative}\0d
+`);
+  let names;
+  try {
+    names = (await readdir21(absolute)).sort();
+  } catch {
+    walk2.hash.update(`${relative}\0!
+`);
+    return;
+  }
+  if (names.some((name) => sameName(name, ".git"))) {
+    walk2.blocked = "nested-repo";
+    return;
+  }
+  for (const name of names) {
+    await visit(path71.join(absolute, name), path71.join(real, name), `${relative}/${name}`, walk2);
+    if (walk2.blocked !== null) return;
+  }
+}
+async function deleteUntracked(targets) {
+  for (const target of targets) {
+    try {
+      await rm9(target, { recursive: true, maxRetries: 3 });
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+  }
+}
+
 // packages/server/src/worktrees/service.ts
 var WorktreeError = class extends ServerTextError {
 };
+var WorktreeInUseError = class extends WorktreeError {
+  constructor(plan) {
+    super(serverText("worktreeInUse"));
+    this.plan = plan;
+  }
+  plan;
+};
 var ROWS_TTL_MS = 5e3;
 var RELEASE_TIMEOUT_MS = 5e3;
 var RELEASE_POLL_MS = 100;
@@ -26120,17 +26495,20 @@ var REPLY_LIMITS = { textMaxChars: 2e5, toolInputMaxChars: 200, toolResultMaxCha
 var REPLY_EVENTS = 300;
 var REPLY_CACHE_MAX = 50;
 var REVIEW_ACTIVITY_DELAY_MS = 1e3;
-async function exists4(candidate) {
+async function leftWithoutGit(folder) {
+  return await exists5(folder) && await lstat5(path72.join(folder, ".git")).catch(() => null) === null;
+}
+async function exists5(candidate) {
   try {
-    await stat44(candidate);
+    await stat45(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function isInside4(outer, inner) {
-  const relative = path70.relative(path70.resolve(outer), path70.resolve(inner));
-  return relative.length === 0 || !relative.startsWith("..") && !path70.isAbsolute(relative);
+  const relative = path72.relative(path72.resolve(outer), path72.resolve(inner));
+  return relative.length === 0 || !relative.startsWith("..") && !path72.isAbsolute(relative);
 }
 function displayCommand(args) {
   return ["git", ...args].map((arg) => /[\s"]/.test(arg) ? `"${arg.replace(/"/g, '\\"')}"` : arg).join(" ");
@@ -26186,7 +26564,7 @@ var WorktreeService = class extends EventEmitter7 {
   /** La carpeta principal del repo de un proyecto o de una pestaña. */
   async mainRootOf(source) {
     const cwd = source.kind === "terminal" ? this.deps.registry.get(source.terminalId)?.cwd ?? null : this.deps.projectCwd(source.projectKey);
-    if (cwd === null || !await exists4(cwd)) throw new WorktreeError(serverText("worktreeProjectUnknown"));
+    if (cwd === null || !await exists5(cwd)) throw new WorktreeError(serverText("worktreeProjectUnknown"));
     const layout = await repoLayout(cwd);
     if (layout === null || layout.mainRoot === null) throw new WorktreeError(serverText("worktreeNotRepo"));
     return layout.mainRoot;
@@ -26205,7 +26583,7 @@ var WorktreeService = class extends EventEmitter7 {
     return {
       mainRoot,
       parentDir: worktreesParentFor(mainRoot),
-      separator: path70.sep,
+      separator: path72.sep,
       currentBranch: current,
       branches: branches.map((name) => ({ name, checkedOut: checkedOut.has(name) })),
       mainChanges: changes?.length ?? 0,
@@ -26227,9 +26605,9 @@ var WorktreeService = class extends EventEmitter7 {
       throw new WorktreeError(serverText("worktreeBranchInUse", { branch }));
     }
     const folder = worktreeFolderFor(mainRoot, branch);
-    if (await exists4(folder)) throw new WorktreeError(serverText("worktreeFolderExists", { folder }));
+    if (await exists5(folder)) throw new WorktreeError(serverText("worktreeFolderExists", { folder }));
     const copy = await planCopy(mainRoot);
-    await mkdir22(path70.dirname(folder), { recursive: true });
+    await mkdir22(path72.dirname(folder), { recursive: true });
     const added = await addWorktree(mainRoot, folder, branch, mode === "new" ? base : null);
     if (added.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(added) }));
     const { copied, copiedDirs } = await this.copyInto(mainRoot, folder, copy, request.copyNotes);
@@ -26274,13 +26652,13 @@ var WorktreeService = class extends EventEmitter7 {
   /** Las filas de "Ramas aparte" para la pestaña que pregunta. Vacío fuera de git. */
   async rows(terminalId) {
     const descriptor = this.deps.registry.get(terminalId);
-    if (descriptor === null || !await exists4(descriptor.cwd)) return [];
+    if (descriptor === null || !await exists5(descriptor.cwd)) return [];
     const layout = await repoLayout(descriptor.cwd);
     if (layout === null || layout.mainRoot === null) return [];
     const mainRoot = layout.mainRoot;
     const tips = await branchTips(mainRoot);
     const tipsStamp = [...tips].map(([branch, commit]) => `${branch}\0${commit}`).join("\n");
-    const cacheKey2 = path70.resolve(mainRoot).toLowerCase();
+    const cacheKey2 = path72.resolve(mainRoot).toLowerCase();
     const cached = this.rowsCache.get(cacheKey2);
     const fresh = cached !== void 0 && cached.tips === tipsStamp && this.now() - cached.at < ROWS_TTL_MS;
     const generation = this.rowsGeneration;
@@ -26289,7 +26667,12 @@ var WorktreeService = class extends EventEmitter7 {
     return rows.map((row) => ({ ...row, isCurrent: samePathShape(row.path, layout.toplevel) }));
   }
   async readRows(mainRoot, tips) {
-    const entries = (await listWorktrees(mainRoot)).filter((entry) => !entry.bare);
+    const listed = await readWorktreeList(mainRoot);
+    const entries = [
+      ...(listed ?? []).filter((entry) => !entry.bare),
+      // Las que git soltó a medias: sin su fila, no había cómo terminar de quitarlas.
+      ...listed === null ? [] : await this.releasedEntries(mainRoot, listed)
+    ];
     const mainBranch = entries.find((entry) => entry.isMain)?.branch ?? null;
     const read2 = await Promise.all(
       entries.map(async (entry) => {
@@ -26336,7 +26719,7 @@ var WorktreeService = class extends EventEmitter7 {
     const baseTip = tips.get(base);
     const branchTip = tips.get(branch);
     if (baseTip === void 0 || branchTip === void 0) return Promise.resolve(null);
-    const key = [path70.resolve(mainRoot).toLowerCase(), base, branch, baseTip, branchTip].join("\0");
+    const key = [path72.resolve(mainRoot).toLowerCase(), base, branch, baseTip, branchTip].join("\0");
     const cached = this.pairs.get(key);
     if (cached !== void 0) {
       this.pairs.delete(key);
@@ -26381,12 +26764,12 @@ var WorktreeService = class extends EventEmitter7 {
   /** Una rama aparte que existe en disco, para lo que la lee o le deja un pedido. */
   async presentRecordOrThrow(id) {
     const record = this.recordOrThrow(id);
-    if (!await exists4(record.path)) throw new WorktreeError(serverText("worktreeUnknown"));
+    if (!await exists5(record.path)) throw new WorktreeError(serverText("worktreeUnknown"));
     return record;
   }
   /** Las pestañas y consolas abiertas dentro de la carpeta de la rama. */
   tabsIn(folder) {
-    return this.deps.registry.list().filter((tab) => isInside4(folder, tab.cwd)).map((tab) => ({ terminalId: tab.terminalId, kind: tab.kind, label: tab.label || path70.basename(tab.cwd) }));
+    return this.deps.registry.list().filter((tab) => isInside4(folder, tab.cwd)).map((tab) => ({ terminalId: tab.terminalId, kind: tab.kind, label: tab.label || path72.basename(tab.cwd) }));
   }
   /**
    * Las pestañas de una carpeta de trabajo, sin las de otra que viva adentro
@@ -26399,17 +26782,70 @@ var WorktreeService = class extends EventEmitter7 {
       return !nested.some((inner) => isInside4(inner, cwd));
     });
   }
+  /**
+   * Los archivos nuevos que se pueden perder al quitar la rama (23-10-2026):
+   * sólo si todo lo que no está commiteado es nuevo y git lo listó entero. null
+   * si no; si git se va a negar a quitarla igual, bloqueada o con un submódulo
+   * cargado (no se borra nada antes de saberlo); o si una entrada no se puede
+   * borrar sin salir de la carpeta. Con algo adentro que la app copió de la
+   * principal y la rama no ignora, no se ofrece (`copied`): no vuelve como una
+   * nota, y se perdería lo que la rama le cambió.
+   */
+  async untrackedIn(record, changes) {
+    const onlyNew = changes.complete && changes.paths.length > 0 && changes.untracked.length === changes.paths.length;
+    if (!onlyNew) return null;
+    const [entries, submodule] = await Promise.all([listWorktrees(record.mainRoot), hasLoadedSubmodule(record.path)]);
+    if (submodule !== false || entries.some((entry) => entry.locked && samePathShape(entry.path, record.path))) return null;
+    const entryOf = (file) => changes.untracked.some((entry) => {
+      const clean = entry.replace(/\/+$/, "").toLowerCase();
+      return file.toLowerCase() === clean || file.toLowerCase().startsWith(`${clean}/`);
+    });
+    const copied = [];
+    for (const file of record.copied) {
+      if (entryOf(file.path) && await exists5(path72.join(record.path, file.path))) copied.push(file.path);
+    }
+    if (copied.length > 0) {
+      const ignored = await ignoredAmong(record.path, copied);
+      if (ignored === null || copied.some((file) => !ignored.has(file))) return { files: 0, bytes: 0, stamp: null, blocked: "copied", targets: [] };
+    }
+    return scanUntracked(record.path, changes.untracked);
+  }
+  /**
+   * Borra los archivos nuevos que el usuario eligió perder, si siguen siendo
+   * los que vio: se mira justo antes, con las pestañas de la rama cerradas y
+   * las notas ya de vuelta. Si desaparecieron solos, no hay nada que borrar.
+   * Devuelve cuántos archivos se perdieron.
+   */
+  async discardNew(record, stamp2) {
+    const changes = await uncommittedChanges(record.path);
+    if (changes === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    if (changes.paths.length === 0) return 0;
+    const scan = await this.untrackedIn(record, changes);
+    if (scan === null || scan.stamp === null || scan.stamp !== stamp2) throw new WorktreeError(serverText("worktreeUntrackedChanged"));
+    try {
+      await deleteUntracked(scan.targets);
+    } catch (error) {
+      throw new WorktreeError(serverText("worktreeDiscardFailed", { detail: error instanceof Error ? error.message : String(error) }));
+    }
+    return scan.files;
+  }
   async planFor(record) {
-    const present = await exists4(record.path);
-    const [uncommitted, notes, integrated] = await Promise.all([
-      present ? uncommittedPaths(record.path) : Promise.resolve([]),
+    const onDisk = await exists5(record.path);
+    const present = onDisk && !await this.releasedByGit(record);
+    const [changes, notes, integrated] = await Promise.all([
+      present ? uncommittedChanges(record.path) : Promise.resolve({ paths: [], untracked: [], complete: true }),
       present ? reviewNotes(record.mainRoot, record.path, record, this.loadNoteBase) : Promise.resolve({ returning: [], merging: [], resolved: [], conflicts: [] }),
       record.createdBranch ? isIntegrated(record.mainRoot, record.branch, record.base) : Promise.resolve(false)
     ]);
-    if (uncommitted === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    if (changes === null) throw new WorktreeError(serverText("worktreeGitFailed", { detail: "git status" }));
+    const uncommitted = changes.paths;
+    const untracked = await this.untrackedIn(record, changes);
     const tabs = this.tabsIn(record.path);
     const deletesBranch = integrated === true;
     const branchUnused = deletesBranch && stillAtStart(record, await branchCommit(record.mainRoot, record.branch) ?? void 0);
+    let inUse = !onDisk ? false : tabs.length > 0 ? null : await folderInUse(record.path);
+    const holders = inUse === true ? await this.holdersOf(record.path) : [];
+    if (inUse === true && holders.length === 0) inUse = await folderInUse(record.path);
     return {
       id: record.id,
       branch: record.branch,
@@ -26420,13 +26856,15 @@ var WorktreeService = class extends EventEmitter7 {
       ],
       uncommitted: uncommitted.slice(0, WORKTREE_PLAN_PATHS_MAX),
       uncommittedCount: uncommitted.length,
+      // Sin las rutas absolutas de `targets`: al cliente le basta con lo que muestra y la huella.
+      untracked: untracked === null ? null : { files: untracked.files, bytes: untracked.bytes, stamp: untracked.stamp, blocked: untracked.blocked },
       tabs,
       returning: notes.returning,
       merging: notes.merging,
       resolved: notes.resolved,
       conflicts: notes.conflicts,
-      // Con pestañas de la app adentro, la prueba daría "en uso" por ellas mismas: se mira al confirmar.
-      inUse: !present ? false : tabs.length > 0 ? null : await folderInUse(record.path),
+      inUse,
+      holders,
       deletesBranch,
       branchUnused,
       createdBranch: record.createdBranch
@@ -26439,34 +26877,46 @@ var WorktreeService = class extends EventEmitter7 {
   /**
    * Quita la rama aparte. Rehace el plan y se detiene en el primer "no" (ver
    * el principio del archivo). `closeTab` cierra una pestaña como lo hace el
-   * socket, soltando todo lo que la seguía.
+   * socket, soltando todo lo que la seguía. `discardUntracked` es la huella de
+   * los archivos nuevos que el usuario eligió perder (23-10-2026).
    */
-  async remove(id, discardConflicts, closeTab) {
+  async remove(id, discardConflicts, closeTab, discardUntracked = null) {
     const record = this.recordOrThrow(id);
     const plan = await this.planFor(record);
     if (plan.uncommittedCount > 0) {
-      throw new WorktreeError(serverText("worktreeUncommitted", { count: plan.uncommittedCount }));
+      if (plan.untracked === null || plan.untracked.stamp === null || discardUntracked === null) {
+        throw new WorktreeError(serverText("worktreeUncommitted", { count: plan.uncommittedCount }));
+      }
+      if (plan.untracked.stamp !== discardUntracked) throw new WorktreeError(serverText("worktreeUntrackedChanged"));
     }
     if (plan.conflicts.length > 0 && !discardConflicts) {
       throw new WorktreeError(serverText("worktreeNotesConflict", { count: plan.conflicts.length }));
     }
-    if (plan.inUse === true) throw new WorktreeError(serverText("worktreeInUse"));
+    if (plan.inUse === true) throw new WorktreeInUseError(plan);
     let returned = 0;
-    if (await exists4(record.path)) {
+    let discardedFiles = 0;
+    if (await exists5(record.path)) {
       for (const tab of plan.tabs) closeTab(tab.terminalId);
-      if (!await this.waitUntilFree(record.path)) throw new WorktreeError(serverText("worktreeInUse"));
-      const bases = new Map(record.copied.map((file) => [file.path, file.hash]));
-      try {
-        returned = (await returnNotes(record.mainRoot, record.path, plan.returning, bases, {
-          loadBase: this.loadNoteBase,
-          onWritten: (file, branch) => this.noteReturned(record.id, file, branch),
-          notesAsked: record.notesAsked
-        })).returned.length;
-      } catch (error) {
-        throw new WorktreeError(serverText("worktreeNotesFailed", { detail: error instanceof Error ? error.message : String(error) }));
+      if (!await this.waitUntilFree(record.path)) {
+        throw new WorktreeInUseError({ ...plan, tabs: [], inUse: true, holders: await this.holdersOf(record.path) });
+      }
+      if (!await this.releasedByGit(record)) {
+        const bases = new Map(record.copied.map((file) => [file.path, file.hash]));
+        try {
+          returned = (await returnNotes(record.mainRoot, record.path, plan.returning, bases, {
+            loadBase: this.loadNoteBase,
+            onWritten: (file, branch) => this.noteReturned(record.id, file, branch),
+            notesAsked: record.notesAsked
+          })).returned.length;
+        } catch (error) {
+          throw new WorktreeError(serverText("worktreeNotesFailed", { detail: error instanceof Error ? error.message : String(error) }));
+        }
+        if (plan.uncommittedCount > 0) discardedFiles = await this.discardNew(record, discardUntracked);
+        const removed = await removeWorktree(record.mainRoot, record.path);
+        if (removed.code !== 0 && !await this.releasedByGit(record)) {
+          throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(removed) }));
+        }
       }
-      const removed = await removeWorktree(record.mainRoot, record.path);
-      if (removed.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(removed) }));
       await this.removeLeftovers(record);
     }
     const endCommit = await branchCommit(record.mainRoot, record.branch);
@@ -26474,7 +26924,15 @@ var WorktreeService = class extends EventEmitter7 {
     await this.deps.store.update(id, { removedAt: this.now(), endCommit: endCommit ?? record.endCommit });
     await this.pruneNoteBases();
     this.changed();
-    return { branchDeleted, returned, discarded: discardConflicts ? plan.conflicts.length : 0 };
+    return { branchDeleted, returned, discarded: discardConflicts ? plan.conflicts.length : 0, discardedFiles };
+  }
+  /** Los programas que tienen la carpeta, para el diálogo. Sin saberlo, ninguno: el diálogo dice lo de antes. */
+  async holdersOf(folder) {
+    try {
+      return await (this.deps.folderHolders ?? folderHolders)(folder);
+    } catch {
+      return [];
+    }
   }
   /** Espera, con tope, a que ningún proceso tenga la carpeta. */
   async waitUntilFree(folder) {
@@ -26492,16 +26950,40 @@ var WorktreeService = class extends EventEmitter7 {
    * contenga, ni una carpeta que git todavía tenga registrada.
    */
   async removeLeftovers(record) {
-    const folder = path70.resolve(record.path);
-    if (!await exists4(folder)) return this.removeEmptyParent(folder);
-    if (isInside4(folder, record.mainRoot) || path70.dirname(folder) === folder) return;
+    const folder = path72.resolve(record.path);
+    if (!await exists5(folder)) return this.removeEmptyParent(folder);
+    if (isInside4(folder, record.mainRoot) || path72.dirname(folder) === folder) return;
     if ((await listWorktrees(record.mainRoot)).some((entry) => samePathShape(entry.path, folder))) return;
-    await rm9(folder, { recursive: true, maxRetries: 3 });
+    await rm10(folder, { recursive: true, maxRetries: 3 });
     await this.removeEmptyParent(folder);
   }
+  /**
+   * true si git ya soltó la rama sin terminar de borrar su carpeta
+   * (23-10-2026). `worktree remove` borra después de sus controles y, si algo
+   * no se deja borrar a mitad de camino, quita su registro igual (medido con git
+   * 2.56: una ruta de más de 260 caracteres sin `core.longpaths`, o un nombre
+   * terminado en punto). Lo que quedó ya pasó esos controles, y lo termina de
+   * borrar la app. Sólo sin `.git` adentro, y si git contesta que no la tiene:
+   * una carpeta con su `.git` puede tener trabajo aunque git ya no la conozca.
+   */
+  async releasedByGit(record) {
+    if (!await leftWithoutGit(record.path)) return false;
+    const entries = await readWorktreeList(record.mainRoot);
+    return entries !== null && !entries.some((entry) => samePathShape(entry.path, record.path));
+  }
+  /** Las ramas de la app que git soltó a medias (`releasedByGit`), como si git las listara. */
+  async releasedEntries(mainRoot, listed) {
+    const released = [];
+    for (const record of this.deps.store.list()) {
+      if (record.removedAt !== null || !samePathShape(record.mainRoot, mainRoot)) continue;
+      if (listed.some((entry) => samePathShape(entry.path, record.path)) || !await leftWithoutGit(record.path)) continue;
+      released.push({ path: path72.resolve(record.path), branch: record.branch, isMain: false, bare: false, locked: false, prunable: true });
+    }
+    return released;
+  }
   /** La carpeta `<proyecto>.worktrees`, sólo si quedó vacía. */
   async removeEmptyParent(folder) {
-    await rmdir(path70.dirname(folder)).catch(() => void 0);
+    await rmdir(path72.dirname(folder)).catch(() => void 0);
   }
   /**
    * Vuelve a abrir la rama de una sesión cuya carpeta se quitó: la saca otra
@@ -26513,7 +26995,7 @@ var WorktreeService = class extends EventEmitter7 {
     const session = this.deps.findSession(agent, sessionId);
     if (session === null || session.cwd.length === 0) throw new WorktreeError(serverText("worktreeUnknown"));
     const record = this.removedRecordAbove(session.cwd);
-    if (record === null || await exists4(record.path) || !await exists4(record.mainRoot)) {
+    if (record === null || await exists5(record.path) || !await exists5(record.mainRoot)) {
       throw new WorktreeError(serverText("worktreeUnknown"));
     }
     const branchExists = await branchCommit(record.mainRoot, record.branch) !== null;
@@ -26525,7 +27007,7 @@ var WorktreeService = class extends EventEmitter7 {
       throw new WorktreeError(serverText("worktreeBranchInUse", { branch: record.branch }));
     }
     const copy = await planCopy(record.mainRoot);
-    await mkdir22(path70.dirname(record.path), { recursive: true });
+    await mkdir22(path72.dirname(record.path), { recursive: true });
     const added = await addWorktree(record.mainRoot, record.path, record.branch, recreateAt);
     if (added.code !== 0) throw new WorktreeError(serverText("worktreeGitFailed", { detail: gitFailureText(added) }));
     const { copied, copiedDirs } = await this.copyInto(record.mainRoot, record.path, copy, record.copyNotes);
@@ -26541,7 +27023,7 @@ var WorktreeService = class extends EventEmitter7 {
    */
   async keptBranches(terminalId) {
     const descriptor = this.deps.registry.get(terminalId);
-    if (descriptor === null || !await exists4(descriptor.cwd)) return [];
+    if (descriptor === null || !await exists5(descriptor.cwd)) return [];
     const layout = await repoLayout(descriptor.cwd);
     if (layout === null || layout.mainRoot === null) return [];
     const mainRoot = layout.mainRoot;
@@ -26612,11 +27094,11 @@ var WorktreeService = class extends EventEmitter7 {
     return { branch: plan.branch };
   }
   removedRecordAbove(cwd) {
-    let current = path70.resolve(cwd);
+    let current = path72.resolve(cwd);
     for (let depth = 0; depth < 24; depth += 1) {
       const record = this.deps.store.byPath(current);
       if (record !== null) return record.removedAt === null ? null : record;
-      const parent = path70.dirname(current);
+      const parent = path72.dirname(current);
       if (parent === current) return null;
       current = parent;
     }
@@ -26728,7 +27210,7 @@ var WorktreeService = class extends EventEmitter7 {
     const open9 = this.authorTab(record);
     if (open9 !== null) return { terminal: open9, opened: false };
     const session = this.authorSession(record);
-    if (session !== null && isAgentId(session.agent) && session.cwd.length > 0 && await exists4(session.cwd)) {
+    if (session !== null && isAgentId(session.agent) && session.cwd.length > 0 && await exists5(session.cwd)) {
       const terminal = await this.deps.registry.open({ cwd: session.cwd, agent: session.agent, resumeSessionId: session.sessionId });
       return { terminal, opened: true };
     }
@@ -26945,11 +27427,11 @@ var WorktreeService = class extends EventEmitter7 {
     const baseEntry = entries.find((entry) => !entry.bare && !entry.prunable && entry.branch === record.base) ?? null;
     const [baseChanges, branchChanges, target] = await Promise.all([
       baseEntry === null ? Promise.resolve([]) : uncommittedPaths(baseEntry.path),
-      await exists4(record.path) ? uncommittedPaths(record.path) : Promise.resolve([]),
+      await exists5(record.path) ? uncommittedPaths(record.path) : Promise.resolve([]),
       baseEntry === null ? Promise.resolve(`refs/heads/${record.branch}`) : mergeTarget(baseEntry.path, record.branch)
     ]);
     const localConflicts = pathsTouching(baseChanges ?? [], files);
-    const notes = baseEntry?.isMain === true && await exists4(record.path) ? await reviewNotes(mainRoot, record.path, record, this.loadNoteBase) : null;
+    const notes = baseEntry?.isMain === true && await exists5(record.path) ? await reviewNotes(mainRoot, record.path, record, this.loadNoteBase) : null;
     const blocker = pair.ahead === 0 ? "nothing" : pair.behind > 0 ? "behind" : baseEntry === null ? "no-base-folder" : localConflicts.length > 0 ? "local-changes" : null;
     const plan = {
       id: record.id,
@@ -28644,17 +29126,24 @@ ${seen.join("\n-----\n")}`);
           })();
           break;
         /*
-          Cuales de esas rutas son archivos del proyecto (§6.33): lo que el
-          hilo vuelve enlace. Sin error para ningun caso —una pestana que ya no
-          esta, una ruta que cae fuera—: nada existe, y el hilo queda como
+          Cuales de esas rutas son archivos o carpetas del proyecto (§6.33): lo
+          que el hilo vuelve enlace. Sin error para ningun caso (una pestana que
+          ya no esta, una ruta que cae fuera): nada existe, y el hilo queda como
           texto. Un cartel por una ruta que escribio el agente no le dice nada
           al usuario.
         */
         case "files.check":
           void (async () => {
             const cwd = cwdOf(message.terminalId);
-            const existing = cwd === null ? [] : await existingFiles(cwd, message.paths, await folders).catch(() => []);
-            send(socket, { type: "files.checked", terminalId: message.terminalId, requestId: message.requestId, existing });
+            const none = { files: [], directories: [] };
+            const { files, directories } = cwd === null ? none : await existingPaths(cwd, message.paths, await folders).catch(() => none);
+            send(socket, {
+              type: "files.checked",
+              terminalId: message.terminalId,
+              requestId: message.requestId,
+              existing: files,
+              directories
+            });
           })();
           break;
         case "files.reveal":
@@ -29024,9 +29513,11 @@ ${seen.join("\n-----\n")}`);
         }
         case "worktree.remove": {
           const { requestId, worktreeId, discardConflicts } = message;
-          void worktrees.remove(worktreeId, discardConflicts, (terminalId) => void dropTab(terminalId)).then(
+          const closeTab = (terminalId) => void dropTab(terminalId);
+          void worktrees.remove(worktreeId, discardConflicts, closeTab, message.discardUntracked ?? null).then(
             (outcome) => send(socket, { type: "worktree.removed", requestId, worktreeId, outcome }),
-            (error) => sendWorktreeError(socket, error, requestId)
+            // Otro programa tiene la carpeta: el plan otra vez, que dice cuál (23-10-2026).
+            (error) => error instanceof WorktreeInUseError ? send(socket, { type: "worktree.removePlan", requestId, plan: error.plan }) : sendWorktreeError(socket, error, requestId)
           );
           break;
         }
@@ -29314,8 +29805,8 @@ ${seen.join("\n-----\n")}`);
 }
 
 // packages/server/src/vault/catalog.ts
-import { open as open8, readdir as readdir21, stat as stat45 } from "node:fs/promises";
-import path71 from "node:path";
+import { open as open8, readdir as readdir22, stat as stat46 } from "node:fs/promises";
+import path73 from "node:path";
 import { createInterface as createInterface4 } from "node:readline";
 var HEADER_MAX_BYTES = 64 * 1024;
 var LOAD_CONCURRENCY = 16;
@@ -29327,7 +29818,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   const folder = assetsDir(dir, agent, sessionId);
   let names;
   try {
-    names = await readdir21(folder);
+    names = await readdir22(folder);
   } catch {
     return 0;
   }
@@ -29335,7 +29826,7 @@ async function assetBytesOf(dir, agent, sessionId) {
   for (const name of names) {
     if (!VAULT_ASSET_NAME_PATTERN.test(name)) continue;
     try {
-      const info = await stat45(path71.join(folder, name));
+      const info = await stat46(path73.join(folder, name));
       if (info.isFile()) total += info.size;
     } catch {
     }
@@ -29346,7 +29837,7 @@ async function readEntry2(dir, agent, sessionId) {
   const file = sessionFile(dir, agent, sessionId);
   let sizeBytes;
   try {
-    const info = await stat45(file);
+    const info = await stat46(file);
     if (!info.isFile()) return { kind: "absent" };
     sizeBytes = info.size;
   } catch {
@@ -29403,7 +29894,7 @@ var VaultCatalog = class {
     const keys = [];
     let agentFolders = [];
     try {
-      agentFolders = await readdir21(sessionsRoot2(dir));
+      agentFolders = await readdir22(sessionsRoot2(dir));
     } catch {
       agentFolders = [];
     }
@@ -29411,7 +29902,7 @@ var VaultCatalog = class {
       if (!isSessionAgentId2(folder)) continue;
       let names;
       try {
-        names = await readdir21(agentSessionsDir(dir, folder));
+        names = await readdir22(agentSessionsDir(dir, folder));
       } catch {
         continue;
       }
@@ -29555,22 +30046,22 @@ var VaultCatalog = class {
 };
 
 // packages/server/src/worktrees/links.ts
-import { stat as stat46 } from "node:fs/promises";
-import path72 from "node:path";
-async function exists5(candidate) {
+import { stat as stat47 } from "node:fs/promises";
+import path74 from "node:path";
+async function exists6(candidate) {
   try {
-    await stat46(candidate);
+    await stat47(candidate);
     return true;
   } catch {
     return false;
   }
 }
 function recordAbove(registry, cwd) {
-  let current = path72.resolve(cwd);
+  let current = path74.resolve(cwd);
   for (let depth = 0; depth < 24; depth += 1) {
     const record = registry.byPath(current);
-    if (record !== null) return { record, inner: path72.relative(current, path72.resolve(cwd)) };
-    const parent = path72.dirname(current);
+    if (record !== null) return { record, inner: path74.relative(current, path74.resolve(cwd)) };
+    const parent = path74.dirname(current);
     if (parent === current) return null;
     current = parent;
   }
@@ -29584,14 +30075,14 @@ var WorktreeLinks = class {
   /** La rama aparte de una carpeta del historial, o null si es la de un proyecto (o no es de git). */
   async sessionLink(cwd) {
     if (cwd.length === 0) return null;
-    if (await exists5(cwd)) {
+    if (await exists6(cwd)) {
       const checkout = await readCheckout(cwd);
       if (checkout === null || !checkout.linked) return null;
       const record = this.registry.byPath(checkout.root);
       return {
         mainCwd: mainCwdFor(cwd, checkout),
         worktree: {
-          branch: checkout.branch ?? record?.branch ?? path72.basename(checkout.root),
+          branch: checkout.branch ?? record?.branch ?? path74.basename(checkout.root),
           exists: true,
           reopenable: false
         }
@@ -29601,13 +30092,13 @@ var WorktreeLinks = class {
     if (found !== null) {
       const { record, inner } = found;
       return {
-        mainCwd: inner.length === 0 ? record.mainRoot : path72.join(record.mainRoot, inner),
+        mainCwd: inner.length === 0 ? record.mainRoot : path74.join(record.mainRoot, inner),
         worktree: { branch: record.branch, exists: false, reopenable: await this.reopenable(record) }
       };
     }
-    const mainRoot = mainRootFromShape(path72.resolve(cwd));
+    const mainRoot = mainRootFromShape(path74.resolve(cwd));
     if (mainRoot === null) return null;
-    return { mainCwd: mainRoot, worktree: { branch: path72.basename(cwd), exists: false, reopenable: false } };
+    return { mainCwd: mainRoot, worktree: { branch: path74.basename(cwd), exists: false, reopenable: false } };
   }
   /**
    * Se puede volver a abrir una rama quitada si la creó la app, su carpeta no
@@ -29616,7 +30107,7 @@ var WorktreeLinks = class {
    */
   async reopenable(record) {
     if (record.removedAt === null) return false;
-    if (await exists5(record.path) || !await exists5(record.mainRoot)) return false;
+    if (await exists6(record.path) || !await exists6(record.mainRoot)) return false;
     try {
       if (await branchCommit(record.mainRoot, record.branch) !== null) return true;
       return record.endCommit !== null && await commitExists(record.mainRoot, record.endCommit);
@@ -29637,15 +30128,15 @@ var WorktreeLinks = class {
 };
 
 // packages/server/src/index.ts
-var serverDir = path73.dirname(fileURLToPath2(import.meta.url));
+var serverDir = path75.dirname(fileURLToPath2(import.meta.url));
 var isPackaged = true;
-var webRoot = isPackaged ? serverDir : path73.resolve(serverDir, "../../web");
-var webDist = isPackaged ? path73.join(serverDir, "web") : path73.join(webRoot, "dist");
-var repoRoot = path73.resolve(serverDir, "../../..");
+var webRoot = isPackaged ? serverDir : path75.resolve(serverDir, "../../web");
+var webDist = isPackaged ? path75.join(serverDir, "web") : path75.join(webRoot, "dist");
+var repoRoot = path75.resolve(serverDir, "../../..");
 var isProduction = isPackaged || process.argv.includes("--prod");
 function resolveDefaultCwd() {
   const override = process.env["AGENT_WORKBENCH_CWD"];
-  if (override !== void 0 && override.length > 0) return path73.resolve(override);
+  if (override !== void 0 && override.length > 0) return path75.resolve(override);
   if (isPackaged) return process.cwd();
   return repoRoot;
 }
@@ -29720,7 +30211,7 @@ async function mountDevUi(app, httpServer) {
 }
 var LOOKS_LIKE_FILE = /\.[a-zA-Z0-9]{1,8}$/;
 function mountBuiltUi(app) {
-  const indexHtml = path73.join(webDist, "index.html");
+  const indexHtml = path75.join(webDist, "index.html");
   if (!existsSync4(indexHtml)) {
     throw new Error(
       `There's no compiled interface in ${webDist}.
@@ -29808,11 +30299,11 @@ async function main() {
     findSession: (agent, sessionId) => index.find(agent, sessionId),
     // Hito 49: las conversaciones de una rama (para dejarle un pedido a su autor) y la respuesta del revisor.
     sessionsUnder: (folder) => {
-      const root = path73.resolve(folder);
+      const root = path75.resolve(folder);
       return index.getProjects().flatMap((project) => project.sessions).filter((session) => {
         if (session.archived || session.cwd.length === 0) return false;
-        const relative = path73.relative(root, path73.resolve(session.cwd));
-        return relative.length === 0 || !relative.startsWith("..") && !path73.isAbsolute(relative);
+        const relative = path75.relative(root, path75.resolve(session.cwd));
+        return relative.length === 0 || !relative.startsWith("..") && !path75.isAbsolute(relative);
       });
     },
     history: (agent) => agents.get(agent)?.adapter.history ?? null