claude-code-session-manager 0.86.0 → 0.87.0

package/src/main/lib/__tests__/watchdog-helpers.test.cjs

@@ -0,0 +1,312 @@
+'use strict';
+
+// Run: timeout 120 npx vitest run src/main/lib/__tests__/watchdog-helpers.test.cjs
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  heartbeatFresh,
+  readLastHeartbeat,
+  localDateStr,
+  maybeFinalizeHistory,
+  tryAcquireLock,
+  releaseLock,
+} = require('../watchdogHelpers.cjs');
+
+function tmpFile() {
+  return path.join(os.tmpdir(), `watchdog-test-${process.pid}-${Math.floor(Math.random() * 1e9)}.log`);
+}
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'watchdog-history-test-'));
+}
+
+function writeLines(p, lines) {
+  fs.writeFileSync(p, lines.join('\n') + '\n');
+}
+
+test('fresh ts (just now) → true', () => {
+  const p = tmpFile();
+  try {
+    writeLines(p, [JSON.stringify({ ts: Date.now(), counts: {}, paused: null })]);
+    assert.equal(heartbeatFresh(p, 180_000), true);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('stale ts (10 min old) → false', () => {
+  const p = tmpFile();
+  try {
+    const staleTs = Date.now() - 10 * 60 * 1000;
+    writeLines(p, [JSON.stringify({ ts: staleTs, counts: {}, paused: null })]);
+    assert.equal(heartbeatFresh(p, 180_000), false);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('missing file → false', () => {
+  const p = path.join(os.tmpdir(), 'watchdog-test-nonexistent-999999.log');
+  assert.equal(heartbeatFresh(p, 180_000), false);
+});
+
+test('garbage last line → false', () => {
+  const p = tmpFile();
+  try {
+    writeLines(p, ['not json at all!!!']);
+    assert.equal(heartbeatFresh(p, 180_000), false);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('last non-empty line wins (fresh after stale)', () => {
+  const p = tmpFile();
+  try {
+    const staleTs = Date.now() - 10 * 60 * 1000;
+    writeLines(p, [
+      JSON.stringify({ ts: staleTs }),
+      JSON.stringify({ ts: Date.now() }),
+    ]);
+    assert.equal(heartbeatFresh(p, 180_000), true);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('empty file → false', () => {
+  const p = tmpFile();
+  try {
+    fs.writeFileSync(p, '');
+    assert.equal(heartbeatFresh(p, 180_000), false);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('JSON line without ts field → false', () => {
+  const p = tmpFile();
+  try {
+    writeLines(p, [JSON.stringify({ counts: {}, paused: null })]);
+    assert.equal(heartbeatFresh(p, 180_000), false);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+// ── readLastHeartbeat ─────────────────────────────────────────────────────────
+
+test('readLastHeartbeat: returns full parsed object including pid', () => {
+  const p = tmpFile();
+  try {
+    const entry = { ts: Date.now(), pid: 12345, counts: {}, paused: null };
+    writeLines(p, [JSON.stringify(entry)]);
+    const result = readLastHeartbeat(p);
+    assert.equal(result.ts, entry.ts);
+    assert.equal(result.pid, 12345);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('readLastHeartbeat: returns null for missing file', () => {
+  const p = path.join(os.tmpdir(), 'watchdog-helpers-test-nonexistent-999999.log');
+  assert.equal(readLastHeartbeat(p), null);
+});
+
+test('readLastHeartbeat: returns null for empty file', () => {
+  const p = tmpFile();
+  try {
+    fs.writeFileSync(p, '');
+    assert.equal(readLastHeartbeat(p), null);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+test('readLastHeartbeat: returns object without pid for legacy entry', () => {
+  const p = tmpFile();
+  try {
+    const staleTs = Date.now() - 10 * 60 * 1000;
+    writeLines(p, [JSON.stringify({ ts: staleTs, counts: {}, paused: null })]);
+    const result = readLastHeartbeat(p);
+    assert.ok(result !== null);
+    assert.equal(result.ts, staleTs);
+    assert.equal(result.pid, undefined);
+  } finally {
+    try { fs.unlinkSync(p); } catch {}
+  }
+});
+
+// ── maybeFinalizeHistory: stamp gate ─────────────────────────────────────────
+
+test('maybeFinalizeHistory: same-day stamp → skip in O(1), finalizeFn never called', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    fs.writeFileSync(stampPath, localDateStr(), 'utf8');
+    let called = false;
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async () => { called = true; return { finalizedDates: [], partial: false }; },
+    });
+    assert.equal(called, false);
+    assert.equal(result.ran, false);
+    assert.equal(result.reason, 'already-finalized-today');
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('maybeFinalizeHistory: new day (stale/missing stamp) → runs and stamps today', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    fs.writeFileSync(stampPath, '2000-01-01', 'utf8');
+    let called = false;
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async (opts) => { called = true; assert.equal(opts.budgetMs, 60_000); return { finalizedDates: ['2000-01-02'], partial: false }; },
+    });
+    assert.equal(called, true);
+    assert.equal(result.ran, true);
+    assert.equal(result.reason, 'finalized');
+    assert.equal(fs.readFileSync(stampPath, 'utf8').trim(), localDateStr());
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('maybeFinalizeHistory: missing stamp file → treated as new day, runs', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async () => ({ finalizedDates: [], partial: false }),
+    });
+    assert.equal(result.ran, true);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── maybeFinalizeHistory: lock contention ────────────────────────────────────
+
+test('maybeFinalizeHistory: lock already held (fresh) by another caller → skip silently', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    // Simulate a concurrent holder (e.g. the in-app Electron boot pass).
+    assert.equal(tryAcquireLock(lockPath, 10 * 60 * 1000), true);
+    let called = false;
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async () => { called = true; return { finalizedDates: [], partial: false }; },
+    });
+    assert.equal(called, false);
+    assert.equal(result.ran, false);
+    assert.equal(result.reason, 'lock-contended');
+    // The other holder's lock must be untouched by the loser.
+    assert.equal(fs.existsSync(lockPath), true);
+  } finally {
+    releaseLock(path.join(dir, 'history-rollup.lock'));
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('maybeFinalizeHistory: stale lock (older than staleLockMs) is reclaimed and runs', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    fs.writeFileSync(lockPath, '99999', 'utf8');
+    const staleTime = new Date(Date.now() - 20 * 60 * 1000);
+    fs.utimesSync(lockPath, staleTime, staleTime);
+
+    let called = false;
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      staleLockMs: 10 * 60 * 1000,
+      finalizeFn: async () => { called = true; return { finalizedDates: [], partial: false }; },
+    });
+    assert.equal(called, true);
+    assert.equal(result.ran, true);
+    // Lock is released after the run.
+    assert.equal(fs.existsSync(lockPath), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('maybeFinalizeHistory: releases the lock even when finalizeFn throws', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    await assert.rejects(() => maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async () => { throw new Error('boom'); },
+    }));
+    assert.equal(fs.existsSync(lockPath), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── maybeFinalizeHistory: budget-partial ─────────────────────────────────────
+
+test('maybeFinalizeHistory: partial finalize (budget exceeded) does NOT stamp the day complete', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      finalizeFn: async () => ({ finalizedDates: [], partial: true }),
+    });
+    assert.equal(result.ran, true);
+    assert.equal(result.reason, 'partial');
+    assert.equal(fs.existsSync(stampPath), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ── maybeFinalizeHistory: dry run ────────────────────────────────────────────
+
+test('maybeFinalizeHistory: dryRun computes without stamping or requiring a write', async () => {
+  const dir = tmpDir();
+  try {
+    const stampPath = path.join(dir, 'history-rollup.stamp');
+    const lockPath = path.join(dir, 'history-rollup.lock');
+    let seenDryRun;
+    const result = await maybeFinalizeHistory({
+      stampPath,
+      lockPath,
+      dryRun: true,
+      finalizeFn: async (opts) => { seenDryRun = opts.dryRun; return { finalizedDates: ['2026-07-01'], partial: false }; },
+    });
+    assert.equal(seenDryRun, true);
+    assert.equal(result.ran, false);
+    assert.equal(result.reason, 'dry-run');
+    assert.deepEqual(result.finalizedDates, ['2026-07-01']);
+    assert.equal(fs.existsSync(stampPath), false);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/main/lib/__tests__/watchdog-relaunch.test.cjs

@@ -0,0 +1,193 @@
+'use strict';
+
+// Run: timeout 120 npx vitest run src/main/lib/__tests__/watchdog-relaunch.test.cjs
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+const {
+  maybeRelaunchApp,
+  readRelaunchState,
+  DEFAULT_MAX_RELAUNCH_ATTEMPTS,
+} = require('../watchdogHelpers.cjs');
+
+function tmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'watchdog-relaunch-test-'));
+}
+
+function writeHeartbeat(hbPath, tsMs, pid) {
+  fs.writeFileSync(hbPath, JSON.stringify({ ts: tsMs, pid }) + '\n');
+}
+
+function makeSpawnSpy() {
+  const calls = [];
+  const fn = (opts) => { calls.push(opts); };
+  fn.calls = calls;
+  return fn;
+}
+
+// heartbeatFresh() reads the real wall clock internally (no injectable `now`),
+// so every heartbeat ts below is anchored to actual Date.now() at test start —
+// only the `now` passed to maybeRelaunchApp (which drives debounce/cap math)
+// is offset from that same anchor.
+//
+// isPidAlive() treats EPERM (pid exists, owned by another user — e.g. pid 1)
+// as alive, so a genuinely-dead pid must actually be gone (ESRCH), not just
+// inaccessible. Spawn a short-lived same-user child and use its exited pid —
+// guaranteed ESRCH under our own uid, unlike a hardcoded low pid number.
+const DEAD_PID = (() => {
+  const result = spawnSync(process.execPath, ['-e', 'process.exit(0)']);
+  return result.pid;
+})();
+
+test('fresh heartbeat → no relaunch, no spawn', () => {
+  const dir = tmpDir();
+  try {
+    const hbPath = path.join(dir, 'heartbeat.log');
+    const statePath = path.join(dir, 'state.json');
+    const now = Date.now();
+    writeHeartbeat(hbPath, now - 1_000, DEAD_PID); // 1s old — fresh
+    const spawnFn = makeSpawnSpy();
+
+    const result = maybeRelaunchApp({
+      heartbeatPath: hbPath,
+      maxAgeMs: 180_000,
+      statePath,
+      now,
+      spawnFn,
+    });
+
+    assert.equal(result.relaunched, false);
+    assert.equal(result.reason, 'alive');
+    assert.equal(spawnFn.calls.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('stale heartbeat + dead pid → relaunch fires', () => {
+  const dir = tmpDir();
+  try {
+    const hbPath = path.join(dir, 'heartbeat.log');
+    const statePath = path.join(dir, 'state.json');
+    const now = Date.now();
+    writeHeartbeat(hbPath, now - 10 * 60_000, DEAD_PID);
+    const spawnFn = makeSpawnSpy();
+
+    const result = maybeRelaunchApp({
+      heartbeatPath: hbPath,
+      maxAgeMs: 180_000,
+      statePath,
+      debounceMs: 90_000,
+      now,
+      spawnFn,
+    });
+
+    assert.equal(result.relaunched, true);
+    assert.equal(result.attemptCount, 1);
+    assert.equal(spawnFn.calls.length, 1);
+
+    const state = readRelaunchState(statePath);
+    assert.equal(state.attemptCount, 1);
+    assert.equal(state.lastAttemptTs, now);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('stale heartbeat but debounce window not elapsed → no relaunch', () => {
+  const dir = tmpDir();
+  try {
+    const hbPath = path.join(dir, 'heartbeat.log');
+    const statePath = path.join(dir, 'state.json');
+    const now = Date.now();
+    writeHeartbeat(hbPath, now - 10 * 60_000, DEAD_PID);
+
+    // First tick: relaunch fires.
+    const spawnFn1 = makeSpawnSpy();
+    const first = maybeRelaunchApp({
+      heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, debounceMs: 90_000, now, spawnFn: spawnFn1,
+    });
+    assert.equal(first.relaunched, true);
+
+    // Second tick 30s later — inside the 90s debounce window.
+    const spawnFn2 = makeSpawnSpy();
+    const second = maybeRelaunchApp({
+      heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, debounceMs: 90_000, now: now + 30_000, spawnFn: spawnFn2,
+    });
+
+    assert.equal(second.relaunched, false);
+    assert.equal(second.reason, 'debounce');
+    assert.equal(spawnFn2.calls.length, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('3 failed attempts → stops attempting and logs, no 4th attempt', () => {
+  const dir = tmpDir();
+  try {
+    const hbPath = path.join(dir, 'heartbeat.log');
+    const statePath = path.join(dir, 'state.json');
+    const logPath = path.join(dir, 'relaunch.log');
+    let now = Date.now();
+    writeHeartbeat(hbPath, now - 10 * 60_000, DEAD_PID); // stays stale/dead throughout
+
+    let lastResult;
+    for (let i = 0; i < DEFAULT_MAX_RELAUNCH_ATTEMPTS; i++) {
+      const spawnFn = makeSpawnSpy();
+      lastResult = maybeRelaunchApp({
+        heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, logPath, debounceMs: 90_000, now, spawnFn,
+      });
+      assert.equal(lastResult.relaunched, true, `attempt ${i + 1} should relaunch`);
+      assert.equal(spawnFn.calls.length, 1);
+      now += 100_000; // past the 90s debounce for the next tick
+    }
+
+    // 4th tick: capped — must NOT spawn again.
+    const spawnFn4 = makeSpawnSpy();
+    const fourth = maybeRelaunchApp({
+      heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, logPath, debounceMs: 90_000, now, spawnFn: spawnFn4,
+    });
+
+    assert.equal(fourth.relaunched, false);
+    assert.equal(fourth.reason, 'capped');
+    assert.equal(spawnFn4.calls.length, 0);
+    assert.equal(fourth.attemptCount, DEFAULT_MAX_RELAUNCH_ATTEMPTS);
+
+    const logContent = fs.readFileSync(logPath, 'utf8');
+    assert.match(logContent, /giving up/i);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('attemptCount resets to 0 once a fresh heartbeat is observed', () => {
+  const dir = tmpDir();
+  try {
+    const hbPath = path.join(dir, 'heartbeat.log');
+    const statePath = path.join(dir, 'state.json');
+    const now = Date.now();
+    writeHeartbeat(hbPath, now - 10 * 60_000, DEAD_PID);
+
+    const spawnFn = makeSpawnSpy();
+    maybeRelaunchApp({ heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, debounceMs: 90_000, now, spawnFn });
+    assert.equal(readRelaunchState(statePath).attemptCount, 1);
+
+    // App comes back up — fresh heartbeat observed on a later tick, recorded
+    // with this test process's own (guaranteed-alive) pid.
+    const later = now + 200_000;
+    writeHeartbeat(hbPath, later - 1_000, process.pid);
+    const result = maybeRelaunchApp({
+      heartbeatPath: hbPath, maxAgeMs: 180_000, statePath, debounceMs: 90_000, now: later, spawnFn,
+    });
+
+    assert.equal(result.relaunched, false);
+    assert.equal(result.reason, 'alive');
+    assert.equal(readRelaunchState(statePath).attemptCount, 0);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/{scripts → src/main}/lib/activeSessions.cjs

@@ -11,7 +11,8 @@
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
-const { KIND_CONFIG: WORKTREE_KIND_CONFIG } = require('../../src/main/lib/gitWorktree.cjs');
+const { KIND_CONFIG: WORKTREE_KIND_CONFIG } = require('./gitWorktree.cjs');
+const { OPS_ROOT_DIR } = require('./opsOwnership.cjs');
 
 const HOME = os.homedir();
 const TMPDIR = os.tmpdir();
@@ -41,6 +42,27 @@ const TAIL_BYTES = 64 * 1024;
 // Safety cap on distinct cwds to bound result set size. O(1) extra space.
 const MAX_CWDS = 50;
 
+// activeProjectCwds' scan is a readdirSync of every dir under ~/.claude
+// /projects (2209 dirs / 8.8 GB observed) plus a statSync per transcript —
+// ~270 ms warm. reconcile() calls into it (directly or via allProjectCwds)
+// several times per pass, so cache the resolved cwd list keyed on the
+// resolved argument TUPLE (projectsDir, maxAgeMin, maxCwds) — never on
+// `!opts`, since allProjectCwds always constructs an options object and that
+// guard would cache nothing on the hottest path.
+//
+// Invalidation: projectsDir's own mtime (bumps when a project DIRECTORY is
+// added/removed — NOT when an existing transcript gains a line, which is
+// fine: a project already in the list stays in the list) plus a short TTL
+// as the backstop for everything else. Same mtime-keyed idiom as
+// scheduler/prdParser.cjs's dirCache and queueHistory.cjs's historyCacheKey.
+const CACHE_TTL_MS = 30_000;
+const cwdScanCache = new Map(); // key -> { dirMtimeMs, cachedAt, result }
+
+/** Forces the next activeProjectCwds/allProjectCwds call to rescan. */
+function bustProjectCwdCache() {
+  cwdScanCache.clear();
+}
+
 // The ops-root folder name. A transcript's `cwd` can point INSIDE it whenever
 // an agent `cd`s into an artifact directory (a PRD folder, prompt-sessions,
 // scheduler/state) — Claude Code records the new absolute cwd on every
@@ -55,7 +77,7 @@ const MAX_CWDS = 50;
 // Truncating at the segment is strictly better than dropping the row: the
 // ancestor IS the project the agent was working in, so the active-project
 // signal survives instead of being silently lost.
-const OPS_DIRNAME = 'session-manager-operations';
+const OPS_DIRNAME = OPS_ROOT_DIR;
 
 // Bound on the ancestor walk in worktreeMainRootOf — well past any real
 // filesystem depth, purely to guarantee termination without relying on
@@ -190,6 +212,23 @@ function activeProjectCwds(maxAgeMin = 90, {
   maxCwds = MAX_CWDS,
   tmpDropRoots = TMP_DROP_ROOTS,
 } = {}) {
+  const cacheKey = [projectsDir, maxAgeMin, maxCwds].join('|');
+  let dirMtimeMs;
+  try {
+    dirMtimeMs = fs.statSync(projectsDir).mtimeMs;
+  } catch {
+    // Missing/unreadable dir: nothing to scan, and any prior cache entry for
+    // this key must not survive to be handed back once the dir later
+    // appears — drop it rather than caching this empty result.
+    cwdScanCache.delete(cacheKey);
+    return [];
+  }
+  const cached = cwdScanCache.get(cacheKey);
+  const now0 = Date.now();
+  if (cached && cached.dirMtimeMs === dirMtimeMs && now0 - cached.cachedAt < CACHE_TTL_MS) {
+    return cached.result;
+  }
+
   // maxAgeMin === Infinity means "every project ever seen, no recency filter"
   // (allProjectCwds below). Date.now() - Infinity is -Infinity, which every
   // mtime clears — spelled out here because it reads like an accident.
@@ -231,7 +270,7 @@ function activeProjectCwds(maxAgeMin = 90, {
 
   // Scan ~/.claude/projects/*/  transcript *.jsonl files.
   let slugs;
-  try { slugs = fs.readdirSync(projectsDir); } catch { return result; }
+  try { slugs = fs.readdirSync(projectsDir); } catch { cwdScanCache.delete(cacheKey); return result; }
 
   for (const slug of slugs) {
     if (result.length >= maxCwds) break;
@@ -266,6 +305,7 @@ function activeProjectCwds(maxAgeMin = 90, {
     }
   }
 
+  cwdScanCache.set(cacheKey, { dirMtimeMs, cachedAt: now0, result });
   return result;
 }
 
@@ -288,4 +328,10 @@ function allProjectCwds(opts = {}) {
   return activeProjectCwds(Infinity, { maxCwds: 500, ...opts });
 }
 
-module.exports = { activeProjectCwds, allProjectCwds, projectRootOf, worktreeMainRootOf };
+module.exports = {
+  activeProjectCwds,
+  allProjectCwds,
+  projectRootOf,
+  worktreeMainRootOf,
+  bustProjectCwdCache,
+};