claude-code-session-manager 0.92.0 → 0.93.0

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);
+});

package/src/main/__tests__/pty-epic-worktree-spawn-cwd.test.cjs

@@ -175,22 +175,87 @@ test('spawn() opens a merged-worktree Epic in the project cwd (dead worktree dir
   manager.kill(sessionId);
 });
 
-test('spawn() refuses a completed Epic without spawning and returns the plan message', () => {
-  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-'));
-  const sessionId = 'epic-session-closed';
-  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-c', claudeSessionId: sessionId, worktreeDir: mainCwd });
+function setEpic(mainCwd, epicId, patch) {
   const idxPath = path.join(mainCwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
   const idx = JSON.parse(fs.readFileSync(idxPath, 'utf8'));
-  idx.sessions['epic-c'].status = 'completed';
+  const rec = idx.sessions[epicId];
+  if (patch.status) rec.status = patch.status;
+  if (patch.worktreeStatus) rec.worktree.status = patch.worktreeStatus;
   fs.writeFileSync(idxPath, JSON.stringify(idx));
+}
 
-  let spawned = false;
-  nodePty.spawn = () => {
-    spawned = true;
+function captureSpawn() {
+  const out = { opts: null, count: 0 };
+  nodePty.spawn = (shell, args, opts) => {
+    out.opts = opts;
+    out.count += 1;
     return fakeProc();
   };
+  return out;
+}
+
+function fakeWindow(sent) {
+  return {
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, isCrashed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
+  };
+}
+
+test('spawn() opens a completed Epic (merged worktree) as a shell in the project cwd with an informational line', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-'));
+  const sessionId = 'epic-session-closed';
+  const deadDir = path.join(os.tmpdir(), 'sm-pty-closed-dead-worktree');
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-c', claudeSessionId: sessionId, worktreeDir: deadDir });
+  setEpic(mainCwd, 'epic-c', { status: 'completed', worktreeStatus: 'merged' });
+
+  const cap = captureSpawn();
+  const sent = [];
+  manager.window = fakeWindow(sent);
+  try {
+    const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+    expect(cap.count).toBe(1);
+    expect(cap.opts.cwd).toBe(mainCwd);
+    expect(result.pid).toBe(4242);
+    expect(result.error).toBeUndefined();
+    const info = sent.find((m) => m.channel === `pty:data:${sessionId}`);
+    expect(info.payload).toMatch(/Epic is completed/);
+    expect(info.payload).toContain(mainCwd);
+  } finally {
+    manager.window = null;
+    manager.kill(sessionId);
+  }
+});
+
+test('spawn() opens a completed Epic whose worktree dir still exists in that worktree dir', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-closed-live-'));
+  const worktreeCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pty-closed-live-wt-'));
+  const sessionId = 'epic-session-closed-live';
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-cl', claudeSessionId: sessionId, worktreeDir: worktreeCwd });
+  setEpic(mainCwd, 'epic-cl', { status: 'completed' });
+
+  const cap = captureSpawn();
+  manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
+  expect(cap.count).toBe(1);
+  expect(cap.opts.cwd).toBe(worktreeCwd);
+  manager.kill(sessionId);
+  fs.rmSync(worktreeCwd, { recursive: true, force: true });
+});
+
+test('spawn() still refuses session_unreachable without any node-pty spawn', () => {
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-pty-unreachable-'));
+  const sessionId = 'epic-session-unreachable';
+  const deadDir = path.join(os.tmpdir(), 'sm-pty-unreachable-dead-worktree');
+  writeActiveIndexWithWorktree(mainCwd, { epicId: 'epic-u', claudeSessionId: sessionId, worktreeDir: deadDir });
+  setEpic(mainCwd, 'epic-u', { worktreeStatus: 'merged' });
+  // Transcript exists only under the dead worktree's encoded project dir.
+  const enc = deadDir.replace(/[^a-zA-Z0-9]/g, '-');
+  const tdir = path.join(tmpHome, '.claude', 'projects', enc);
+  fs.mkdirSync(tdir, { recursive: true });
+  fs.writeFileSync(path.join(tdir, `${sessionId}.jsonl`), '{"type":"user"}\n');
+
+  const cap = captureSpawn();
   const result = manager.spawn({ tabId: sessionId, cwd: mainCwd, cols: 80, rows: 24 });
-  expect(spawned).toBe(false);
+  expect(cap.count).toBe(0);
   expect(result.pid).toBeNull();
-  expect(result.error).toMatch(/closed/);
+  expect(result.error).toMatch(/cannot be resumed/);
 });

package/src/main/__tests__/scheduler-prd-persona-spawn.test.cjs

@@ -82,8 +82,10 @@ function writePersona(dir, name, frontmatterLines, bodyText) {
   fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
 }
 
-async function runJobWithAgentType({ agentType }) {
-  const mainCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-prd-persona-main-'));
+async function runJobWithAgentType({ agentType, overlay }) {
+  // Under tmpHome so config.validatePath's home-dir boundary admits the project overlay.
+  const mainCwd = fs.mkdtempSync(path.join(tmpHome, 'sm-prd-persona-main-'));
+  if (overlay) writePersona(path.join(mainCwd, '.claude', 'agents'), overlay.name, overlay.frontmatter, overlay.body || '');
   fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
   const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'sm-prd-persona-run-'));
   const slug = `1115-test-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
@@ -131,3 +133,46 @@ test('executeJob: a job with no agentType at all runs unaffected (no persona, so
   const modelIdx = argv.indexOf('--model');
   expect(argv[modelIdx + 1]).toBe('sonnet');
 });
+
+// ---------- persona effort → --effort ----------
+
+test('buildClaudeSpawnArgs: effort appends --effort <level>; null/inherit/absent add no token', () => {
+  const base = { prompt: 'x', model: 'sonnet', sessionId: 'sid', resume: false };
+  const args = buildClaudeSpawnArgs({ ...base, effort: 'high' });
+  expect(args[args.indexOf('--effort') + 1]).toBe('high');
+  expect(args.indexOf('--model')).toBeGreaterThanOrEqual(0);
+  for (const effort of [null, 'inherit', undefined]) {
+    expect(buildClaudeSpawnArgs({ ...base, effort })).not.toContain('--effort');
+  }
+});
+
+test('executeJob: persona effort reaches the child as --effort; inherit yields no --effort token', async () => {
+  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
+  writePersona(globalAgentsDir, 'effort-high', ['model: opus', 'effort: high'], 'body');
+  writePersona(globalAgentsDir, 'effort-inherit', ['model: opus', 'effort: inherit'], 'body');
+
+  const high = await runJobWithAgentType({ agentType: 'effort-high' });
+  expect(high.argv[high.argv.indexOf('--effort') + 1]).toBe('high');
+  expect(high.argv[high.argv.indexOf('--model') + 1]).toBe('opus');
+
+  const inherit = await runJobWithAgentType({ agentType: 'effort-inherit' });
+  expect(inherit.argv).not.toContain('--effort');
+  expect(inherit.argv).not.toContain('inherit');
+});
+
+// ---------- project overlay MERGE: frontmatter-only overlay patches the runtime fields ----------
+
+test('executeJob: a frontmatter-only project overlay changes --model/--effort while the global persona body still reaches --append-system-prompt', async () => {
+  const globalAgentsDir = path.join(tmpHome, '.claude', 'agents');
+  writePersona(globalAgentsDir, 'dev-lead', ['model: sonnet'], 'You are dev-lead. Global body.');
+
+  const { result, argv } = await runJobWithAgentType({
+    agentType: 'dev-lead',
+    overlay: { name: 'dev-lead', frontmatter: ['model: claude-opus-4-6', 'effort: high'], body: '' },
+  });
+
+  expect(result.exitCode).toBe(0);
+  expect(argv[argv.indexOf('--model') + 1]).toBe('claude-opus-4-6');
+  expect(argv[argv.indexOf('--effort') + 1]).toBe('high');
+  expect(argv[argv.indexOf('--append-system-prompt') + 1]).toBe('You are dev-lead. Global body.');
+});

package/src/main/agentLibrary.cjs

@@ -22,7 +22,7 @@ const fsSync = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
 const { splitFrontmatter } = require('./lib/prdFrontmatter.cjs');
-const { resolvePersonaPaths } = require('./lib/epicMint.cjs');
+const { resolveMergedPersona, PERSONA_NAME_RE } = require('./lib/personaMerge.cjs');
 const configMgr = require('./config.cjs');
 const sessionsStore = require('./sessionsStore.cjs');
 
@@ -32,9 +32,6 @@ function parseTools(raw) {
   return raw.split(',').map((t) => t.trim()).filter(Boolean);
 }
 
-/** Filename-safe persona name: lowercase, hyphenated, matches the `.md` files on disk. */
-const PERSONA_NAME_RE = /^[a-z][a-z0-9-]*$/;
-
 /** Sentinel `projects:` entry meaning "this agent's Action button shows in every project". */
 const ALL_PROJECTS = '*';
 
@@ -70,11 +67,12 @@ function decodeLine(s) {
  * overrides the button's caption (defaults to the persona name). Claude Code
  * ignores all three; only this app reads them.
  */
-function serializePersona({ name, description, tools, model, color, tags, projects, action, actionLabel, title, body }) {
+function serializePersona({ name, description, tools, model, effort, color, tags, projects, action, actionLabel, title, body }) {
   const lines = ['---', `name: ${name}`];
   if (description) lines.push(`description: ${description}`);
   if (tools && tools.length) lines.push(`tools: ${tools.join(', ')}`);
   if (model && model !== 'inherit') lines.push(`model: ${model}`);
+  if (effort && effort !== 'inherit') lines.push(`effort: ${effort}`);
   if (color) lines.push(`color: ${color}`);
   if (tags && tags.length) lines.push(`tags: ${tags.join(', ')}`);
   if (projects && projects.length) lines.push(`projects: ${projects.join(', ')}`);
@@ -85,10 +83,51 @@ function serializePersona({ name, description, tools, model, color, tags, projec
   return lines.join('\n') + (body || '').trim() + '\n';
 }
 
+/**
+ * Project OVERRIDE write: a frontmatter-only overlay at
+ * `<cwd>/.claude/agents/<name>.md` carrying ONLY the overridden `model` /
+ * `effort` keys and no body (lib/personaMerge.cjs inherits everything else
+ * from the global persona). Keys already in an existing frontmatter-only
+ * overlay are preserved; an existing overlay that has a BODY is refused so a
+ * full-body overlay is never silently converted. Both keys unset removes the
+ * file (same as `removeOverride`) rather than leaving an empty overlay.
+ */
+async function saveOverlay({ name, projectName, model, effort, loadSessions, validatePath, writeTextAtomic }) {
+  const projects = await openProjects({ loadSessions });
+  const project = projects.find((p) => p.name === projectName);
+  if (!project) throw new Error(`project not open: ${projectName}`);
+  const target = validatePath(path.join(project.cwd, '.claude', 'agents', `${name}.md`));
+  let fm = {};
+  try {
+    const existing = splitFrontmatter(await fsp.readFile(target, 'utf8'));
+    if (existing.body.trim() !== '') {
+      throw new Error(`${name} has a full-body override in ${projectName} — edit ${target} directly; it is not converted to a frontmatter-only override`);
+    }
+    fm = existing.fm;
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  const next = { ...fm };
+  for (const [k, v] of [['model', model], ['effort', effort]]) {
+    if (v && v !== 'inherit') next[k] = v;
+    else delete next[k];
+  }
+  if (Object.keys(next).length === 0) {
+    await removeOverride({ name, projectName, loadSessions, validatePath });
+    return { ok: true, path: target, removed: true };
+  }
+  const lines = ['---', ...Object.entries(next).map(([k, v]) => `${k}: ${v}`), '---', ''];
+  await writeTextAtomic(target, lines.join('\n'));
+  return { ok: true, path: target };
+}
+
 /**
  * Writes a global persona `.md` file — `~/.claude/agents/<name>.md`. Pass
  * `originalName` when renaming an existing persona so the old file is
- * removed once the new one is written (no-op if names match).
+ * removed once the new one is written (no-op if names match). Pass
+ * `projectName` (an open project) to instead write that project's
+ * frontmatter-only OVERRIDE of the persona — see saveOverlay; only `model` and
+ * `effort` are read in that mode.
  */
 async function savePersona({
   name,
@@ -96,6 +135,7 @@ async function savePersona({
   description,
   tools,
   model,
+  effort,
   color,
   tags,
   projects,
@@ -103,15 +143,20 @@ async function savePersona({
   actionLabel,
   title,
   body,
+  projectName,
   globalDir = path.join(os.homedir(), '.claude', 'agents'),
+  loadSessions = sessionsStore.load,
   validatePath = configMgr.validatePath,
   writeTextAtomic = configMgr.writeTextAtomic,
 } = {}) {
   if (!PERSONA_NAME_RE.test(name || '')) {
     throw new Error('agent name must be lowercase, hyphenated (e.g. "my-agent")');
   }
+  if (projectName) {
+    return saveOverlay({ name, projectName, model, effort, loadSessions, validatePath, writeTextAtomic });
+  }
   const target = validatePath(path.join(globalDir, `${name}.md`));
-  const text = serializePersona({ name, description, tools, model, color, tags, projects, action, actionLabel, title, body });
+  const text = serializePersona({ name, description, tools, model, effort, color, tags, projects, action, actionLabel, title, body });
   await writeTextAtomic(target, text);
   if (originalName && originalName !== name) {
     const oldReal = validatePath(path.join(globalDir, `${originalName}.md`));
@@ -220,6 +265,9 @@ async function listPersonas({
     const { fm, body } = splitFrontmatter(text);
 
     const overridingProjects = [];
+    // Per-project merged view: which frontmatter fields (and whether the body)
+    // the overlay actually overrides — from the shared merge, not a boolean.
+    const overrideDetails = [];
     for (const p of projects) {
       let overlayReal;
       try {
@@ -227,7 +275,18 @@ async function listPersonas({
       } catch {
         continue; // project cwd outside allowed roots — skip rather than throw
       }
-      if (fsSync.existsSync(overlayReal)) overridingProjects.push(p.name);
+      if (!fsSync.existsSync(overlayReal)) continue;
+      overridingProjects.push(p.name);
+      const merged = resolveMergedPersona(p.cwd, path.basename(file, '.md'), { validatePath, globalDir });
+      const fields = merged ? Object.keys(merged.provenance).filter((k) => merged.provenance[k] === 'overlay') : [];
+      overrideDetails.push({
+        project: p.name,
+        fields,
+        // The project's value for each overridden key (the UI renders global → project).
+        values: merged ? Object.fromEntries(fields.map((k) => [k, merged.fm[k]])) : {},
+        bodyOverridden: merged ? merged.bodySource === 'overlay' : false,
+        issue: merged ? merged.overlayIssue : null,
+      });
     }
 
     personas.push({
@@ -235,6 +294,7 @@ async function listPersonas({
       description: fm.description || null,
       tools: parseTools(fm.tools),
       model: fm.model || null,
+      effort: fm.effort || null,
       color: fm.color || null,
       tags: parseTools(fm.tags),
       projects: parseTools(fm.projects),
@@ -244,6 +304,7 @@ async function listPersonas({
       path: real,
       body: body.trim(),
       overridingProjects,
+      overrideDetails,
     });
   }
 
@@ -251,44 +312,29 @@ async function listPersonas({
 }
 
 /**
- * Reads a persona `.md` file's raw text for `epicIntake.ts`'s `agentBody`
- * input, honoring the same project-overlay-then-global precedence as
- * `epicMint.cjs`'s `resolvePersonaPaths` (a project's `<cwd>/.claude/agents/
- * <name>.md` wins over `~/.claude/agents/<name>.md`) — the same precedence
- * `listPersonas` deliberately does NOT apply, since that lists only the
- * global directory for the Agent Library nav page. Returns `null` when
- * neither location has the file; frontmatter stripping and the 6000-char cap
- * are epicIntake.ts's job, not this reader's.
+ * Reads a persona for `epicIntake.ts`'s `agentBody` input and the PRD spawn
+ * path, through the shared overlay-over-global MERGE (lib/personaMerge.cjs —
+ * see its header for the rules). Returns `{ path, text, fm, body, fromOverlay,
+ * bodySource, provenance, overlayIssue }` where `fm`/`body` are the MERGED
+ * view, `provenance[key]` says which frontmatter keys came from the overlay,
+ * and `text` is the body-source file's raw text (byte-identical to the
+ * pre-merge result for a full-body overlay) or a re-serialized merge for a
+ * frontmatter-only overlay. `listPersonas` deliberately does NOT apply this —
+ * it lists the global directory for the Agent Library nav page. Returns `null`
+ * when neither location has the file; frontmatter stripping and the 6000-char
+ * cap are epicIntake.ts's / agentModelResolve.cjs's job, not this reader's.
+ * (Sync fs inside an async signature: the merge module is shared with the
+ * synchronous model resolver.)
  */
 async function getPersonaBody({
   cwd,
   name,
   validatePath = configMgr.validatePath,
+  ...deps
 } = {}) {
-  // Same gate savePersona/deletePersona apply before touching a path built
-  // from `name` (agentLibrary.cjs's PERSONA_NAME_RE check) — without it a
-  // `name` like "../../other-project/CLAUDE" survives resolvePersonaPaths'
-  // plain path.join and validatePath's allowed-roots check (which only
-  // confirms the resolved path stays under the home dir / an opened
-  // project), letting any readable .md under those roots be read and
-  // forwarded into the Epic's opening prompt.
-  if (!PERSONA_NAME_RE.test(name || '')) return null;
-  const { projectPath, globalPath } = resolvePersonaPaths(cwd, name);
-  for (const candidate of [projectPath, globalPath]) {
-    let real;
-    try {
-      real = validatePath(candidate);
-    } catch {
-      continue;
-    }
-    try {
-      const text = await fsp.readFile(real, 'utf8');
-      return { path: real, text };
-    } catch {
-      continue;
-    }
-  }
-  return null;
+  // PERSONA_NAME_RE is enforced inside resolveMergedPersona (the traversal
+  // guard for "../../other-project/CLAUDE"-style names).
+  return resolveMergedPersona(cwd, name, { ...deps, validatePath });
 }
 
 module.exports = {

package/src/main/build-info.json

@@ -1,8 +1,8 @@
 {
-  "version": "0.92.0",
-  "gitSha": "d0e160e50a2560620e956e6d819cb405b0423110",
-  "gitShortSha": "d0e160e",
+  "version": "0.93.0",
+  "gitSha": "78fa526eb94e044b2c72c736681e956bee653451",
+  "gitShortSha": "78fa526",
   "gitBranch": "HEAD",
-  "builtAt": "2026-09-20T21:26:16.666Z",
+  "builtAt": "2026-09-21T03:09:24.532Z",
   "dirty": false
 }

package/src/main/chatRunner.cjs

@@ -53,6 +53,7 @@ const { classifyPromptTicket } = require('./lib/classifyPromptTicket.cjs');
 const sessionSlots = require('./lib/sessionSlots.cjs');
 const opsErrorLog = require('./lib/opsErrorLog.cjs');
 const agentModelResolve = require('./lib/agentModelResolve.cjs');
+const { resolveEpicEffort, effortArgs } = require('./lib/agentEffortResolve.cjs');
 const { planEpicSpawn } = require('./lib/epicSpawnPlan.cjs');
 const logs = require('./logs.cjs');
 
@@ -546,6 +547,9 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
     // Epic, no agentType, or the persona has no model/'inherit' — --model
     // must never be left unpinned (CLAUDE.md model-pinning rule).
     const model = agentModelResolve.resolveEpicModel({ cwd, claudeSessionId: sessionId });
+    // Persona `effort:` (same overlay-aware persona, agentEffortResolve.cjs);
+    // effortArgs() yields NO tokens for inherit/absent/dangling.
+    const effortFlags = effortArgs(resolveEpicEffort({ cwd, claudeSessionId: sessionId }).effort);
 
     // Main is authoritative about --resume vs --session-id AND the spawn cwd, and it decides
     // them TOGETHER (epicSpawnPlan.cjs): a transcript under an encoding the spawn cwd cannot see
@@ -579,6 +583,7 @@ function executeRun({ tabId, sessionId, prompt, cwd, resume, silent, onSilentRes
       const a = [
         '-p', fullPrompt,
         '--model', model,
+        ...effortFlags,
         '--dangerously-skip-permissions',
         '--output-format', 'stream-json',
         '--verbose',

package/src/main/index.cjs

@@ -43,7 +43,9 @@ const epicWorktreeMerge = require('./lib/epicWorktreeMerge.cjs');
 const epicWorktreeProjectConfig = require('./lib/epicWorktreeProjectConfig.cjs');
 const agentLibrary = require('./agentLibrary.cjs');
 const agentModelResolve = require('./lib/agentModelResolve.cjs');
+const agentEffortResolve = require('./lib/agentEffortResolve.cjs');
 const { resolveEffectiveModelInfo } = require('./lib/effectiveModelInfo.cjs');
+const { resolveModelCatalog } = require('./lib/modelCatalog.cjs');
 const { checkDelegationReadiness, ensureGuardsInstalled, installPrdWriteGuard, installDestructiveGitGuard, installInlineImplementationGuard, installSelfScheduleGuard } = require('./lib/delegationReadiness.cjs');
 const { resolveProjectContext } = require('./lib/projectRootResolve.cjs');
 const upgradeDrain = require('./lib/upgradeDrain.cjs');
@@ -565,6 +567,10 @@ ipcMain.handle('agents:get-persona-body', validated(schemas.agentsGetPersonaBody
 // is merely supposed to. Never throws (resolveEpicModel's own contract).
 ipcMain.handle('agents:resolve-epic-model', validated(schemas.agentsResolveEpicModel, (payload) =>
   agentModelResolve.resolveEpicModel(payload)));
+// Effort twin of the above (agentEffortResolve.cjs): Terminal appends
+// `--effort <level>` only when `effort` is non-null. Never throws.
+ipcMain.handle('agents:resolve-epic-effort', validated(schemas.agentsResolveEpicEffort, (payload) =>
+  agentEffortResolve.resolveEpicEffort(payload)));
 
 // "What will this Epic actually run as?" (PRD: effective-model-resolver) —
 // persona alias + evidence-based concrete model id + provenance, for a given
@@ -572,6 +578,10 @@ ipcMain.handle('agents:resolve-epic-model', validated(schemas.agentsResolveEpicM
 ipcMain.handle('agents:resolve-model-info', validated(schemas.agentsResolveModelInfo, (payload) =>
   resolveEffectiveModelInfo(payload)));
 
+// Live model/effort catalog (modelCatalog.cjs) — never throws; `force` bypasses its cache.
+ipcMain.handle('models:catalog', validated(schemas.modelsCatalog, (payload) =>
+  resolveModelCatalog(payload)));
+
 // "Can this project actually delegate?" probe (PRD: delegation-readiness).
 // Structured data over the preconditions for scheduler_create_prd being in an
 // agent's tool list at all — surfacing it in the UI is a sibling PRD.

package/src/main/ipcSchemas.cjs

@@ -198,6 +198,9 @@ const promptSessionsCreateEpic = z.object({
   goalText: z.string().min(1).max(20000),
   tag: EpicTagSchema.optional(),
   agentType: z.string().min(1).max(256).optional(),
+  // Per-Epic runtime overrides (New Session card) — absent = use the persona's own value.
+  model: z.string().min(1).max(256).optional(),
+  effort: z.string().min(1).max(64).optional(),
   source: EpicSourceSchema.optional(),
   // The full first-prompt body + its labeled sections (epicIntake.ts's
   // composeEpicIntake) — both optional, since not every mint caller (e.g. a
@@ -661,6 +664,12 @@ const agentsResolveModelInfo = z.object({
   agentType: z.string().min(1).max(200),
 }).strict();
 
+// ──────────────────────────────────────────── Live model/effort catalog (modelCatalog.cjs)
+const modelsCatalog = z.object({
+  cwd: z.string().optional(),
+  force: z.boolean().optional(),
+}).strict();
+
 // ──────────────────────────────────────────── Epic launch model (PRD: unify-epic-model-resolution)
 // Terminal's (EpicTerminalPane.tsx) call into agentModelResolve.cjs's
 // resolveEpicModel — the same launch-model authority chatRunner.cjs's Chat
@@ -669,6 +678,7 @@ const agentsResolveEpicModel = z.object({
   cwd: z.string().min(1).max(4096),
   claudeSessionId: z.string().min(1).max(200),
 }).strict();
+const agentsResolveEpicEffort = agentsResolveEpicModel;
 
 // ──────────────────────────────────────────── Project Pages (PRD 932)
 // Same validation split as projectBriefCwd above: real path validation is
@@ -1146,7 +1156,9 @@ module.exports = {
     agentsSavePersona,
     agentsGetPersonaBody,
     agentsResolveModelInfo,
+    modelsCatalog,
     agentsResolveEpicModel,
+    agentsResolveEpicEffort,
     delegationReadinessCwd,
     telemetrySetConfig,
   },