claude-code-session-manager 0.57.0 → 0.58.0

package/scripts/lib/watchdogHelpers.cjs

@@ -7,10 +7,6 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 
-const { activeProjectCwds } = require('./activeSessions.cjs');
-const { resolvePrdWriteDir, listEpicPrdDirs } = require('../../src/main/lib/prdLocations.cjs');
-const { ensureEpic, appendPrdCreatedEvent } = require('../../src/main/lib/epicMint.cjs');
-const { projectQueuePath } = require('../../src/main/lib/queueStore.cjs');
 
 // Mirrors scheduler.cjs:215 (single source of truth there; kept in sync here).
 const DEFAULT_HEARTBEAT_PATH = path.join(
@@ -100,89 +96,6 @@ function heartbeatFresh(heartbeatPath = DEFAULT_HEARTBEAT_PATH, maxAgeMs = DEFAU
   return (Date.now() - ts) < maxAgeMs;
 }
 
-// Default paths — callers can override via opts for testing.
-const DEFAULT_QUEUE_PATH = path.join(
-  os.homedir(), '.claude', 'session-manager', 'scheduled-plans', 'queue.json',
-);
-const PLUGIN_CACHE_ROOT = path.join(
-  os.homedir(), '.claude', 'plugins', 'cache', 'session-manager', 'session-manager-dev',
-);
-
-/**
- * compareVersionsDesc(a, b) → number
- *
- * Numeric per-segment version compare (descending) for plugin-cache version
- * dirs like "0.1.0" / "0.2.0" / "0.10.0". Plain lexicographic sort is wrong
- * here — "0.10.0" < "0.2.0" as strings even though 10 > 2 numerically. Falls
- * back to a string compare for any non-numeric segment (e.g. a stray dir name
- * that isn't a version) so listSkillCandidates never throws on garbage input.
- */
-function compareVersionsDesc(a, b) {
-  const as = a.split('.');
-  const bs = b.split('.');
-  const len = Math.max(as.length, bs.length);
-  for (let i = 0; i < len; i++) {
-    const an = Number(as[i]);
-    const bn = Number(bs[i]);
-    if (Number.isFinite(an) && Number.isFinite(bn)) {
-      if (an !== bn) return bn - an;
-    } else if (as[i] !== bs[i]) {
-      return (as[i] ?? '') < (bs[i] ?? '') ? 1 : -1;
-    }
-  }
-  return 0;
-}
-
-/**
- * listSkillCandidates(cwd, skillName, fileName, pluginCacheRoot?) → string[]
- *
- * Ordered candidate paths for an inlined skill/standards file, most-specific
- * first — the process-feedback SKILL.md and develop standards.md moved out of
- * the legacy ~/.claude/skills/ location into the session-manager-dev plugin:
- *
- *   1. <cwd>/plugins/session-manager-dev/skills/<skillName>/<fileName>  — repo-local
- *      copy, correct when the swept project vendors the plugin (e.g. session-manager itself).
- *   2. <pluginCacheRoot>/<newest-version>/skills/<skillName>/<fileName> — the installed
- *      plugin cache (default ~/.claude/plugins/cache/session-manager/session-manager-dev).
- *      Enumerates every version dir present, newest (lexicographically-highest) first.
- *   3. ~/.claude/skills/<skillName>/<fileName> — legacy location, kept last so an
- *      old install still works.
- *
- * pluginCacheRoot is overridable for tests; defaults to the real plugin cache.
- */
-function listSkillCandidates(cwd, skillName, fileName, pluginCacheRoot = PLUGIN_CACHE_ROOT) {
-  const candidates = [
-    path.join(cwd, 'plugins', 'session-manager-dev', 'skills', skillName, fileName),
-  ];
-
-  let entries = [];
-  try {
-    entries = fs.readdirSync(pluginCacheRoot, { withFileTypes: true });
-  } catch { /* plugin cache not installed */ }
-  const versions = entries.filter((e) => e.isDirectory()).map((e) => e.name).sort(compareVersionsDesc);
-  for (const version of versions) {
-    candidates.push(path.join(pluginCacheRoot, version, 'skills', skillName, fileName));
-  }
-
-  candidates.push(path.join(os.homedir(), '.claude', 'skills', skillName, fileName));
-  return candidates;
-}
-
-/**
- * resolveSkillFile(cwd, skillName, fileName, pluginCacheRoot?) → string | null
- *
- * Returns the first candidate from listSkillCandidates() that is a readable
- * file, or null if none resolve.
- */
-function resolveSkillFile(cwd, skillName, fileName, pluginCacheRoot = PLUGIN_CACHE_ROOT) {
-  for (const candidate of listSkillCandidates(cwd, skillName, fileName, pluginCacheRoot)) {
-    try {
-      if (fs.statSync(candidate).isFile()) return candidate;
-    } catch { /* try next candidate */ }
-  }
-  return null;
-}
-
 /**
  * isPidAlive(pid) → boolean
  *
@@ -212,286 +125,6 @@ function isPidAlive(pid) {
 // relaunch means the app is never down long enough to need an external
 // reconciler — the in-app scheduler is queue.json's single owner again.
 
-// ── slugify ──────────────────────────────────────────────────────────────────
-
-/** Lowercase, non-alphanumeric runs → single `-`, strip leading/trailing `-`. */
-function slugify(name) {
-  return name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
-}
-
-// ── YAML frontmatter stripper ─────────────────────────────────────────────────
-
-/**
- * Strip leading YAML frontmatter block (---\n…\n---) from skill/standards files
- * so they can be inlined cleanly into a PRD body.
- */
-function stripFrontmatter(content) {
-  if (!content.startsWith('---')) return content;
-  const end = content.indexOf('\n---', 3);
-  if (end === -1) return content;
-  return content.slice(end + 4).replace(/^\n/, '');
-}
-
-/**
- * Strip a leading H1 line (`# …\n`) — used to drop the `# Engineering standards`
- * heading from standards.md before adding our own `## Engineering standards` heading.
- */
-function stripLeadingH1(content) {
-  return content.replace(/^# [^\n]*\n/, '');
-}
-
-// ── hasOpenFeedback ───────────────────────────────────────────────────────────
-
-/**
- * hasOpenFeedback(cwd) → boolean
- *
- * Returns true iff `<cwd>/session-manager-operations/feedback/` (the PRD-462
- * convention) or, as a transitional fallback for repos not yet relocated,
- * the legacy `<cwd>/feedback/` exists AND contains at least one *.md file
- * directly in its root (i.e. NOT inside `processed/` or any subdirectory).
- * Pure filesystem check — no LLM call.
- *
- * Mirrors process-feedback skill step 0 (cheap quick-exit signal).
- * Complexity: O(F) where F ≤ entries in the feedback folder root.
- */
-function hasOpenFeedback(cwd) {
-  for (const folderName of [path.join('session-manager-operations', 'feedback'), 'feedback']) {
-    const folderPath = path.join(cwd, folderName);
-    let entries;
-    try {
-      entries = fs.readdirSync(folderPath);
-    } catch {
-      continue; // folder does not exist
-    }
-    for (const entry of entries) {
-      if (!entry.endsWith('.md')) continue;
-      // README.md is the folder's convention doc, not an open feedback item —
-      // counting it makes a folder with only a README look perpetually "pending".
-      if (entry.toLowerCase() === 'readme.md') continue;
-      try {
-        const st = fs.statSync(path.join(folderPath, entry));
-        if (st.isFile()) return true;
-      } catch { continue; }
-    }
-  }
-  return false;
-}
-
-// ── emitFeedbackPRD ──────────────────────────────────────────────────────────
-
-/**
- * emitFeedbackPRD(cwd, opts?) → { emitted: boolean, slug?: string, prdPath?: string, reason?: string }
- *
- * De-dups against queue.json (pending/running jobs whose slug matches
- * `^\d+-feedback-<project>$`). If a match exists, returns { emitted: false, reason: 'duplicate' }.
- *
- * Otherwise picks the next free NN by scanning prdsDir, writes a self-contained
- * PRD file with the inlined process-feedback procedure + engineering standards,
- * and returns { emitted: true, slug, prdPath }.
- *
- * Never writes to queue.json — the app's reconcile picks up new PRD files.
- * Atomic write: tmp → rename (mirrors config.cjs writeJsonSync pattern).
- *
- * Complexity: O(P) over PRD files in prdsDir + O(J) over queue jobs.
- */
-async function emitFeedbackPRD(cwd, {
-  prdsDir,
-  queuePath,
-  skillPath,
-  standardsPath,
-  pluginCacheRoot = PLUGIN_CACHE_ROOT,
-} = {}) {
-  // Explicit overrides (used by tests) are honored verbatim and skip the
-  // candidate search entirely — only resolve via candidates when the caller
-  // didn't pass a path. Same convention for prdsDir: an explicit override
-  // (tests pass a tmpdir) wins verbatim; otherwise resolve the project's own
-  // PRD dir so the sweep writer agrees with scheduler.cjs's reader (see
-  // prdLocations.cjs — PRD chain 808→811 moved PRD sources out of the legacy
-  // global dir into `<cwd>/session-manager-operations/scheduler/prds`).
-  let epicId = null;
-  if (prdsDir === undefined) {
-    // Every PRD belongs to an Epic (CLAUDE.md domain model). The sweep joins
-    // one standing "Inbound feedback" Epic per project (reuseByGoal) so
-    // recurring ticks chain into a single Epic rather than minting one each.
-    // This is an unattended automated sweep, not a human action — status
-    // MUST be 'proposed' (same as lib/rcaFeedbackHook.cjs) so the Epic lands
-    // behind the Approve & start human gate instead of running immediately;
-    // an 'active' default here would let an unattended process mint and
-    // execute PRDs with zero human approval, exactly the hole the 'proposed'
-    // gate exists to close.
-    const epic = await ensureEpic(cwd, {
-      goalText: 'Inbound feedback processing',
-      tag: 'discussion',
-      status: 'proposed',
-      reuseByGoal: true,
-      source: { producer: 'feedback-sweep' },
-    });
-    epicId = epic.epicId;
-    prdsDir = epic.prdDir;
-  }
-  const skillPathExplicit = skillPath !== undefined;
-  const standardsPathExplicit = standardsPath !== undefined;
-  if (!skillPathExplicit) {
-    skillPath = resolveSkillFile(cwd, 'process-feedback', 'SKILL.md', pluginCacheRoot);
-  }
-  if (!standardsPathExplicit) {
-    standardsPath = resolveSkillFile(cwd, 'develop', 'standards.md', pluginCacheRoot);
-  }
-  const project = slugify(path.basename(cwd));
-
-  // De-dup: check the queue for a pending/running feedback job for this
-  // project. Federated state (2026-07-31): the project's own shard is the
-  // system of record; the legacy global path is still consulted as a fallback
-  // during transition. An explicit queuePath override (tests) wins verbatim.
-  const queuePaths = queuePath !== undefined
-    ? [queuePath]
-    : [projectQueuePath(cwd), DEFAULT_QUEUE_PATH];
-  const queueState = { jobs: [] };
-  for (const qp of queuePaths) {
-    try {
-      const parsed = JSON.parse(fs.readFileSync(qp, 'utf8'));
-      queueState.jobs.push(...(Array.isArray(parsed.jobs) ? parsed.jobs : []));
-    } catch { /* file may not exist */ }
-  }
-
-  // project only contains [a-z0-9-] after slugify — no regex metachar escaping needed.
-  const dupRe = new RegExp(`^\\d+-feedback-${project}$`);
-  const isDuplicate = (queueState.jobs ?? []).some(
-    (j) => (j.status === 'pending' || j.status === 'running') && dupRe.test(j.slug),
-  );
-  if (isDuplicate) {
-    return { emitted: false, reason: 'duplicate' };
-  }
-
-  // Pick next NN: max existing NN prefix + 1. O(P) scan.
-  // We ALSO dedup against the prds dir here: while the app is down it never
-  // ingests new PRD files into queue.json, so the queue check above can't see a
-  // feedback PRD we already wrote on a previous tick. Without this, every stale
-  // watchdog tick emits a fresh NN-feedback-<project>.md, unbounded.
-  const prdDupRe = new RegExp(`^\\d+-feedback-${project}\\.md$`);
-  let maxNN = 0;
-  // NN numbering and the on-disk dedup are project-global, so scan every PRD
-  // location the project has: the write dir, the legacy flat dir, and every
-  // Epic's prds/ dir. (An explicit prdsDir override — tests — scans only it.)
-  const scanDirs = new Set([prdsDir]);
-  if (epicId !== null) {
-    try { scanDirs.add(resolvePrdWriteDir(cwd)); } catch { /* unusable cwd */ }
-    for (const d of listEpicPrdDirs(cwd)) scanDirs.add(d);
-  }
-  for (const dir of scanDirs) {
-    let prdFiles = [];
-    try {
-      prdFiles = fs.readdirSync(dir);
-    } catch { continue; /* dir may not exist yet */ }
-    for (const f of prdFiles) {
-      if (prdDupRe.test(f)) {
-        return { emitted: false, reason: 'duplicate' };
-      }
-      const m = f.match(/^(\d+)-/);
-      if (m) {
-        const n = parseInt(m[1], 10);
-        if (n > maxNN) maxNN = n;
-      }
-    }
-  }
-  const nn = String(maxNN + 1).padStart(2, '0');
-  const slug = `${nn}-feedback-${project}`;
-  const prdPath = path.join(prdsDir, `${slug}.md`);
-
-  // Read and inline skill content.
-  let rawSkill = '';
-  if (skillPath) {
-    try {
-      rawSkill = fs.readFileSync(skillPath, 'utf8');
-    } catch { /* handled by the empty-body guard below */ }
-  }
-  const skillBody = stripFrontmatter(rawSkill).trim();
-
-  // Read and inline standards — strip H1 so our ## heading is the section anchor.
-  let rawStandards = '';
-  if (standardsPath) {
-    try {
-      rawStandards = fs.readFileSync(standardsPath, 'utf8');
-    } catch { /* handled by the empty-body guard below */ }
-  }
-  const standardsBody = stripLeadingH1(stripFrontmatter(rawStandards)).trim();
-
-  // Hard-fail rather than silently ship a hollow PRD: if either inline is
-  // empty/unreadable, refuse to write anything and name every candidate tried
-  // so a future relocation shows up loudly in the watchdog log instead of
-  // queueing a template with no procedure and no standards in it.
-  if (!skillBody || !standardsBody) {
-    const missing = [];
-    if (!skillBody) {
-      const tried = skillPathExplicit ? [skillPath] : listSkillCandidates(cwd, 'process-feedback', 'SKILL.md', pluginCacheRoot);
-      missing.push(`process-feedback SKILL.md (tried: ${tried.join(', ')})`);
-    }
-    if (!standardsBody) {
-      const tried = standardsPathExplicit ? [standardsPath] : listSkillCandidates(cwd, 'develop', 'standards.md', pluginCacheRoot);
-      missing.push(`develop standards.md (tried: ${tried.join(', ')})`);
-    }
-    process.stderr.write(`[emitFeedbackPRD] refusing to emit for ${cwd}: missing inline(s) — ${missing.join('; ')}\n`);
-    return { emitted: false, reason: 'missing-inline' };
-  }
-
-  const projectName = path.basename(cwd);
-  const body = [
-    '---',
-    `title: Process feedback for ${projectName}`,
-    `cwd: ${cwd}`,
-    'estimateMinutes: 15',
-    '---',
-    '',
-    '# Goal',
-    '',
-    `Process the inbound feedback folder for ${projectName}. The quick-exit (step 0 below)`,
-    'means this run bails in milliseconds if no open items exist — safe to execute even if',
-    'feedback was already cleared between scheduling and execution.',
-    '',
-    '# Acceptance criteria',
-    '',
-    '- [ ] All open feedback items evaluated and either queued via /develop, declined with RESOLUTION, or forwarded upstream.',
-    '- [ ] Processed items archived to session-manager-operations/feedback/processed/ (or, for repos not yet relocated, legacy feedback/processed/) with RESOLUTION notes.',
-    '- [ ] session-manager-operations/feedback/README.md (or legacy feedback/README.md) self-improved with lessons from this pass.',
-    '- [ ] timeout 60 git diff --exit-code runs clean (no uncommitted inline work).',
-    '',
-    '# Implementation notes',
-    '',
-    'Follow the inlined process-feedback procedure below exactly. No skills are loaded in',
-    'headless execution — the procedure is fully self-contained. Use /develop for any work',
-    'that belongs to this project; never implement feedback inline.',
-    '',
-    '# Out of scope',
-    '',
-    '- Implementing feedback items directly (that is /develop → scheduler).',
-    '- Cross-project feedback beyond filing upstream items.',
-    '',
-    skillBody,
-    '',
-    '## Engineering standards',
-    '',
-    standardsBody,
-  ].join('\n');
-
-  // Atomic write: tmp-<pid>-<ts> → rename (mirrors config.cjs writeJsonSync).
-  const tmpPath = `${prdPath}.tmp-${process.pid}-${Date.now()}`;
-  try {
-    fs.mkdirSync(prdsDir, { recursive: true });
-    fs.writeFileSync(tmpPath, body + '\n', 'utf8');
-    fs.renameSync(tmpPath, prdPath);
-    if (epicId !== null) {
-      // Trace the dispatch on the Epic's event chain (prompt → prd_created →
-      // ...) so the Epic conversation shows the PRD it spawned.
-      try { await appendPrdCreatedEvent(cwd, epicId, slug, `Feedback sweep emitted ${slug}`); } catch { /* trace is best-effort */ }
-    }
-  } catch (e) {
-    try { fs.unlinkSync(tmpPath); } catch { /* best-effort cleanup */ }
-    throw e;
-  }
-
-  return { emitted: true, slug, prdPath };
-}
-
 // ── app liveness + auto-relaunch ─────────────────────────────────────────────
 //
 // The watchdog's one supervision job: is session-manager itself running, and
@@ -644,68 +277,6 @@ function maybeRelaunchApp({
   return { relaunched: true, reason: 'launched', attemptCount };
 }
 
-// ── sweep ─────────────────────────────────────────────────────────────────────
-
-/**
- * sweep(opts?) → { scanned: number, emitted: number, skipped: number }
- *
- * For each active-session cwd (from activeProjectCwds), cheaply checks for open
- * feedback. Projects without open feedback cost a readdir per folder name — no LLM.
- * Projects with open feedback get a PRD emitted into prdsDir (de-duped against queue).
- *
- * Never mutates queue.json — only adds PRD files, so it is safe to run while the
- * in-app scheduler is alive.
- *
- * Complexity: O(C × F) where C = active cwds (≤50) and F = root entries per
- * feedback folder (typically small).
- *
- * opts:
- *   projectsDir  — forwarded to activeProjectCwds for testing
- *   prdsDir, queuePath, skillPath, standardsPath — forwarded to emitFeedbackPRD
- */
-async function sweep({
-  projectsDir,
-  prdsDir,
-  queuePath,
-  skillPath,
-  standardsPath,
-} = {}) {
-  const activeOpts = {};
-  if (projectsDir !== undefined) activeOpts.projectsDir = projectsDir;
-
-  const cwds = activeProjectCwds(90, activeOpts);
-
-  let scanned = 0;
-  let emitted = 0;
-  let skipped = 0;
-
-  for (const cwd of cwds) {
-    scanned++;
-    if (!hasOpenFeedback(cwd)) continue;
-
-    // prdsDir unset → emitFeedbackPRD resolves per-cwd (project's own PRD
-    // dir); an explicit override (tests) is forwarded verbatim to every cwd.
-    let result;
-    try {
-      result = await emitFeedbackPRD(cwd, { prdsDir, queuePath, skillPath, standardsPath });
-    } catch (e) {
-      process.stderr.write(`[sweep] error emitting PRD for ${cwd}: ${e?.message}\n`);
-      continue;
-    }
-
-    if (result.emitted) {
-      emitted++;
-      process.stderr.write(`[sweep] emitted ${result.slug} for ${cwd}\n`);
-    } else {
-      skipped++;
-      process.stderr.write(`[sweep] skipped ${cwd} (${result.reason})\n`);
-    }
-  }
-
-  process.stderr.write(`[sweep] scanned=${scanned} emitted=${emitted} skipped=${skipped}\n`);
-  return { scanned, emitted, skipped };
-}
-
 // ── maybeFinalizeHistory ─────────────────────────────────────────────────────
 //
 // Precomputes closed History-dashboard days outside Electron, so the app's
@@ -853,11 +424,6 @@ module.exports = {
   readLastHeartbeatTs,
   heartbeatFresh,
   isPidAlive,
-  hasOpenFeedback,
-  resolveSkillFile,
-  listSkillCandidates,
-  emitFeedbackPRD,
-  sweep,
   localDateStr,
   maybeFinalizeHistory,
   tryAcquireLock,

package/scripts/mint-epic.cjs

@@ -5,11 +5,11 @@
  * manual-write fallback).
  *
  * This script never creates an Epic. It only resolves an EXISTING Epic's
- * prds/ write directory. An Epic may only come into existence through
- * explicit human intent — the New Epic UI, or /propose-epic followed by a
- * human pressing Approve & start — never implicitly from a PRD-authoring
- * path. /develop must already be running inside that Epic's own
- * conversation (or have the approved Epic's id in hand) before it calls this.
+ * prds/ write directory. An Epic comes into existence in exactly one place —
+ * the human pressing New Epic in the app (epicMint.cjs's SINGLE-CREATOR LAW)
+ * — never implicitly from a PRD-authoring path. /develop must already be
+ * running inside that Epic's own conversation (or have its id in hand)
+ * before it calls this.
  *
  * Usage:
  *   node scripts/mint-epic.cjs <cwd> <epic-id>
@@ -31,7 +31,7 @@ if (!cwd || !epicId) {
 
 (async () => {
   try {
-    const { prdDir } = await ensureEpic(cwd, { epicId, mintIfMissing: false });
+    const { prdDir } = await ensureEpic(cwd, { epicId });
     process.stderr.write(`joined epic ${epicId}\n`);
     process.stdout.write(`${prdDir}\n`);
   } catch (e) {

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

@@ -21,7 +21,7 @@ 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 } = require('../lib/epicMint.cjs');
+const { ensureEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
 const { appendResponseEventIfKnown } = require('../promptSessionEvents.cjs');
 const config = require('../config.cjs');
 
@@ -199,7 +199,7 @@ test('mint-during-persist: an ensureEpic mint interleaved with a merge call surv
   await mergeActiveIndex(cwd, { sessions: { [existing.id]: existing }, events: {} });
 
   const [mintResult] = await Promise.all([
-    ensureEpic(cwd, { goalText: 'minted during a concurrent merge' }),
+    ensureEpic(cwd, { goalText: 'minted during a concurrent merge', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI }),
     mergeActiveIndex(cwd, { sessions: { [existing.id]: existing }, events: {} }),
   ]);
 

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

@@ -0,0 +1,119 @@
+/**
+ * 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,
+  readPersonaModel,
+} = 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('readPersonaModel returns null for a persona with no model field', async () => {
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
+  writePersona(globalDir, 'no-model-persona', []);
+  expect(readPersonaModel('no-model-persona', { globalDir, validatePath: noopValidatePath })).toBeNull();
+});
+
+test('readPersonaModel returns null (never throws) for a path-traversal agentType rejected by validatePath', async () => {
+  const globalDir = await mkTmpDir('sm-agentmodel-agents-');
+  const realValidatePath = (p) => {
+    const real = path.resolve(p);
+    if (!real.startsWith(path.resolve(globalDir) + path.sep)) throw new Error('outside allowed boundaries');
+    return real;
+  };
+  expect(readPersonaModel('../../../etc/passwd', { globalDir, validatePath: realValidatePath })).toBeNull();
+});