@staff0rd/assist 0.488.0 → 0.488.2

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.488.0",
+  version: "0.488.2",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -10891,6 +10891,18 @@ function resolveNamedRepoWriteLabel(globalRaw, name) {
   return matches[0];
 }
 
+// src/commands/config/resolveRepoConfigBlock.ts
+function resolveRepoConfigBlock(repoName, cwd) {
+  const globalRaw = loadGlobalConfigRaw();
+  const label2 = repoName === void 0 ? resolveRepoWriteLabel(globalRaw, getCurrentOrigin(cwd)) : resolveNamedRepoWriteLabel(globalRaw, repoName);
+  const repos2 = isPlainObject3(globalRaw.repos) ? { ...globalRaw.repos } : {};
+  const block = isPlainObject3(repos2[label2]) ? repos2[label2] : {};
+  return { globalRaw, repos: repos2, label: label2, block };
+}
+function isPlainObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
 // src/commands/config/applyRepoConfigSet.ts
 function applyRepoConfigSet(key, coerced, repoName, cwd = process.cwd()) {
   if (isGlobalOnlyConfigKey(key)) {
@@ -10901,20 +10913,17 @@ function applyRepoConfigSet(key, coerced, repoName, cwd = process.cwd()) {
       ]
     };
   }
-  const globalRaw = loadGlobalConfigRaw();
-  const label2 = repoName === void 0 ? resolveRepoWriteLabel(globalRaw, getCurrentOrigin(cwd)) : resolveNamedRepoWriteLabel(globalRaw, repoName);
-  const repos2 = isPlainObject3(globalRaw.repos) ? { ...globalRaw.repos } : {};
-  const existingBlock = isPlainObject3(repos2[label2]) ? repos2[label2] : {};
-  const updatedBlock = setNestedValue(existingBlock, key, coerced);
+  const { globalRaw, repos: repos2, label: label2, block } = resolveRepoConfigBlock(
+    repoName,
+    cwd
+  );
+  const updatedBlock = setNestedValue(block, key, coerced);
   const validation = validateConfig(updatedBlock, key, repoConfigSchema);
   if (!validation.ok) return validation;
   repos2[label2] = updatedBlock;
   saveGlobalConfig({ ...globalRaw, repos: repos2 });
   return { ok: true, target: "repo", label: label2 };
 }
-function isPlainObject3(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
 
 // src/commands/sessions/web/applyScopedConfigSet.ts
 function applyScopedConfigSet(key, value, cwd, scope) {
@@ -10994,6 +11003,11 @@ function setConfig(req, res) {
   });
 }
 
+// src/commands/config/isKnownConfigKey.ts
+function isKnownConfigKey(key) {
+  return enumerateConfigLeafKeys(assistConfigSchema).includes(key);
+}
+
 // src/commands/config/unsetNestedValue.ts
 function isPlainObject4(val) {
   return val !== null && typeof val === "object" && !Array.isArray(val);
@@ -11084,9 +11098,48 @@ function applyConfigUnset(key, global, cwd = process.cwd()) {
   return { ok: true, target, removed: true };
 }
 
-// src/commands/config/isKnownConfigKey.ts
-function isKnownConfigKey(key) {
-  return enumerateConfigLeafKeys(assistConfigSchema).includes(key);
+// src/commands/config/applyRepoConfigUnset.ts
+function applyRepoConfigUnset(key, repoName, cwd = process.cwd()) {
+  if (isGlobalOnlyConfigKey(key)) {
+    return {
+      ok: false,
+      errors: [
+        `"${key}" is a global-only key. Unset it in ~/.assist.yml rather than under repos:`
+      ]
+    };
+  }
+  const { globalRaw, repos: repos2, label: label2, block } = resolveRepoConfigBlock(
+    repoName,
+    cwd
+  );
+  const { config: updatedBlock, removed } = unsetNestedValue(block, key);
+  if (!removed) return { ok: true, target: "repo", label: label2, removed: false };
+  const validation = validateConfig(updatedBlock, key, repoConfigSchema);
+  if (!validation.ok) return validation;
+  if (Object.keys(updatedBlock).length === 0) delete repos2[label2];
+  else repos2[label2] = updatedBlock;
+  const next3 = { ...globalRaw };
+  if (Object.keys(repos2).length === 0) delete next3.repos;
+  else next3.repos = repos2;
+  saveGlobalConfig(next3);
+  return { ok: true, target: "repo", label: label2, removed: true };
+}
+
+// src/commands/sessions/web/applyScopedConfigUnset.ts
+function applyScopedConfigUnset(key, cwd, scope) {
+  if (scope === "repo") {
+    const result2 = applyRepoConfigUnset(key, void 0, cwd);
+    return result2.ok ? {
+      ok: true,
+      payload: {
+        target: result2.target,
+        repoKey: result2.label,
+        removed: result2.removed
+      }
+    } : result2;
+  }
+  const result = applyConfigUnset(key, scope === "global", cwd);
+  return result.ok ? { ok: true, payload: { target: result.target, removed: result.removed } } : result;
 }
 
 // src/commands/sessions/web/unsetConfig.ts
@@ -11094,22 +11147,7 @@ function unsetConfig(req, res) {
   return handleConfigWrite(req, res, (request) => {
     if (!isKnownConfigKey(request.key))
       return { ok: false, errors: [`Unknown config key "${request.key}"`] };
-    if (request.scope === "repo")
-      return {
-        ok: false,
-        errors: [
-          "Clearing a repos override is not supported \u2014 remove the key from repos: in ~/.assist.yml"
-        ]
-      };
-    const result = applyConfigUnset(
-      request.key,
-      request.scope === "global",
-      request.cwd
-    );
-    return result.ok ? {
-      ok: true,
-      payload: { target: result.target, removed: result.removed }
-    } : result;
+    return applyScopedConfigUnset(request.key, request.cwd, request.scope);
   });
 }
 
@@ -16566,16 +16604,48 @@ function applyRepoOrExit(key, coerced, repoName) {
 
 // src/commands/config/configUnset.ts
 import chalk132 from "chalk";
+
+// src/commands/config/resolveRepoUnsetTarget.ts
+function resolveRepoUnsetTarget(key, repo) {
+  if (typeof repo === "string") {
+    if (key === void 0)
+      return { key: repo, useRepo: true, repoName: void 0 };
+    return { key, useRepo: true, repoName: repo };
+  }
+  return { key, useRepo: repo === true, repoName: void 0 };
+}
+
+// src/commands/config/configUnset.ts
 function configUnset(key, options2 = {}) {
-  const result = applyConfigUnset(key, options2.global ?? false);
+  if (options2.repo !== void 0 && !options2.global) {
+    console.error(
+      chalk132.red(
+        "--repo removes from the global config; add -g (e.g. -g --repo)"
+      )
+    );
+    process.exit(1);
+  }
+  const resolved = resolveRepoUnsetTarget(key, options2.repo);
+  if (resolved.key === void 0) {
+    console.error(chalk132.red("Missing required argument 'key'"));
+    process.exit(1);
+    return;
+  }
+  const result = resolved.useRepo ? applyRepoConfigUnset(resolved.key, resolved.repoName) : applyConfigUnset(resolved.key, options2.global ?? false);
   if (!result.ok) exitWithConfigErrors(result.errors);
   if (!result.removed) {
     console.log(
-      chalk132.yellow(`${key} is not set in the ${result.target} config`)
+      chalk132.yellow(`${resolved.key} is not set in ${whereLabel(result)}`)
     );
     return;
   }
-  console.log(chalk132.green(`Unset ${key} (${result.target})`));
+  console.log(chalk132.green(`Unset ${resolved.key} (${targetLabel(result)})`));
+}
+function whereLabel(result) {
+  return result.target === "repo" ? `repos.${result.label}` : `the ${result.target} config`;
+}
+function targetLabel(result) {
+  return result.target === "repo" ? `repo: ${result.label}` : result.target;
 }
 
 // src/commands/registerConfig.ts
@@ -16585,7 +16655,10 @@ function registerConfig(program2) {
     "-r, --repo [name]",
     "Requires -g: scope the global write to a repo's identity (defaults to the current repo)"
   ).action((key, value, options2) => configSet(key, value, options2));
-  configCommand.command("unset <key>").description("Remove a config value (e.g. commit.push)").option("-g, --global", "Remove from global ~/.assist.yml").action((key, options2) => configUnset(key, options2));
+  configCommand.command("unset [key]").description("Remove a config value (e.g. commit.push)").option("-g, --global", "Remove from global ~/.assist.yml").option(
+    "-r, --repo [name]",
+    "Requires -g: remove the key from a repo's identity block (defaults to the current repo)"
+  ).action((key, options2) => configUnset(key, options2));
   configCommand.command("get <key>").description("Get a config value").action(configGet);
   configCommand.command("list").description("List all config values").action(configList);
 }
@@ -18970,6 +19043,7 @@ function createWorktree(clone, strategy, boundTreeRoots2) {
 
 // src/commands/sessions/daemon/worktree/treeDurability.ts
 import { existsSync as existsSync45 } from "fs";
+var treeIsGone = { durable: true, gone: true };
 function treeDurability(state) {
   if (state.dirty) return { durable: false, reason: "uncommitted changes" };
   if (state.localOnlyCommits)
@@ -18999,14 +19073,14 @@ function* durabilityProbes() {
   });
 }
 async function checkDurability(cwd) {
-  if (!existsSync45(cwd)) return { durable: true };
+  if (!existsSync45(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
   return step2.value;
 }
 function checkDurabilitySync(cwd) {
-  if (!existsSync45(cwd)) return { durable: true };
+  if (!existsSync45(cwd)) return treeIsGone;
   const probes = durabilityProbes();
   let step2 = probes.next();
   while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
@@ -28400,6 +28474,7 @@ function readDesignSystemPrompt() {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
+import { existsSync as existsSync62 } from "fs";
 import * as pty from "node-pty";
 
 // src/commands/sessions/daemon/ensureSpawnHelperExecutable.ts
@@ -28424,7 +28499,15 @@ function ensureSpawnHelperExecutable() {
 }
 
 // src/commands/sessions/daemon/spawnPty.ts
+var MissingCwdError = class extends Error {
+  constructor(cwd) {
+    super(`working directory no longer exists: ${cwd}`);
+    this.cwd = cwd;
+    this.name = "MissingCwdError";
+  }
+};
 function spawnPty(args, cwd, sessionId, extraEnv) {
+  refuseMissingCwd(cwd, sessionId);
   ensureSpawnHelperExecutable();
   const shell = process.platform === "win32" ? "cmd.exe" : process.env.SHELL ?? "bash";
   const shellArgs = process.platform === "win32" ? ["/c", ...args] : ["-l", "-c", `exec ${args.map(shellEscape).join(" ")}`];
@@ -28445,6 +28528,13 @@ function spawnPty(args, cwd, sessionId, extraEnv) {
     }
   });
 }
+function refuseMissingCwd(cwd, sessionId) {
+  if (!cwd || existsSync62(cwd)) return;
+  daemonLog(
+    `${sessionId ? `session ${sessionId}` : "pty"} not spawned: working directory ${cwd} no longer exists`
+  );
+  throw new MissingCwdError(cwd);
+}
 function shellEscape(s) {
   return `'${s.replace(/'/g, String.raw`'\''`)}'`;
 }
@@ -28578,11 +28668,11 @@ function otherTreeHolders(sessions, session) {
 }
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
-import { existsSync as existsSync63 } from "fs";
+import { existsSync as existsSync64 } from "fs";
 import { basename as basename18 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteStrandedTree.ts
-import { existsSync as existsSync62 } from "fs";
+import { existsSync as existsSync63 } from "fs";
 import { join as join74 } from "path";
 
 // src/commands/sessions/daemon/worktree/deleteTreeDirectly.ts
@@ -28651,7 +28741,7 @@ async function deleteStrandedTree(clone, worktreePath, cause) {
   );
 }
 function strandedReason(worktreePath, cause) {
-  if (!existsSync62(join74(worktreePath, ".git")))
+  if (!existsSync63(join74(worktreePath, ".git")))
     return "its .git link is already gone";
   if (/not a working tree|not a git repository/i.test(reason2(cause)))
     return "git no longer recognises it as a working tree";
@@ -28703,7 +28793,7 @@ function reason3(error) {
 
 // src/commands/sessions/daemon/worktree/reapWorktree.ts
 async function reapWorktree(worktreePath, force = false) {
-  if (!existsSync63(worktreePath)) {
+  if (!existsSync64(worktreePath)) {
     daemonLog(`worktree ${worktreePath} already gone; skipping reap`);
     return false;
   }
@@ -28724,7 +28814,7 @@ async function reapWorktree(worktreePath, force = false) {
 }
 function owningClone(worktreePath) {
   const recorded = worktreeAttributionIncludingReaped(worktreePath)?.clone;
-  if (recorded && existsSync63(recorded)) return recorded;
+  if (recorded && existsSync64(recorded)) return recorded;
   const detected = mainWorktree(worktreePath);
   if (detected) return detected;
   daemonLog(
@@ -28811,12 +28901,12 @@ function setStatus2(session, newStatus) {
 }
 
 // src/commands/sessions/daemon/worktree/watchGitState.ts
-import { existsSync as existsSync64, watch } from "fs";
+import { existsSync as existsSync65, watch } from "fs";
 var DEBOUNCE_MS = 500;
 var POLL_MS = 3e4;
 function watchGitState(cwd, onChange) {
   const common = gitCommonDir(cwd);
-  if (!common || !existsSync64(common)) return void 0;
+  if (!common || !existsSync65(common)) return void 0;
   const watchers = [
     watchGitDir(common, onChange),
     pollGitState(cwd, onChange)
@@ -28862,6 +28952,10 @@ async function resolveCloseDurability(session, finalize, notify2) {
     holdStopped(session, tree, durability.reason, finalize, notify2);
     return;
   }
+  if (durability.gone)
+    daemonLog(
+      `session ${session.id} closing: worktree ${tree.path} is gone from disk \u2014 released with nothing to land, not landed work`
+    );
   if (tree.removable) await reapWorktree(tree.path);
   session.worktree = void 0;
   session.undurable = void 0;
@@ -29220,10 +29314,10 @@ function emitSessionOutput(session, clients, data) {
 }
 
 // src/commands/sessions/daemon/exitReason.ts
-import { existsSync as existsSync65 } from "fs";
+import { existsSync as existsSync66 } from "fs";
 function exitReason(session, exitCode) {
   const base = `process exited with code ${exitCode}`;
-  if (session.cwd && !existsSync65(session.cwd))
+  if (session.cwd && !existsSync66(session.cwd))
     return `${base}: working directory ${session.cwd} no longer exists`;
   return base;
 }
@@ -29241,7 +29335,7 @@ function handleFailedResume(session, exitCode, onStatusChange) {
 }
 
 // src/commands/sessions/daemon/watchActivity.ts
-import { existsSync as existsSync66, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
+import { existsSync as existsSync67, mkdirSync as mkdirSync26, watch as watch2 } from "fs";
 import { dirname as dirname33 } from "path";
 
 // src/commands/sessions/daemon/applyReviewPause.ts
@@ -29322,7 +29416,7 @@ function watchActivity(session, notify2, onClaudeSessionId) {
     if (timer) clearTimeout(timer);
     timer = setTimeout(read, DEBOUNCE_MS2);
   });
-  if (existsSync66(path71)) read();
+  if (existsSync67(path71)) read();
 }
 function refreshActivity(session) {
   if (session.commandType !== "assist" || !session.cwd) return;
@@ -30034,6 +30128,26 @@ function makeStatusChangeHandler(sessions, dismiss, notify2, reuseForRun) {
   );
 }
 
+// src/commands/sessions/daemon/refuseSpawn.ts
+function refuseSpawn(session, error, clients, onStatusChange, stage = "respawned") {
+  const reason4 = error instanceof Error ? error.message : String(error);
+  session.pty = null;
+  session.pendingStart = void 0;
+  session.error = reason4;
+  daemonLog(
+    `session ${session.id} ("${session.name}") not ${stage}: ${reason4}`
+  );
+  broadcast(clients, { type: "clear", sessionId: session.id });
+  emitSessionOutput(
+    session,
+    clients,
+    `\r
+\x1B[31mCannot start this session: ${reason4}\x1B[0m\r
+`
+  );
+  onStatusChange(session, "error");
+}
+
 // src/commands/sessions/daemon/respawnSession.ts
 function respawnSession(session, respawn, status3, clients, onStatusChange) {
   session.gitWatcher?.close();
@@ -30047,7 +30161,12 @@ function respawnSession(session, respawn, status3, clients, onStatusChange) {
   session.runningSince = null;
   setStatus2(session, status3);
   session.restored = void 0;
-  session.pty = respawn();
+  try {
+    session.pty = respawn();
+  } catch (error) {
+    refuseSpawn(session, error, clients, onStatusChange);
+    return;
+  }
   if (session.cols && session.rows)
     try {
       session.pty?.resize(session.cols, session.rows);
@@ -30182,6 +30301,9 @@ function restoreBase(id, persisted) {
 function errorSession(id, persisted, error) {
   return {
     ...restoreBase(id, persisted),
+    scrollback: `\r
+\x1B[31m${error}\x1B[0m\r
+`,
     status: "error",
     startedAt: persisted.startedAt,
     runningMs: persisted.runningMs ?? 0,
@@ -30411,7 +30533,7 @@ function rearmStoppedSessions(sessions, notify2) {
 }
 
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
-import { existsSync as existsSync69 } from "fs";
+import { existsSync as existsSync70 } from "fs";
 import { basename as basename20 } from "path";
 
 // src/commands/sessions/daemon/worktree/accountedTrees.ts
@@ -30501,9 +30623,9 @@ function capped(lines) {
 }
 
 // src/commands/sessions/daemon/worktree/reclaimVanishedWorktrees.ts
-import { existsSync as existsSync68 } from "fs";
+import { existsSync as existsSync69 } from "fs";
 async function reclaimVanishedWorktrees(clone, paths) {
-  if (!existsSync68(clone)) {
+  if (!existsSync69(clone)) {
     for (const { path: path71 } of paths) forgetWorktree(path71);
     daemonLog(
       `clone ${clone} is gone; forgot ${paths.length} worktree record(s) it owned`
@@ -30586,6 +30708,21 @@ function recoveryNotice({ orphan, held }) {
   ].join("");
 }
 
+// src/commands/sessions/daemon/worktree/logVanishedTree.ts
+function logVanishedTree(sessions, path71) {
+  const claimants = [...sessions.values()].filter(
+    (s) => s.cwd === path71 || s.worktree?.path === path71
+  );
+  if (claimants.length === 0) {
+    daemonLog(`worktree ${path71} gone from disk and unclaimed; reclaiming it`);
+    return;
+  }
+  for (const s of claimants)
+    daemonLog(
+      `session ${s.id} ("${s.name}") claims worktree ${path71}, which is gone from disk; reclaiming it`
+    );
+}
+
 // src/commands/sessions/daemon/worktree/reconcileWorktreesOnRestore.ts
 function reconcileWorktreesOnRestore(sessions, spawnWith, notify2) {
   bindRestoredWorktrees(sessions);
@@ -30595,14 +30732,15 @@ async function recoverOrphanedWorktrees(sessions, spawnWith, notify2) {
   const accounted = accountedTrees(sessions);
   const vanished = /* @__PURE__ */ new Map();
   for (const { path: path71, clone } of readWorktreeRegistry()) {
-    if (accounted.has(path71)) continue;
-    if (!existsSync69(path71)) {
+    if (!existsSync70(path71)) {
+      logVanishedTree(sessions, path71);
       vanished.set(clone, [
         ...vanished.get(clone) ?? [],
         { path: path71, branch: basename20(path71) }
       ]);
       continue;
     }
+    if (accounted.has(path71)) continue;
     await recoverOrphan(sessions, spawnWith, { path: path71, clone }, notify2);
   }
   for (const [clone, paths] of vanished)
@@ -30742,11 +30880,16 @@ function holdsTree(session, root) {
   if (session.status !== "done" && session.status !== "error") return true;
   if (!worktreeConfigFor(root).enabled) return true;
   const durability = checkDurabilitySync(root);
-  daemonLog(
-    durability.durable ? `tree ${root} free for allocation: session ${session.id} finished and its work is landed` : `tree ${root} still held by finished session ${session.id}: ${durability.reason}`
-  );
+  daemonLog(`tree ${root} ${releaseReason(durability, session)}`);
   return !durability.durable;
 }
+function releaseReason(durability, session) {
+  if (!durability.durable)
+    return `still held by finished session ${session.id}: ${durability.reason}`;
+  if (durability.gone)
+    return `free for allocation: session ${session.id}'s directory is gone from disk \u2014 nothing to land, not landed work`;
+  return `free for allocation: session ${session.id} finished and its work is landed`;
+}
 
 // src/commands/sessions/daemon/worktree/planReuseTree.ts
 function planReuseTree(session, ctx) {
@@ -30768,13 +30911,24 @@ function reuseSessionForRun(session, itemId2, clients, onStatusChange, tree) {
   resetCardForRun(session, assistArgs);
   const alloc = planReuseTree(session, tree);
   if (alloc) session.cwd = alloc.cwd;
-  Object.assign(
-    session,
-    startOrHoldPty(
-      () => spawnPty(["assist", ...assistArgs], session.cwd, session.id),
-      alloc !== void 0
-    )
-  );
+  try {
+    Object.assign(
+      session,
+      startOrHoldPty(
+        () => spawnPty(["assist", ...assistArgs], session.cwd, session.id),
+        alloc !== void 0
+      )
+    );
+  } catch (error) {
+    refuseSpawn(
+      session,
+      error,
+      clients,
+      onStatusChange,
+      `reused for backlog run ${itemId2}`
+    );
+    return;
+  }
   broadcast(clients, { type: "clear", sessionId: session.id });
   if (alloc)
     bindNewWorktree(
@@ -30798,26 +30952,45 @@ function shutdownSessions(sessions) {
   }
 }
 
-// src/commands/sessions/daemon/startHeldSession.ts
-function startHeldSession(session, sessions, clients, onStatusChange, notify2) {
-  const start3 = session.pendingStart;
-  if (!start3) return;
-  session.pendingStart = void 0;
+// src/commands/sessions/daemon/heldStartBlocked.ts
+function heldStartBlocked(session, sessions) {
+  const where = session.worktree?.path ?? "no worktree";
   if (sessions.get(session.id) !== session) {
     daemonLog(
-      `session ${session.id} not started after seeding: card is gone (${session.worktree?.path ?? "no worktree"})`
+      `session ${session.id} not started after seeding: card is gone (${where})`
     );
-    return;
+    return true;
   }
   if (session.closing) {
     daemonLog(
-      `session ${session.id} not started after seeding: card is closing (${session.worktree?.path ?? "no worktree"})`
+      `session ${session.id} not started after seeding: card is closing (${where})`
     );
-    return;
+    return true;
   }
+  return false;
+}
+
+// src/commands/sessions/daemon/startHeldSession.ts
+function startHeldSession(session, sessions, clients, onStatusChange, notify2) {
+  const start3 = session.pendingStart;
+  if (!start3) return;
+  session.pendingStart = void 0;
+  if (heldStartBlocked(session, sessions)) return;
   session.startedAt = Date.now();
   if (session.status === "running") session.runningSince = session.startedAt;
-  session.pty = start3();
+  try {
+    session.pty = start3();
+  } catch (error) {
+    refuseSpawn(
+      session,
+      error,
+      clients,
+      onStatusChange,
+      "started after seeding"
+    );
+    notify2();
+    return;
+  }
   if (session.cols && session.rows)
     try {
       session.pty?.resize(session.cols, session.rows);
@@ -30964,13 +31137,13 @@ async function defaultConnect() {
 }
 
 // src/commands/sessions/daemon/hasPersistedWindowsSessions.ts
-import { existsSync as existsSync70, readFileSync as readFileSync51 } from "fs";
+import { existsSync as existsSync71, readFileSync as readFileSync51 } from "fs";
 import { posix } from "path";
 function hasPersistedWindowsSessions() {
   const sessionsFile = windowsSessionsFileFromWsl();
   if (!sessionsFile) return false;
   try {
-    if (!existsSync70(sessionsFile)) return false;
+    if (!existsSync71(sessionsFile)) return false;
     const data = JSON.parse(readFileSync51(sessionsFile, "utf8"));
     return Array.isArray(data) && data.length > 0;
   } catch (error) {
@@ -32005,9 +32178,9 @@ function safeParse2(line) {
 }
 
 // src/commands/sessions/daemon/repoDirExists.ts
-import { existsSync as existsSync71 } from "fs";
+import { existsSync as existsSync72 } from "fs";
 function repoDirExists(cwd) {
-  return existsSync71(toGitCwd(cwd));
+  return existsSync72(toGitCwd(cwd));
 }
 
 // src/commands/sessions/daemon/withRepoGroups.ts

package/package.json

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