claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,235 +0,0 @@
-/**
- * activeIndexMerge.test.cjs — unit tests for the main-process read-merge-write
- * of a cwd's prompt-sessions/active-index.json (lib/activeIndexMerge.cjs),
- * moved here from the renderer (state/promptSessions.ts's old
- * persistActiveIndex, commit 3d12e19) so the merge runs inside the same
- * withPathLock instance epicMint.cjs's ensureEpic already serializes through.
- *
- * Covers the two holes a purely-renderer merge left open:
- *  - resurrection: a tombstoned id must never be written back by a later
- *    merge call whose memory contribution still thinks it's open.
- *  - TOCTOU: a mint (ensureEpic) interleaved with a merge call must survive,
- *    since both now go through the same lock.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/activeIndexMerge.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { mergeActiveIndex } = require('../lib/activeIndexMerge.cjs');
-const { ensureEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-const { appendResponseEventIfKnown } = require('../promptSessionEvents.cjs');
-const config = require('../config.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-activeindexmerge-cwd-'));
-  // config.cjs's readJson/writeJson restrict to registered roots (home dir by
-  // default) — register this tmp dir so the merge's config.readJson/writeJson
-  // calls don't reject it as outside the allowed boundary.
-  config.addAllowedRoot(cwd);
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-function session(id, overrides = {}) {
-  return {
-    id,
-    cwd: overrides.cwd || '/proj',
-    goalText: overrides.goalText || `goal for ${id}`,
-    claudeSessionId: overrides.claudeSessionId || `claude-${id}`,
-    status: overrides.status || 'active',
-    createdAt: overrides.createdAt || '2026-08-02T13:48:00.000Z',
-    completedAt: overrides.completedAt ?? null,
-  };
-}
-
-function promptEvent(id, promptSessionId, at) {
-  return { id, promptSessionId, kind: 'prompt', causedByEventId: null, at, text: 'x' };
-}
-
-// Incident 2026-08-02: two Epics created by another (already-running) window
-// sat on disk. A second window booted empty and, on its first mutation,
-// persisted its own (empty-of-those-two) contribution straight over the file.
-// The main-side merge must still preserve every pre-existing on-disk Epic.
-test('a fresh caller contributing one Epic preserves pre-existing on-disk Epics untouched', async () => {
-  const cwd = await mkCwd();
-  const other = session('psess-other');
-  await mergeActiveIndex(cwd, {
-    sessions: { [other.id]: other },
-    events: { [other.id]: [promptEvent('evt-1', other.id, other.createdAt)] },
-  });
-
-  const fresh = session('psess-fresh', { createdAt: '2026-08-02T13:50:00.000Z' });
-  await mergeActiveIndex(cwd, {
-    sessions: { [fresh.id]: fresh },
-    events: { [fresh.id]: [promptEvent('evt-2', fresh.id, fresh.createdAt)] },
-  });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[other.id]).toEqual(other);
-  expect(index.sessions[fresh.id]).toEqual(fresh);
-  expect(index.events[other.id]).toHaveLength(1);
-});
-
-test('memory wins over disk on id collision', async () => {
-  const cwd = await mkCwd();
-  const original = session('psess-1', { goalText: 'Fresh title' });
-  await mergeActiveIndex(cwd, { sessions: { [original.id]: original }, events: {} });
-
-  const updated = { ...original, goalText: 'Updated title' };
-  await mergeActiveIndex(cwd, { sessions: { [updated.id]: updated }, events: {} });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[original.id].goalText).toBe('Updated title');
-});
-
-test('removedIds drops the row from the merged write and records a removal tombstone', async () => {
-  const cwd = await mkCwd();
-  const s = session('psess-1');
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: {} });
-
-  await mergeActiveIndex(cwd, { sessions: {}, events: {}, removedIds: [s.id] });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[s.id]).toBeUndefined();
-  expect(index.tombstones[s.id]).toBeTruthy();
-});
-
-// The resurrection hole this PRD closes: two simulated windows. Window A
-// completes (markCompleted) and persists the removal. Window B never
-// hydrated that removal — its in-memory snapshot still holds the Epic as
-// 'active' — and persists afterward. The tombstone must win: the Epic stays
-// gone, not resurrected.
-test('regression: a later merge whose memory still holds a removed Epic as active does not resurrect it', async () => {
-  const cwd = await mkCwd();
-  const s = session('psess-1', { status: 'active' });
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: { [s.id]: [promptEvent('e1', s.id, s.createdAt)] } });
-
-  // Window A: markCompleted removes it.
-  await mergeActiveIndex(cwd, { sessions: {}, events: {}, removedIds: [s.id] });
-  expect(readActiveIndex(cwd).sessions[s.id]).toBeUndefined();
-
-  // Window B: stale in-memory snapshot still has it as 'active', persists
-  // its own (unrelated) mutation — a resurrection-prone merge.
-  const windowBOther = session('psess-2', { status: 'proposed' });
-  await mergeActiveIndex(cwd, {
-    sessions: { [s.id]: s, [windowBOther.id]: windowBOther },
-    events: { [s.id]: [promptEvent('e1', s.id, s.createdAt)] },
-  });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[s.id]).toBeUndefined();
-  expect(index.events[s.id]).toBeUndefined();
-  expect(index.sessions[windowBOther.id]).toEqual(windowBOther);
-});
-
-test('event union: disk-only events are appended and re-sorted chain-aware; memory-only events kept', async () => {
-  const cwd = await mkCwd();
-  const s = session('psess-1');
-  const e1 = promptEvent('e1', s.id, '2026-08-02T13:00:00.000Z');
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: { [s.id]: [e1] } });
-
-  // A scheduler job appended a response event directly to disk between our
-  // two merge calls (simulated by mutating the file out of band).
-  const midIndex = readActiveIndex(cwd);
-  const schedulerEvent = { id: 'e2', promptSessionId: s.id, kind: 'response', causedByEventId: 'e1', at: '2026-08-02T13:05:00.000Z', text: 'done' };
-  midIndex.events[s.id] = [e1, schedulerEvent];
-  await config.writeJson(path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'), midIndex, { writer: 'epics' });
-
-  // This caller's memory still only knows about e1 plus its own optimistic
-  // append e3 (not yet on disk).
-  const e3 = { id: 'e3', promptSessionId: s.id, kind: 'prd_created', causedByEventId: 'e2', at: '2026-08-02T13:10:00.000Z', prdSlug: 'x' };
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: { [s.id]: [e1, e3] } });
-
-  const finalEvents = readActiveIndex(cwd).events[s.id];
-  expect(finalEvents.map((e) => e.id)).toEqual(['e1', 'e2', 'e3']);
-});
-
-// Electron's structured-clone IPC transport (unlike JSON.parse) can produce
-// an own-enumerable "__proto__" key on a cloned object. A plain-object merge
-// target's bracket assignment with that key would re-link its own prototype
-// instead of storing a normal entry, silently dropping/corrupting the Epic
-// and potentially breaking every later Object.keys/JSON.stringify over it.
-test('a "__proto__"-keyed session id merges as an ordinary entry, not a prototype pollution', async () => {
-  const cwd = await mkCwd();
-  const polluted = session('__proto__', { goalText: 'polluted' });
-  // Computed key, not `{ __proto__: polluted }` — the latter is special-cased
-  // by object-literal syntax to set the prototype rather than create an own
-  // enumerable "__proto__" property, which wouldn't exercise this hazard.
-  await mergeActiveIndex(cwd, { sessions: { ['__proto__']: polluted }, events: {} });
-
-  const index = readActiveIndex(cwd);
-  expect(Object.prototype.hasOwnProperty.call(index.sessions, '__proto__')).toBe(true);
-  expect(index.sessions.__proto__).toEqual(polluted);
-  expect(Object.getPrototypeOf({})).toBe(Object.prototype);
-});
-
-test('falls back to writing memory state alone when the disk index is corrupt JSON', async () => {
-  const cwd = await mkCwd();
-  const filePath = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
-  await fsp.mkdir(path.dirname(filePath), { recursive: true });
-  await fsp.writeFile(filePath, '{ not valid json', 'utf8');
-
-  const s = session('psess-1');
-  await mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: {} });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[s.id]).toEqual(s);
-});
-
-// TOCTOU: a mint interleaved with a merge call must survive, since both now
-// serialize through the same withPathLock (epicMint.cjs exports it; this
-// module requires it via the same module — Node's require cache means one
-// lock instance, not two independent maps that could still interleave).
-test('mint-during-persist: an ensureEpic mint interleaved with a merge call survives', async () => {
-  const cwd = await mkCwd();
-  const existing = session('psess-existing');
-  await mergeActiveIndex(cwd, { sessions: { [existing.id]: existing }, events: {} });
-
-  const [mintResult] = await Promise.all([
-    ensureEpic(cwd, { goalText: 'minted during a concurrent merge', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI }),
-    mergeActiveIndex(cwd, { sessions: { [existing.id]: existing }, events: {} }),
-  ]);
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[mintResult.epicId]).toBeDefined();
-  expect(index.sessions[existing.id]).toBeDefined();
-});
-
-// The third writer: promptSessionEvents.cjs's appendResponseEventIfKnown
-// (the scheduler's narrow 'scheduler'-delegation append) used to hold its
-// OWN independent lock map — a merge call and a response-event append could
-// still race past each other's stale read. It now imports activeIndexPath/
-// withPathLock from epicMint.cjs (same module, same require-cache instance),
-// so a response-event append interleaved with a merge call must survive too.
-test('a scheduler response-event append interleaved with a merge call survives (third writer shares the same lock)', async () => {
-  const cwd = await mkCwd();
-  const s = session('psess-1', { status: 'active' });
-  await mergeActiveIndex(cwd, {
-    sessions: { [s.id]: s },
-    events: { [s.id]: [promptEvent('e1', s.id, s.createdAt)] },
-  });
-
-  const [, appended] = await Promise.all([
-    mergeActiveIndex(cwd, { sessions: { [s.id]: s }, events: { [s.id]: [promptEvent('e1', s.id, s.createdAt)] } }),
-    appendResponseEventIfKnown(cwd, s.id, 'PRD finished'),
-  ]);
-
-  expect(appended).toBe(true);
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[s.id]).toBeDefined();
-  expect(index.events[s.id]).toHaveLength(2);
-  expect(index.events[s.id][1].kind).toBe('response');
-});

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

@@ -1,117 +0,0 @@
-/**
- * agentEffortResolve.test.cjs — the effort twin of agentModelResolve.test.cjs:
- * persona `effort:` wins (overlay beats global), inherit/absent/dangling → no flag.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/agentEffortResolve.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 { resolveEpicEffort, effortArgs } = require('../lib/agentEffortResolve.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { 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: {} }));
-}
-
-function writePersona(dir, name, frontmatter) {
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${name}.md`), ['---', `name: ${name}`, ...frontmatter, '---', 'body'].join('\n'));
-}
-
-const noopValidatePath = (p) => p;
-
-test('persona effort wins (global) for a matching Epic', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  writeIndex(cwd, { e1: { id: 'e1', claudeSessionId: 's1', agentType: 'p' } });
-  writePersona(globalDir, 'p', ['effort: high']);
-  expect(resolveEpicEffort({ cwd, claudeSessionId: 's1', deps: { globalDir, validatePath: noopValidatePath } }))
-    .toEqual({ effort: 'high', source: 'persona' });
-});
-
-test('project overlay beats global', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  const projectDir = await mkTmpDir('sm-effort-proj-');
-  writePersona(globalDir, 'p', ['effort: low']);
-  writePersona(projectDir, 'p', ['effort: max']);
-  expect(resolveEpicEffort({ cwd, agentType: 'p', deps: { globalDir, projectDir, validatePath: noopValidatePath } }))
-    .toEqual({ effort: 'max', source: 'persona-overlay' });
-});
-
-test('inherit and absent resolve to null effort', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  writePersona(globalDir, 'inh', ['effort: inherit']);
-  writePersona(globalDir, 'none', []);
-  const deps = { globalDir, validatePath: noopValidatePath };
-  expect(resolveEpicEffort({ cwd, agentType: 'inh', deps })).toEqual({ effort: null, source: 'inherit' });
-  expect(resolveEpicEffort({ cwd, agentType: 'none', deps })).toEqual({ effort: null, source: 'inherit' });
-});
-
-test('a persona effort of `auto` (a /effort reset verb) resolves to no flag', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  writePersona(globalDir, 'au', ['effort: auto']);
-  const deps = { globalDir, validatePath: noopValidatePath };
-  const r = resolveEpicEffort({ cwd, agentType: 'au', deps });
-  expect(r.effort).toBeNull();
-  expect(effortArgs(r.effort)).toEqual([]);
-});
-
-test('dangling agentType / unknown Epic / empty opts resolve to null without throwing', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  writeIndex(cwd, {});
-  const deps = { globalDir, validatePath: noopValidatePath };
-  expect(resolveEpicEffort({ cwd, agentType: 'gone', deps })).toEqual({ effort: null, source: null });
-  expect(resolveEpicEffort({ cwd, claudeSessionId: 'nope', deps })).toEqual({ effort: null, source: null });
-  expect(resolveEpicEffort({})).toEqual({ effort: null, source: null });
-  expect(resolveEpicEffort({ cwd, agentType: '../../etc/passwd', deps })).toEqual({ effort: null, source: null });
-});
-
-test('an unknown level is passed through unchanged (CLI warns and degrades)', async () => {
-  const cwd = await mkTmpDir('sm-effort-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-agents-');
-  writePersona(globalDir, 'odd', ['effort: turbo']);
-  expect(resolveEpicEffort({ cwd, agentType: 'odd', deps: { globalDir, validatePath: noopValidatePath } }).effort).toBe('turbo');
-});
-
-test('effortArgs emits the pair only for a real level', () => {
-  expect(effortArgs('high')).toEqual(['--effort', 'high']);
-  for (const v of [null, undefined, '', 'inherit']) expect(effortArgs(v)).toEqual([]);
-});
-
-// Epic-level override (New Session card) > persona frontmatter > no flag.
-test('an Epic-level effort override beats the persona effort; an Epic without the field resolves unchanged', async () => {
-  const cwd = await mkTmpDir('sm-effort-ovr-cwd-');
-  const globalDir = await mkTmpDir('sm-effort-ovr-agents-');
-  writeIndex(cwd, {
-    withOverride: { id: 'withOverride', claudeSessionId: 's-ovr', agentType: 'p', effort: 'max' },
-    legacy: { id: 'legacy', claudeSessionId: 's-old', agentType: 'p' },
-    noPersona: { id: 'noPersona', claudeSessionId: 's-np', effort: 'low' },
-  });
-  writePersona(globalDir, 'p', ['effort: low']);
-  const deps = { globalDir, validatePath: noopValidatePath };
-  expect(resolveEpicEffort({ cwd, claudeSessionId: 's-ovr', deps })).toEqual({ effort: 'max', source: 'epic' });
-  expect(resolveEpicEffort({ cwd, claudeSessionId: 's-old', deps })).toEqual({ effort: 'low', source: 'persona' });
-  expect(resolveEpicEffort({ cwd, claudeSessionId: 's-np', deps })).toEqual({ effort: 'low', source: 'epic' });
-});

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:');
-});