claude-code-session-manager 0.74.0 → 0.75.0

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

@@ -0,0 +1,145 @@
+/**
+ * seedSchedulerMcp.test.cjs — unit tests for src/main/seedSchedulerMcp.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedSchedulerMcp.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 seedSchedulerMcp;
+
+// config.cjs bakes os.homedir() into top-level consts at first require
+// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
+// alongside seedSchedulerMcp.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = ['../seedSchedulerMcp.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-scheduler-mcp-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
+  purgeRequireCache();
+  ({ seedSchedulerMcp } = require('../seedSchedulerMcp.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+function markerPath() {
+  return path.join(tmpHome, '.claude', 'session-manager', '.scheduler-mcp-seeded');
+}
+
+function claudeJsonPath() {
+  return path.join(tmpHome, '.claude.json');
+}
+
+function silentLogger() {
+  return { log: () => {}, warn: () => {} };
+}
+
+function readMarker() {
+  return JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
+}
+
+test('fresh registration calls addFn with the absolute server path and writes done marker', async () => {
+  const calls = [];
+  const addFn = async (serverPath) => {
+    calls.push(serverPath);
+    return { ok: true, exitCode: 0 };
+  };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(calls).toHaveLength(1);
+  expect(path.isAbsolute(calls[0])).toBe(true);
+  expect(calls[0].endsWith(path.join('scripts', 'scheduler-mcp-server.cjs'))).toBe(true);
+
+  const marker = readMarker();
+  expect(marker.done).toBe(true);
+  expect(marker.attempts).toBe(0);
+});
+
+test('already-registered at user scope short-circuits without calling addFn', async () => {
+  fs.writeFileSync(
+    claudeJsonPath(),
+    JSON.stringify({
+      mcpServers: {
+        'session-manager-scheduler': { type: 'stdio', command: 'node', args: ['/some/path/scheduler-mcp-server.cjs'] },
+        fetch: { type: 'stdio', command: 'uvx', args: ['mcp-server-fetch'] },
+      },
+    })
+  );
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+  const marker = readMarker();
+  expect(marker.done).toBe(true);
+
+  // Untouched — the pre-existing registration (and sibling entries) stay as-is.
+  const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath(), 'utf8'));
+  expect(claudeJson.mcpServers['session-manager-scheduler'].args).toEqual(['/some/path/scheduler-mcp-server.cjs']);
+  expect(claudeJson.mcpServers.fetch).toBeDefined();
+});
+
+test('done:true marker short-circuits without calling addFn', async () => {
+  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
+  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+});
+
+test('SM_SEED_SCHEDULER_MCP_DISABLE=1 short-circuits', async () => {
+  process.env.SM_SEED_SCHEDULER_MCP_DISABLE = '1';
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+  expect(fs.existsSync(markerPath())).toBe(false);
+});
+
+test('a failed attempt bumps the counter and stops after MAX_ATTEMPTS', async () => {
+  const addFn = async () => ({ ok: false, error: 'boom' });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 1 });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 2 });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
+
+  // MAX_ATTEMPTS reached — a 4th run must not call addFn again or bump further.
+  let called = false;
+  const trackedAddFn = async () => { called = true; return { ok: false, error: 'boom' }; };
+  await seedSchedulerMcp({ logger: silentLogger(), addFn: trackedAddFn });
+
+  expect(called).toBe(false);
+  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
+});

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

@@ -0,0 +1,100 @@
+/**
+ * seedStatus.test.cjs — unit tests for src/main/seedStatus.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedStatus.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 getSeedStatus;
+
+// config.cjs (via seedSchedulerMcp/seedAgentPersonas) and each seed*.cjs
+// module bake os.homedir() into top-level consts at first require — purge
+// all of them alongside seedStatus.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = [
+  '../seedStatus.cjs',
+  '../seedDevPlugin.cjs',
+  '../seedSchedulerMcp.cjs',
+  '../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-status-test-'));
+  process.env.HOME = tmpHome;
+  purgeRequireCache();
+  ({ getSeedStatus } = require('../seedStatus.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+const MARKER_NAMES = {
+  'dev-plugin': '.dev-plugin-seeded',
+  'scheduler-mcp': '.scheduler-mcp-seeded',
+  'agent-personas': '.agent-personas-seeded',
+};
+
+function markerPath(id) {
+  return path.join(tmpHome, '.claude', 'session-manager', MARKER_NAMES[id]);
+}
+
+function writeMarker(id, contents) {
+  const p = markerPath(id);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, contents);
+}
+
+test('no marker files at all → every seeder reports pending with a fix string', () => {
+  const status = getSeedStatus();
+  for (const id of Object.keys(MARKER_NAMES)) {
+    expect(status[id].status).toBe('pending');
+    expect(typeof status[id].fix).toBe('string');
+    expect(status[id].fix.length).toBeGreaterThan(0);
+  }
+});
+
+for (const id of Object.keys(MARKER_NAMES)) {
+  test(`${id}: done:true marker → done`, () => {
+    writeMarker(id, JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('done');
+  });
+
+  test(`${id}: done:false, attempts below max → pending`, () => {
+    writeMarker(id, JSON.stringify({ done: false, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+
+  test(`${id}: done:false, attempts >= max → exhausted`, () => {
+    writeMarker(id, JSON.stringify({ done: false, attempts: 3, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('exhausted');
+  });
+
+  test(`${id}: unparseable marker → pending, never throws`, () => {
+    writeMarker(id, 'not json at all {{{');
+    expect(() => getSeedStatus()).not.toThrow();
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+
+  test(`${id}: missing marker file → pending`, () => {
+    // No file written for this id — directory may not even exist.
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+}

package/src/main/agentLibrary.cjs

@@ -22,6 +22,7 @@ const fsSync = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const { splitFrontmatter } = require('./lib/prdFrontmatter.cjs');
+const { resolvePersonaPaths } = require('./lib/epicMint.cjs');
 const configMgr = require('./config.cjs');
 const sessionsStore = require('./sessionsStore.cjs');
 
@@ -249,6 +250,47 @@ async function listPersonas({
   return personas;
 }
 
+/**
+ * Reads a persona `.md` file's raw text for `epicIntake.ts`'s `agentBody`
+ * input, honoring the same project-overlay-then-global precedence as
+ * `epicMint.cjs`'s `resolvePersonaPaths` (a project's `<cwd>/.claude/agents/
+ * <name>.md` wins over `~/.claude/agents/<name>.md`) — the same precedence
+ * `listPersonas` deliberately does NOT apply, since that lists only the
+ * global directory for the Agent Library nav page. Returns `null` when
+ * neither location has the file; frontmatter stripping and the 6000-char cap
+ * are epicIntake.ts's job, not this reader's.
+ */
+async function getPersonaBody({
+  cwd,
+  name,
+  validatePath = configMgr.validatePath,
+} = {}) {
+  // Same gate savePersona/deletePersona apply before touching a path built
+  // from `name` (agentLibrary.cjs's PERSONA_NAME_RE check) — without it a
+  // `name` like "../../other-project/CLAUDE" survives resolvePersonaPaths'
+  // plain path.join and validatePath's allowed-roots check (which only
+  // confirms the resolved path stays under the home dir / an opened
+  // project), letting any readable .md under those roots be read and
+  // forwarded into the Epic's opening prompt.
+  if (!PERSONA_NAME_RE.test(name || '')) return null;
+  const { projectPath, globalPath } = resolvePersonaPaths(cwd, name);
+  for (const candidate of [projectPath, globalPath]) {
+    let real;
+    try {
+      real = validatePath(candidate);
+    } catch {
+      continue;
+    }
+    try {
+      const text = await fsp.readFile(real, 'utf8');
+      return { path: real, text };
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
 module.exports = {
   listPersonas,
   openProjects,
@@ -257,6 +299,7 @@ module.exports = {
   deletePersona,
   removeOverride,
   serializePersona,
+  getPersonaBody,
   PERSONA_NAME_RE,
   ALL_PROJECTS,
 };

package/src/main/index.cjs

@@ -36,6 +36,7 @@ const epicWorktreeMint = require('./lib/epicWorktreeMint.cjs');
 const epicWorktreeMerge = require('./lib/epicWorktreeMerge.cjs');
 const epicWorktreeProjectConfig = require('./lib/epicWorktreeProjectConfig.cjs');
 const agentLibrary = require('./agentLibrary.cjs');
+const { checkDelegationReadiness } = require('./lib/delegationReadiness.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { resolveBuildTarget } = require('./lib/buildTarget.cjs');
 const crossProjectFeedback = require('./lib/crossProjectFeedback.cjs');
@@ -54,6 +55,9 @@ const teams = require('./teams.cjs');
 const queueOps = require('./queueOps.cjs');
 const pluginInstall = require('./pluginInstall.cjs');
 const { seedDevPlugin } = require('./seedDevPlugin.cjs');
+const { seedAgentPersonas } = require('./seedAgentPersonas.cjs');
+const { seedSchedulerMcp } = require('./seedSchedulerMcp.cjs');
+const { getSeedStatus } = require('./seedStatus.cjs');
 const otel = require('./otel.cjs');
 const otelSettings = require('./otelSettings.cjs');
 const { registerHistoryAggregatorHandlers, finalizeClosedDays, refreshIntradayToday } = require('./historyAggregator.cjs');
@@ -67,6 +71,7 @@ const { registerProjectBriefIpc } = require('./projectBrief.cjs');
 const { registerProjectPagesIpc } = require('./projectPages.cjs');
 const { registerBilkoHostIpc } = require('./bilkoHost.cjs');
 const promptSessionTranscript = require('./promptSessionTranscript.cjs');
+const { computeEpicDelegationStats } = require('./lib/epicDelegationStats.cjs');
 const agentMemory = require('./agentMemory.cjs');
 const git = require('./git.cjs');
 const heapSnapshot = require('./heapSnapshot.cjs');
@@ -481,6 +486,19 @@ ipcMain.handle('agents:remove-override', async (_e, payload) => {
   broadcastAgentsChanged();
   return result;
 });
+// New Epic AIM composer (epicIntake.ts's `agentBody`/`agentPath`): unlike
+// list-personas above (global dir only), this honors the project-overlay-
+// then-global precedence so an Epic's opening prompt carries the persona
+// body that actually applies to its cwd. Read-only.
+ipcMain.handle('agents:get-persona-body', validated(schemas.agentsGetPersonaBody, (payload) =>
+  agentLibrary.getPersonaBody(payload)));
+
+// "Can this project actually delegate?" probe (PRD: delegation-readiness).
+// Structured data over the four preconditions for scheduler_create_prd being
+// in an agent's tool list at all — surfacing it in the UI is a sibling PRD.
+ipcMain.handle('app:delegation-readiness', validated(schemas.delegationReadinessCwd, (payload) =>
+  checkDelegationReadiness(payload)
+));
 
 ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE_RULES || null);
 
@@ -488,6 +506,9 @@ ipcMain.handle('app:engage-rules-path', () => process.env.SESSION_MANAGER_ENGAGE
 // on disk or the home self-check failed (e.g. macOS /Users symlink mismatch).
 ipcMain.handle('app:claude-bin-status', () => bootClaudeBin);
 ipcMain.handle('app:home-self-check', () => bootHomeSelfCheck);
+// First-boot seeder outcomes ('done' | 'pending' | 'exhausted' per seeder),
+// read live from each seeder's own marker file — see seedStatus.cjs.
+ipcMain.handle('app:seed-status', () => getSeedStatus());
 
 ipcMain.handle('app:pick-directory', async () => {
   console.log('[main] pick-directory invoked');
@@ -802,6 +823,11 @@ ipcMain.handle('promptSessionTranscript:read', validated(schemas.promptSessionTr
   const turns = await promptSessionTranscript.readTurns(cwd, epicId, { limit });
   return { turns };
 }));
+// Derived-at-read-time "PRDs queued vs inline edits" counter (no writer —
+// reads the Epic's own live prds/ dir + its own claude session transcript).
+ipcMain.handle('epicDelegationStats:get', validated(schemas.epicDelegationStatsGet, async ({ cwd, epicId, claudeSessionId }) => {
+  return computeEpicDelegationStats(cwd, epicId, claudeSessionId || null);
+}));
 // Renderer Epic lifecycle trace (PRD 940) — append-only, no read/list IPC.
 // Kind allowlist enforced by schemas.auditLogAppend, not here.
 ipcMain.handle('auditLog:append', validated(schemas.auditLogAppend, async ({ kind, cwd, epicId, source }) => {
@@ -1149,9 +1175,24 @@ app.whenReady().then(async () => {
   // First-boot default: install the bundled session-manager-dev plugin (its 10
   // dev skills) from the app's own marketplace. One-shot + idempotent; never
   // throws. SM_SEED_DEV_PLUGIN_DISABLE=1 to opt out.
-  seedDevPlugin({ logger: console }).catch((e) => {
+  seedDevPlugin({ logger: console, writeLog: logs.writeLine }).catch((e) => {
     logs.writeLine({ scope: 'seed-dev-plugin', level: 'error', message: 'seed failed', meta: { error: e?.message } });
   });
+  // First-boot default: seed the bundled Architect + Dev Lead Agent personas
+  // into ~/.claude/agents/ so the Agent Library isn't empty on a fresh
+  // install. One-shot + idempotent; never overwrites an existing persona;
+  // never throws. SM_SEED_AGENT_PERSONAS_DISABLE=1 to opt out.
+  seedAgentPersonas({ logger: console, writeLog: logs.writeLine }).catch((e) => {
+    logs.writeLine({ scope: 'seed-agent-personas', level: 'error', message: 'seed failed', meta: { error: e?.message } });
+  });
+  // First-boot default: register the session-manager-scheduler MCP server at
+  // USER scope so scheduler_create_prd is available in every project, not
+  // just this repo's own .mcp.json. One-shot + idempotent; never overwrites
+  // an existing registration; never throws. SM_SEED_SCHEDULER_MCP_DISABLE=1
+  // to opt out.
+  seedSchedulerMcp({ logger: console, writeLog: logs.writeLine }).catch((e) => {
+    logs.writeLine({ scope: 'seed-scheduler-mcp', level: 'error', message: 'seed failed', meta: { error: e?.message } });
+  });
   // History rollup finalize pass: deferred 30s past boot so it never competes
   // with first-paint, fire-and-forget (cron/offline refresh is PRD 651 — this
   // is just the one-shot in-app pass).

package/src/main/ipcSchemas.cjs

@@ -537,6 +537,17 @@ const projectBriefCwd = z.object({
   cwd: z.string().min(1).max(4096),
 }).strict();
 
+// ──────────────────────────────────────────── Delegation readiness
+const delegationReadinessCwd = z.object({
+  cwd: z.string().min(1).max(4096),
+}).strict();
+
+// ──────────────────────────────────────────── Agent persona body (New Epic AIM)
+const agentsGetPersonaBody = z.object({
+  cwd: z.string().min(1).max(4096),
+  name: z.string().min(1).max(200),
+}).strict();
+
 // ──────────────────────────────────────────── Project Pages (PRD 932)
 // Same validation split as projectBriefCwd above: real path validation is
 // config.cjs's validatePath at first fs access in projectPages.cjs.
@@ -608,6 +619,17 @@ const promptSessionTranscriptRead = z.object({
   limit: z.number().int().positive().max(10_000).optional(),
 }).strict();
 
+// ──────────────────────────────────────────── Epic delegation stats
+// (derived-at-read-time "PRDs queued vs inline edits" counter surfaced on
+// the Epic card). claudeSessionId is optional — a proposed Epic that never
+// started chatting has none, and the computation just reports 0 inline
+// edits rather than throwing.
+const epicDelegationStatsGet = z.object({
+  cwd: z.string().min(1).max(4096),
+  epicId: z.string().regex(PROMPT_SESSION_EPIC_ID_RE),
+  claudeSessionId: z.string().max(128).optional().nullable(),
+}).strict();
+
 // ──────────────────────────────────────────── Audit log (renderer Epic
 // lifecycle trace, PRD 940). Kind allowlist is enforced HERE, main-side — the
 // renderer cannot write arbitrary kinds through this channel, only the six
@@ -949,6 +971,7 @@ module.exports = {
     projectBriefUpdate,
     promptSessionTranscriptAppend,
     promptSessionTranscriptRead,
+    epicDelegationStatsGet,
     promptSessionsMergeActiveIndex,
     promptSessionsCreateEpic,
     promptSessionsCreateWorktree,
@@ -974,6 +997,8 @@ module.exports = {
     chatExternalSend,
     exchangesList,
     agentsSavePersona,
+    agentsGetPersonaBody,
+    delegationReadinessCwd,
   },
   validated,
 };

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

@@ -0,0 +1,185 @@
+/**
+ * delegationReadiness.test.cjs — unit tests for the "can this project
+ * actually delegate?" probe. Uses a temp HOME and a temp cwd so the real
+ * ~/.claude and this repo's own config are never touched.
+ *
+ * Run: timeout 300 npx vitest run src/main/lib/__tests__/delegationReadiness.test.cjs
+ */
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { checkDelegationReadiness } = require('../delegationReadiness.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) {
+    const d = tmpDirs.pop();
+    await fsp.rm(d, { recursive: true, force: true });
+  }
+});
+
+async function mkTmp(prefix) {
+  const d = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(d);
+  return d;
+}
+
+async function writeJson(absPath, value) {
+  await fsp.mkdir(path.dirname(absPath), { recursive: true });
+  await fsp.writeFile(absPath, JSON.stringify(value), 'utf8');
+}
+
+async function makeGreenFixtures() {
+  const homeDir = await mkTmp('sm-delegation-home-');
+  const cwd = await mkTmp('sm-delegation-cwd-');
+
+  await writeJson(path.join(homeDir, '.claude.json'), {
+    mcpServers: { 'session-manager-scheduler': { type: 'stdio', command: 'node', args: [] } },
+  });
+  await writeJson(path.join(homeDir, '.claude', 'settings.json'), {
+    enabledPlugins: { 'session-manager-dev@session-manager': true },
+  });
+  await fsp.mkdir(path.join(homeDir, '.claude', 'agents'), { recursive: true });
+  await fsp.writeFile(path.join(homeDir, '.claude', 'agents', 'dev-lead.md'), '# dev-lead', 'utf8');
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: 'Write|Edit|NotebookEdit',
+          hooks: [{ type: 'command', command: 'node scripts/hooks/guard-prd-writes.cjs' }],
+        },
+      ],
+    },
+  });
+
+  return { homeDir, cwd };
+}
+
+test('all four checks pass on a fully-configured project', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  const result = checkDelegationReadiness({ cwd, homeDir });
+
+  expect(result.ok).toBe(true);
+  expect(result.checks).toHaveLength(4);
+  expect(result.checks.every((c) => c.ok)).toBe(true);
+  expect(result.checks.map((c) => c.id)).toEqual([
+    'scheduler-mcp',
+    'dev-plugin',
+    'agent-personas',
+    'prd-write-guard',
+  ]);
+});
+
+test('scheduler-mcp: passes via project-scope .mcp.json even without user scope', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), { mcpServers: {} });
+  await writeJson(path.join(cwd, '.mcp.json'), {
+    mcpServers: { 'session-manager-scheduler': { command: 'node', args: [] } },
+  });
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp');
+  expect(check.ok).toBe(true);
+  expect(result.ok).toBe(true);
+});
+
+test('scheduler-mcp: fails with a runnable fix when absent from both scopes', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude.json'), { mcpServers: {} });
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'scheduler-mcp');
+  expect(check.ok).toBe(false);
+  expect(result.ok).toBe(false);
+  expect(check.fix).toMatch(/^claude mcp add session-manager-scheduler --scope user/);
+  expect(check.fix).toContain('scheduler-mcp-server.cjs');
+});
+
+test('dev-plugin: fails independently when enabledPlugins is missing the key', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(homeDir, '.claude', 'settings.json'), { enabledPlugins: {} });
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'dev-plugin');
+  expect(check.ok).toBe(false);
+  expect(result.ok).toBe(false);
+  expect(check.fix).toBeTruthy();
+  // the other three checks still pass independently
+  expect(result.checks.filter((c) => c.id !== 'dev-plugin').every((c) => c.ok)).toBe(true);
+});
+
+test('agent-personas: fails independently when ~/.claude/agents has no personas', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await fsp.rm(path.join(homeDir, '.claude', 'agents', 'dev-lead.md'));
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'agent-personas');
+  expect(check.ok).toBe(false);
+  expect(result.ok).toBe(false);
+  expect(result.checks.filter((c) => c.id !== 'agent-personas').every((c) => c.ok)).toBe(true);
+});
+
+test('agent-personas: passes via project-scope .claude/agents/ even without global personas', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await fsp.rm(path.join(homeDir, '.claude', 'agents'), { recursive: true, force: true });
+  await fsp.mkdir(path.join(cwd, '.claude', 'agents'), { recursive: true });
+  await fsp.writeFile(path.join(cwd, '.claude', 'agents', 'builder.md'), '# builder', 'utf8');
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'agent-personas');
+  expect(check.ok).toBe(true);
+  expect(result.ok).toBe(true);
+});
+
+test('agent-personas: fails when the directory does not exist at all', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await fsp.rm(path.join(homeDir, '.claude', 'agents'), { recursive: true, force: true });
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'agent-personas');
+  expect(check.ok).toBe(false);
+});
+
+test('prd-write-guard: fails independently when the hook is missing', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await writeJson(path.join(cwd, '.claude', 'settings.json'), { hooks: { PreToolUse: [] } });
+
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  const check = result.checks.find((c) => c.id === 'prd-write-guard');
+  expect(check.ok).toBe(false);
+  expect(result.ok).toBe(false);
+  expect(result.checks.filter((c) => c.id !== 'prd-write-guard').every((c) => c.ok)).toBe(true);
+});
+
+test('unparseable JSON files yield ok:false with a detail, never a throw', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await fs.promises.writeFile(path.join(homeDir, '.claude.json'), '{ not valid json', 'utf8');
+  await fs.promises.writeFile(path.join(homeDir, '.claude', 'settings.json'), '{ not valid json', 'utf8');
+  await fs.promises.writeFile(path.join(cwd, '.claude', 'settings.json'), '{ not valid json', 'utf8');
+
+  expect(() => checkDelegationReadiness({ cwd, homeDir })).not.toThrow();
+  const result = checkDelegationReadiness({ cwd, homeDir });
+
+  const scheduler = result.checks.find((c) => c.id === 'scheduler-mcp');
+  const devPlugin = result.checks.find((c) => c.id === 'dev-plugin');
+  const guard = result.checks.find((c) => c.id === 'prd-write-guard');
+  expect(scheduler.ok).toBe(false);
+  expect(scheduler.detail).toBeTruthy();
+  expect(devPlugin.ok).toBe(false);
+  expect(devPlugin.detail).toBeTruthy();
+  expect(guard.ok).toBe(false);
+  expect(guard.detail).toBeTruthy();
+  expect(result.ok).toBe(false);
+});
+
+test('missing cwd/.claude/settings.json entirely is treated as guard-absent, not a throw', async () => {
+  const { homeDir, cwd } = await makeGreenFixtures();
+  await fsp.rm(path.join(cwd, '.claude', 'settings.json'));
+
+  expect(() => checkDelegationReadiness({ cwd, homeDir })).not.toThrow();
+  const result = checkDelegationReadiness({ cwd, homeDir });
+  expect(result.checks.find((c) => c.id === 'prd-write-guard').ok).toBe(false);
+});