claude-code-session-manager 0.94.0 → 0.96.0

package/src/main/lib/__tests__/loopDelay.test.cjs

@@ -0,0 +1,68 @@
+/**
+ * loopDelay.test.cjs — event-loop delay probe used by crashDiagnostics's heartbeat.
+ *
+ * Run: timeout 120 npx vitest run src/main/lib/__tests__/loopDelay.test.cjs
+ */
+'use strict';
+
+import { test, expect } from 'vitest';
+
+const { createLoopDelayMonitor, stallVerdict, LOOP_STALL_WARN_MS } = require('../loopDelay.cjs');
+
+// Histogram stub: values in ns, like perf_hooks.
+function stubHistogram(state) {
+  return () => ({
+    enabled: false,
+    enable() { this.enabled = true; },
+    disable() { this.enabled = false; },
+    percentile(p) { return p === 50 ? state.p50 : state.p99; },
+    get max() { return state.max; },
+    reset() { state.resets += 1; state.p50 = 0; state.p99 = 0; state.max = 0; },
+  });
+}
+
+test('normal beat: converts ns to ms (1 decimal) and does not flag a stall', () => {
+  const state = { p50: 21_040_000, p99: 34_960_000, max: 40_000_000, resets: 0 };
+  const m = createLoopDelayMonitor(stubHistogram(state));
+  m.enable();
+  const snap = m.snapshot();
+  expect(snap).toEqual({ loopDelayP50Ms: 21, loopDelayP99Ms: 35, loopDelayMaxMs: 40 });
+  expect(stallVerdict(snap)).toBeNull();
+});
+
+test('stall beat: max above threshold yields warn "main loop stall"', () => {
+  const state = { p50: 20_000_000, p99: 300_000_000, max: 412_300_000, resets: 0 };
+  const snap = createLoopDelayMonitor(stubHistogram(state)).snapshot();
+  expect(snap.loopDelayMaxMs).toBe(412.3);
+  expect(stallVerdict(snap)).toEqual({ level: 'warn', message: 'main loop stall' });
+  expect(stallVerdict({ loopDelayMaxMs: LOOP_STALL_WARN_MS })).toBeNull(); // strictly greater
+});
+
+test('reset between beats: a stall does not bleed into the next interval', () => {
+  const state = { p50: 20_000_000, p99: 300_000_000, max: 500_000_000, resets: 0 };
+  const m = createLoopDelayMonitor(stubHistogram(state));
+  expect(stallVerdict(m.snapshot())).not.toBeNull();
+  expect(state.resets).toBe(1);
+  const second = m.snapshot();
+  expect(second.loopDelayMaxMs).toBe(0);
+  expect(stallVerdict(second)).toBeNull();
+  expect(state.resets).toBe(2);
+});
+
+test('passes a 20 ms resolution to the histogram factory and disable() stops it', () => {
+  let opts; let h;
+  const m = createLoopDelayMonitor((o) => { opts = o; h = stubHistogram({ resets: 0 })(); return h; });
+  m.enable();
+  expect(opts).toEqual({ resolution: 20 });
+  expect(h.enabled).toBe(true);
+  m.disable();
+  expect(h.enabled).toBe(false);
+});
+
+test('real perf_hooks histogram produces finite numbers', () => {
+  const m = createLoopDelayMonitor();
+  m.enable();
+  const snap = m.snapshot();
+  m.disable();
+  for (const v of Object.values(snap)) expect(Number.isFinite(v)).toBe(true);
+});

package/src/main/lib/__tests__/opsOwnership.test.cjs

@@ -73,6 +73,20 @@ test('assertOpsWrite throws for a refused write and is silent for an allowed one
   assert.doesNotThrow(() => assertOpsWrite(`${P}/project-brief/brief.json`, 'project-home'));
 });
 
+test('assertOpsWrite fails closed (not a raw crash) on a relative path that looks like it is inside an ops root', () => {
+  // A caller that skips opsPath/resolveProjectRoot (which already throw on a
+  // relative cwd) and builds its own path string by hand must still get a
+  // graceful, catchable refusal here — this is the last line of defense
+  // (PRD 1082). Before this guard, classifyCwd's absolute-path check (added
+  // for the worktree-relative-cwd hazard) left innermostOpsRoot null for a
+  // relative path, and path.dirname(null) threw an untagged TypeError
+  // instead of the intended `unknownCwd`-tagged Error.
+  assert.throws(
+    () => assertOpsWrite('session-manager-operations/scheduler/state/queue.json', 'scheduler'),
+    (e) => e.unknownCwd === true && /absolute/.test(e.message),
+  );
+});
+
 test('every declared owner is a non-empty string (table sanity)', () => {
   for (const [ns, owner] of Object.entries(OWNERS)) {
     assert.equal(typeof owner, 'string', `${ns} owner must be a string`);

package/src/main/lib/__tests__/telemetryBacklog.test.cjs

@@ -56,7 +56,7 @@ function freshTelemetry(home) {
   process.env.HOME = home;
   // Explicit opt-in: overrides the test-environment no-op guard so this
   // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.config', 'session-manager');
+  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
   for (const p of ['../telemetryClient.cjs', '../../config.cjs', '../telemetrySettings.cjs', '../machineProfile.cjs']) {
     const resolved = require.resolve(p);
     delete require.cache[resolved];
@@ -133,7 +133,7 @@ function makeDeps({ home, telemetryClient, config, tabCwds }) {
 }
 
 function watermarksFileFor(home) {
-  return path.join(home, '.config', 'session-manager', 'telemetry-watermarks.json');
+  return path.join(home, '.claude', 'session-manager', 'telemetry-watermarks.json');
 }
 
 async function readWatermarks(home) {
@@ -569,7 +569,7 @@ test('bootDrain always drains with reason "boot", and drains a second time with
 
 test('drainBacklog resolves (never rejects) when readdir fails, telemetryClient throws, and the watermarks file is corrupt', async () => {
   const home = await mkHome();
-  await fsp.mkdir(path.join(home, '.config', 'session-manager'), { recursive: true });
+  await fsp.mkdir(path.join(home, '.claude', 'session-manager'), { recursive: true });
   await fsp.writeFile(watermarksFileFor(home), 'not valid { json', 'utf8');
   const project = await mkProject('contained');
   writeErrorsFile(project, recentDateStr(), [errLine(1)]);
@@ -584,7 +584,7 @@ test('drainBacklog resolves (never rejects) when readdir fails, telemetryClient
     logLine: async () => { throw new Error('boom client'); },
     flush: async () => { throw new Error('boom flush'); },
     isPending: async () => { throw new Error('boom pending'); },
-    sentPath: () => path.join(home, '.config', 'session-manager', 'telemetry-sent.json'),
+    sentPath: () => path.join(home, '.claude', 'session-manager', 'telemetry-sent.json'),
   };
   const deps = {
     sessionsStore: { load: async () => ({ tabs: [{ cwd: project }] }) },

package/src/main/lib/__tests__/telemetryConsent.test.cjs

@@ -40,7 +40,7 @@ function freshModules(home) {
   process.env.HOME = home;
   // Explicit opt-in: overrides the test-environment no-op guard so this
   // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.config', 'session-manager');
+  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
   for (const p of ['../telemetryConsent.cjs', '../telemetryClient.cjs', '../telemetrySettings.cjs', '../machineProfile.cjs', '../../config.cjs']) {
     const resolved = require.resolve(p);
     delete require.cache[resolved];
@@ -105,7 +105,7 @@ test('turning off does NOT clear telemetry-sent.json or the watermarks — re-en
   expect(JSON.parse(sentPathContent).ids.length).toBeGreaterThan(0);
 
   // Also seed a watermarks file to prove opt-out leaves it untouched.
-  const watermarksDir = path.join(home, '.config', 'session-manager');
+  const watermarksDir = path.join(home, '.claude', 'session-manager');
   await fsp.mkdir(watermarksDir, { recursive: true });
   const watermarksPath = path.join(watermarksDir, 'telemetry-watermarks.json');
   const watermarksBefore = { 'abc123/errors-2026-01-01.jsonl': { bytesEnqueued: 100, bytesConfirmed: 100 } };

package/src/main/lib/__tests__/telemetryCountersMetadataColumn.test.cjs

@@ -37,7 +37,7 @@ async function mkHome() {
   process.env.HOME = dir;
   // Explicit opt-in: overrides the test-environment no-op guard so this
   // suite's real telemetryClient calls actually persist into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(dir, '.config', 'session-manager');
+  process.env.SM_TELEMETRY_SPOOL = path.join(dir, '.claude', 'session-manager');
   return dir;
 }
 

package/src/main/lib/__tests__/usageCircuit.test.cjs

@@ -101,18 +101,74 @@ test('isResetFresh: past -> false, future -> true, null -> false', () => {
   assert.strictEqual(isResetFresh('not-a-date', now), false);
 });
 
-test('bindingWindow: limits[] with weekly_all is_active wins over five_hour', () => {
+const REAL_LIMITS = [
+  { kind: 'session', group: 'session', percent: 6, severity: 'normal', resets_at: '2026-09-22T00:40:00.280514+00:00', scope: null, is_active: false },
+  { kind: 'weekly_all', group: 'weekly', percent: 64, severity: 'normal', resets_at: '2026-09-24T17:00:00.280532+00:00', scope: null, is_active: true },
+  { kind: 'weekly_scoped', group: 'weekly', percent: 18, severity: 'normal', resets_at: '2026-09-24T17:00:00.280763+00:00', scope: { model: { id: null, display_name: 'Fable' }, surface: null }, is_active: false },
+];
+
+test('bindingWindow: verbatim real payload selects weekly_all 64', () => {
   const payload = {
-    five_hour: { utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
+    five_hour: { utilization: 6, resets_at: '2026-09-22T00:40:00.280514+00:00' },
+    seven_day: { utilization: 64, resets_at: '2026-09-24T17:00:00.280532+00:00' },
+    limits: REAL_LIMITS,
+  };
+  assert.deepStrictEqual(bindingWindow(payload), {
+    name: 'weekly_all',
+    utilization: 64,
+    resets_at: '2026-09-24T17:00:00.280532+00:00',
+  });
+});
+
+test('bindingWindow: max percent wins over is_active (session 95 beats weekly_all 64)', () => {
+  const win = bindingWindow({
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 5, resets_at: '2026-09-13T15:00:00Z' },
-      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+      { kind: 'session', percent: 95, resets_at: '2026-09-22T00:40:00Z', scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
     ],
-  };
-  const win = bindingWindow(payload);
+  });
+  assert.strictEqual(win.name, 'session');
+  assert.strictEqual(win.utilization, 95);
+});
+
+test('bindingWindow: is_active breaks a percent tie', () => {
+  const win = bindingWindow({
+    limits: [
+      { kind: 'session', percent: 50, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 50, resets_at: null, scope: null, is_active: true },
+    ],
+  });
   assert.strictEqual(win.name, 'weekly_all');
-  assert.strictEqual(win.utilization, 81);
-  assert.strictEqual(win.resets_at, '2026-09-19T00:00:00Z');
+});
+
+test('bindingWindow: a high weekly_scoped entry is never selected', () => {
+  const win = bindingWindow({
+    limits: [
+      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 10, resets_at: null, scope: null, is_active: true },
+      { kind: 'weekly_scoped', percent: 99, resets_at: null, scope: { model: { display_name: 'Fable' } }, is_active: false },
+    ],
+  });
+  assert.strictEqual(win.name, 'weekly_all');
+  assert.strictEqual(win.utilization, 10);
+});
+
+test('bindingWindow: percent over 100 is returned raw, not clamped', () => {
+  const win = bindingWindow({ limits: [{ kind: 'session', percent: 112, resets_at: null, scope: null }] });
+  assert.strictEqual(win.utilization, 112);
+});
+
+test('bindingWindow: null resets_at backfills from the matching flat window', () => {
+  const win = bindingWindow({
+    five_hour: { utilization: 40, resets_at: '2026-09-22T00:40:00Z' },
+    seven_day: { utilization: 5, resets_at: '2026-09-24T17:00:00Z' },
+    limits: [
+      { kind: 'session', percent: 40, resets_at: null, scope: null },
+      { kind: 'weekly_all', percent: 5, resets_at: null, scope: null },
+    ],
+  });
+  assert.strictEqual(win.name, 'session');
+  assert.strictEqual(win.resets_at, '2026-09-22T00:40:00Z');
 });
 
 test('bindingWindow: limits[] absent falls back to five_hour', () => {
@@ -122,12 +178,12 @@ test('bindingWindow: limits[] absent falls back to five_hour', () => {
   assert.strictEqual(win.utilization, 42);
 });
 
-test('bindingWindow: limits[] present but nothing is_active also falls back to five_hour', () => {
+test('bindingWindow: limits[] with only scoped / non-finite entries falls back to five_hour', () => {
   const payload = {
     five_hour: { utilization: 12, resets_at: null },
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 12, resets_at: null },
-      { type: 'weekly_all', is_active: false, utilization: 81, resets_at: null },
+      { kind: 'weekly_scoped', percent: 81, resets_at: null, scope: { model: { display_name: 'Fable' } } },
+      { kind: 'session', resets_at: null, scope: null },
     ],
   };
   const win = bindingWindow(payload);
@@ -135,19 +191,32 @@ test('bindingWindow: limits[] present but nothing is_active also falls back to f
   assert.strictEqual(win.utilization, 12);
 });
 
-test('degradedBudget: never yields 0 utilization, even when the last good binding window read 0', () => {
+test('degradedBudget: a last-good binding window that genuinely read 0% carries forward as 0, not 100', () => {
   const payload = { five_hour: { utilization: 0, resets_at: null } };
-  const { utilization } = degradedBudget(payload, {});
-  assert.notStrictEqual(utilization, 0);
-  assert.strictEqual(utilization, 100); // no real signal -> conservative default
+  assert.strictEqual(degradedBudget(payload, {}).utilization, 0);
+});
+
+test('degradedBudget: no payload ever received (null/absent) still yields 100, never a blind 0', () => {
+  assert.strictEqual(degradedBudget(null, {}).utilization, 100);
+  assert.strictEqual(degradedBudget(undefined, {}).utilization, 100);
+});
+
+test('degradedBudget: a degraded cycle after a real-shape poll carries forward the real percent (64), not 100', () => {
+  const payload = {
+    limits: [
+      { kind: 'session', percent: 6, resets_at: null, scope: null, is_active: false },
+      { kind: 'weekly_all', percent: 64, resets_at: '2026-09-24T17:00:00Z', scope: null, is_active: true },
+    ],
+  };
+  assert.strictEqual(degradedBudget(payload, {}).utilization, 64);
 });
 
 test('degradedBudget: carries forward the real last-good BINDING (weekly_all) utilization, e.g. 81%, never 0', () => {
   const payload = {
     five_hour: { utilization: 0, resets_at: null },
     limits: [
-      { type: 'five_hour', is_active: false, utilization: 0, resets_at: null },
-      { type: 'weekly_all', is_active: true, utilization: 81, resets_at: '2026-09-19T00:00:00Z' },
+      { kind: 'session', is_active: false, percent: 0, resets_at: null, scope: null },
+      { kind: 'weekly_all', is_active: true, percent: 81, resets_at: '2026-09-19T00:00:00Z', scope: null },
     ],
   };
   const { utilization } = degradedBudget(payload, {});

package/src/main/lib/agentModelResolve.cjs

@@ -238,6 +238,7 @@ async function resolvePrdPersonaForSpawn({ cwd, agentType, fallbackModel = FALLB
 
 module.exports = {
   FALLBACK_MODEL,
+  AGENT_BODY_CHAR_CAP,
   resolveEpicModel,
   findAgentTypeByClaudeSessionId,
   findEpicByClaudeSessionId,

package/src/main/lib/credentials.cjs

@@ -120,6 +120,38 @@ function isExpiringSoon(creds, withinMs = 5 * 60_000) {
   return ms !== null && ms - Date.now() < withinMs;
 }
 
+/**
+ * isRefreshFutile(creds) → boolean
+ *
+ * True when the token is already expired AND there is no refresh token to
+ * present. In that state every refresh avenue is a dead end: tryOAuthRefresh
+ * short-circuits to 'unsupported' (it needs `creds.refreshToken`), and the
+ * `claude --version` CLI fallback performs its own silent OAuth refresh from
+ * that SAME missing refresh token, so it cannot help either. The only recovery
+ * is an out-of-band `claude login` — which refreshIfNeeded picks up on its very
+ * next call via the isExpiringSoon early-return, since fresh creds never reach
+ * this path. Left ungated, this state made pollLoop spawn a `claude --version`
+ * process and write the oauth_refresh_unsupported → cli_fallback_ok →
+ * auth_failed_expired triple on EVERY 15 s poll, forever (observed 2026-09-23:
+ * expiredAtMs 1775277875159, identical triple every ~15 min across the log).
+ */
+function isRefreshFutile(creds) {
+  return isExpired(creds) && !creds.refreshToken;
+}
+
+// Throttle for the futile-refresh state above: once seen, don't respawn the
+// CLI fallback or re-log the auth triple on every poll. Re-probe at most once
+// per this window (an external `claude login` is still caught immediately by
+// refreshIfNeeded's isExpiringSoon early-return, and by the cheap re-read
+// below — neither needs the storm). Mirrors loadGate.cjs's AUDIT_INTERVAL_MS.
+const FUTILE_REFRESH_COOLDOWN_MS = 15 * 60_000;
+let lastFutileRefreshLoggedAt = null;
+
+/** Test-only: reset the futile-refresh throttle so each test starts clean. */
+function __resetFutileRefreshThrottle() {
+  lastFutileRefreshLoggedAt = null;
+}
+
 async function writeCredentials(rawData, freshOauth, source = 'file') {
   const next = { ...rawData, claudeAiOauth: { ...rawData.claudeAiOauth, ...freshOauth } };
   if (source === 'keychain') {
@@ -222,6 +254,33 @@ async function refreshIfNeeded(forceRefresh = false) {
 
   const alreadyExpired = isExpired(creds);
 
+  // Futile-refresh short-circuit: token already expired AND no refresh token
+  // to present. Every downstream avenue (OAuth grant, `claude --version` CLI
+  // fallback) is a guaranteed dead end from the same missing token, so running
+  // them on every 15 s poll only spawns a doomed child process and re-logs the
+  // same triple forever (2026-09-23 storm). Re-read once — cheap, and the ONE
+  // real recovery (`claude login`) lands here — then, if still futile, return
+  // the auth verdict WITHOUT the OAuth call or the CLI-fallback spawn, logging
+  // at most once per FUTILE_REFRESH_COOLDOWN_MS instead of every poll.
+  if (isRefreshFutile(creds)) {
+    const recheckCr = await readCredentials();
+    if (recheckCr.kind === 'ok' && !isRefreshFutile(recheckCr.creds) && !isExpired(recheckCr.creds)) {
+      appendRefreshLog({ event: 'externally_refreshed_ok', recheckExpiresAt: recheckCr.creds.expiresAt ?? null });
+      lastFutileRefreshLoggedAt = null;
+      return { kind: 'ok', creds: recheckCr.creds };
+    }
+    const nowMs = Date.now();
+    if (lastFutileRefreshLoggedAt === null || nowMs - lastFutileRefreshLoggedAt >= FUTILE_REFRESH_COOLDOWN_MS) {
+      lastFutileRefreshLoggedAt = nowMs;
+      appendRefreshLog({ event: 'auth_failed_expired_no_refresh_token', expiredAtMs: expiresAtMs(creds) });
+    }
+    return {
+      kind: 'auth',
+      message: 'Credentials expired and cannot be auto-refreshed (no refresh token). Run `claude` in a terminal to log in.',
+      expiredAt: expiresAtMs(creds),
+    };
+  }
+
   // Stretch: try OAuth refresh endpoint first.
   const oauthResult = await tryOAuthRefresh(creds);
   appendRefreshLog({ event: `oauth_refresh_${oauthResult.kind}`, message: oauthResult.message ?? null });
@@ -277,8 +336,11 @@ module.exports = {
   expiresAtMs,
   isExpired,
   isExpiringSoon,
+  isRefreshFutile,
   refreshIfNeeded,
   parseCredsRaw,
+  __resetFutileRefreshThrottle,
+  FUTILE_REFRESH_COOLDOWN_MS,
   KEYCHAIN_SERVICE,
   CREDS_PATH,
 };

package/src/main/lib/cwdClassify.cjs

@@ -152,6 +152,21 @@ function classifyCwd(cwd) {
   if (!cwd || typeof cwd !== 'string') {
     return { kind: 'unknown', projectRoot: null, outermostOpsRoot: null, innermostOpsRoot: null, reason: 'cwd is not a non-empty string' };
   }
+  // Must run BEFORE inspectGit: nearestGitEntry walks ancestors via
+  // fs.statSync, which silently resolves a relative `dir` against
+  // process.cwd() — so a relative cwd that happens to be a real subpath of
+  // WHATEVER PROCESS IS RUNNING THIS CODE (not the transcript's actual
+  // project) can walk up into a real `.git`, including a linked worktree's
+  // `.git` FILE, and return that worktree's real main-tree root as if it
+  // were the relative fragment's own project. The 'worktree' branch below
+  // returns early on g.shape alone with no absolute check of its own, so
+  // this guard cannot be deferred to after inspectGit runs (confirmed via
+  // opsRootAbsoluteCwd.test.cjs: reproduces in every git worktree, not just
+  // job worktrees — process.cwd() there is a worktree whose .git FILE
+  // resolves back to the real main tree root).
+  if (!path.isAbsolute(cwd)) {
+    return { kind: 'unknown', projectRoot: null, outermostOpsRoot: null, innermostOpsRoot: null, reason: 'cwd is not an absolute path' };
+  }
   const parts = cwd.split(path.sep);
   const first = parts.indexOf(OPS_DIRNAME);
   const last = parts.lastIndexOf(OPS_DIRNAME);

package/src/main/lib/definitionOfDone.cjs

@@ -14,6 +14,7 @@ const path = require('node:path');
 const { spawn, spawnSync } = require('node:child_process');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { resolvePrdWriteDir } = require('./prdLocations.cjs');
+const schedulerPaths = require('./schedulerPaths.cjs');
 
 // Regex identifying meta/dod slugs that must NOT influence the batchKey.
 // This is the load-bearing loop-avoidance filter: when the gate job itself
@@ -21,11 +22,6 @@ const { resolvePrdWriteDir } = require('./prdLocations.cjs');
 // a no-op (idempotent) instead of re-firing forever.
 const DOD_SLUG_RE = /(^|-)dod(-|$)|definition-of-done/i;
 
-const RUNS_DIR = path.join(
-  os.homedir(),
-  '.claude', 'session-manager', 'scheduled-plans', 'runs'
-);
-
 /**
  * Compute a stable short hash for a completed job-set.
  *
@@ -62,7 +58,7 @@ function batchKey(jobs) {
 function reportPathFor(key) {
   if (!/^[0-9a-f]+$/.test(key)) throw new Error(`invalid batchKey: ${key}`);
   const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  return path.join(RUNS_DIR, ts, `definition-of-done-${key}.md`);
+  return path.join(schedulerPaths.runsDir(), ts, `definition-of-done-${key}.md`);
 }
 
 /**
@@ -70,10 +66,10 @@ function reportPathFor(key) {
  * run subdirectory. Scans runs/<ts>/ (shallow, one level).
  *
  * @param {string} key       Output of batchKey()
- * @param {string} [runsDir] Override for testing; defaults to RUNS_DIR
+ * @param {string} [runsDir] Override for testing; defaults to schedulerPaths.runsDir()
  * @returns {boolean}
  */
-function reportExists(key, runsDir = RUNS_DIR) {
+function reportExists(key, runsDir = schedulerPaths.runsDir()) {
   if (!/^[0-9a-f]+$/.test(key)) throw new Error(`invalid batchKey: ${key}`);
   let entries;
   try {
@@ -604,7 +600,7 @@ const STATUS_EMOJI = { pass: '✅', fail: '❌', unverifiable: '⚠️' };
 function writeReport(key, { acResults = [], riskFlags = [], runsDir } = {}) {
   if (!/^[0-9a-f]+$/.test(key)) throw new Error(`invalid batchKey: ${key}`);
 
-  const resolvedRunsDir = runsDir ?? RUNS_DIR;
+  const resolvedRunsDir = runsDir ?? schedulerPaths.runsDir();
   const ts = new Date().toISOString().replace(/[:.]/g, '-');
   const dir = path.join(resolvedRunsDir, ts);
   const reportPath = path.join(dir, `definition-of-done-${key}.md`);
@@ -781,10 +777,10 @@ const WATERMARK_FILENAME = '.dod-watermark.json';
  * sidecar means "beginning of time" (process everything), matching the
  * pre-watermark unbounded behavior on first-ever drain.
  *
- * @param {string} [runsDir] Override for testing; defaults to RUNS_DIR
+ * @param {string} [runsDir] Override for testing; defaults to schedulerPaths.runsDir()
  * @returns {string|null}  ISO8601 timestamp, or null if unset/unreadable.
  */
-function readWatermark(runsDir = RUNS_DIR) {
+function readWatermark(runsDir = schedulerPaths.runsDir()) {
   try {
     const raw = fs.readFileSync(path.join(runsDir, WATERMARK_FILENAME), 'utf8');
     const parsed = JSON.parse(raw);
@@ -799,9 +795,9 @@ function readWatermark(runsDir = RUNS_DIR) {
  * jobs that completed after it.
  *
  * @param {string} lastFinishedAt  ISO8601 timestamp.
- * @param {string} [runsDir]       Override for testing; defaults to RUNS_DIR
+ * @param {string} [runsDir]       Override for testing; defaults to schedulerPaths.runsDir()
  */
-function writeWatermark(lastFinishedAt, runsDir = RUNS_DIR) {
+function writeWatermark(lastFinishedAt, runsDir = schedulerPaths.runsDir()) {
   fs.mkdirSync(runsDir, { recursive: true });
   _writeFileAtomic(
     path.join(runsDir, WATERMARK_FILENAME),

package/src/main/lib/effectiveModelInfo.cjs

@@ -28,6 +28,7 @@ const path = require('node:path');
 const os = require('node:os');
 const { splitFrontmatter } = require('./prdFrontmatter.cjs');
 const { resolveEpicTranscriptPath } = require('./epicTranscriptPath.cjs');
+const schedulerPaths = require('./schedulerPaths.cjs');
 
 // Deliberately stays a FIXED alias set (reviewed against the catalog-driven raw picker): it answers
 // "alias vs concrete id", not "which options to offer", so live catalog ids must not enter it.
@@ -51,13 +52,6 @@ const MAX_RUN_LOG_HEAD_BYTES = 64 * 1024;
 // pass over a transcript that can reach tens of MB. O(min(size, cap)).
 const MAX_TRANSCRIPT_TAIL_BYTES = 8 * 1024 * 1024;
 
-// Mirrors scheduler.cjs's own ROOT/RUNS_DIR constants (same convention as
-// queueStore.cjs's LEGACY_QUEUE_PATH, which duplicates this literal rather
-// than requiring scheduler.cjs's ~530KB module graph for one path).
-function runsDir(homeDir) {
-  return path.join(homeDir, '.claude', 'session-manager', 'scheduled-plans', 'runs');
-}
-
 function isConcreteModelId(modelAlias) {
   if (!modelAlias) return false;
   // 'opus[1m]' is an alias with a context suffix; 'claude-opus-4-7[1m]' keeps its id.
@@ -232,10 +226,9 @@ function findLatestSchedulerModel(cwd, agentType, deps) {
   const matches = jobs.filter((j) => j && j.agentType === agentType && j.runId && j.slug);
   matches.sort((a, b) => jobTimestampMs(b) - jobTimestampMs(a));
 
-  const homeDir = deps.homeDir || os.homedir();
   const re = /\[scheduler\] agentType=\S+ persona=.*? model=(\S+)/g;
   for (const job of matches) {
-    const logPath = path.join(runsDir(homeDir), job.runId, `${job.slug}.log`);
+    const logPath = path.join(schedulerPaths.runsDir(), job.runId, `${job.slug}.log`);
     const head = readHead(logPath, MAX_RUN_LOG_HEAD_BYTES, deps);
     if (!head) continue;
     let match;