claude-code-session-manager 0.95.0 → 0.96.0

package/src/main/__tests__/seedValidatorPersona.test.cjs

@@ -0,0 +1,116 @@
+/**
+ * seedValidatorPersona.test.cjs — covers the `validator` persona's delivery
+ * through seedAgentPersonas.cjs's existing "names not yet in `seeded`" path.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedValidatorPersona.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let realHome;
+let seedAgentPersonas;
+
+// config.cjs bakes os.homedir() into top-level consts at first require
+// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
+// alongside seedAgentPersonas.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = ['../seedAgentPersonas.cjs', '../config.cjs'];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-validator-persona-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
+  purgeRequireCache();
+  ({ seedAgentPersonas } = require('../seedAgentPersonas.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+function agentsDir() {
+  return path.join(tmpHome, '.claude', 'agents');
+}
+
+function markerPath() {
+  return path.join(tmpHome, '.claude', 'session-manager', '.agent-personas-seeded');
+}
+
+function silentLogger() {
+  return { log: () => {}, warn: () => {} };
+}
+
+const ALL_PERSONAS = ['architect', 'dev-lead', 'project-home-builder', 'validator'];
+const seedSrc = (name) => path.join(__dirname, '..', '..', 'seed', 'agents', `${name}.md`);
+
+test('a fresh homedir gets all four persona files', async () => {
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  for (const name of ALL_PERSONAS) {
+    const dest = path.join(agentsDir(), `${name}.md`);
+    expect(fs.existsSync(dest)).toBe(true);
+    expect(fs.readFileSync(dest, 'utf8')).toBe(fs.readFileSync(seedSrc(name), 'utf8'));
+  }
+
+  const marker = JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
+  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
+});
+
+test('a homedir whose marker already lists the first three receives validator.md, and the other three files are byte-identical before and after', async () => {
+  const mPath = markerPath();
+  fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  fs.writeFileSync(
+    mPath,
+    JSON.stringify({ seeded: ['architect', 'dev-lead', 'project-home-builder'], attempts: 0, ts: '2026-01-01T00:00:00.000Z' })
+  );
+  fs.mkdirSync(agentsDir(), { recursive: true });
+  const preExisting = {};
+  for (const name of ['architect', 'dev-lead', 'project-home-builder']) {
+    const content = `existing ${name} content\n`;
+    fs.writeFileSync(path.join(agentsDir(), `${name}.md`), content);
+    preExisting[name] = content;
+  }
+
+  expect(fs.existsSync(path.join(agentsDir(), 'validator.md'))).toBe(false);
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  expect(fs.readFileSync(path.join(agentsDir(), 'validator.md'), 'utf8')).toBe(fs.readFileSync(seedSrc('validator'), 'utf8'));
+
+  for (const name of ['architect', 'dev-lead', 'project-home-builder']) {
+    expect(fs.readFileSync(path.join(agentsDir(), `${name}.md`), 'utf8')).toBe(preExisting[name]);
+  }
+
+  const marker = JSON.parse(fs.readFileSync(mPath, 'utf8'));
+  expect(marker.seeded.sort()).toEqual([...ALL_PERSONAS].sort());
+});
+
+test('the seeded validator body is under AGENT_BODY_CHAR_CAP and contains both required sentinel lines', () => {
+  const { AGENT_BODY_CHAR_CAP } = require('../lib/agentModelResolve.cjs');
+  const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
+  const raw = fs.readFileSync(seedSrc('validator'), 'utf8');
+  const { body } = splitFrontmatter(raw);
+  const trimmed = body.trim();
+
+  expect(trimmed.length).toBeLessThan(AGENT_BODY_CHAR_CAP);
+  expect(trimmed).toContain('VALIDATION: <slug> VERIFIED');
+  expect(trimmed).toContain('SCHEDULER_VERDICT: PASS');
+  expect(trimmed).not.toContain('Do not touch:');
+  expect(trimmed).not.toContain('Report explicitly:');
+  expect(trimmed.endsWith('report them.')).toBe(true);
+});

package/src/main/__tests__/telemetryClient.test.cjs

@@ -78,8 +78,8 @@ function freshClient(home, profileOverrides) {
   // Explicit opt-in: this suite deliberately exercises telemetryClient's real
   // queue/sent-file I/O, so it must override the test-environment no-op guard
   // by pointing the spool at this test's own isolated tmp dir (never a real
-  // user's ~/.config/session-manager).
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.config', 'session-manager');
+  // user's ~/.claude/session-manager).
+  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
   for (const p of ['../lib/telemetryClient.cjs', '../config.cjs', '../lib/telemetrySettings.cjs', '../lib/machineProfile.cjs']) {
     const resolved = require.resolve(p);
     delete require.cache[resolved];

package/src/main/__tests__/telemetryContract.test.cjs

@@ -348,7 +348,7 @@ function freshClient(home, profileOverrides) {
   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 HOME_DEPENDENT_MODULES) {
     const resolved = require.resolve(p);
     delete require.cache[resolved];
@@ -695,7 +695,7 @@ test('records queued, a 503 mid-drain, then a fresh client flushing successfully
 
   expect(stubServer.state.errors.length).toBe(before); // nothing landed during the failure
 
-  const wmPath = path.join(home, '.config', 'session-manager', 'telemetry-watermarks.json');
+  const wmPath = path.join(home, '.claude', 'session-manager', 'telemetry-watermarks.json');
   const wmAfterFailure = JSON.parse(await fsp.readFile(wmPath, 'utf8'));
   const entryAfterFailure = Object.values(wmAfterFailure).find((e) => e && typeof e === 'object' && 'bytesConfirmed' in e);
   expect(entryAfterFailure.bytesConfirmed).toBe(0); // bytesConfirmed frozen during the failed phase

package/src/main/__tests__/usageSingleFlight.test.cjs

@@ -88,6 +88,7 @@ afterEach(() => {
   process.env.HOME = realHome;
   vi.unstubAllGlobals();
   vi.restoreAllMocks();
+  vi.useRealTimers();
   purgeRequireCache();
   // maxRetries: a fire-and-forget cache write inside usage.cjs can land in .claude/ mid-rm
   // (ENOTEMPTY) when the machine is loaded; this is cleanup robustness, not a test retry.
@@ -112,6 +113,15 @@ test('two concurrent fetchUsage() calls produce exactly one HTTP fetch', async (
 });
 
 test('an ok result resets the shared circuit streak built up by prior failures', async () => {
+  // The breaker's open->half_open transition (usageCircuit.cjs's state())
+  // compares real Date.now() against a jittered 15-30s backoff deadline. On
+  // a loaded machine, real wall-clock time can drift far enough between the
+  // 3rd failure and the assertions below for that deadline to pass, flipping
+  // 'open' to 'half_open' out from under this test. Freeze time so the
+  // open/closed assertions are decided by call sequence, not the real clock.
+  vi.useFakeTimers();
+  vi.setSystemTime(Date.now());
+
   const usage = require('../usage.cjs');
   const circuit = usage.__usageCircuitForTest;
 

package/src/main/__tests__/validationSentinels.test.cjs

@@ -0,0 +1,84 @@
+/**
+ * validationSentinels.test.cjs — unit tests for parseValidationSentinels
+ * (PRD 1407): a plan-level validator job ends its run with one
+ * `VALIDATION: <slug> VERIFIED` or `VALIDATION: <slug> REFUTED — <reason>`
+ * line per PRD; this module extracts those lines from the job's result text.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/validationSentinels.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { parseValidationSentinels } = require('../lib/validationSentinels.cjs');
+
+test('parses a VERIFIED line with no reason', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo VERIFIED')).toEqual([
+    { slug: '123-foo', verdict: 'verified', reason: '' },
+  ]);
+});
+
+test('parses a REFUTED line with an em-dash reason', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo REFUTED — missing test coverage')).toEqual([
+    { slug: '123-foo', verdict: 'refuted', reason: 'missing test coverage' },
+  ]);
+});
+
+test('parses a REFUTED line with an en-dash reason', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo REFUTED – bad wiring')).toEqual([
+    { slug: '123-foo', verdict: 'refuted', reason: 'bad wiring' },
+  ]);
+});
+
+test('parses a REFUTED line with a hyphen reason', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo REFUTED - wrong file touched')).toEqual([
+    { slug: '123-foo', verdict: 'refuted', reason: 'wrong file touched' },
+  ]);
+});
+
+test('parses a REFUTED line with no reason', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo REFUTED')).toEqual([
+    { slug: '123-foo', verdict: 'refuted', reason: '' },
+  ]);
+});
+
+test('ignores lowercase verified/refuted', () => {
+  expect(parseValidationSentinels('VALIDATION: 123-foo verified')).toEqual([]);
+  expect(parseValidationSentinels('VALIDATION: 123-foo refuted')).toEqual([]);
+});
+
+test('ignores every other line in a multi-line transcript', () => {
+  const text = [
+    'Some preamble text',
+    'Running gate...',
+    'VALIDATION: 111-alpha VERIFIED',
+    'random noise mentioning VALIDATION: not-a-real-line',
+    'VALIDATION: 222-beta REFUTED — the fix was incomplete',
+    'trailing notes',
+  ].join('\n');
+
+  expect(parseValidationSentinels(text)).toEqual([
+    { slug: '111-alpha', verdict: 'verified', reason: '' },
+    { slug: '222-beta', verdict: 'refuted', reason: 'the fix was incomplete' },
+  ]);
+});
+
+test('last line per slug wins, order of first appearance kept', () => {
+  const text = [
+    'VALIDATION: 111-alpha VERIFIED',
+    'VALIDATION: 222-beta REFUTED — first reason',
+    'VALIDATION: 111-alpha REFUTED — actually broken',
+    'VALIDATION: 222-beta VERIFIED',
+  ].join('\n');
+
+  expect(parseValidationSentinels(text)).toEqual([
+    { slug: '111-alpha', verdict: 'refuted', reason: 'actually broken' },
+    { slug: '222-beta', verdict: 'verified', reason: '' },
+  ]);
+});
+
+test('returns [] for null, undefined, and empty input', () => {
+  expect(parseValidationSentinels(null)).toEqual([]);
+  expect(parseValidationSentinels(undefined)).toEqual([]);
+  expect(parseValidationSentinels('')).toEqual([]);
+});

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.95.0",
-  "gitSha": "42f7779080772b1b8432b6287aff06c52b9f0f90",
-  "gitShortSha": "42f77790",
+  "version": "0.96.0",
+  "gitSha": "32cc4ebad387727ee0d691ffcf524d938efdcfca",
+  "gitShortSha": "32cc4eba",
   "gitBranch": "HEAD",
-  "builtAt": "2026-09-21T22:01:57.972Z",
+  "builtAt": "2026-09-24T19:16:51.123Z",
   "dirty": false
 }

package/src/main/config.cjs

@@ -19,7 +19,7 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
-const { assertOpsWrite, opsPath } = require('./lib/opsOwnership.cjs');
+const { assertOpsWrite, opsPath, OWNERS } = require('./lib/opsOwnership.cjs');
 const chokidar = require('chokidar');
 const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
@@ -113,7 +113,6 @@ const WRITE_PREFIXES = [
   path.join(os.homedir(), '.claude'),
   path.join(os.homedir(), '.claude.json'), // global MCP servers config
   path.join(os.homedir(), '.config', 'claude-code'),
-  path.join(os.homedir(), '.config', 'session-manager'),
 ];
 
 /**
@@ -144,17 +143,15 @@ function validateWrite(realAbs) {
       if (realAbs === claudeSub || realAbs.startsWith(claudeSub + path.sep)) {
         return;
       }
-      // Writable ops namespaces under a registered project root — this
-      // repo's per-project artifact-store convention:
-      //   prompt-sessions  PromptSession persistence (promptSessions.ts) and
-      //                    the scheduler's read-modify-write of active-index
-      //                    (promptSessionEvents.cjs, PRD 814)
-      //   scheduler        PRD sources + Epic PRD dirs + state shards
-      //                    (PRD 825; scheduler.cjs remote.writePrd)
-      //   project-brief    projectBrief.cjs's brief.json (PRD 837)
-      //   bilko-host       bilkoHost.cjs's bundle prep
-      //   project-pages    projectHomeAdminRoutes.cjs's project_home_write
-      //                    path (home.html)
+      // Writable ops namespaces under a registered project root — every
+      // namespace declared in opsOwnership.cjs's OWNERS map is writable here
+      // by construction (PRD 1410): OWNERS is the single source of truth for
+      // "this namespace exists and has an owner", so a namespace can never
+      // again be declared owned yet unwritable (incident: PRD 1398 added
+      // 'ui-prefs' to OWNERS but this list was hand-maintained separately and
+      // never updated, so every ui-prefs write threw here before
+      // assertOpsWrite's per-writer check ever ran). Which WRITER may use a
+      // given namespace is still assertOpsWrite's job below, not this list's.
       // Paths come from opsOwnership.opsPath (PRD 1082) — the one ops-root
       // resolver — which THROWS for an ephemeral root (a linked worktree that
       // pty.cjs registered as an allowed root for its spawn cwd, or
@@ -162,7 +159,7 @@ function validateWrite(realAbs) {
       // never a writable destination, so its exemptions simply do not exist.
       let opsSubs;
       try {
-        opsSubs = ['prompt-sessions', 'scheduler', 'project-brief', 'bilko-host', 'project-pages'].map((ns) => opsPath(realRoot, ns));
+        opsSubs = Object.keys(OWNERS).map((ns) => opsPath(realRoot, ns));
       } catch {
         opsSubs = [];
       }
@@ -313,6 +310,20 @@ function writeJsonSync(abs, data, opts = {}) {
   return { ok: true, mtimeMs: stat.mtimeMs };
 }
 
+/**
+ * One-shot best-effort move of a legacy config file to its new home. No-op
+ * (silent) when the new path already exists or the old path never existed —
+ * either way there is nothing to migrate. Same-filesystem rename is atomic,
+ * so there is no partial-write window to worry about.
+ */
+function migrateLegacyHomeFile(oldPath, newPath) {
+  try {
+    if (fs.existsSync(newPath) || !fs.existsSync(oldPath)) return;
+    fs.mkdirSync(path.dirname(newPath), { recursive: true });
+    fs.renameSync(oldPath, newPath);
+  } catch { /* best-effort; a stale/missing legacy file must never block boot */ }
+}
+
 async function listDir(abs, { filesOnly = false, dirsOnly = false, includeHidden = false } = {}) {
   try {
     abs = validatePath(expandHome(abs));
@@ -490,6 +501,7 @@ module.exports = {
   readText,
   writeJson,
   writeJsonSync,
+  migrateLegacyHomeFile,
   writeTextAtomic,
   writeBinaryAtomic,
   listDir,

package/src/main/exchanges.cjs

@@ -3,8 +3,15 @@
 /**
  * exchanges.cjs — durable append-only log of completed terminal-chat exchanges.
  *
- * Appends one NDJSON record per successful chat run to:
- *   ~/.claude/knowledge-log/exchanges/<encodeCwd(cwd)>.jsonl
+ * Appends one NDJSON record per successful chat run to the per-project ops
+ * root (single-writer law, lib/opsOwnership.cjs — 'prompt-sessions' is owned
+ * by 'epics'):
+ *   <cwd>/session-manager-operations/prompt-sessions/exchanges.jsonl
+ *
+ * Historical rows from before this PRD live on, untouched, in the old global
+ * store (~/.claude/knowledge-log/exchanges/<encodeCwd(cwd)>.jsonl) — migrating
+ * them would require the same unsafe cwd-decoding this store is meant to
+ * avoid, so they are simply left behind; only new exchanges land here.
  *
  * Record shape (contract for PRDs 324 + 325):
  *   { ts, sessionId, cwd, prompt, result, summary, degraded?, promptId? }
@@ -20,31 +27,30 @@
  */
 
 const fsp = require('node:fs/promises');
-const fs = require('node:fs');
 const path = require('node:path');
-const os = require('node:os');
-const { encodeCwd } = require('./lib/encodeCwd.cjs');
-const { validatePath } = require('./config.cjs');
+const { opsPath, assertOpsWrite } = require('./lib/opsOwnership.cjs');
 const { summarize } = require('./lib/summarize.cjs');
 
-const HOME = os.homedir();
-const EXCHANGES_DIR = path.join(HOME, '.claude', 'knowledge-log', 'exchanges');
+const EXCHANGES_WRITER = 'epics';
+
+function exchangesFilePath(cwd) {
+  return opsPath(cwd, 'prompt-sessions', 'exchanges.jsonl');
+}
 
 /**
- * Record a completed exchange. Creates the exchanges directory if needed.
- * Appends one JSON line; uses O_APPEND so concurrent writes from separate
- * processes are safe (each line is a single write, POSIX O_APPEND atomic for
- * pipe-sized payloads).
+ * Record a completed exchange. Creates the ops directory if needed. Appends
+ * one JSON line via raw fs O_APPEND (not config.cjs's writeJson) so
+ * concurrent writes from separate processes stay safe — each line is a
+ * single write, POSIX O_APPEND atomic for pipe-sized payloads. Because this
+ * bypasses config.cjs's normal write boundary, the single-writer law is
+ * asserted explicitly here.
  *
  * @param {{ sessionId: string, cwd: string, prompt: string, result: string, promptId?: string }} opts
  * @returns {Promise<void>}
  */
 async function recordExchange({ sessionId, cwd, prompt, result, promptId }) {
-  const encoded = encodeCwd(cwd);
-  const filePath = path.join(EXCHANGES_DIR, `${encoded}.jsonl`);
-
-  // Security: validate that the target path stays within home dir
-  validatePath(EXCHANGES_DIR);
+  const filePath = exchangesFilePath(cwd);
+  assertOpsWrite(filePath, EXCHANGES_WRITER);
 
   // Summarize — always resolves; never throws
   const { summary, model, degraded } = await summarize(result);
@@ -63,7 +69,7 @@ async function recordExchange({ sessionId, cwd, prompt, result, promptId }) {
 
   const line = JSON.stringify(record) + '\n';
 
-  await fsp.mkdir(EXCHANGES_DIR, { recursive: true });
+  await fsp.mkdir(path.dirname(filePath), { recursive: true });
   await fsp.appendFile(filePath, line, { encoding: 'utf8' });
 }
 
@@ -79,8 +85,7 @@ const DEFAULT_LIMIT = 100;
  * @returns {Promise<object[]>}
  */
 async function listExchanges({ cwd, sessionId, limit = DEFAULT_LIMIT, offset = 0 }) {
-  const encoded = encodeCwd(cwd);
-  const filePath = path.join(EXCHANGES_DIR, `${encoded}.jsonl`);
+  const filePath = exchangesFilePath(cwd);
 
   let stat;
   try { stat = await fsp.stat(filePath); } catch { return []; }
@@ -128,4 +133,4 @@ async function listExchanges({ cwd, sessionId, limit = DEFAULT_LIMIT, offset = 0
   return filtered.slice(offset, offset + limit);
 }
 
-module.exports = { recordExchange, listExchanges, EXCHANGES_DIR };
+module.exports = { recordExchange, listExchanges };

package/src/main/health.cjs

@@ -23,7 +23,7 @@ const { computeStallSummary, computeDepHistorySatisfaction, FAILURE_STREAK_ESCAL
 const { findStarvedProjects, findUnresolvableDepRoots, DEFAULT_PROJECT_CWD, DEP_HISTORY_FAIL_OPEN } = require('./lib/schedulerBatch.cjs');
 const { auditLogPath, readTail } = require('./lib/auditLog.cjs');
 const { resolveBuildIdentity } = require('./lib/buildIdentity.cjs');
-const { DEFAULT_RUNS_DIR, computeReport, isRetentionEnabled, liveKeysFromJobs } = require('./lib/runLogRetention.cjs');
+const { computeReport, isRetentionEnabled, liveKeysFromJobs } = require('./lib/runLogRetention.cjs');
 const { allProjectCwds } = require('./lib/activeSessions.cjs');
 const { scanEpicTranscripts } = require('./lib/epicTranscriptDiagnostic.cjs');
 
@@ -627,6 +627,50 @@ function evaluateBuildFreshness({ running = null, installedOnDisk = null, repoHe
   return { ok: true, running, installedOnDisk, repoHead, restartNeeded, publishNeeded, ...(notes.length ? { note: notes.join('; ') } : {}) };
 }
 
+/**
+ * evaluateCredentialHealth({ credState, now }) → { component, issues }
+ *
+ * Pure over its inputs — `credState` is the shape lib/credentials.cjs's
+ * refreshIfNeeded()/readCredentials() return ({ kind, message?, expiredAt? }),
+ * injected so this is testable without touching the Keychain. Surfaces the ONE
+ * failure that silently voids the whole scheduler on a user's machine: the
+ * OAuth token is expired (or missing) so every headless `claude -p` job fails
+ * to authenticate. The scheduler already pauses on a live 'auth' poll
+ * (scheduler.cjs setPaused('auth')), but nothing told the OPERATOR why the
+ * queue went quiet — `npm run health` read GREEN while no job could run. This
+ * names the cause and the fix (`claude login`).
+ *
+ * NON-CRITICAL by design: reported in components.credentials + issues so
+ * /local-project-health shows it, but it does not flip status.ok — health must
+ * not hard-fail a repo checkout just because THIS machine's token lapsed, and
+ * an expired token is an operator action (re-login), not a code defect. Maps:
+ *   kind 'auth'   → not ok, actionable `claude login` message (the real block)
+ *   kind 'config' → not ok, credentials unreadable/absent
+ *   kind 'ok'/'unsupported' → ok (token usable, or too-fresh-to-refresh)
+ */
+function evaluateCredentialHealth({ credState, now = Date.now() } = {}) {
+  const issues = [];
+  if (!credState || typeof credState !== 'object') {
+    return { component: { ok: true, state: 'unknown' }, issues };
+  }
+  const { kind } = credState;
+  if (kind === 'auth') {
+    const expiredAt = typeof credState.expiredAt === 'number' ? credState.expiredAt : null;
+    const agoMin = expiredAt ? Math.max(0, Math.round((now - expiredAt) / 60_000)) : null;
+    const when = expiredAt ? new Date(expiredAt).toISOString() : 'unknown';
+    const msg = `Claude credentials expired${agoMin !== null ? ` (${agoMin}m ago, at ${when})` : ''} — headless \`claude -p\` scheduler jobs cannot authenticate. Run \`claude login\` in a terminal to refresh.`;
+    issues.push(msg);
+    return { component: { ok: false, state: 'expired', expiredAt, message: msg }, issues };
+  }
+  if (kind === 'config') {
+    const msg = `Claude credentials unreadable: ${credState.message ?? 'unknown'} — scheduler jobs cannot authenticate. Run \`claude login\`.`;
+    issues.push(msg);
+    return { component: { ok: false, state: 'unreadable', message: msg }, issues };
+  }
+  // 'ok' (fresh) or 'unsupported' (auto-refresh unavailable but token still valid)
+  return { component: { ok: true, state: kind === 'unsupported' ? 'valid-no-refresh' : 'valid' }, issues };
+}
+
 /**
  * evaluateStarveEscalationHealth(jobs, now, thresholdMs, escalationReasons)
  *   → { ok, projects?, message? }
@@ -1138,15 +1182,16 @@ async function check(opts = {}) {
   // `config`, same home as every other scheduler machine setting.
   try {
     const retentionCfg = queueState?.config?.schedulerRunLogRetention;
-    const liveKeys = liveKeysFromJobs(queueState?.jobs || [], { runsDir: DEFAULT_RUNS_DIR });
+    const runsDir = schedulerPaths.runsDir();
+    const liveKeys = liveKeysFromJobs(queueState?.jobs || [], { runsDir });
     const report = computeReport(
-      DEFAULT_RUNS_DIR,
+      runsDir,
       retentionCfg?.policy || {},
       { liveKeys }
     );
     status.components.run_log_retention = {
       ok: true,
-      path: DEFAULT_RUNS_DIR,
+      path: runsDir,
       totalBytes: report.usage.totalBytes,
       dirCount: report.usage.dirCount,
       runCount: report.usage.runCount,
@@ -1205,6 +1250,22 @@ async function check(opts = {}) {
     status.components.build = { ok: true, error: e.message };
   }
 
+  // 6.8. Credential health (informational-but-loud): is the Claude OAuth token
+  // usable? An expired/absent token silently voids every headless `claude -p`
+  // job — the queue "runs" but nothing authenticates. refreshIfNeeded() reads
+  // the Keychain/file and (post futile-refresh fix) never spawns a doomed CLI
+  // fallback for an expired-no-refresh-token creds, so this is a cheap read.
+  // Non-critical: names the cause + `claude login` fix without flipping ok.
+  try {
+    const { refreshIfNeeded } = require('./lib/credentials.cjs');
+    const credState = await refreshIfNeeded();
+    const { component, issues } = evaluateCredentialHealth({ credState, now: Date.now() });
+    status.components.credentials = component;
+    for (const i of issues) status.issues.push(i);
+  } catch (e) {
+    status.components.credentials = { ok: true, state: 'unknown', error: e.message };
+  }
+
   // 7. Summary scoring: ok if all critical components pass.
   // Critical: nodejs, config dir, typescript, build artifact, test infrastructure.
   // Non-fatal: scheduler/transcripts dirs may not exist on fresh install.
@@ -1231,6 +1292,7 @@ module.exports = {
   readFreshHeartbeat,
   evaluatePrdMigrationHealth,
   evaluateDelegationChainHealth,
+  evaluateCredentialHealth,
   computeEpicIndexDrift,
   evaluateEpicIndexHealth,
   computeProjectProblemCounts,

package/src/main/index.cjs

@@ -1027,7 +1027,7 @@ ipcMain.handle('exchanges:list', validated(schemas.exchangesList, async (payload
   }
 }));
 
-// OTEL telemetry export (opt-in via ~/.config/session-manager/otel.json).
+// OTEL telemetry export (opt-in via ~/.claude/session-manager/otel.json).
 ipcMain.handle('otel:get-config', async () => otelSettings.load());
 ipcMain.handle('otel:set-config', async (_e, cfg) => {
   if (!otelSettings.isValid(cfg)) {

package/src/main/ipcSchemas.cjs

@@ -632,10 +632,14 @@ const memoryStale = z.object({
 // the encoded cwd slug (memoryAggregate.cjs reads directly from
 // ~/.claude/projects/<workspace>/memory/), same regex as the other memory:*
 // handlers. `refresh: true` is the cost gate that fires the single claude -p
-// clustering pass; falsy returns the cached result.
+// clustering pass; falsy returns the cached result. `cwd` (PRD 1389,
+// optional — same shape as memory:stale's) addresses the per-project cache
+// at <cwd>/session-manager-operations/memory-clusters/clusters.json;
+// absent/invalid cwd just disables caching for that call.
 const memoryAggregate = z.object({
   workspace: z.string().regex(MEMORY_WORKSPACE_RE),
   refresh: z.boolean().optional(),
+  cwd: z.string().max(4096).optional(),
 }).strict();
 
 // ──────────────────────────────────────────── Project Brief (PRD 837)

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

@@ -35,7 +35,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;
 }