claude-code-session-manager 0.92.1 → 0.94.0

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

@@ -0,0 +1,95 @@
+/**
+ * agentOverlayWrite.test.cjs — Agent Library's per-project OVERRIDE write path
+ * (savePersona with `projectName`): frontmatter-only overlay, removal on clear,
+ * full-body refusal, and end-to-end resolution for a scheduled PRD.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/agentOverlayWrite.test.cjs
+ */
+
+'use strict';
+
+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 { savePersona, listPersonas, getPersonaBody } = require('../agentLibrary.cjs');
+const { resolvePrdPersonaForSpawn } = require('../lib/agentModelResolve.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
+});
+
+function setup() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-ov-cwd-'));
+  const globalDir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-ov-global-'));
+  tmpDirs.push(cwd, globalDir);
+  const globalFile = path.join(globalDir, 'dev-lead.md');
+  fs.writeFileSync(globalFile, '---\nname: dev-lead\ndescription: d\nmodel: sonnet\n---\nGlobal body.\n');
+  const overlayFile = path.join(cwd, '.claude', 'agents', 'dev-lead.md');
+  const deps = { globalDir, loadSessions: async () => ({ tabs: [{ cwd }] }), validatePath: (p) => p,
+    writeTextAtomic: async (p, t) => { await fsp.mkdir(path.dirname(p), { recursive: true }); await fsp.writeFile(p, t); } };
+  const projectName = path.basename(cwd);
+  const save = (over) => savePersona({ name: 'dev-lead', projectName, description: '', tools: [], color: '', tags: [], body: '', ...over, ...deps });
+  return { cwd, globalFile, overlayFile, deps, save, projectName };
+}
+
+test('setting a model writes a frontmatter-only overlay with only that key; global untouched', async () => {
+  const { overlayFile, globalFile, save } = setup();
+  const before = fs.readFileSync(globalFile, 'utf8');
+  await save({ model: 'claude-opus-4-6', effort: 'inherit' });
+  expect(fs.readFileSync(overlayFile, 'utf8')).toBe('---\nmodel: claude-opus-4-6\n---\n');
+  expect(fs.readFileSync(globalFile, 'utf8')).toBe(before);
+});
+
+test('adding effort adds only that key', async () => {
+  const { overlayFile, save } = setup();
+  await save({ model: 'claude-opus-4-6' });
+  await save({ model: 'claude-opus-4-6', effort: 'high' });
+  expect(fs.readFileSync(overlayFile, 'utf8')).toBe('---\nmodel: claude-opus-4-6\neffort: high\n---\n');
+});
+
+test('clearing both removes the overlay file', async () => {
+  const { overlayFile, save } = setup();
+  await save({ model: 'claude-opus-4-6', effort: 'high' });
+  const r = await save({ model: 'inherit', effort: 'inherit' });
+  expect(r.removed).toBe(true);
+  expect(fs.existsSync(overlayFile)).toBe(false);
+});
+
+test('a full-body overlay is refused, not rewritten', async () => {
+  const { overlayFile, save } = setup();
+  fs.mkdirSync(path.dirname(overlayFile), { recursive: true });
+  const full = '---\nname: dev-lead\nmodel: haiku\n---\nProject body.\n';
+  fs.writeFileSync(overlayFile, full);
+  await expect(save({ model: 'opus' })).rejects.toThrow(/full-body/);
+  expect(fs.readFileSync(overlayFile, 'utf8')).toBe(full);
+});
+
+test('unknown project is rejected', async () => {
+  const { save } = setup();
+  await expect(save({ projectName: 'nope', model: 'opus' })).rejects.toThrow(/project not open/);
+});
+
+test('listPersonas counts a frontmatter-only overlay and reports global → project values', async () => {
+  const { save, deps, projectName } = setup();
+  await save({ model: 'claude-opus-4-6' });
+  const [p] = await listPersonas(deps);
+  expect(p.model).toBe('sonnet');
+  expect(p.overridingProjects).toEqual([projectName]);
+  expect(p.overrideDetails[0]).toMatchObject({ fields: ['model'], values: { model: 'claude-opus-4-6' }, bodyOverridden: false });
+});
+
+test('scheduled-PRD model resolution returns the overlay model; global persona stays sonnet', async () => {
+  const { cwd, save, deps } = setup();
+  await save({ model: 'claude-opus-4-6' });
+  const r = await resolvePrdPersonaForSpawn({
+    cwd, agentType: 'dev-lead', fallbackModel: 'fallback',
+    deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) },
+  });
+  expect(r.model).toBe('claude-opus-4-6');
+  expect(r.systemPrompt).toContain('Global body.');
+  const [g] = await listPersonas(deps);
+  expect(g.model).toBe('sonnet');
+});

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

@@ -37,6 +37,9 @@ process.env.SM_CLAUDE_BIN = stubPath;
 
 const cr = require('../chatRunner.cjs');
 
+// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
+const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
+
 const tick = () => new Promise((r) => setImmediate(r));
 
 test('cancelling an ACTIVE run broadcasts a terminal event (unsticks the UI)', async () => {
@@ -50,7 +53,7 @@ test('cancelling an ACTIVE run broadcasts a terminal event (unsticks the UI)', a
     },
   });
 
-  cr.run({ tabId: 'T', sessionId: 'S', prompt: 'hello', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T', sessionId: 'S', prompt: 'hello', cwd: scratchCwd, resume: false });
 
   // Let the spawn happen and started event fire.
   for (let i = 0; i < 6; i++) await tick();
@@ -86,7 +89,7 @@ test('cancel() resolves only AFTER the terminal broadcast fires, not immediately
     },
   });
 
-  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'hello', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'hello', cwd: scratchCwd, resume: false });
 
   for (let i = 0; i < 6; i++) await tick();
 

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

@@ -32,6 +32,9 @@ import { test, afterAll } from 'vitest';
 const assert = require('node:assert/strict');
 const EventEmitter = require('node:events');
 const cp = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
 
 // Replace spawn BEFORE chatRunner.cjs is first required, so the module's
 // top-level `const { spawn } = require('node:child_process')` destructuring
@@ -50,6 +53,9 @@ cp.spawn = () => {
 
 const cr = require('../chatRunner.cjs');
 
+// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
+const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
+
 const tick = () => new Promise((r) => setImmediate(r));
 
 test('a final-text-only turn whose stdout chunk lands after exit still surfaces chat:run:complete', async () => {
@@ -63,7 +69,7 @@ test('a final-text-only turn whose stdout chunk lands after exit still surfaces
     },
   });
 
-  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T2', sessionId: 'S2', prompt: 'show me a sample post', cwd: scratchCwd, resume: false });
 
   for (let i = 0; i < 20 && !nextChild; i++) await tick();
   const child = nextChild;
@@ -108,7 +114,7 @@ test('a crashed process with no result event ever emitted still fires the fallba
     },
   });
 
-  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T3', sessionId: 'S3', prompt: 'anything', cwd: scratchCwd, resume: false });
 
   for (let i = 0; i < 20 && !nextChild; i++) await tick();
   const child = nextChild;

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

@@ -18,6 +18,9 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
+
+// Scratch project dir under os.tmpdir() — never the real repo root (opsErrorLog would pollute it).
+const scratchCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-cwd-'));
 const claudeStub = require('../../../tests/helpers/claudeStub.cjs');
 
 function writeStub(lines) {
@@ -70,7 +73,7 @@ test('MCP consent denial in a tool_result surfaces a chat:run:notice event', asy
     },
   });
 
-  cr.run({ tabId: 'T-notice', sessionId: 'S-notice', prompt: 'do a design thing', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T-notice', sessionId: 'S-notice', prompt: 'do a design thing', cwd: scratchCwd, resume: false });
 
   for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
     await new Promise((r) => setTimeout(r, 25));
@@ -120,7 +123,7 @@ test('a normal tool_result with no consent marker does not fire chat:run:notice'
     },
   });
 
-  cr.run({ tabId: 'T-clean', sessionId: 'S-clean', prompt: 'do a normal thing', cwd: process.cwd(), resume: false });
+  cr.run({ tabId: 'T-clean', sessionId: 'S-clean', prompt: 'do a normal thing', cwd: scratchCwd, resume: false });
 
   for (let i = 0; i < 60 && !events.some((e) => isTerminal(e.channel)); i++) {
     await new Promise((r) => setTimeout(r, 25));

package/src/main/__tests__/chatRunner-session-flag-retry.test.cjs

@@ -206,3 +206,47 @@ test('non-zero exit with unrelated stderr keeps the generic fallback message', a
     fs.rmSync(cwd, { recursive: true, force: true });
   }
 });
+
+// ---------- persona effort → --effort (agentEffortResolve.cjs) ----------
+
+async function chatArgvForPersona(effortLine) {
+  attachRecorder();
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-chat-effort-cwd-'));
+  const logFile = path.join(cwd, 'argv.log');
+  const sessionId = `effort-sess-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
+  fs.mkdirSync(path.join(tmpHome, '.claude', 'agents'), { recursive: true });
+  fs.writeFileSync(
+    path.join(tmpHome, '.claude', 'agents', 'effort-persona.md'),
+    ['---', 'name: effort-persona', 'model: opus', ...(effortLine ? [effortLine] : []), '---', 'body'].join('\n'),
+  );
+  const opsDir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(opsDir, { recursive: true });
+  fs.writeFileSync(path.join(opsDir, 'active-index.json'), JSON.stringify({
+    sessions: { e1: { id: 'e1', claudeSessionId: sessionId, agentType: 'effort-persona' } }, events: {},
+  }));
+  // First call succeeds outright: firstStderr unused because alwaysFail/n===1 → use a passing stub.
+  const stubPath = path.join(os.tmpdir(), `sm-effort-stub-${process.pid}-${Math.floor(Math.random() * 1e9)}.cjs`);
+  fs.writeFileSync(stubPath, `#!${process.execPath}\nrequire('fs').appendFileSync(${JSON.stringify(logFile)}, JSON.stringify(process.argv.slice(2)) + '\\n');\nprocess.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');\n`, { mode: 0o755 });
+  process.env.SM_CLAUDE_BIN = stubPath;
+  try {
+    curTab = 'tab-effort';
+    cr.run({ tabId: 'tab-effort', sessionId, prompt: 'hello', cwd, resume: false });
+    await waitFor(() => terminals().length >= 1 && fs.existsSync(logFile));
+    return spawns(logFile)[0];
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+    fs.rmSync(stubPath, { force: true });
+  }
+}
+
+test('chat spawn: persona effort adds --effort <level> beside --model and --session-id', async () => {
+  const argv = await chatArgvForPersona('effort: xhigh');
+  expect(argv[argv.indexOf('--effort') + 1]).toBe('xhigh');
+  expect(argv[argv.indexOf('--model') + 1]).toBe('opus');
+  expect(argv).toContain('--session-id');
+});
+
+test('chat spawn: effort inherit / absent adds no --effort token', async () => {
+  expect(await chatArgvForPersona('effort: inherit')).not.toContain('--effort');
+  expect(await chatArgvForPersona(null)).not.toContain('--effort');
+});

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

@@ -0,0 +1,39 @@
+import { test, expect, vi } from 'vitest';
+const { createIntradayRefresh } = require('../lib/intradayRefresh.cjs');
+
+const mk = (over = {}) => {
+  const logs = { writeLine: vi.fn() };
+  const releaseLock = vi.fn();
+  const deps = { tryAcquireLock: vi.fn(() => true), releaseLock, lockPath: '/x.lock', refresh: vi.fn(async () => {}), logs, ...over };
+  return { deps, run: createIntradayRefresh(deps), logs, releaseLock };
+};
+const flush = () => new Promise((r) => setTimeout(r, 0));
+
+test('sync throw from refresh releases the lock and logs', async () => {
+  const { run, logs, releaseLock } = mk({ refresh: () => { throw new Error('boom'); } });
+  expect(() => run()).not.toThrow();
+  await flush();
+  expect(releaseLock).toHaveBeenCalledWith('/x.lock');
+  expect(logs.writeLine).toHaveBeenCalled();
+});
+
+test('async rejection releases the lock', async () => {
+  const { run, releaseLock } = mk({ refresh: async () => { throw new Error('x'); } });
+  run(); await flush();
+  expect(releaseLock).toHaveBeenCalledTimes(1);
+});
+
+test('lock-acquire throw is logged, not escaped, and no release', async () => {
+  const { run, logs, releaseLock, deps } = mk({ tryAcquireLock: () => { throw Object.assign(new Error('EACCES'), { code: 'EACCES' }); } });
+  expect(() => run()).not.toThrow();
+  expect(logs.writeLine).toHaveBeenCalledTimes(1);
+  expect(releaseLock).not.toHaveBeenCalled();
+  expect(deps.refresh).not.toHaveBeenCalled();
+});
+
+test('contended lock skips refresh', () => {
+  const { run, deps, releaseLock } = mk({ tryAcquireLock: () => false });
+  run();
+  expect(deps.refresh).not.toHaveBeenCalled();
+  expect(releaseLock).not.toHaveBeenCalled();
+});

package/src/main/__tests__/openExternalApp-spawn-error.test.cjs

@@ -0,0 +1,25 @@
+import { test, expect, vi } from 'vitest';
+const Module = require('node:module');
+const origLoad = Module._load;
+Module._load = function (req, ...rest) {
+  if (req === 'electron') return { shell: { openPath: async () => '' } };
+  return origLoad.call(this, req, ...rest);
+};
+const { spawnDetached } = require('../lib/openExternalApp.cjs');
+Module._load = origLoad;
+
+test('non-existent command resolves ok:false with no uncaught exception', async () => {
+  const onUncaught = vi.fn();
+  process.on('uncaughtException', onUncaught);
+  const r = await spawnDetached('sm-definitely-not-a-real-binary-xyz', ['/tmp']);
+  await new Promise((res) => setTimeout(res, 20));
+  process.off('uncaughtException', onUncaught);
+  expect(r.ok).toBe(false);
+  expect(r.error).toMatch(/failed to launch/);
+  expect(onUncaught).not.toHaveBeenCalled();
+});
+
+test('real command resolves ok:true with opener name', async () => {
+  const r = await spawnDetached('true', []);
+  expect(r).toEqual({ ok: true, opener: 'true' });
+});

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

@@ -85,3 +85,25 @@ test('appendError merges caller tags without duplicating auto-derived ones', ()
   assert.equal(count, 1);
   assert.ok(line.tags.includes('silent-probe'));
 });
+
+test('under vitest, a real project root is refused: no file written, no telemetry', () => {
+  const repoRoot = path.resolve(__dirname, '..', '..', '..');
+  const logsBefore = fs.existsSync(path.join(repoRoot, 'session-manager-operations', 'logs'))
+    ? fs.readdirSync(path.join(repoRoot, 'session-manager-operations', 'logs')).map((f) => [f, fs.statSync(path.join(repoRoot, 'session-manager-operations', 'logs', f)).mtimeMs])
+    : null;
+  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
+  const saved = require.cache[telemetryPath];
+  let calls = 0;
+  require.cache[telemetryPath] = { id: telemetryPath, filename: telemetryPath, loaded: true, exports: { reportError: () => { calls++; }, logLine: () => { calls++; } } };
+  try {
+    opsErrorLog.appendError({ cwd: repoRoot, scope: 'chatRunner', tabId: 'T', message: 'fixture' });
+    opsErrorLog.appendError({ cwd: repoRoot, scope: 'chatRunner', level: 'warn', message: 'fixture' });
+  } finally {
+    if (saved) require.cache[telemetryPath] = saved; else delete require.cache[telemetryPath];
+  }
+  const logsAfter = fs.existsSync(path.join(repoRoot, 'session-manager-operations', 'logs'))
+    ? fs.readdirSync(path.join(repoRoot, 'session-manager-operations', 'logs')).map((f) => [f, fs.statSync(path.join(repoRoot, 'session-manager-operations', 'logs', f)).mtimeMs])
+    : null;
+  assert.deepEqual(logsAfter, logsBefore);
+  assert.equal(calls, 0);
+});

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

@@ -0,0 +1,169 @@
+/**
+ * personaMerge.test.cjs — overlay-over-global persona MERGE (lib/personaMerge.cjs)
+ * and every reader that goes through it.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/personaMerge.test.cjs
+ */
+
+'use strict';
+
+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 { resolveMergedPersona } = require('../lib/personaMerge.cjs');
+const { readOverlayAwarePersonaModel, resolvePrdPersonaForSpawn } = require('../lib/agentModelResolve.cjs');
+const { resolveEpicEffort } = require('../lib/agentEffortResolve.cjs');
+const { resolveEffectiveModelInfo } = require('../lib/effectiveModelInfo.cjs');
+const { getPersonaBody, listPersonas } = require('../agentLibrary.cjs');
+
+const tmpDirs = [];
+afterEach(async () => {
+  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
+});
+
+function mk(prefix) {
+  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  tmpDirs.push(d);
+  return d;
+}
+
+const noop = (p) => p;
+
+function persona(dir, name, fmLines, body) {
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, `${name}.md`), ['---', ...fmLines, '---', body].join('\n'));
+}
+
+function setup({ global, overlay }) {
+  const cwd = mk('sm-pm-cwd-');
+  const globalDir = mk('sm-pm-global-');
+  if (global) persona(globalDir, 'dev-lead', global.fm, global.body);
+  if (overlay) persona(path.join(cwd, '.claude', 'agents'), 'dev-lead', overlay.fm, overlay.body);
+  return { cwd, globalDir, deps: { globalDir, validatePath: noop } };
+}
+
+const GLOBAL = { fm: ['name: dev-lead', 'description: d', 'model: sonnet', 'effort: low'], body: 'Global body.' };
+
+test('frontmatter-only overlay overrides model', () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
+  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('claude-opus-4-6');
+  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
+  expect(m.provenance.model).toBe('overlay');
+  expect(m.provenance.description).toBe('global');
+});
+
+test('frontmatter-only overlay overrides effort; source reports persona-overlay', () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['effort: high'], body: '' } });
+  expect(resolveEpicEffort({ cwd, agentType: 'dev-lead', deps })).toEqual({ effort: 'high', source: 'persona-overlay' });
+});
+
+test('a key absent from the overlay falls back to the global (model stays global, effort from overlay)', () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['effort: high'], body: '' } });
+  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('sonnet');
+  // and the reverse: effort absent from overlay -> global effort, sourced 'persona'
+  const s2 = setup({ global: GLOBAL, overlay: { fm: ['model: opus'], body: '' } });
+  expect(resolveEpicEffort({ cwd: s2.cwd, agentType: 'dev-lead', deps: s2.deps })).toEqual({ effort: 'low', source: 'persona' });
+});
+
+test('an overlay with no body uses the global body', () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: opus'], body: '\n  \n' } });
+  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
+  expect(m.body.trim()).toBe('Global body.');
+  expect(m.bodySource).toBe('global');
+});
+
+test('a full-body overlay replaces the body wholesale and keeps its raw text byte-identical', () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['name: dev-lead', 'model: haiku'], body: 'Overlay body.' } });
+  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
+  expect(m.body.trim()).toBe('Overlay body.');
+  expect(m.bodySource).toBe('overlay');
+  expect(m.text).toBe(fs.readFileSync(path.join(cwd, '.claude', 'agents', 'dev-lead.md'), 'utf8'));
+});
+
+test("this repo's three full-body overlays resolve byte-identically (text + body + path)", async () => {
+  const repoAgents = path.resolve(__dirname, '..', '..', '..', '.claude', 'agents');
+  const globalDir = mk('sm-pm-global-');
+  for (const name of ['bilko-host-publisher', 'builder', 'project-home-builder']) {
+    persona(globalDir, name, [`name: ${name}`, 'description: g', 'model: opus'], 'global body');
+    const overlayFile = path.join(repoAgents, `${name}.md`);
+    const raw = fs.readFileSync(overlayFile, 'utf8');
+    const m = resolveMergedPersona(path.resolve(repoAgents, '..', '..'), name, { globalDir, validatePath: noop });
+    expect(m.text).toBe(raw);
+    expect(m.path).toBe(overlayFile);
+    expect(m.body).toBe(require('../lib/prdFrontmatter.cjs').splitFrontmatter(raw).body);
+    const viaLib = await getPersonaBody({ cwd: path.resolve(repoAgents, '..', '..'), name, globalDir, validatePath: noop });
+    expect(viaLib.text).toBe(raw);
+  }
+});
+
+test('malformed overlay frontmatter degrades to the global persona, never throws, and is reported', () => {
+  const { cwd, globalDir } = setup({ global: GLOBAL });
+  fs.mkdirSync(path.join(cwd, '.claude', 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(cwd, '.claude', 'agents', 'dev-lead.md'), '---\nmodel: claude-opus-4-6\nno closing fence');
+  const deps = { globalDir, validatePath: noop };
+  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
+  expect(m.fm.model).toBe('sonnet');
+  expect(m.fromOverlay).toBe(false);
+  expect(m.overlayIssue).toMatch(/malformed/);
+  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('sonnet');
+  const { todayFile } = require('../lib/opsErrorLog.cjs');
+  expect(fs.readFileSync(todayFile(cwd), 'utf8')).toMatch(/malformed frontmatter/);
+});
+
+test('an overlay with no global counterpart works standalone', () => {
+  const { cwd, deps } = setup({ overlay: { fm: ['name: dev-lead', 'model: opus'], body: 'Solo body.' } });
+  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
+  expect(m.body.trim()).toBe('Solo body.');
+  expect(m.globalPath).toBeNull();
+  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('opus');
+});
+
+test("overlay `model: inherit` defers to the settings default — it does NOT fall back to the global model", async () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: inherit'], body: '' } });
+  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('inherit');
+  const r = await resolvePrdPersonaForSpawn({ cwd, agentType: 'dev-lead', fallbackModel: 'sonnet-fallback', deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) } });
+  expect(r.model).toBe('sonnet-fallback');
+});
+
+test('resolvePrdPersonaForSpawn hands the executor the merged model AND the global body for a frontmatter-only overlay', async () => {
+  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
+  const r = await resolvePrdPersonaForSpawn({ cwd, agentType: 'dev-lead', deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) } });
+  expect(r.model).toBe('claude-opus-4-6');
+  expect(r.systemPrompt).toBe('Global body.');
+});
+
+test('a crafted agentType is rejected by every reader (PERSONA_NAME_RE traversal guard)', async () => {
+  const { cwd, deps } = setup({ global: GLOBAL });
+  const evil = '../../other-project/CLAUDE';
+  expect(resolveMergedPersona(cwd, evil, deps)).toBeNull();
+  expect(readOverlayAwarePersonaModel(evil, { ...deps, cwd })).toBeNull();
+  expect(await getPersonaBody({ cwd, name: evil, ...deps })).toBeNull();
+});
+
+test('getPersonaBody / effectiveModelInfo / listPersonas report per-field provenance, not a whole-file boolean', async () => {
+  const { cwd, globalDir, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
+  const body = await getPersonaBody({ cwd, name: 'dev-lead', ...deps });
+  expect(body.provenance.model).toBe('overlay');
+  expect(body.provenance.effort).toBe('global');
+
+  const info = await resolveEffectiveModelInfo({
+    cwd,
+    agentType: 'dev-lead',
+    deps: {
+      ...deps,
+      activeSessions: { projectRootOf: (p) => p },
+      getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }),
+    },
+  });
+  expect(info.modelAlias).toBe('claude-opus-4-6');
+  expect(info.modelSource).toBe('persona-overlay');
+  expect(info.personaProvenance.effort).toBe('global');
+  expect(info.personaEffortSource).toBe('persona');
+
+  const list = await listPersonas({ globalDir, validatePath: noop, loadSessions: async () => ({ tabs: [{ cwd }] }) });
+  const dev = list.find((p) => p.name === 'dev-lead');
+  expect(dev.overridingProjects).toEqual([path.basename(cwd)]);
+  expect(dev.overrideDetails[0]).toMatchObject({ fields: ['model'], bodyOverridden: false, issue: null });
+});

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

@@ -0,0 +1,132 @@
+/**
+ * prdCreatePlanId.test.cjs — createPrd() stamps a durable `planId` (wave identity):
+ * first-ever PRD mints, append inherits the terminal's, new-head mints, explicit
+ * multi-dep inherits the lowest-numbered dependency's (diverged ids logged once).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdCreatePlanId.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach, vi } from 'vitest';
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const config = require('../config.cjs');
+const prdParser = require('../scheduler/prdParser.cjs');
+const { parsePrdFile } = require('../lib/prdFrontmatter.cjs');
+const { createPrd } = require('../lib/prdCreate.cjs');
+const { resolveInheritedPlanId, isValidPlanId } = require('../lib/prdDisposition.cjs');
+
+async function mkTmpPrdsDir() {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-planid-create-prd-'));
+  config.addAllowedRoot(root);
+  const prdsDir = path.join(root, '.claude', 'prds');
+  await fsp.mkdir(prdsDir, { recursive: true });
+  return prdsDir;
+}
+
+function makeFakeRemote(prdsDir, statusBySlug = {}) {
+  return {
+    async allocateParallelGroup() { return prdParser.allocateParallelGroup(prdsDir); },
+    async readPrd(slug) {
+      try { return { ok: true, text: await fsp.readFile(path.join(prdsDir, `${slug}.md`), 'utf8') }; }
+      catch (e) { return { ok: false, error: e?.message }; }
+    },
+    async writePrd(slug, body) {
+      await config.writeTextAtomic(path.join(prdsDir, `${slug}.md`), body, { writer: 'scheduler' });
+      return { ok: true };
+    },
+    async listPrds() {
+      const prds = [];
+      for (const f of await fsp.readdir(prdsDir)) {
+        if (!f.endsWith('.md')) continue;
+        const slug = f.slice(0, -3);
+        const { frontmatter } = parsePrdFile(await fsp.readFile(path.join(prdsDir, f), 'utf8'));
+        prds.push({
+          slug,
+          sourcePromptId: frontmatter.sourcePromptId ?? null,
+          dependsOn: frontmatter.dependsOn ?? null,
+          planId: frontmatter.planId ?? null,
+          status: statusBySlug[slug] ?? null,
+        });
+      }
+      return { prds, total: prds.length, limit: prds.length, offset: 0, hasMore: false };
+    },
+  };
+}
+
+async function seedPrd(prdsDir, slug, { planId, dependsOn } = {}) {
+  const lines = ['---', 'title: seed', 'sourcePromptId: epic-1'];
+  if (dependsOn) lines.push(`dependsOn: [${dependsOn.join(', ')}]`);
+  if (planId) lines.push(`planId: ${planId}`);
+  lines.push('---', '# Goal', '', 'seed', '');
+  await fsp.writeFile(path.join(prdsDir, `${slug}.md`), lines.join('\n'));
+}
+
+const body = (o = {}) => ({
+  title: 'Next wave', cwd: os.homedir(), estimateMinutes: 10, goal: 'g',
+  acceptanceCriteria: ['a'], implementationNotes: 'n', ...o,
+});
+const planIdOf = async (dir, result) =>
+  parsePrdFile(await fsp.readFile(path.join(dir, result.filename), 'utf8')).frontmatter.planId;
+
+const originalJobSlug = process.env.SM_SCHEDULER_JOB_SLUG;
+beforeEach(() => { delete process.env.SM_SCHEDULER_JOB_SLUG; });
+afterEach(() => {
+  vi.restoreAllMocks();
+  if (originalJobSlug === undefined) delete process.env.SM_SCHEDULER_JOB_SLUG;
+  else process.env.SM_SCHEDULER_JOB_SLUG = originalJobSlug;
+});
+
+test('first-ever PRD in an Epic mints a valid planId', async () => {
+  const dir = await mkTmpPrdsDir();
+  const r = await createPrd(body({ sourcePromptId: 'epic-1' }), makeFakeRemote(dir));
+  expect(r.ok).toBe(true);
+  expect(isValidPlanId(await planIdOf(dir, r))).toBe(true);
+});
+
+test('a caller-supplied planId is ignored (API-owned)', async () => {
+  const dir = await mkTmpPrdsDir();
+  const r = await createPrd(body({ planId: 'evil-id' }), makeFakeRemote(dir));
+  expect(await planIdOf(dir, r)).not.toBe('evil-id');
+});
+
+test('append inherits the chain terminal\'s planId', async () => {
+  const dir = await mkTmpPrdsDir();
+  await seedPrd(dir, '1-tail', { planId: 'pl-abc' });
+  const r = await createPrd(body({ sourcePromptId: 'epic-1', disposition: 'append' }), makeFakeRemote(dir, { '1-tail': 'pending' }));
+  expect(r.ok).toBe(true);
+  expect(await planIdOf(dir, r)).toBe('pl-abc');
+});
+
+test('new-head mints a fresh planId, distinct from the existing plan', async () => {
+  const dir = await mkTmpPrdsDir();
+  await seedPrd(dir, '1-tail', { planId: 'pl-abc' });
+  const r = await createPrd(body({ sourcePromptId: 'epic-1', disposition: 'new-head' }), makeFakeRemote(dir, { '1-tail': 'pending' }));
+  const id = await planIdOf(dir, r);
+  expect(isValidPlanId(id)).toBe(true);
+  expect(id).not.toBe('pl-abc');
+});
+
+test('explicit multi-dep across two plans inherits the lowest-numbered dependency\'s and warns once', async () => {
+  const dir = await mkTmpPrdsDir();
+  await seedPrd(dir, '9-late', { planId: 'pl-late' });
+  await seedPrd(dir, '2-early', { planId: 'pl-early' });
+  const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+  const r = await createPrd(body({ dependsOn: ['9-late', '2-early'] }), makeFakeRemote(dir));
+  expect(r.ok).toBe(true);
+  expect(await planIdOf(dir, r)).toBe('pl-early');
+  expect(warn.mock.calls.filter((c) => String(c[0]).includes('spans plans')).length).toBe(1);
+});
+
+test('deps that predate the stamp fall back to a freshly minted planId', async () => {
+  const dir = await mkTmpPrdsDir();
+  await seedPrd(dir, '1-legacy');
+  const r = await createPrd(body({ dependsOn: ['1-legacy'] }), makeFakeRemote(dir));
+  expect(isValidPlanId(await planIdOf(dir, r))).toBe(true);
+});
+
+test('resolveInheritedPlanId ignores garbage planIds', () => {
+  expect(resolveInheritedPlanId(['1-a'], [{ slug: '1-a', planId: 'bad id,[x]' }]).planId).toBeNull();
+});

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

@@ -144,3 +144,16 @@ test('a cwd outside every allowed root is rejected before anything is minted', a
   const index = readActiveIndex(unregistered);
   expect(Object.keys(index.sessions)).toHaveLength(0);
 });
+
+test('model/effort overrides persist on the minted Epic; without them the record gains no such keys', async () => {
+  const cwd = await mkCwd();
+  const payload = schemas.promptSessionsCreateEpic.parse({ cwd, goalText: 'Override run', agentType: 'architect', model: 'claude-opus-5', effort: 'max' });
+  const withOverride = await createEpicViaIpc(cwd, payload);
+  expect(withOverride.session).toMatchObject({ model: 'claude-opus-5', effort: 'max' });
+  expect(readActiveIndex(cwd).sessions[withOverride.epicId]).toEqual(withOverride.session);
+  expect(PromptSessionSchema.safeParse(withOverride.session).success).toBe(true);
+
+  const plain = await createEpicViaIpc(cwd, schemas.promptSessionsCreateEpic.parse({ cwd, goalText: 'Plain run', agentType: 'architect' }));
+  expect('model' in plain.session).toBe(false);
+  expect('effort' in plain.session).toBe(false);
+});