claude-code-session-manager 0.86.0 → 0.88.0

package/scripts/scheduler-mcp-server.cjs

@@ -11,10 +11,7 @@
  *   feedback_list_projects()       -> GET  /admin/feedback/targets
  *   feedback_open_session({ ... }) -> POST /admin/feedback/open-session
  *
- *   project_home_get_contract({ cwd? })              -> GET  /admin/project-home/contract
- *   project_home_validate_summary({ cwd?, summary }) -> POST /admin/project-home/validate-summary
- *   project_home_render({ cwd?, summary, picks })    -> POST /admin/project-home/render
- *   project_home_status({ cwd? })                    -> GET  /admin/project-home/status
+ *   project_home_write({ cwd?, html }) -> POST /admin/project-home/write
  *
  * This is a separate process from the Electron app — it only ever reaches
  * it over the token-authed loopback HTTP API in admin-api.json, never by
@@ -24,7 +21,9 @@
 
 'use strict';
 
-const os = require('node:os');
+// Name this process first (pn-03): otherwise it shows as a bare `node`.
+const { PROC_NAMES, setProcessTitle } = require('../src/main/lib/smProcNames.cjs');
+setProcessTitle(PROC_NAMES.mcpServer);
 const path = require('node:path');
 const fsp = require('node:fs/promises');
 const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
@@ -44,7 +43,7 @@ function descriptionFor(toolName) {
   return composeDescription(entry);
 }
 
-const TOKEN_PATH = path.join(os.homedir(), '.claude', 'session-manager', 'admin-api.json');
+const { adminTokenPath } = require('../src/main/lib/schedulerPaths.cjs');
 
 // Defined once so every failure path points to the same next call, verbatim
 // — never paste this sentence at each return site (PRD: session_manager_help).
@@ -71,7 +70,7 @@ function resolveCwdArg(args) {
 }
 
 async function readAdminConfig() {
-  const raw = await fsp.readFile(TOKEN_PATH, 'utf8');
+  const raw = await fsp.readFile(adminTokenPath(), 'utf8');
   const parsed = JSON.parse(raw);
   if (!parsed || typeof parsed.port !== 'number' || typeof parsed.token !== 'string') {
     throw new Error(NOT_RUNNING_ERROR);
@@ -140,6 +139,16 @@ const TOOLS = [
       required: ['slug'],
     },
   },
+  {
+    name: 'scheduler_pause',
+    description: descriptionFor('scheduler_pause'),
+    inputSchema: { type: 'object', properties: {} },
+  },
+  {
+    name: 'scheduler_resume',
+    description: descriptionFor('scheduler_resume'),
+    inputSchema: { type: 'object', properties: {} },
+  },
   {
     name: 'scheduler_list_jobs',
     description: descriptionFor('scheduler_list_jobs'),
@@ -164,6 +173,11 @@ const TOOLS = [
         slug: { type: 'string', description: 'Optional kebab-case slug; derived from title if omitted' },
         parallelGroup: { type: 'number', description: 'DEPRECATED and ignored (PRD 832): numbers are strictly unique per project; use dependsOn for ordering' },
         dependsOn: { type: 'array', items: { type: 'string' }, description: 'Optional: PRD slugs that must complete before this one becomes eligible (replaces the retired shared-NN-parallel convention)' },
+        disposition: {
+          type: 'string',
+          enum: ['append', 'new-head'],
+          description: 'Required when this PRD would land as a new root (no dependsOn given) in an Epic that already has incomplete PRDs: "append" depends this wave on the existing chain\'s current terminal PRD(s); "new-head" leaves it independent, eligible to run in parallel. Omit when the Epic has no incomplete PRDs yet, or when dependsOn already places this PRD explicitly.',
+        },
         sourcePromptId: { type: 'string', description: "Effectively required: an EXISTING, already-human-approved Epic's promptSessionId (the id shown in the Epics list / active-index.json sessions key) to join — NOT a PromptTicket.id (those are distinct fields). The server never mints a new Epic; if this is omitted and no Epic can be resolved (via the SM_CHAT_SESSION_ID fallback below), the write is refused with an error telling the caller to create/approve an Epic first." },
         sourceTabId: { type: 'string', description: 'Optional: tab id (claudeSessionId) this PRD was queued from, so the scheduler can route a completion status prompt back to it' },
         tag: {
@@ -231,6 +245,8 @@ const TOOLS = [
             tag: { type: 'string', enum: PRD_WORK_TYPES },
             agentType: { type: 'string', description: 'WHO executes this PRD (persona name) — patchable after creation too, see scheduler_create_prd' },
             quietMachine: { type: 'boolean', description: 'Optional: the exclusive machine-wide quiet lease flag (see scheduler_create_prd) — patchable after creation too' },
+            dependsOn: { type: 'array', items: { type: 'string' }, description: 'Optional: replaces the dependsOn list; an explicit empty array CLEARS it — see scheduler_create_prd' },
+            disposition: { type: 'string', enum: ['append', 'new-head'], description: 'Optional: patches the recorded wave-authoring decision — see scheduler_create_prd' },
           },
         },
         body: { type: 'string', description: 'Optional: full replacement body (everything after the frontmatter)' },
@@ -340,48 +356,15 @@ const TOOLS = [
     },
   },
   {
-    name: 'project_home_get_contract',
-    description: descriptionFor('project_home_get_contract'),
+    name: 'project_home_write',
+    description: descriptionFor('project_home_write'),
     inputSchema: {
       type: 'object',
       properties: {
         cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root (SM_PROJECT_ROOT or process.cwd()) when omitted." },
+        html: { type: 'string', description: 'The complete self-contained HTML document (<= 1MB; no <script src>, <link href=http*>, @import, or url(http*)).' },
       },
-    },
-  },
-  {
-    name: 'project_home_validate_summary',
-    description: descriptionFor('project_home_validate_summary'),
-    inputSchema: {
-      type: 'object',
-      properties: {
-        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
-        summary: { type: 'object', description: 'ProjectPageSummary object matching the summarySchema from project_home_get_contract' },
-      },
-      required: ['summary'],
-    },
-  },
-  {
-    name: 'project_home_render',
-    description: descriptionFor('project_home_render'),
-    inputSchema: {
-      type: 'object',
-      properties: {
-        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
-        summary: { type: 'object', description: 'ProjectPageSummary object matching the summarySchema from project_home_get_contract' },
-        picks: { type: 'object', description: 'ProjectPagePicks object (lensId -> slotId -> variantId) matching the picksSchema from project_home_get_contract' },
-      },
-      required: ['summary', 'picks'],
-    },
-  },
-  {
-    name: 'project_home_status',
-    description: descriptionFor('project_home_status'),
-    inputSchema: {
-      type: 'object',
-      properties: {
-        cwd: { type: 'string', description: "Optional: absolute path to the target project. Defaults to the calling session's own project root when omitted." },
-      },
+      required: ['html'],
     },
   },
   {
@@ -421,6 +404,10 @@ async function handleCallTool(request) {
       const result = await adminRequest('POST', '/admin/scheduler/reset-job', { slug, force, cwd });
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
+    if (name === 'scheduler_pause' || name === 'scheduler_resume') {
+      const result = await adminRequest('POST', `/admin/scheduler/${name === 'scheduler_pause' ? 'pause' : 'resume'}`, {});
+      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+    }
     if (name === 'scheduler_list_jobs') {
       const result = await adminRequest('GET', '/admin/scheduler/jobs');
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
@@ -568,35 +555,12 @@ async function handleCallTool(request) {
       const result = await adminRequest('POST', '/admin/chat/send-prompt', { tabId, prompt });
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
-    if (name === 'project_home_get_contract') {
-      const cwd = resolveCwdArg(args);
-      const qs = new URLSearchParams({ cwd });
-      const result = await adminRequest('GET', `/admin/project-home/contract?${qs.toString()}`);
-      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    }
-    if (name === 'project_home_validate_summary') {
-      if (!args || typeof args.summary !== 'object' || args.summary === null) {
-        return errorResult('missing required argument: summary');
-      }
-      const cwd = resolveCwdArg(args);
-      const result = await adminRequest('POST', '/admin/project-home/validate-summary', { cwd, summary: args.summary });
-      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    }
-    if (name === 'project_home_render') {
-      if (!args || typeof args.summary !== 'object' || args.summary === null) {
-        return errorResult('missing required argument: summary');
-      }
-      if (typeof args.picks !== 'object' || args.picks === null) {
-        return errorResult('missing required argument: picks');
+    if (name === 'project_home_write') {
+      if (!args || typeof args.html !== 'string' || args.html.length === 0) {
+        return errorResult('missing required argument: html');
       }
       const cwd = resolveCwdArg(args);
-      const result = await adminRequest('POST', '/admin/project-home/render', { cwd, summary: args.summary, picks: args.picks });
-      return { content: [{ type: 'text', text: JSON.stringify(result) }] };
-    }
-    if (name === 'project_home_status') {
-      const cwd = resolveCwdArg(args);
-      const qs = new URLSearchParams({ cwd });
-      const result = await adminRequest('GET', `/admin/project-home/status?${qs.toString()}`);
+      const result = await adminRequest('POST', '/admin/project-home/write', { cwd, html: args.html });
       return { content: [{ type: 'text', text: JSON.stringify(result) }] };
     }
     if (name === 'session_manager_help') {

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

@@ -17,7 +17,7 @@ const {
   FALLBACK_MODEL,
   resolveEpicModel,
   findAgentTypeByClaudeSessionId,
-  readPersonaModel,
+  readOverlayAwarePersonaModel,
   resolvePrdPersonaForSpawn,
 } = require('../lib/agentModelResolve.cjs');
 
@@ -103,37 +103,39 @@ test('findAgentTypeByClaudeSessionId returns null for no match', async () => {
   expect(findAgentTypeByClaudeSessionId(cwd, 'missing')).toBeNull();
 });
 
-test('readPersonaModel returns null for a persona with no model field', async () => {
+test('readOverlayAwarePersonaModel returns null for a persona with no model field', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
   const globalDir = await mkTmpDir('sm-agentmodel-agents-');
   writePersona(globalDir, 'no-model-persona', []);
-  expect(readPersonaModel('no-model-persona', { globalDir, validatePath: noopValidatePath })).toBeNull();
+  expect(readOverlayAwarePersonaModel('no-model-persona', { cwd, globalDir, validatePath: noopValidatePath })).toBeNull();
 });
 
-test('readPersonaModel returns null (never throws) for a path-traversal agentType rejected by validatePath', async () => {
+test('readOverlayAwarePersonaModel returns null (never throws) for a path-traversal agentType rejected by validatePath', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
   const globalDir = await mkTmpDir('sm-agentmodel-agents-');
   const realValidatePath = (p) => {
     const real = path.resolve(p);
     if (!real.startsWith(path.resolve(globalDir) + path.sep)) throw new Error('outside allowed boundaries');
     return real;
   };
-  expect(readPersonaModel('../../../etc/passwd', { globalDir, validatePath: realValidatePath })).toBeNull();
+  expect(readOverlayAwarePersonaModel('../../../etc/passwd', { cwd, globalDir, validatePath: realValidatePath })).toBeNull();
 });
 
 // READ side of the agentType FK: a persona that was valid when the Epic was
 // created but got deleted afterward (rename/deletion in Agent Library) must
 // still resolve to null, not throw — the WRITE side (epicMint.cjs's
 // ensureEpic) is what refuses a bad reference at creation time.
-test('readPersonaModel returns null (does not throw) for a persona deleted after the Epic was created, and logs it once via opsErrorLog', async () => {
+test('readOverlayAwarePersonaModel returns null (does not throw) for a persona deleted after the Epic was created, and logs it once via opsErrorLog', async () => {
   const cwd = await mkTmpDir('sm-agentmodel-cwd-');
   const globalDir = await mkTmpDir('sm-agentmodel-agents-'); // never written to — simulates a deleted persona
 
-  expect(() => readPersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).not.toThrow();
-  expect(readPersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).toBeNull();
+  expect(() => readOverlayAwarePersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).not.toThrow();
+  expect(readOverlayAwarePersonaModel('deleted-persona', { globalDir, validatePath: noopValidatePath, cwd })).toBeNull();
 
   const { todayFile } = require('../lib/opsErrorLog.cjs');
   const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
   const matches = lines.filter((l) => l.message.includes('deleted-persona'));
-  // Logged once despite two readPersonaModel calls above — dedup key is (cwd, agentType).
+  // Logged once despite two readOverlayAwarePersonaModel calls above — dedup key is (cwd, agentType).
   expect(matches).toHaveLength(1);
   expect(matches[0].level).toBe('warn');
 });
@@ -190,6 +192,95 @@ test('resolvePrdPersonaForSpawn returns the fallback (no persona applied) when a
   expect(result).toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
 });
 
+// Overlay-aware resolution (unify-epic-model-resolution): resolveEpicModel
+// must use the SAME project-overlay-then-global precedence
+// resolvePrdPersonaForSpawn already uses — so a project's
+// `.claude/agents/<name>.md` wins for a launched Chat/Terminal session
+// exactly like it already does for a scheduled PRD.
+
+test('resolveEpicModel prefers a project-overlay persona over the global one with the same name', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
+  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-overlay', agentType: 'shared-persona' } });
+  writePersona(globalDir, 'shared-persona', ['model: opus']);
+  const projectAgentsDir = path.join(cwd, '.claude', 'agents');
+  writePersona(projectAgentsDir, 'shared-persona', ['model: haiku']);
+
+  const model = resolveEpicModel({
+    cwd,
+    claudeSessionId: 'sess-overlay',
+    deps: { globalDir, validatePath: noopValidatePath },
+  });
+
+  expect(model).toBe('haiku');
+});
+
+test('resolveEpicModel falls through to the global persona when no project overlay exists', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
+  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-global-only', agentType: 'global-only-persona' } });
+  writePersona(globalDir, 'global-only-persona', ['model: opus']);
+
+  const model = resolveEpicModel({
+    cwd,
+    claudeSessionId: 'sess-global-only',
+    deps: { globalDir, validatePath: noopValidatePath },
+  });
+
+  expect(model).toBe('opus');
+});
+
+test('resolveEpicModel falls back to FALLBACK_MODEL (never throws) for a dangling agentType with no persona file anywhere, and logs it once', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-'); // never written to
+  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-dangling', agentType: 'ghost-persona' } });
+
+  const call = () => resolveEpicModel({
+    cwd,
+    claudeSessionId: 'sess-dangling',
+    deps: { globalDir, validatePath: noopValidatePath },
+  });
+
+  expect(call).not.toThrow();
+  expect(call()).toBe(FALLBACK_MODEL);
+  call(); // second call must not log a second line (dedup per (cwd, agentType))
+
+  const { todayFile } = require('../lib/opsErrorLog.cjs');
+  const lines = fs.readFileSync(todayFile(cwd), 'utf8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+  const matches = lines.filter((l) => l.message.includes('ghost-persona'));
+  expect(matches).toHaveLength(1);
+});
+
+// Chat (chatRunner.cjs, in-process) and Terminal (EpicTerminalPane.tsx, via
+// the agents:resolve-epic-model IPC added in this change) both call this
+// exact function with the same { cwd, claudeSessionId } shape — so "the same
+// Epic resolves identically in both views" is structural (one function, one
+// call signature), not a coincidence of two implementations agreeing. This
+// asserts the function is a pure, deterministic read of that Epic's overlay-
+// resolved persona model, which is what makes that guarantee hold.
+test('resolveEpicModel resolves identically for the same Epic across repeated calls (the guarantee Chat and Terminal both rely on)', async () => {
+  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
+  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-shared', agentType: 'shared-epic-persona' } });
+  writePersona(globalDir, 'shared-epic-persona', ['model: haiku']);
+
+  const callArgs = { cwd, claudeSessionId: 'sess-shared', deps: { globalDir, validatePath: noopValidatePath } };
+  const chatResult = resolveEpicModel(callArgs);
+  const terminalResult = resolveEpicModel(callArgs); // simulates the IPC-forwarded call Terminal makes
+
+  expect(chatResult).toBe('haiku');
+  expect(terminalResult).toBe(chatResult);
+});
+
+// --model must never be left unpinned (CLAUDE.md model-pinning rule) on any
+// of the three launch paths. resolvePrdPersonaForSpawn's own miss-path tests
+// above already cover the scheduler call site; this covers the shared
+// Chat/Terminal resolver.
+test('resolveEpicModel never returns an empty/falsy --model value, even on every miss path', async () => {
+  expect(resolveEpicModel({})).toBeTruthy();
+  expect(resolveEpicModel({ cwd: '/nonexistent-cwd-xyz', claudeSessionId: 'no-such-session' })).toBeTruthy();
+});
+
 test('resolvePrdPersonaForSpawn caps the persona body at 6000 characters with a truncation notice naming the persona path', async () => {
   const longBody = 'x'.repeat(6500);
   const result = await resolvePrdPersonaForSpawn({

package/src/main/__tests__/bilkoHost-integration.test.cjs

@@ -14,8 +14,8 @@ function makeProject() {
   config.addAllowedRoot(root);
   fs.mkdirSync(path.join(root, 'session-manager-operations', 'project-pages', 'output'), { recursive: true });
   fs.writeFileSync(
-    path.join(root, 'session-manager-operations', 'project-pages', 'output', 'marketing.html'),
-    '<html><title>Demo</title>Marketing</html>',
+    path.join(root, 'session-manager-operations', 'project-pages', 'home.html'),
+    '<html><title>Demo</title>Home</html>',
   );
   fs.writeFileSync(
     path.join(root, 'session-manager-operations', 'project-pages', 'output', 'feature.html'),
@@ -29,7 +29,7 @@ test('prepareBundle seeds a root document and writes dist/index.html + manifest.
   const root = makeProject();
   const result = await bilkoHost.prepareBundle({ cwd: root, slug: 'demo-app' });
   assert.equal(fs.existsSync(path.join(result.distPath, 'index.html')), true);
-  assert.equal(fs.readFileSync(path.join(result.distPath, 'index.html'), 'utf8'), '<html><title>Demo</title>Marketing</html>');
+  assert.equal(fs.readFileSync(path.join(result.distPath, 'index.html'), 'utf8'), '<html><title>Demo</title>Home</html>');
   assert.equal(result.manifest.slug, 'demo-app');
   assert.equal(result.manifest.bundle.fileCount, 1);
   fs.rmSync(root, { recursive: true, force: true });

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

@@ -101,4 +101,22 @@ test('flush() with no pending timer still sends (no-arm case)', async () => {
   expect(sent).toEqual(['state-1']);
 });
 
+test('a getPayload() that throws does not wedge the coalescer — the next schedule() still sends', async () => {
+  const sent = [];
+  const send = vi.fn((payload) => sent.push(payload));
+  const getPayload = vi.fn()
+    .mockRejectedValueOnce(new Error('boom'))
+    .mockResolvedValue('state-recovered');
+  const coalescer = createBroadcastCoalescer({ delayMs: 200, send, getPayload });
+
+  coalescer.schedule();
+  await vi.advanceTimersByTimeAsync(200);
+  expect(sent).toEqual([]);
+
+  coalescer.schedule();
+  await vi.advanceTimersByTimeAsync(200);
+  expect(sent).toEqual(['state-recovered']);
+  expect(getPayload).toHaveBeenCalledTimes(2);
+});
+
 console.log('broadcastCoalescer tests: PASS');

package/src/main/__tests__/chat-cancel-terminal.test.cjs

@@ -13,14 +13,14 @@
  * path (via SM_CLAUDE_BIN pointing at a stub process) and asserts a terminal
  * event is broadcast on cancel.
  *
- * Run: timeout 120 node --test src/main/__tests__/chat-cancel-terminal.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/chat-cancel-terminal.test.cjs
  */
 
 'use strict';
 
 delete process.env.SM_CHAT_CONCURRENCY;
 
-const { test } = require('node:test');
+import { test, afterAll } from 'vitest';
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
@@ -30,12 +30,9 @@ const path = require('node:path');
 // mimics a long-running headless run so cancel() has something to SIGTERM.
 // Shebang + chmod makes it directly spawnable as a single executable (spawn
 // does not split a path on spaces, so SM_CLAUDE_BIN must be one binary).
-const stubPath = path.join(os.tmpdir(), `sm-claude-stub-${process.pid}.cjs`);
-fs.writeFileSync(
-  stubPath,
-  `#!${process.execPath}\nsetInterval(() => {}, 1000);\n`,
-  { mode: 0o755 },
-);
+const stubPath = require('../../../tests/helpers/claudeStub.cjs').writeClaudeStub({
+  body: 'setInterval(() => {}, 1000);',
+});
 process.env.SM_CLAUDE_BIN = stubPath;
 
 const cr = require('../chatRunner.cjs');
@@ -114,7 +111,7 @@ function isTerminal(channel) {
   );
 }
 
-test.after(() => {
+afterAll(() => {
   try { fs.unlinkSync(stubPath); } catch { /* already gone */ }
   delete process.env.SM_CLAUDE_BIN;
 });

package/src/main/__tests__/chat-exit-close-race.test.cjs

@@ -21,14 +21,14 @@
  * arrives, THEN close fires) rather than relying on real OS/pipe timing,
  * which is not reliably reproducible from a real child process.
  *
- * Run: timeout 120 node --test src/main/__tests__/chat-exit-close-race.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/chat-exit-close-race.test.cjs
  */
 
 'use strict';
 
 delete process.env.SM_CHAT_CONCURRENCY;
 
-const { test } = require('node:test');
+import { test, afterAll } from 'vitest';
 const assert = require('node:assert/strict');
 const EventEmitter = require('node:events');
 const cp = require('node:child_process');
@@ -134,7 +134,7 @@ function isTerminal(channel) {
   );
 }
 
-test.after(() => {
+afterAll(() => {
   cp.spawn = originalSpawn;
   delete process.env.SM_CHAT_CONCURRENCY;
 });

package/src/main/__tests__/chat-mcp-consent-notice.test.cjs

@@ -6,24 +6,23 @@
  * asserts a `chat:run:notice` event is broadcast — informational, not a
  * terminal event.
  *
- * Run: timeout 120 node --test src/main/__tests__/chat-mcp-consent-notice.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/chat-mcp-consent-notice.test.cjs
  */
 
 'use strict';
 
 delete process.env.SM_CHAT_CONCURRENCY;
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
 
 function writeStub(lines) {
-  const stubPath = path.join(os.tmpdir(), `sm-claude-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
   const body = lines.map((l) => `process.stdout.write(${JSON.stringify(JSON.stringify(l))} + "\\n");`).join('\n');
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\nprocess.exit(0);\n`, { mode: 0o755 });
-  return stubPath;
+  return claudeStub.writeClaudeStub({ body: `${body}\nprocess.exit(0);` });
 }
 
 function isTerminal(channel) {

package/src/main/__tests__/chat-queue.test.cjs

@@ -6,7 +6,7 @@
  * this cap/FIFO governs silent runs only — manual runs bypass it entirely
  * (see chatRunner.spec.ts's "manual runs are uncapped" tests).
  *
- * Run: timeout 120 node --test src/main/__tests__/chat-queue.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/chat-queue.test.cjs
  */
 
 'use strict';
@@ -14,7 +14,7 @@
 // Force the default cap (2) regardless of the developer's shell env.
 delete process.env.SM_CHAT_CONCURRENCY;
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const cr = require('../chatRunner.cjs');
 

package/src/main/__tests__/chat-stop-signal.test.cjs

@@ -2,12 +2,12 @@
  * chat-stop-signal.test.cjs — unit tests for chatRunner.parseStopSignal, the
  * single source of truth for the terminal-chat stop-signal protocol (PRD 318).
  *
- * Run: timeout 120 node --test src/main/__tests__/chat-stop-signal.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/chat-stop-signal.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const { parseStopSignal, STOP_SENTINEL } = require('../chatRunner.cjs');
 

package/src/main/__tests__/dep-orphan-archive-health.test.cjs

@@ -0,0 +1,77 @@
+/**
+ * PRD 1286 — archiving a row must never orphan its dependents, and a fully
+ * blocked queue must never read healthy.
+ *
+ * Option (b): the depends-gate (computeDepHistorySatisfaction) treats a dep
+ * whose PRD file was archived — including the manual-archive layout
+ * prds-archived/<ISO-ts>/<slug>.md — as satisfied. A dep with no row, no
+ * history and no archived file still HOLDS.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/dep-orphan-archive-health.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1286-home-'));
+process.env.HOME = tmpHome;
+
+const scheduler = require('../scheduler.cjs');
+const { pickNextBatch } = require('../lib/schedulerBatch.cjs');
+const { evaluateUnresolvableDepHealth } = require('../health.cjs');
+
+function projectWithDependent(dep) {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1286-proj-'));
+  const jobs = [{ slug: '902-next', status: 'pending', cwd, dependsOn: [dep] }];
+  return { cwd, jobs };
+}
+
+async function eligible(jobs) {
+  const satisfiedSlugsByCwd = await scheduler.computeDepHistorySatisfaction({ jobs });
+  const { batch: picked } = pickNextBatch(jobs, new Set(), 3, { satisfiedSlugsByCwd });
+  return { batch: picked.map((j) => j.slug ?? j.job?.slug ?? j), satisfiedSlugsByCwd };
+}
+
+test('a dep archived via the manual-archive layout (prds-archived/<ts>/) leaves its dependent eligible', async () => {
+  const { cwd, jobs } = projectWithDependent('fo-01-base'); // bare slug, as authored
+  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'e1', 'prds-archived', '2026-09-18T01-00-00-000Z');
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, '900-fo-01-base.md'), '# Goal\n');
+  const { batch } = await eligible(jobs);
+  expect(batch).toContain('902-next');
+});
+
+test('a dep that never ran (no row, history or archived file) keeps its dependent held', async () => {
+  const { jobs } = projectWithDependent('fo-01-base');
+  const { batch } = await eligible(jobs);
+  expect(batch).not.toContain('902-next');
+});
+
+test('health: every pending row held behind one unresolvable root is non-GREEN and names the root', async () => {
+  const { cwd } = projectWithDependent('fo-01-base');
+  const jobs = [
+    { slug: '902-a', status: 'pending', cwd, dependsOn: ['fo-01-base'] },
+    { slug: '903-b', status: 'pending', cwd, dependsOn: ['a'] }, // transitive, bare
+  ];
+  const satisfied = await scheduler.computeDepHistorySatisfaction({ jobs });
+  const res = evaluateUnresolvableDepHealth(jobs, satisfied);
+  expect(res.ok).toBe(false);
+  expect(res.projects[0].roots).toEqual(['fo-01-base']);
+  expect(res.message).toContain('fo-01-base');
+});
+
+test('health: a project with any dispatchable pending row, or a satisfied root, stays GREEN', async () => {
+  const { cwd } = projectWithDependent('x');
+  const mixed = [
+    { slug: '902-a', status: 'pending', cwd, dependsOn: ['fo-01-base'] },
+    { slug: '903-free', status: 'pending', cwd, dependsOn: [] },
+  ];
+  const satisfied = await scheduler.computeDepHistorySatisfaction({ jobs: mixed });
+  expect(evaluateUnresolvableDepHealth(mixed, satisfied).ok).toBe(true);
+  const satisfiedRoot = new Map([[cwd, new Set(['900-fo-01-base'])]]);
+  expect(evaluateUnresolvableDepHealth([mixed[0]], satisfiedRoot).ok).toBe(true);
+});

package/src/main/__tests__/dod-batchkey.test.cjs

@@ -1,12 +1,12 @@
 /**
  * dod-batchkey.test.cjs — unit tests for definitionOfDone.cjs helpers.
  *
- * Run: timeout 120 node --test src/main/__tests__/dod-batchkey.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/dod-batchkey.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const os = require('node:os');
 const fs = require('node:fs');

package/src/main/__tests__/dod-drain-hook.test.cjs

@@ -1,7 +1,7 @@
 /**
  * dod-drain-hook.test.cjs — drives the DoD drain handler.
  *
- * Run: timeout 120 node --test src/main/__tests__/dod-drain-hook.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/dod-drain-hook.test.cjs
  *
  * Scenarios:
  *   1. Drain with completed jobs → writes report once.
@@ -13,7 +13,7 @@
 
 'use strict';
 
-const { test, beforeEach, afterEach } = require('node:test');
+import { test, beforeEach, afterEach } from 'vitest';
 const assert = require('node:assert/strict');
 const os = require('node:os');
 const fs = require('node:fs');

package/src/main/__tests__/dod-report.test.cjs

@@ -1,14 +1,14 @@
 /**
  * dod-report.test.cjs — unit tests for flagRiskySurfaces + writeReport.
  *
- * Run: timeout 120 node --test src/main/__tests__/dod-report.test.cjs
+ * Run: timeout 300 npx vitest run src/main/__tests__/dod-report.test.cjs
  *
  * Fixtures: os.tmpdir() only — never writes into real runs/.
  */
 
 'use strict';
 
-const { test } = require('node:test');
+import { test } from 'vitest';
 const assert = require('node:assert/strict');
 const os = require('node:os');
 const fs = require('node:fs');