@staff0rd/assist 0.433.5 → 0.434.1

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.433.5",
+  version: "0.434.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -4198,7 +4198,7 @@ ${failed2.length} script(s) failed:`);
   }
 }
 function runEntry(entry) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const startTime = Date.now();
     const child = spawnCommand(
       entry.fullCommand,
@@ -4210,7 +4210,7 @@ function runEntry(entry) {
     child.on("close", (code) => {
       const exitCode = code ?? 1;
       flushIfFailed(exitCode, chunks);
-      resolve19({
+      resolve20({
         script: entry.name,
         code: exitCode,
         durationMs: Date.now() - startTime
@@ -5357,8 +5357,8 @@ function spawnInherit(command, args, options2 = {}) {
     env,
     cwd: options2.cwd
   });
-  const done2 = new Promise((resolve19, reject) => {
-    child.on("close", (code) => resolve19(code ?? 0));
+  const done2 = new Promise((resolve20, reject) => {
+    child.on("close", (code) => resolve20(code ?? 0));
     child.on("error", reject);
   });
   return { child, done: done2 };
@@ -6431,9 +6431,9 @@ Failed to launch Claude for ${context}: ${message2}`)
 // src/commands/sessions/daemon/connectToDaemon.ts
 import * as net from "net";
 function connectToDaemon() {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const socket = net.connect(daemonPaths.socket);
-    socket.once("connect", () => resolve19(socket));
+    socket.once("connect", () => resolve20(socket));
     socket.once("error", reject);
   });
 }
@@ -6449,7 +6449,7 @@ async function isDaemonRunning() {
 // src/commands/sessions/daemon/sendToDaemon.ts
 var WRITE_TIMEOUT_MS = 500;
 function sendToDaemon(message2) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     connectToDaemon().then((socket) => {
       const timer = setTimeout(() => {
         socket.destroy();
@@ -6463,7 +6463,7 @@ function sendToDaemon(message2) {
 `, () => {
         clearTimeout(timer);
         socket.end();
-        resolve19();
+        resolve20();
       });
     }, reject);
   });
@@ -6486,7 +6486,7 @@ function readSocketLines(socket, onLine) {
 // src/commands/sessions/daemon/sendToDaemonAwaitAck.ts
 var ACK_TIMEOUT_MS = 1e3;
 function sendToDaemonAwaitAck(message2) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error) => {
@@ -6495,7 +6495,7 @@ function sendToDaemonAwaitAck(message2) {
         clearTimeout(timer);
         socket.destroy();
         if (error) reject(error);
-        else resolve19();
+        else resolve20();
       };
       const timer = setTimeout(
         () => finish(new Error("timed out awaiting daemon ack")),
@@ -6569,7 +6569,7 @@ async function deliverReliably(sessionId, status3, payload) {
   }
 }
 function sleep(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 function describeError(error) {
   return error instanceof Error ? error.message : String(error);
@@ -8065,7 +8065,7 @@ function spawnDaemon(reason) {
   child.unref();
 }
 function delay(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 
 // src/shared/createBundleHandler.ts
@@ -8333,12 +8333,12 @@ async function loadVisibleItems(req) {
 
 // src/commands/backlog/web/parseStatusBody.ts
 function readBody(req) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     let body = "";
     req.on("data", (chunk) => {
       body += chunk.toString();
     });
-    req.on("end", () => resolve19(body));
+    req.on("end", () => resolve20(body));
     req.on("error", reject);
   });
 }
@@ -8620,6 +8620,64 @@ async function diff2(req, res) {
   }
 }
 
+// src/commands/sessions/web/fileContent.ts
+import { readFile, stat as stat2 } from "fs/promises";
+import { isAbsolute, relative as relative2, resolve as resolve9 } from "path";
+
+// src/commands/sessions/web/windowsCwdToWslPath.ts
+function windowsCwdToWslPath(cwd) {
+  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
+  if (!match) return cwd;
+  const drive = match[1].toLowerCase();
+  const rest = match[2].replace(/\\/g, "/");
+  return `/mnt/${drive}/${rest}`;
+}
+
+// src/commands/sessions/web/toGitCwd.ts
+function toGitCwd(cwd) {
+  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
+}
+
+// src/commands/sessions/web/fileContent.ts
+var MAX_FILE_BYTES = 2 * 1024 * 1024;
+function resolveWithinCwd(cwd, path71) {
+  const root = resolve9(toGitCwd(cwd));
+  const target = resolve9(root, path71);
+  const rel = relative2(root, target);
+  if (rel === "" || rel.startsWith("..") || isAbsolute(rel)) return null;
+  return target;
+}
+async function fileContent(req, res) {
+  const cwd = getCwdParam(req, res);
+  if (!cwd) return;
+  const path71 = new URL(req.url ?? "/", "http://localhost").searchParams.get(
+    "path"
+  );
+  if (!path71) {
+    respondJson(res, 400, { error: "Missing path" });
+    return;
+  }
+  const target = resolveWithinCwd(cwd, path71);
+  if (!target) {
+    respondJson(res, 400, { error: "Path outside cwd" });
+    return;
+  }
+  try {
+    const info = await stat2(target);
+    if (!info.isFile()) {
+      respondJson(res, 404, { error: "File not found" });
+      return;
+    }
+    if (info.size > MAX_FILE_BYTES) {
+      respondJson(res, 413, { error: "File too large" });
+      return;
+    }
+    respondJson(res, 200, { content: await readFile(target, "utf8") });
+  } catch {
+    respondJson(res, 404, { error: "File not found" });
+  }
+}
+
 // src/shared/db/listBackups.ts
 import { desc } from "drizzle-orm";
 async function listBackups(db) {
@@ -8663,20 +8721,6 @@ function getHtml() {
 </html>`;
 }
 
-// src/commands/sessions/web/windowsCwdToWslPath.ts
-function windowsCwdToWslPath(cwd) {
-  const match = /^([A-Za-z]):[\\/](.*)$/.exec(cwd);
-  if (!match) return cwd;
-  const drive = match[1].toLowerCase();
-  const rest = match[2].replace(/\\/g, "/");
-  return `/mnt/${drive}/${rest}`;
-}
-
-// src/commands/sessions/web/toGitCwd.ts
-function toGitCwd(cwd) {
-  return detectPlatform() === "wsl" ? windowsCwdToWslPath(cwd) : cwd;
-}
-
 // src/commands/sessions/web/handleServerRuns.ts
 function getServerRuns(rawCwd) {
   try {
@@ -9242,17 +9286,17 @@ async function stopDaemon() {
   }
 }
 function closedBeforeTimeout(socket) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const timer = setTimeout(() => {
       socket.destroy();
-      resolve19(false);
+      resolve20(false);
     }, STOP_TIMEOUT_MS);
     socket.resume();
     socket.on("error", () => {
     });
     socket.once("close", () => {
       clearTimeout(timer);
-      resolve19(true);
+      resolve20(true);
     });
   });
 }
@@ -9303,8 +9347,8 @@ async function restartWeb(req, res, deps2 = {}) {
     respondJson(res, 400, { error: "Invalid target" });
     return;
   }
-  await new Promise((resolve19) => {
-    res.once("finish", resolve19);
+  await new Promise((resolve20) => {
+    res.once("finish", resolve20);
     respondJson(res, 200, { ok: true });
   });
   if (target === "daemon" || target === "both") {
@@ -9488,6 +9532,7 @@ var routes2 = {
   "GET /api/github-url": githubUrl,
   "GET /api/git-status": gitStatus,
   "GET /api/diff": diff2,
+  "GET /api/file": fileContent,
   "GET /api/jira-site": jiraSite,
   "GET /api/harness": harnessCapabilities,
   "GET /api/pr-status": prStatus,
@@ -10275,7 +10320,7 @@ function registerExportCommand(cmd) {
 }
 
 // src/commands/backlog/import/index.ts
-import { readFile } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import chalk71 from "chalk";
 
 // src/commands/backlog/dump/countCopyRows.ts
@@ -10452,7 +10497,7 @@ async function restore(client, parsed) {
 
 // src/commands/backlog/import/index.ts
 async function importBacklog(file, options2 = {}) {
-  const raw = file ? await readFile(file) : await readStdinBuffer();
+  const raw = file ? await readFile2(file) : await readStdinBuffer();
   const parsed = parseDump(raw);
   validateDump(parsed);
   const { tables } = parsed.header;
@@ -12396,7 +12441,7 @@ function findBuiltinDenyRaw(rawCommand) {
 }
 
 // src/shared/isApprovedRead.ts
-import { resolve as resolve10, sep } from "path";
+import { resolve as resolve11, sep } from "path";
 
 // src/shared/tokenize.ts
 function tokenize(command) {
@@ -12478,7 +12523,7 @@ function extractGraphqlQuery(args) {
 
 // src/shared/loadCliReads.ts
 import { existsSync as existsSync29, readFileSync as readFileSync23, writeFileSync as writeFileSync22 } from "fs";
-import { dirname as dirname21, resolve as resolve9 } from "path";
+import { dirname as dirname21, resolve as resolve10 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 var __filename3 = fileURLToPath5(import.meta.url);
 var __dirname4 = dirname21(__filename3);
@@ -12493,13 +12538,13 @@ var cachedReads;
 var cachedWrites;
 function getCliReadsLines() {
   if (!cachedReads) {
-    cachedReads = readLines(resolve9(packageRoot(), "allowed.cli-reads"));
+    cachedReads = readLines(resolve10(packageRoot(), "allowed.cli-reads"));
   }
   return cachedReads;
 }
 function getCliWritesLines() {
   if (!cachedWrites) {
-    cachedWrites = readLines(resolve9(packageRoot(), "allowed.cli-writes"));
+    cachedWrites = readLines(resolve10(packageRoot(), "allowed.cli-writes"));
   }
   return cachedWrites;
 }
@@ -12508,7 +12553,7 @@ function loadCliReads() {
 }
 function saveCliReads(commands) {
   writeFileSync22(
-    resolve9(packageRoot(), "allowed.cli-reads"),
+    resolve10(packageRoot(), "allowed.cli-reads"),
     `${commands.join("\n")}
 `
   );
@@ -12630,19 +12675,19 @@ function isCdToCwd(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length > 2) return false;
   if (parts.length === 1) return false;
-  const resolved = resolve10(normalizeMsysPath(parts[1]));
-  return resolved === resolve10(process.cwd());
+  const resolved = resolve11(normalizeMsysPath(parts[1]));
+  return resolved === resolve11(process.cwd());
 }
 function isCdToReadAllowedDir(command) {
   const parts = command.split(/\s+/);
   if (parts[0] !== "cd" || parts.length !== 2) return void 0;
-  const target = resolve10(normalizeMsysPath(parts[1]));
+  const target = resolve11(normalizeMsysPath(parts[1]));
   for (const entry of readSettingsPerms("allow")) {
     const m = entry.match(READ_RE);
     if (!m) continue;
     const base = globBaseDir(m[1]);
     if (!base) continue;
-    const resolved = resolve10(normalizeMsysPath(base));
+    const resolved = resolve11(normalizeMsysPath(base));
     if (target === resolved || target.startsWith(resolved + sep)) {
       return `cd to Read-allowed directory: ${entry}`;
     }
@@ -12959,12 +13004,12 @@ function hasSubcommands(helpText) {
 // src/commands/permitCliReads/runHelp.ts
 import { exec as exec2 } from "child_process";
 function runHelp(args) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     exec2(
       `${args.join(" ")} --help`,
       { encoding: "utf8", timeout: 3e4 },
       (_err, stdout, stderr) => {
-        resolve19(stdout || stderr || "");
+        resolve20(stdout || stderr || "");
       }
     );
   });
@@ -15285,10 +15330,10 @@ function findSlnFiles(dir, maxDepth, depth = 0) {
       continue;
     const full = path32.join(dir, entry);
     try {
-      const stat2 = statSync5(full);
-      if (stat2.isFile() && entry.endsWith(".sln")) {
+      const stat3 = statSync5(full);
+      if (stat3.isFile() && entry.endsWith(".sln")) {
         results.push(full);
-      } else if (stat2.isDirectory()) {
+      } else if (stat3.isDirectory()) {
         results.push(...findSlnFiles(full, maxDepth, depth + 1));
       }
     } catch {
@@ -16753,12 +16798,12 @@ function registerList(program2) {
 
 // src/commands/mermaid/index.ts
 import { mkdirSync as mkdirSync16, readdirSync as readdirSync9 } from "fs";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 import chalk156 from "chalk";
 
 // src/commands/mermaid/exportFile.ts
 import { readFileSync as readFileSync36, writeFileSync as writeFileSync31 } from "fs";
-import { basename as basename11, extname as extname2, resolve as resolve11 } from "path";
+import { basename as basename11, extname as extname2, resolve as resolve12 } from "path";
 import chalk155 from "chalk";
 
 // src/commands/mermaid/renderBlock.ts
@@ -16806,7 +16851,7 @@ async function exportFile(file, outDir, krokiUrl, onlyIndex) {
   for (const [i, source] of blocks.entries()) {
     const idx = i + 1;
     if (onlyIndex !== void 0 && idx !== onlyIndex) continue;
-    const outPath = resolve11(outDir, `${stem}-${idx}.svg`);
+    const outPath = resolve12(outDir, `${stem}-${idx}.svg`);
     const svg = await renderBlock(krokiUrl, source);
     writeFileSync31(outPath, svg, "utf8");
     console.log(chalk155.green(`  \u2192 ${outPath}`));
@@ -16820,7 +16865,7 @@ function extractMermaidBlocks(markdown) {
 // src/commands/mermaid/index.ts
 async function mermaidExport(file, options2 = {}) {
   const { mermaid } = loadConfig();
-  const outDir = resolve12(process.cwd(), options2.out ?? ".");
+  const outDir = resolve13(process.cwd(), options2.out ?? ".");
   mkdirSync16(outDir, { recursive: true });
   if (options2.index !== void 0) {
     if (!Number.isInteger(options2.index) || options2.index < 1) {
@@ -16945,7 +16990,7 @@ function createNetcapHandler(options2) {
 }
 
 // src/commands/netcap/prepareExtensionForLoad.ts
-import { cp, readFile as readFile2, writeFile as writeFile3 } from "fs/promises";
+import { cp, readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
 import { networkInterfaces } from "os";
 import { join as join47 } from "path";
 import chalk157 from "chalk";
@@ -16971,7 +17016,7 @@ function lanIPv4() {
 }
 async function configureBackground(dir, host, port, filter) {
   const file = join47(dir, "background.js");
-  const source = await readFile2(file, "utf8");
+  const source = await readFile3(file, "utf8");
   await writeFile3(
     file,
     source.replace(
@@ -17010,7 +17055,7 @@ async function prepareExtensionForLoad(port, filter = "") {
 }
 
 // src/commands/netcap/resolveNetcapOutPath.ts
-import { isAbsolute, join as join49, resolve as resolve13 } from "path";
+import { isAbsolute as isAbsolute2, join as join49, resolve as resolve14 } from "path";
 
 // src/commands/netcap/defaultCapturePath.ts
 import { homedir as homedir19 } from "os";
@@ -17022,7 +17067,7 @@ function defaultCapturePath() {
 // src/commands/netcap/resolveNetcapOutPath.ts
 function resolveNetcapOutPath(out) {
   if (!out) return defaultCapturePath();
-  const dir = isAbsolute(out) ? out : resolve13(process.cwd(), out);
+  const dir = isAbsolute2(out) ? out : resolve14(process.cwd(), out);
   return join49(dir, "capture.jsonl");
 }
 
@@ -17113,25 +17158,25 @@ function isVisibleText(t) {
   return /[a-zA-Z]{3,}/.test(t);
 }
 var isHashtag = (t) => /^#[A-Za-z0-9_]+$/.test(t);
-function collectRscText(v, resolve19, sink2, seen) {
+function collectRscText(v, resolve20, sink2, seen) {
   if (v == null) return;
   if (typeof v === "string") {
     if (isRscRef(v)) {
       if (!seen.has(v)) {
         seen.add(v);
-        collectRscText(resolve19(v), resolve19, sink2, seen);
+        collectRscText(resolve20(v), resolve20, sink2, seen);
       }
     } else if (isHashtag(v)) sink2.hashtags.push(v);
     else if (isVisibleText(v)) sink2.text.push(v);
     return;
   }
   if (Array.isArray(v)) {
-    for (const x of v) collectRscText(x, resolve19, sink2, seen);
+    for (const x of v) collectRscText(x, resolve20, sink2, seen);
     return;
   }
   if (typeof v === "object") {
     for (const val of Object.values(v)) {
-      collectRscText(val, resolve19, sink2, seen);
+      collectRscText(val, resolve20, sink2, seen);
     }
   }
 }
@@ -17163,7 +17208,7 @@ function visitObjects(root, fn) {
     }
   }
 }
-function buildMentionMap(rows, resolve19) {
+function buildMentionMap(rows, resolve20) {
   const map = /* @__PURE__ */ new Map();
   visitObjects(rows, (o) => {
     const url = profileActionUrl(o);
@@ -17171,7 +17216,7 @@ function buildMentionMap(rows, resolve19) {
     const slug = slugFromProfileUrl(url);
     if (!slug || map.has(slug)) return;
     const sink2 = { text: [], hashtags: [] };
-    collectRscText(o.children, resolve19, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve20, sink2, /* @__PURE__ */ new Set());
     const name = sink2.text.join(" ").replace(/\s+/g, " ").trim();
     map.set(slug, name ? { slug, name, url } : { slug, url });
   });
@@ -17257,10 +17302,10 @@ function buildPost(raw, mentionMap, author) {
 
 // src/commands/netcap/walkPostRow.ts
 var isCommentary = (o) => asObject(o.viewTrackingSpecs)?.viewName === "feed-commentary";
-function walkPostRow(v, resolve19, raw) {
+function walkPostRow(v, resolve20, raw) {
   if (v == null || typeof v !== "object") return;
   if (Array.isArray(v)) {
-    for (const x of v) walkPostRow(x, resolve19, raw);
+    for (const x of v) walkPostRow(x, resolve20, raw);
     return;
   }
   const o = v;
@@ -17274,9 +17319,9 @@ function walkPostRow(v, resolve19, raw) {
   }
   if (isCommentary(o)) {
     const sink2 = { text: raw.text, hashtags: raw.hashtags };
-    collectRscText(o.children, resolve19, sink2, /* @__PURE__ */ new Set());
+    collectRscText(o.children, resolve20, sink2, /* @__PURE__ */ new Set());
   }
-  for (const val of Object.values(o)) walkPostRow(val, resolve19, raw);
+  for (const val of Object.values(o)) walkPostRow(val, resolve20, raw);
 }
 
 // src/commands/netcap/extractLinkedInPosts.ts
@@ -17290,8 +17335,8 @@ function findCommentaryRows(rows) {
 }
 function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
   const rows = parseRscRows(flight);
-  const resolve19 = makeRscResolver(rows);
-  const mentionMap = buildMentionMap(rows, resolve19);
+  const resolve20 = makeRscResolver(rows);
+  const mentionMap = buildMentionMap(rows, resolve20);
   const posts = [];
   for (const id of findCommentaryRows(rows)) {
     const raw = {
@@ -17301,7 +17346,7 @@ function extractLinkedInPosts(flight, author = findAuthorSlug(flight)) {
       links: [],
       related: []
     };
-    walkPostRow(rows[id], resolve19, raw);
+    walkPostRow(rows[id], resolve20, raw);
     const post = buildPost(raw, mentionMap, author);
     if (post) posts.push(post);
   }
@@ -18600,7 +18645,7 @@ function parseIncoming(line, requestId) {
 
 // src/commands/prs/requestPrDecision.ts
 function requestPrDecision(request) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     connectToDaemon().then((socket) => {
       let settled = false;
       const finish = (error, decision) => {
@@ -18608,7 +18653,7 @@ function requestPrDecision(request) {
         settled = true;
         socket.destroy();
         if (error) reject(error);
-        else resolve19(decision);
+        else resolve20(decision);
       };
       readSocketLines(socket, (line) => {
         const incoming = parseIncoming(line, request.requestId);
@@ -19510,7 +19555,7 @@ function getViolations(pattern2, options2 = {}, maxLines = DEFAULT_MAX_LINES) {
 
 // src/commands/refactor/check/index.ts
 function runScript(script, cwd) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const child = spawn5("npm", ["run", script], {
       stdio: "pipe",
       shell: true,
@@ -19524,7 +19569,7 @@ function runScript(script, cwd) {
       output += data.toString();
     });
     child.on("close", (code) => {
-      resolve19({ script, code: code ?? 1, output });
+      resolve20({ script, code: code ?? 1, output });
     });
   });
 }
@@ -22336,12 +22381,12 @@ function onCloseResult(ctx, code) {
   return { ...closed, stderr: ctx.stderr.value, stdout: ctx.stdout.value };
 }
 function waitForChildExit(ctx) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     let settled = false;
     const settle = (result) => {
       if (settled) return;
       settled = true;
-      resolve19(result);
+      resolve20(result);
     };
     ctx.child.on("error", (err) => settle(onErrorResult(ctx, err)));
     ctx.child.on("close", (code) => settle(onCloseResult(ctx, code)));
@@ -23448,9 +23493,9 @@ function createReadlineInterface() {
   });
 }
 function askQuestion(rl, question) {
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     rl.question(question, (answer) => {
-      resolve19(answer.trim());
+      resolve20(answer.trim());
     });
   });
 }
@@ -24215,7 +24260,7 @@ function extractCode(url, expectedState) {
   return code;
 }
 function waitForCallback(port, expectedState) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const timeout = setTimeout(() => {
       server.close();
       reject(new Error("Authorization timed out after 120 seconds"));
@@ -24232,7 +24277,7 @@ function waitForCallback(port, expectedState) {
         const code = extractCode(url, expectedState);
         respondHtml(res, 200, "Authorization successful!");
         server.close();
-        resolve19(code);
+        resolve20(code);
       } catch (error) {
         respondHtml(res, 400, error.message);
         server.close();
@@ -24497,7 +24542,7 @@ var rootConfigHelp = {
 };
 
 // src/commands/run/index.ts
-import { resolve as resolve15 } from "path";
+import { resolve as resolve16 } from "path";
 
 // src/commands/run/findRunConfig.ts
 function exitNoRunConfigs() {
@@ -24596,12 +24641,12 @@ function runPreCommands(pre, cwd) {
 // src/commands/run/spawnRunCommand.ts
 import { execFileSync as execFileSync10, spawn as spawn8 } from "child_process";
 import { existsSync as existsSync54 } from "fs";
-import { dirname as dirname27, join as join64, resolve as resolve14 } from "path";
+import { dirname as dirname27, join as join64, resolve as resolve15 } from "path";
 function resolveCommand2(command) {
   if (process.platform !== "win32" || command !== "bash") return command;
   try {
     const gitPath = execFileSync10("where", ["git"], { encoding: "utf8" }).trim().split("\r\n")[0];
-    const gitRoot = resolve14(dirname27(gitPath), "..");
+    const gitRoot = resolve15(dirname27(gitPath), "..");
     const gitBash = join64(gitRoot, "bin", "bash.exe");
     if (existsSync54(gitBash)) return gitBash;
   } catch {
@@ -24649,7 +24694,7 @@ function listRunConfigs(verbose) {
   }
 }
 function execRunConfig(config, args) {
-  const cwd = config.cwd ? resolve15(getConfigDir(), config.cwd) : void 0;
+  const cwd = config.cwd ? resolve16(getConfigDir(), config.cwd) : void 0;
   if (config.pre) runPreCommands(config.pre, cwd);
   const resolved = resolveParams(config.params, args);
   spawnRunCommand(
@@ -24889,7 +24934,7 @@ function registerRun(program2) {
 import { execSync as execSync58 } from "child_process";
 import { existsSync as existsSync56, mkdirSync as mkdirSync24, unlinkSync as unlinkSync21, writeFileSync as writeFileSync42 } from "fs";
 import { tmpdir as tmpdir8 } from "os";
-import { join as join67, resolve as resolve16 } from "path";
+import { join as join67, resolve as resolve17 } from "path";
 import chalk203 from "chalk";
 
 // src/commands/screenshot/captureWindowPs1.ts
@@ -25023,7 +25068,7 @@ function buildOutputPath(outputDir, processName) {
     mkdirSync24(outputDir, { recursive: true });
   }
   const timestamp6 = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
-  return resolve16(outputDir, `${processName}-${timestamp6}.png`);
+  return resolve17(outputDir, `${processName}-${timestamp6}.png`);
 }
 function runPowerShellScript(processName, outputPath) {
   const scriptPath = join67(tmpdir8(), `assist-screenshot-${Date.now()}.ps1`);
@@ -25039,7 +25084,7 @@ function runPowerShellScript(processName, outputPath) {
 }
 function screenshot(processName) {
   const config = loadConfig();
-  const outputDir = resolve16(config.screenshot.outputDir);
+  const outputDir = resolve17(config.screenshot.outputDir);
   const outputPath = buildOutputPath(outputDir, processName);
   console.log(chalk203.gray(`Capturing window for process "${processName}" ...`));
   try {
@@ -25072,10 +25117,10 @@ var STATUS_TIMEOUT_MS = 5e3;
 function queryDaemon(socket) {
   socket.write(`${JSON.stringify({ type: "ping" })}
 `);
-  return new Promise((resolve19) => {
+  return new Promise((resolve20) => {
     const result = { sessions: [] };
     const pending = /* @__PURE__ */ new Set(["sessions", "pong"]);
-    const timer = setTimeout(() => resolve19(result), STATUS_TIMEOUT_MS);
+    const timer = setTimeout(() => resolve20(result), STATUS_TIMEOUT_MS);
     const lines = createInterface5({ input: socket });
     lines.on("error", () => {
     });
@@ -25083,7 +25128,7 @@ function queryDaemon(socket) {
       applyLine(result, pending, line);
       if (pending.size === 0) {
         clearTimeout(timer);
-        resolve19(result);
+        resolve20(result);
       }
     });
   });
@@ -25200,7 +25245,7 @@ var persistedSessionSchema = z5.object({
   assistArgs: z5.array(z5.string()).optional(),
   activity: activitySchema.optional(),
   starred: z5.boolean().optional(),
-  undurable: z5.object({ reason: z5.string() }).optional()
+  undurable: z5.object({ reason: z5.string(), removesTree: z5.boolean().optional() }).optional()
 });
 
 // src/commands/sessions/daemon/toPersistedSession.ts
@@ -25259,40 +25304,95 @@ function logPersist(live) {
   );
 }
 
+// src/commands/sessions/daemon/clearPersistedSessionsOnDrain.ts
+function clearPersistedSessionsOnDrain() {
+  const held = loadPersistedSessions().filter((s) => s.status === "stopped");
+  savePersistedSessions(held);
+  console.log(
+    held.length > 0 ? `Sessions daemon is not running; cleared persisted sessions (kept ${held.length} stopped session(s) holding unpushed work)` : "Sessions daemon is not running; cleared persisted sessions"
+  );
+}
+
+// src/commands/sessions/daemon/readDaemonMessage.ts
+function readDaemonMessage(lines, timeoutMs, fallback, match) {
+  return new Promise((resolve20) => {
+    const finish = (value) => {
+      clearTimeout(timer);
+      lines.off("line", onLine);
+      resolve20(value);
+    };
+    const timer = setTimeout(() => finish(fallback), timeoutMs);
+    const onLine = (line) => {
+      try {
+        const matched = match(JSON.parse(line));
+        if (matched !== void 0) finish(matched);
+      } catch {
+      }
+    };
+    lines.on("line", onLine);
+  });
+}
+
 // src/commands/sessions/daemon/drainDaemon.ts
 var DRAIN_TIMEOUT_MS = 5e3;
-async function drainDaemon() {
+var LIST_TIMEOUT_MS = 2e3;
+async function drainDaemon(options2 = {}) {
   let socket;
   try {
     socket = await connectToDaemon();
   } catch {
-    savePersistedSessions([]);
-    console.log("Sessions daemon is not running; cleared persisted sessions");
+    clearPersistedSessionsOnDrain();
     return;
   }
-  const count7 = await requestDrain(socket);
+  const lines = createInterface6({ input: socket });
+  lines.on("error", () => {
+  });
+  const live = await liveSessions(lines);
+  if (live.length > 0 && options2.yes !== true) {
+    reportLive(live);
+    if (!await confirmDrain()) {
+      socket.destroy();
+      return;
+    }
+  }
+  const count7 = await requestDrain(socket, lines);
   socket.destroy();
   console.log(`Drained ${count7} session(s)`);
 }
-function requestDrain(socket) {
+function reportLive(live) {
+  console.log(`${live.length} live session(s) would be closed:`);
+  for (const s of live)
+    console.log(`  - ${s.name} [${s.status}]${s.cwd ? ` in ${s.cwd}` : ""}`);
+}
+async function confirmDrain() {
+  if (!process.stdin.isTTY) {
+    console.log("Refusing to close live sessions; re-run with --yes");
+    process.exitCode = 1;
+    return false;
+  }
+  if (await promptConfirm("Close them all?", false)) return true;
+  console.log("Drain cancelled");
+  return false;
+}
+function liveSessions(lines) {
+  return readDaemonMessage(
+    lines,
+    LIST_TIMEOUT_MS,
+    [],
+    (data) => data.type === "sessions" ? (data.sessions ?? []).filter(
+      (s) => s.status === "running" || s.status === "waiting"
+    ) : void 0
+  );
+}
+function requestDrain(socket, lines) {
   socket.write(`${JSON.stringify({ type: "drain" })}
 `);
-  return new Promise((resolve19) => {
-    const timer = setTimeout(() => resolve19(0), DRAIN_TIMEOUT_MS);
-    const lines = createInterface6({ input: socket });
-    lines.on("error", () => {
-    });
-    lines.on("line", (line) => {
-      try {
-        const data = JSON.parse(line);
-        if (data.type === "drained") {
-          clearTimeout(timer);
-          resolve19(data.count ?? 0);
-        }
-      } catch {
-      }
-    });
-  });
+  return readDaemonMessage(
+    lines,
+    DRAIN_TIMEOUT_MS,
+    0,
+    (data) => data.type === "drained" ? data.count ?? 0 : void 0
+  );
 }
 
 // src/commands/sessions/daemon/runDaemon.ts
@@ -25702,8 +25802,40 @@ function createRunSession(id, runName, runArgs, cwd, meta = serverRunMeta(runNam
   };
 }
 
+// src/commands/sessions/daemon/killPtyTree.ts
+function killPtyTree(pty2) {
+  if (process.platform === "win32") {
+    pty2.kill();
+    return;
+  }
+  try {
+    process.kill(-pty2.pid, "SIGHUP");
+  } catch {
+    try {
+      pty2.kill();
+    } catch {
+    }
+  }
+}
+
+// src/commands/sessions/daemon/worktree/treeUnderClose.ts
+function treeUnderClose(session) {
+  if (session.worktree) return { path: session.worktree.path, removable: true };
+  if (session.cwd) return { path: session.cwd, removable: false };
+  return void 0;
+}
+
+// src/commands/sessions/daemon/worktree/otherTreeHolders.ts
+function otherTreeHolders(sessions, session) {
+  const tree = treeUnderClose(session)?.path;
+  if (!tree) return [];
+  return [...sessions.values()].filter(
+    (s) => s.id !== session.id && treeUnderClose(s)?.path === tree
+  );
+}
+
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync58 } from "fs";
+import { existsSync as existsSync59 } from "fs";
 
 // src/commands/sessions/daemon/worktree/git.ts
 import { execFile as execFile7, execFileSync as execFileSync12 } from "child_process";
@@ -25720,10 +25852,10 @@ function gitInvocation(cwd, args) {
 }
 function git3(cwd, args) {
   const { file, argv, options: options2 } = gitInvocation(cwd, args);
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     execFile7(file, argv, options2, (error, stdout) => {
       if (error) reject(error);
-      else resolve19(stdout.toString());
+      else resolve20(stdout.toString());
     });
   });
 }
@@ -25734,6 +25866,16 @@ async function gitOrNull(cwd, args) {
     return null;
   }
 }
+async function gitResult(cwd, args) {
+  try {
+    return { ok: true, out: (await git3(cwd, args)).trim() };
+  } catch (error) {
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
 function gitSync(cwd, args) {
   const { file, argv, options: options2 } = gitInvocation(cwd, args);
   return execFileSync12(file, argv, {
@@ -25773,6 +25915,7 @@ function gitCommonDir(cwd) {
 }
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
+import { existsSync as existsSync58 } from "fs";
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
   if (!state.push && state.localOnlyCommits)
@@ -25780,35 +25923,27 @@ function treeDurability(state) {
   return { durable: true };
 }
 async function hasLocalOnlyCommits(cwd) {
-  const upstream = await gitOrNull(cwd, [
+  const upstream = await gitResult(cwd, [
     "rev-parse",
     "--abbrev-ref",
     "--symbolic-full-name",
     "@{upstream}"
   ]);
-  if (upstream) {
-    const ahead = await gitOrNull(cwd, [
+  if (upstream.ok && upstream.out) {
+    const ahead = await gitResult(cwd, [
       "rev-list",
       "--count",
       "@{upstream}..HEAD"
     ]);
-    return Number(ahead ?? "0") > 0;
+    return !ahead.ok || Number(ahead.out) > 0;
   }
-  const remoteBranches = await gitOrNull(cwd, [
+  const remoteBranches = await gitResult(cwd, [
     "branch",
     "-r",
     "--contains",
     "HEAD"
   ]);
-  return !remoteBranches;
-}
-async function collectTreeState(cwd, push) {
-  const status3 = await gitOrNull(cwd, ["status", "--porcelain"]);
-  return {
-    dirty: status3 !== null,
-    push,
-    localOnlyCommits: await hasLocalOnlyCommits(cwd)
-  };
+  return !remoteBranches.ok || remoteBranches.out === "";
 }
 function pushOnCommit(cwd) {
   try {
@@ -25818,12 +25953,20 @@ function pushOnCommit(cwd) {
   }
 }
 async function checkDurability(cwd) {
-  return treeDurability(await collectTreeState(cwd, pushOnCommit(cwd)));
+  if (!existsSync58(cwd)) return { durable: true };
+  const status3 = await gitResult(cwd, ["status", "--porcelain"]);
+  if (!status3.ok)
+    return { durable: false, reason: `tree state unreadable: ${status3.error}` };
+  return treeDurability({
+    dirty: status3.out !== "",
+    push: pushOnCommit(cwd),
+    localOnlyCommits: await hasLocalOnlyCommits(cwd)
+  });
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync58(worktreePath)) {
+  if (!existsSync59(worktreePath)) {
     daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
     return false;
   }
@@ -25870,7 +26013,8 @@ async function deleteBranch(clone, branch2) {
 function dismissSession(sessions, id) {
   const s = sessions.get(id);
   if (!s) return false;
-  if (s.status !== "done") s.pty?.kill();
+  const sharedWith = otherTreeHolders(sessions, s);
+  if (s.status !== "done" && s.pty) killPtyTree(s.pty);
   s.activityWatcher?.close();
   s.transcriptWatcher?.close();
   s.gitWatcher?.close();
@@ -25878,36 +26022,39 @@ function dismissSession(sessions, id) {
   if (s.activity?.itemId != null) releaseLock(s.activity.itemId);
   sessions.delete(id);
   daemonLog(`session ${id} dismissed (${s.name})`);
-  if (s.worktree) void reapWorktree(s.worktree.path);
+  if (!s.worktree) return true;
+  if (sharedWith.length > 0)
+    daemonLog(
+      `worktree ${s.worktree.path} kept: still held by session(s) ${sharedWith.map((h) => h.id).join(", ")}`
+    );
+  else void reapWorktree(s.worktree.path);
   return true;
 }
-function drainSessions(sessions, onDrained) {
-  const names = [...sessions.values()].map((s) => s.name);
-  const ids = [...sessions.keys()];
-  for (const id of ids) dismissSession(sessions, id);
-  onDrained();
-  daemonLog(
-    ids.length > 0 ? `drained ${ids.length} session(s): ${names.join(", ")}` : "drained 0 sessions"
-  );
-  return ids.length;
-}
 
-// src/commands/sessions/daemon/killPtyTree.ts
-function killPtyTree(pty2) {
-  if (process.platform === "win32") {
-    pty2.kill();
-    return;
-  }
+// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
+var DISABLED = {
+  enabled: false,
+  install: true,
+  copy: [".env", "settings.local.json", ".claude/settings.local.json"]
+};
+function worktreeConfigFor(cwd) {
   try {
-    process.kill(-pty2.pid, "SIGHUP");
+    return loadConfigFrom(cwd).worktree ?? DISABLED;
   } catch {
-    try {
-      pty2.kill();
-    } catch {
-    }
+    return DISABLED;
   }
 }
 
+// src/commands/sessions/daemon/worktree/closeGateApplies.ts
+function closeGateApplies(sessions, session) {
+  if (otherTreeHolders(sessions, session).length > 0) return false;
+  if (session.worktree) return true;
+  if (!session.cwd) return false;
+  if (session.status !== "running" && session.status !== "waiting")
+    return false;
+  return worktreeConfigFor(session.cwd).enabled === true;
+}
+
 // src/commands/sessions/daemon/setStatus.ts
 function setStatus2(session, newStatus) {
   const now = Date.now();
@@ -25919,11 +26066,11 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync59, watch } from "fs";
+import { existsSync as existsSync60, watch } from "fs";
 var DEBOUNCE_MS = 500;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync59(common)) return void 0;
+  if (!common || !existsSync60(common)) return void 0;
   let timer = null;
   try {
     return watch(common, { recursive: true }, () => {
@@ -25938,19 +26085,19 @@ function watchGitState(cwd, onChange) {
   }
 }
 
-// src/commands/sessions/daemon/worktree/resolveDoneDurability.ts
-async function resolveDoneDurability(session, finalize, notify2) {
-  const worktree = session.worktree;
-  if (!worktree) {
+// src/commands/sessions/daemon/worktree/resolveCloseDurability.ts
+async function resolveCloseDurability(session, finalize, notify2) {
+  const tree = treeUnderClose(session);
+  if (!tree) {
     finalize();
     return;
   }
-  const durability = await checkDurability(worktree.path);
+  const durability = await checkDurability(tree.path);
   if (!durability.durable) {
-    holdStopped(session, durability.reason, finalize, notify2);
+    holdStopped(session, tree, durability.reason, finalize, notify2);
     return;
   }
-  await reapWorktree(worktree.path);
+  if (tree.removable) await reapWorktree(tree.path);
   session.worktree = void 0;
   session.undurable = void 0;
   session.closing = void 0;
@@ -25958,16 +26105,18 @@ async function resolveDoneDurability(session, finalize, notify2) {
   session.gitWatcher = void 0;
   finalize();
 }
-function holdStopped(session, reason, finalize, notify2) {
+function holdStopped(session, tree, reason, finalize, notify2) {
   if (session.undurable?.reason !== reason)
-    daemonLog(`session ${session.id} stopped; reap blocked: ${reason}`);
-  session.undurable = { reason };
+    daemonLog(
+      `session ${session.id} stopped; ${tree.removable ? "reap" : "close"} blocked in ${tree.path}: ${reason}`
+    );
+  session.undurable = { reason, removesTree: tree.removable };
   session.closing = void 0;
   setStatus2(session, "stopped");
-  if (!session.gitWatcher && session.worktree)
-    session.gitWatcher = watchGitState(session.worktree.path, () => {
+  if (!session.gitWatcher)
+    session.gitWatcher = watchGitState(tree.path, () => {
       if (session.status !== "stopped") return;
-      void resolveDoneDurability(session, finalize, notify2);
+      void resolveCloseDurability(session, finalize, notify2);
     });
   notify2();
 }
@@ -25975,14 +26124,15 @@ function holdStopped(session, reason, finalize, notify2) {
 // src/commands/sessions/daemon/dismissSessionGated.ts
 function dismissSessionGated(sessions, id, notify2, discard = false) {
   const s = sessions.get(id);
-  if (!s?.worktree) {
+  const tree = s && treeUnderClose(s);
+  if (!s || !tree || !closeGateApplies(sessions, s)) {
     if (dismissSession(sessions, id)) notify2();
     return;
   }
   const removeCard = () => {
     if (dismissSession(sessions, id)) notify2();
   };
-  const discardTree = async () => {
+  const discardWork = async () => {
     if (s.worktree) {
       await reapWorktree(s.worktree.path, true);
       s.worktree = void 0;
@@ -25991,10 +26141,10 @@ function dismissSessionGated(sessions, id, notify2, discard = false) {
   };
   s.closing = true;
   daemonLog(
-    `session ${id} closing: ${discard ? "discarding" : "checking durability of"} ${s.worktree.path}`
+    `session ${id} closing: ${discard ? "discarding" : "checking durability of"} ${tree.path}`
   );
   if (s.pty) {
-    s.pendingDismiss = discard ? () => void discardTree() : () => void resolveDoneDurability(s, removeCard, notify2);
+    s.pendingDismiss = discard ? () => void discardWork() : () => void resolveCloseDurability(s, removeCard, notify2);
     daemonLog(
       `session ${id} ${discard ? "discard" : "dismiss"} requested: killing process tree first`
     );
@@ -26003,8 +26153,27 @@ function dismissSessionGated(sessions, id, notify2, discard = false) {
     return;
   }
   notify2();
-  if (discard) void discardTree();
-  else void resolveDoneDurability(s, removeCard, notify2);
+  if (discard) void discardWork();
+  else void resolveCloseDurability(s, removeCard, notify2);
+}
+
+// src/commands/sessions/daemon/drainSessions.ts
+function drainSessions(sessions, notify2) {
+  const drained = [...sessions.values()].map((s) => ({
+    id: s.id,
+    name: s.name
+  }));
+  for (const { id } of drained) dismissSessionGated(sessions, id, notify2);
+  notify2();
+  daemonLog(
+    drained.length > 0 ? `drained ${drained.length} session(s): ${drained.map((s) => s.name).join(", ")}` : "drained 0 sessions"
+  );
+  const gated = [...sessions.values()];
+  if (gated.length > 0)
+    daemonLog(
+      `${gated.length} drained session(s) closing under the durability gate: ${gated.map((s) => s.name).join(", ")} \u2014 any holding unpushed work stay as stopped cards`
+    );
+  return drained.length;
 }
 
 // src/shared/db/recordPhaseActiveMs.ts
@@ -26419,7 +26588,7 @@ function applyStatusChange(session, status3, exitCode, dismiss, notify2, reuseFo
       `session ${session.id} closing: checking durability of ${session.worktree.path} before reap`
     );
     notify2();
-    void resolveDoneDurability(
+    void resolveCloseDurability(
       session,
       () => finishStatusChange(session, "done", exitCode, deps2),
       notify2
@@ -26432,7 +26601,7 @@ function finishStatusChange(session, status3, exitCode, deps2) {
   daemonLog(`session ${session.id} status: ${session.status} -> ${status3}`);
   void flushPhaseActiveMs(session);
   setStatus2(session, status3);
-  if (status3 !== "waiting") session.undurable = void 0;
+  if (status3 !== "stopped") session.undurable = void 0;
   const autoRun = shouldAutoRun(session);
   if (autoRun.run) {
     deps2.reuseForRun(session, autoRun.itemId);
@@ -26464,10 +26633,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync60 } from "fs";
+import { existsSync as existsSync61 } from "fs";
 function exitReason(session, exitCode) {
   const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync60(session.cwd))
+  if (session.cwd && !existsSync61(session.cwd))
     return `${base}: working directory ${session.cwd} no longer exists`;
   return base;
 }
@@ -26485,7 +26654,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync61, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
+import { existsSync as existsSync62, mkdirSync as mkdirSync25, watch as watch2 } from "fs";
 import { dirname as dirname29 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -26566,7 +26735,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync61(path71)) read();
+  if (existsSync62(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -27203,8 +27372,8 @@ function restoreAll(spawn12, sessions) {
 // src/commands/sessions/daemon/worktree/rearmStoppedSessions.ts
 function rearmStoppedSessions(sessions, notify2) {
   for (const s of sessions.values()) {
-    if (s.status !== "stopped" || !s.worktree) continue;
-    void resolveDoneDurability(
+    if (s.status !== "stopped" || !treeUnderClose(s)) continue;
+    void resolveCloseDurability(
       s,
       () => {
         if (dismissSession(sessions, s.id)) notify2();
@@ -27215,23 +27384,9 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 import { basename as basename14 } from "path";
 
-// src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
-var DISABLED = {
-  enabled: false,
-  install: true,
-  copy: [".env", "settings.local.json", ".claude/settings.local.json"]
-};
-function worktreeConfigFor(cwd) {
-  try {
-    return loadConfigFrom(cwd).worktree ?? DISABLED;
-  } catch {
-    return DISABLED;
-  }
-}
-
 // src/commands/sessions/daemon/worktree/detectExistingWorktree.ts
 function detectExistingWorktree(cwd) {
   const repoRoot = findRepoRoot(cwd) ?? cwd;
@@ -27243,17 +27398,17 @@ function detectExistingWorktree(cwd) {
 
 // src/commands/sessions/daemon/worktree/seedWorktree.ts
 import { execFile as execFile8 } from "child_process";
-import { copyFileSync, existsSync as existsSync64, mkdirSync as mkdirSync26 } from "fs";
+import { copyFileSync, existsSync as existsSync65, mkdirSync as mkdirSync26 } from "fs";
 import { dirname as dirname30, join as join71 } from "path";
 
 // src/commands/sessions/daemon/worktree/resolveInstallCommand.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import { join as join70 } from "path";
 function detectInstallCommand(repoRoot) {
-  if (!existsSync63(join70(repoRoot, "package.json"))) return null;
-  if (existsSync63(join70(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
-  if (existsSync63(join70(repoRoot, "yarn.lock"))) return "yarn install";
-  if (existsSync63(join70(repoRoot, "bun.lockb"))) return "bun install";
+  if (!existsSync64(join70(repoRoot, "package.json"))) return null;
+  if (existsSync64(join70(repoRoot, "pnpm-lock.yaml"))) return "pnpm install";
+  if (existsSync64(join70(repoRoot, "yarn.lock"))) return "yarn install";
+  if (existsSync64(join70(repoRoot, "bun.lockb"))) return "bun install";
   return "npm install";
 }
 function resolveInstallCommand(repoRoot, install) {
@@ -27272,7 +27427,7 @@ function seedWorktree(worktreePath, clone, onSeeded = () => {
 function copyConfigFiles(worktreePath, clone, copy) {
   for (const rel of copy) {
     const src = join71(clone, rel);
-    if (!existsSync64(src)) continue;
+    if (!existsSync65(src)) continue;
     const dest = join71(worktreePath, rel);
     try {
       mkdirSync26(dirname30(dest), { recursive: true });
@@ -27362,7 +27517,7 @@ async function pruneWorktrees(liveCwds) {
   const orphanBranches = [];
   for (const { path: path71, clone } of readWorktreeRegistry()) {
     if (accounted.has(path71)) continue;
-    if (!existsSync65(path71)) {
+    if (!existsSync66(path71)) {
       clonesToPrune.add(clone);
       orphanBranches.push({ clone, branch: basename14(path71) });
       continue;
@@ -27371,7 +27526,7 @@ async function pruneWorktrees(liveCwds) {
     await reapWorktree(path71);
   }
   for (const clone of clonesToPrune) {
-    if (!existsSync65(clone)) continue;
+    if (!existsSync66(clone)) continue;
     try {
       await git3(clone, ["worktree", "prune"]);
       daemonLog(`worktree bookkeeping pruned for clone ${clone}`);
@@ -27379,7 +27534,7 @@ async function pruneWorktrees(liveCwds) {
     }
   }
   for (const { clone, branch: branch2 } of orphanBranches)
-    if (existsSync65(clone)) await pruneStaleWorktreeBranch(clone, branch2);
+    if (existsSync66(clone)) await pruneStaleWorktreeBranch(clone, branch2);
 }
 async function pruneStaleWorktreeBranch(clone, branch2) {
   if (!listLocalBranches(clone).includes(branch2)) return;
@@ -27544,7 +27699,7 @@ function treeSpawnContext(sessions, spawnWith, notify2, clients, onStatusChange)
 }
 
 // src/commands/sessions/daemon/watchTranscript.ts
-import { existsSync as existsSync66, watch as watch3 } from "fs";
+import { existsSync as existsSync67, watch as watch3 } from "fs";
 
 // src/commands/sessions/daemon/reconcileTranscriptStatus.ts
 async function resolveTranscriptPath(session) {
@@ -27579,7 +27734,7 @@ function watchTranscript(session, onStatusChange) {
   if (!session.cwd || !session.claudeSessionId) return;
   if (session.watchedTranscriptId === session.claudeSessionId) return;
   const dir = projectDirForCwd(session.cwd);
-  if (!existsSync66(dir)) return;
+  if (!existsSync67(dir)) return;
   if (session.transcriptWatcher) {
     session.transcriptWatcher.close();
     session.transcriptWatcher = void 0;
@@ -27632,7 +27787,7 @@ function windowsDaemonHost() {
 var CONNECT_TIMEOUT_MS = 2e3;
 var KEEPALIVE_PROBE_MS = 1e4;
 function connectToWindowsDaemon() {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const socket = net2.connect(windowsDaemonPort(), windowsDaemonHost());
     socket.setTimeout(CONNECT_TIMEOUT_MS);
     socket.once("timeout", () => {
@@ -27642,7 +27797,7 @@ function connectToWindowsDaemon() {
     socket.once("connect", () => {
       socket.setTimeout(0);
       socket.setKeepAlive(true, KEEPALIVE_PROBE_MS);
-      resolve19(socket);
+      resolve20(socket);
     });
     socket.once("error", reject);
   });
@@ -27720,7 +27875,7 @@ async function waitForWindowsDaemon() {
   );
 }
 function delay2(ms) {
-  return new Promise((resolve19) => setTimeout(resolve19, ms));
+  return new Promise((resolve20) => setTimeout(resolve20, ms));
 }
 
 // src/commands/sessions/daemon/defaultConnect.ts
@@ -27730,13 +27885,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync67, readFileSync as readFileSync49 } from "fs";
+import { existsSync as existsSync68, readFileSync as readFileSync49 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync67(sessionsFile)) return false;
+    if (!existsSync68(sessionsFile)) return false;
     const data = JSON.parse(readFileSync49(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -28001,7 +28156,7 @@ async function healWindowsDaemon() {
   daemonLog("windows daemon: auto-heal: stale daemon stopped");
 }
 function runOnWindowsHost(command, timeoutMs) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const child = spawn11("pwsh.exe", ["-Command", command], {
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -28021,7 +28176,7 @@ function runOnWindowsHost(command, timeoutMs) {
     });
     child.on("exit", (code) => {
       clearTimeout(timer);
-      if (code === 0) resolve19();
+      if (code === 0) resolve20();
       else
         reject(
           new Error(
@@ -28324,7 +28479,7 @@ function resumeSession(id, sessionId, cwd, name) {
 }
 
 // src/commands/sessions/daemon/worktree/createWorktree.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 import { basename as basename16, dirname as dirname31 } from "path";
 
 // src/commands/sessions/daemon/worktree/planAllocation.ts
@@ -28349,7 +28504,7 @@ function createWorktree(clone, root, boundTreeRoots2) {
   const path71 = nextWorktreePath(
     clone,
     base,
-    (candidate) => registered.has(candidate) || existsSync68(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
+    (candidate) => registered.has(candidate) || existsSync69(candidate) || boundTreeRoots2.has(candidate) || branches.has(basename16(candidate))
   );
   const trunk = cloneTrunkBranch(clone);
   gitSync(clone, ["config", "push.default", "upstream"]);
@@ -29076,8 +29231,8 @@ function registerDaemon(program2) {
     "Restart the sessions daemon, resuming previously running claude sessions"
   ).action(restartDaemon);
   cmd.command("drain").description(
-    "Remove all sessions from the local daemon for a clean slate (does not affect the Windows daemon)"
-  ).action(drainDaemon);
+    "Remove all sessions from the local daemon for a clean slate (does not affect the Windows daemon); prompts before closing live sessions, and a session holding unpushed work is stopped, not removed"
+  ).option("--yes", "Close live sessions without confirming").action((options2) => drainDaemon(options2));
 }
 
 // src/commands/sessions/registerSetStatusCommand.ts
@@ -29355,16 +29510,16 @@ function buildLimitsSegment(rateLimits) {
 
 // src/commands/readGitBranch.ts
 import { readFileSync as readFileSync52, statSync as statSync12 } from "fs";
-import { isAbsolute as isAbsolute2, join as join73, resolve as resolve17 } from "path";
+import { isAbsolute as isAbsolute3, join as join73, resolve as resolve18 } from "path";
 function resolveGitDir(cwd) {
   const dotGit = join73(cwd, ".git");
-  let stat2;
+  let stat3;
   try {
-    stat2 = statSync12(dotGit);
+    stat3 = statSync12(dotGit);
   } catch {
     return null;
   }
-  if (stat2.isDirectory()) {
+  if (stat3.isDirectory()) {
     return dotGit;
   }
   let contents;
@@ -29378,7 +29533,7 @@ function resolveGitDir(cwd) {
     return null;
   }
   const gitDir = match[1].trim();
-  return isAbsolute2(gitDir) ? gitDir : resolve17(cwd, gitDir);
+  return isAbsolute3(gitDir) ? gitDir : resolve18(cwd, gitDir);
 }
 function readGitBranch(cwd) {
   const gitDir = resolveGitDir(cwd);