@staff0rd/assist 0.434.0 → 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.434.0",
+  version: "0.434.1",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -25245,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
@@ -25304,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((resolve20) => {
-    const timer = setTimeout(() => resolve20(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);
-          resolve20(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
@@ -25747,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";
@@ -25779,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, {
@@ -25818,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)
@@ -25825,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 {
@@ -25863,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;
   }
@@ -25915,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();
@@ -25923,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();
@@ -25964,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 }, () => {
@@ -25983,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;
@@ -26003,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();
 }
@@ -26020,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;
@@ -26036,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`
     );
@@ -26048,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
@@ -26464,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
@@ -26477,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);
@@ -26509,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;
 }
@@ -26530,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
@@ -26611,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;
@@ -27248,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();
@@ -27260,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;
@@ -27288,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) {
@@ -27317,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 });
@@ -27407,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;
@@ -27416,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}`);
@@ -27424,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;
@@ -27589,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) {
@@ -27624,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;
@@ -27775,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) {
@@ -28369,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
@@ -28394,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"]);
@@ -29121,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

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.434.0",
+	"version": "0.434.1",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {