claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,276 +0,0 @@
-/**
- * agentLibrary.test.cjs — unit tests for the Agent Library nav page's
- * backend: enumerating global `~/.claude/agents/*.md` personas and
- * detecting per-project `.claude/agents/<name>.md` overlays among
- * currently-open tabs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/agentLibrary.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 { listPersonas, openProjects, parseTools, savePersona, deletePersona, removeOverride } = require('../agentLibrary.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;
-}
-
-// listPersonas/openProjects take injectable deps; tests pass an identity
-// validatePath since the fixture dirs live under os.tmpdir(), not the real
-// home directory config.cjs's validatePath would otherwise enforce.
-const identityValidatePath = (p) => p;
-
-// savePersona/deletePersona/removeOverride take an injectable writeTextAtomic
-// too, since the real config.cjs one enforces its own home-dir validatePath
-// regardless of what's injected for the `validatePath` param here.
-async function fakeWriteTextAtomic(abs, text) {
-  await fsp.mkdir(path.dirname(abs), { recursive: true });
-  await fsp.writeFile(abs, text, 'utf8');
-  return { ok: true, mtimeMs: Date.now() };
-}
-
-test('parseTools splits + trims a comma-separated tools frontmatter value', () => {
-  expect(parseTools('Read, Grep, Glob, Bash')).toEqual(['Read', 'Grep', 'Glob', 'Bash']);
-  expect(parseTools('')).toEqual([]);
-  expect(parseTools(undefined)).toEqual([]);
-});
-
-test('openProjects dedups by cwd and uses the last path segment as name', async () => {
-  const loadSessions = async () => ({
-    tabs: [
-      { cwd: '/home/u/Projects/alpha' },
-      { cwd: '/home/u/Projects/beta/' },
-      { cwd: '/home/u/Projects/alpha' }, // duplicate — should collapse
-      { cwd: null }, // malformed — should be skipped
-    ],
-  });
-  const projects = await openProjects({ loadSessions });
-  expect(projects).toEqual([
-    { cwd: '/home/u/Projects/alpha', name: 'alpha' },
-    { cwd: '/home/u/Projects/beta/', name: 'beta' },
-  ]);
-});
-
-test('listPersonas returns [] when the global agents dir does not exist', async () => {
-  const missingDir = path.join(os.tmpdir(), 'sm-agent-library-does-not-exist-' + Date.now());
-  const personas = await listPersonas({
-    globalDir: missingDir,
-    loadSessions: async () => ({ tabs: [] }),
-    validatePath: identityValidatePath,
-  });
-  expect(personas).toEqual([]);
-});
-
-test('listPersonas parses frontmatter and reports overridingProjects for open tabs with a local overlay', async () => {
-  const globalDir = await mkTmp('sm-agent-library-global-');
-  await fsp.writeFile(
-    path.join(globalDir, 'builder.md'),
-    [
-      '---',
-      'name: builder',
-      'description: Watch git history and drive the next publish.',
-      'tools: Read, Grep, Glob, Bash',
-      'tags: feature, bug',
-      '---',
-      '',
-      'You are the Builder agent.',
-      '',
-    ].join('\n'),
-  );
-  await fsp.writeFile(
-    path.join(globalDir, 'debugger.md'),
-    ['---', 'name: debugger', 'description: Diagnose a failing test.', '---', '', 'Body.', ''].join('\n'),
-  );
-
-  const projectWithOverlay = await mkTmp('sm-agent-library-project-a-');
-  await fsp.mkdir(path.join(projectWithOverlay, '.claude', 'agents'), { recursive: true });
-  await fsp.writeFile(
-    path.join(projectWithOverlay, '.claude', 'agents', 'builder.md'),
-    '---\nname: builder\n---\nProject-specific overlay.\n',
-  );
-
-  const projectWithoutOverlay = await mkTmp('sm-agent-library-project-b-');
-
-  const loadSessions = async () => ({
-    tabs: [{ cwd: projectWithOverlay }, { cwd: projectWithoutOverlay }],
-  });
-
-  const personas = await listPersonas({ globalDir, loadSessions, validatePath: identityValidatePath });
-  expect(personas).toHaveLength(2);
-
-  const byName = Object.fromEntries(personas.map((p) => [p.name, p]));
-  expect(byName.builder.description).toBe('Watch git history and drive the next publish.');
-  expect(byName.builder.tags).toEqual(['feature', 'bug']);
-  expect(byName.debugger.tags).toEqual([]);
-  expect(byName.builder.tools).toEqual(['Read', 'Grep', 'Glob', 'Bash']);
-  expect(byName.builder.body).toContain('You are the Builder agent.');
-  expect(byName.builder.overridingProjects).toEqual([path.basename(projectWithOverlay)]);
-
-  expect(byName.debugger.overridingProjects).toEqual([]);
-});
-
-test('listPersonas skips a project cwd that validatePath rejects, rather than throwing', async () => {
-  const globalDir = await mkTmp('sm-agent-library-global-');
-  await fsp.writeFile(path.join(globalDir, 'builder.md'), '---\nname: builder\n---\nBody.\n');
-
-  const rejectedProject = await mkTmp('sm-agent-library-project-rejected-');
-  await fsp.mkdir(path.join(rejectedProject, '.claude', 'agents'), { recursive: true });
-  await fsp.writeFile(path.join(rejectedProject, '.claude', 'agents', 'builder.md'), 'overlay\n');
-
-  const loadSessions = async () => ({ tabs: [{ cwd: rejectedProject }] });
-  // Simulate config.cjs's validatePath throwing for anything under the
-  // rejected project (as it would for a cwd outside the allowed-roots set)
-  // while still allowing the global agents dir itself to resolve.
-  const selectiveValidatePath = (p) => {
-    if (p.startsWith(rejectedProject)) throw new Error('outside allowed boundaries');
-    return p;
-  };
-
-  const personas = await listPersonas({ globalDir, loadSessions, validatePath: selectiveValidatePath });
-  expect(personas).toHaveLength(1);
-  expect(personas[0].overridingProjects).toEqual([]);
-});
-
-test('savePersona writes frontmatter + body, and rejects a non-slug name', async () => {
-  const globalDir = await mkTmp('sm-agent-library-save-');
-  await savePersona({
-    name: 'my-agent',
-    description: 'Does a thing.',
-    tools: ['Read', 'Grep'],
-    model: 'opus',
-    color: 'blue',
-    tags: ['feature', 'bug'],
-    body: 'You are my-agent.',
-    globalDir,
-    validatePath: identityValidatePath,
-    writeTextAtomic: fakeWriteTextAtomic,
-  });
-  const text = await fsp.readFile(path.join(globalDir, 'my-agent.md'), 'utf8');
-  expect(text).toContain('name: my-agent');
-  expect(text).toContain('description: Does a thing.');
-  expect(text).toContain('tools: Read, Grep');
-  expect(text).toContain('model: opus');
-  expect(text).toContain('color: blue');
-  expect(text).toContain('tags: feature, bug');
-  expect(text).toContain('You are my-agent.');
-
-  await expect(
-    savePersona({ name: 'Not Valid', body: '', globalDir, validatePath: identityValidatePath, writeTextAtomic: fakeWriteTextAtomic }),
-  ).rejects.toThrow(/lowercase, hyphenated/);
-});
-
-test('savePersona with originalName renames — writes the new file and removes the old one', async () => {
-  const globalDir = await mkTmp('sm-agent-library-rename-');
-  await fsp.writeFile(path.join(globalDir, 'old-name.md'), '---\nname: old-name\n---\nBody.\n');
-  await savePersona({
-    name: 'new-name',
-    originalName: 'old-name',
-    description: '',
-    tools: [],
-    model: 'inherit',
-    color: '',
-    body: 'Body.',
-    globalDir,
-    validatePath: identityValidatePath,
-    writeTextAtomic: fakeWriteTextAtomic,
-  });
-  expect(fs.existsSync(path.join(globalDir, 'new-name.md'))).toBe(true);
-  expect(fs.existsSync(path.join(globalDir, 'old-name.md'))).toBe(false);
-});
-
-test('deletePersona removes the file, and is a no-op when it is already gone', async () => {
-  const globalDir = await mkTmp('sm-agent-library-delete-');
-  await fsp.writeFile(path.join(globalDir, 'gone-soon.md'), '---\nname: gone-soon\n---\nBody.\n');
-  await deletePersona({ name: 'gone-soon', globalDir, validatePath: identityValidatePath });
-  expect(fs.existsSync(path.join(globalDir, 'gone-soon.md'))).toBe(false);
-  await expect(deletePersona({ name: 'gone-soon', globalDir, validatePath: identityValidatePath })).resolves.toEqual({ ok: true });
-});
-
-test('removeOverride deletes a project overlay resolved by project name, and rejects an unknown project', async () => {
-  const project = await mkTmp('sm-agent-library-override-');
-  await fsp.mkdir(path.join(project, '.claude', 'agents'), { recursive: true });
-  const overlayPath = path.join(project, '.claude', 'agents', 'builder.md');
-  await fsp.writeFile(overlayPath, 'overlay\n');
-  const loadSessions = async () => ({ tabs: [{ cwd: project }] });
-
-  await removeOverride({ name: 'builder', projectName: path.basename(project), loadSessions, validatePath: identityValidatePath });
-  expect(fs.existsSync(overlayPath)).toBe(false);
-
-  await expect(
-    removeOverride({ name: 'builder', projectName: 'not-open', loadSessions, validatePath: identityValidatePath }),
-  ).rejects.toThrow(/project not open/);
-});
-
-test('projects/action/actionLabel round-trip through savePersona -> listPersonas, with newlines preserved', async () => {
-  const globalDir = await mkTmp('sm-agent-library-action-');
-  const action = '/builder\n\nCheck git vs the published package and publish anything new.';
-  await savePersona({
-    name: 'builder',
-    description: 'Drives the next publish.',
-    tools: ['Bash'],
-    model: 'inherit',
-    color: '',
-    tags: ['build'],
-    projects: ['/home/bilko/Projects/alpha', '/home/bilko/Projects/beta'],
-    action,
-    actionLabel: 'Run Build',
-    body: 'Body.',
-    globalDir,
-    validatePath: identityValidatePath,
-    writeTextAtomic: fakeWriteTextAtomic,
-  });
-
-  // The frontmatter parser is line-based, so the multi-line action must be
-  // stored escaped — a raw newline would silently truncate it on read.
-  const raw = await fsp.readFile(path.join(globalDir, 'builder.md'), 'utf8');
-  expect(raw).toContain('action: /builder\\n\\nCheck git');
-  expect(raw).toContain('projects: /home/bilko/Projects/alpha, /home/bilko/Projects/beta');
-
-  const [p] = await listPersonas({ globalDir, loadSessions: async () => ({ tabs: [] }), validatePath: identityValidatePath });
-  expect(p.projects).toEqual(['/home/bilko/Projects/alpha', '/home/bilko/Projects/beta']);
-  expect(p.action).toBe(action);
-  expect(p.actionLabel).toBe('Run Build');
-});
-
-test('a persona with no Action fields reports them as empty/null rather than undefined', async () => {
-  const globalDir = await mkTmp('sm-agent-library-noaction-');
-  await fsp.writeFile(path.join(globalDir, 'plain.md'), '---\nname: plain\n---\nBody.\n');
-  const [p] = await listPersonas({ globalDir, loadSessions: async () => ({ tabs: [] }), validatePath: identityValidatePath });
-  expect(p.projects).toEqual([]);
-  expect(p.action).toBeNull();
-  expect(p.actionLabel).toBeNull();
-});
-
-test('effort: written when set, omitted for inherit/unset, round-trips, and untouched personas gain no line', async () => {
-  const globalDir = await mkTmp('sm-agent-library-effort-');
-  const base = { tools: [], color: '', tags: [], body: 'B.', globalDir, validatePath: identityValidatePath, writeTextAtomic: fakeWriteTextAtomic };
-  await savePersona({ ...base, name: 'with-effort', model: 'opus', effort: 'xhigh' });
-  await savePersona({ ...base, name: 'inherit-effort', model: 'opus', effort: 'inherit' });
-  await savePersona({ ...base, name: 'unset-effort', model: 'opus' });
-  const raw = (n) => fsp.readFile(path.join(globalDir, `${n}.md`), 'utf8');
-  expect(await raw('with-effort')).toContain('effort: xhigh');
-  expect(await raw('inherit-effort')).not.toContain('effort:');
-  expect(await raw('unset-effort')).not.toContain('effort:');
-
-  const ps = await listPersonas({ globalDir, loadSessions: async () => ({ tabs: [] }), validatePath: identityValidatePath });
-  const by = Object.fromEntries(ps.map((p) => [p.name, p]));
-  expect(by['with-effort'].effort).toBe('xhigh');
-  expect(by['unset-effort'].effort).toBeNull();
-
-  // Untouched save of a no-effort persona (UI maps null -> 'inherit') must not add a line.
-  await savePersona({ ...base, name: 'unset-effort', model: 'opus', effort: by['unset-effort'].effort ?? 'inherit' });
-  expect(await raw('unset-effort')).not.toContain('effort:');
-});

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

@@ -1,311 +0,0 @@
-/**
- * agentModelResolve.test.cjs — unit tests for resolveEpicModel: the shared
- * persona-model resolver both EpicTerminalPane.tsx's Terminal-view launch
- * and chatRunner.cjs's headless Chat-view launch should agree with.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/agentModelResolve.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 {
-  FALLBACK_MODEL,
-  resolveEpicModel,
-  findAgentTypeByClaudeSessionId,
-  readOverlayAwarePersonaModel,
-  resolvePrdPersonaForSpawn,
-} = require('../lib/agentModelResolve.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkTmpDir(prefix) {
-  const dir = await fsp.mkdtemp(path.join(os.tmpdir(), prefix));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function writeIndex(cwd, sessions) {
-  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events: {} }, null, 2));
-}
-
-function writePersona(globalDir, name, frontmatter) {
-  fs.mkdirSync(globalDir, { recursive: true });
-  const lines = ['---', `name: ${name}`, ...frontmatter, '---', 'body'];
-  fs.writeFileSync(path.join(globalDir, `${name}.md`), lines.join('\n'));
-}
-
-const noopValidatePath = (p) => p;
-
-test('resolves the agentType persona model for a matching Epic', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-opus', agentType: 'opus-persona' } });
-  writePersona(globalDir, 'opus-persona', ['model: opus']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-opus',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe('opus');
-});
-
-test('falls back to the fallback model when the Epic has no agentType', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-none' } });
-
-  const model = resolveEpicModel({ cwd, claudeSessionId: 'sess-none' });
-
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test("falls back when the persona's model is 'inherit'", async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
-  writeIndex(cwd, { 'epic-1': { id: 'epic-1', claudeSessionId: 'sess-inherit', agentType: 'inherit-persona' } });
-  writePersona(globalDir, 'inherit-persona', ['model: inherit']);
-
-  const model = resolveEpicModel({
-    cwd,
-    claudeSessionId: 'sess-inherit',
-    deps: { globalDir, validatePath: noopValidatePath },
-  });
-
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test('falls back when no Epic matches the claudeSessionId', () => {
-  const model = resolveEpicModel({ cwd: '/nonexistent-cwd-xyz', claudeSessionId: 'no-such-session' });
-  expect(model).toBe(FALLBACK_MODEL);
-});
-
-test('never throws when cwd/claudeSessionId are missing', () => {
-  expect(resolveEpicModel({})).toBe(FALLBACK_MODEL);
-});
-
-test('findAgentTypeByClaudeSessionId returns null for no match', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  writeIndex(cwd, {});
-  expect(findAgentTypeByClaudeSessionId(cwd, 'missing')).toBeNull();
-});
-
-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(readOverlayAwarePersonaModel('no-model-persona', { cwd, globalDir, validatePath: noopValidatePath })).toBeNull();
-});
-
-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(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('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(() => 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 readOverlayAwarePersonaModel calls above — dedup key is (cwd, agentType).
-  expect(matches).toHaveLength(1);
-  expect(matches[0].level).toBe('warn');
-});
-
-// resolvePrdPersonaForSpawn — the PRD-path resolver scheduler.cjs's executeJob
-// calls to turn a job's agentType into a --append-system-prompt body and a
-// --model value (PRD 1115).
-
-test('resolvePrdPersonaForSpawn returns the persona body and its own model, overriding the fallback', async () => {
-  const result = await resolvePrdPersonaForSpawn({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: {
-      getPersonaBody: async ({ name }) => {
-        expect(name).toBe('dev-lead');
-        return { path: '/home/user/.claude/agents/dev-lead.md', text: '---\nmodel: opus\n---\nOperate methodically.' };
-      },
-    },
-  });
-  expect(result.model).toBe('opus');
-  expect(result.systemPrompt).toBe('Operate methodically.');
-  expect(result.personaPath).toBe('/home/user/.claude/agents/dev-lead.md');
-});
-
-test("resolvePrdPersonaForSpawn falls back to the fallback model when the persona's model is 'inherit'", async () => {
-  const result = await resolvePrdPersonaForSpawn({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: { getPersonaBody: async () => ({ path: '/x/dev-lead.md', text: '---\nmodel: inherit\n---\nBody text.' }) },
-  });
-  expect(result.model).toBe(FALLBACK_MODEL);
-});
-
-test('resolvePrdPersonaForSpawn falls back without throwing when agentType no longer resolves to a persona file, and logs it once', async () => {
-  const cwd = await mkTmpDir('sm-agentmodel-cwd-');
-  const call = () => resolvePrdPersonaForSpawn({
-    cwd,
-    agentType: 'ghost-persona',
-    deps: { getPersonaBody: async () => null },
-  });
-  await expect(call()).resolves.toEqual({ model: FALLBACK_MODEL, systemPrompt: null, personaPath: null });
-  await call(); // second call must not log a second line (dedup)
-
-  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);
-  expect(matches[0].level).toBe('warn');
-});
-
-test('resolvePrdPersonaForSpawn returns the fallback (no persona applied) when agentType is absent, without touching getPersonaBody', async () => {
-  const getPersonaBody = async () => { throw new Error('must not be called'); };
-  const result = await resolvePrdPersonaForSpawn({ cwd: '/irrelevant', agentType: null, deps: { getPersonaBody } });
-  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({
-    cwd: '/irrelevant',
-    agentType: 'dev-lead',
-    deps: { getPersonaBody: async () => ({ path: '/home/user/.claude/agents/dev-lead.md', text: longBody }) },
-  });
-  expect(result.systemPrompt.startsWith('x'.repeat(6000))).toBe(true);
-  expect(result.systemPrompt.length).toBeLessThan(longBody.length);
-  expect(result.systemPrompt.toLowerCase()).toContain('truncat');
-  expect(result.systemPrompt).toContain('/home/user/.claude/agents/dev-lead.md');
-});
-
-// Epic-level override (New Session card) > persona frontmatter > fallback.
-test('an Epic-level model override beats the persona model; an Epic without the field resolves unchanged', async () => {
-  const cwd = await mkTmpDir('sm-model-ovr-cwd-');
-  const globalDir = await mkTmpDir('sm-model-ovr-agents-');
-  writeIndex(cwd, {
-    withOverride: { id: 'withOverride', claudeSessionId: 's-ovr', agentType: 'p', model: 'claude-opus-5' },
-    legacy: { id: 'legacy', claudeSessionId: 's-old', agentType: 'p' },
-    inheritOverride: { id: 'inheritOverride', claudeSessionId: 's-inh', agentType: 'p', model: 'inherit' },
-  });
-  writePersona(globalDir, 'p', ['model: haiku']);
-  const deps = { globalDir, validatePath: (p) => p };
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-ovr', deps })).toBe('claude-opus-5');
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-old', deps })).toBe('haiku');
-  expect(resolveEpicModel({ cwd, claudeSessionId: 's-inh', deps })).toBe('haiku');
-});