claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/lib/__tests__/dispatchLoop.test.cjs

@@ -1,63 +0,0 @@
-/**
- * dispatchLoop.test.cjs — interval clamping, no overlap, throw isolation, stop(), kill switch.
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/dispatchLoop.test.cjs
- */
-'use strict';
-
-import { test, expect, vi, beforeEach, afterEach } from 'vitest';
-const { startDispatchLoop, resolveIntervalMs } = require('../dispatchLoop.cjs');
-
-beforeEach(() => { vi.useFakeTimers(); delete process.env.SM_DISPATCH_LOOP_DISABLE; delete process.env.SM_DISPATCH_LOOP_INTERVAL_MS; });
-afterEach(() => { vi.useRealTimers(); delete process.env.SM_DISPATCH_LOOP_DISABLE; delete process.env.SM_DISPATCH_LOOP_INTERVAL_MS; });
-
-test('interval defaults to 30s and clamps to [10s, 300s]', () => {
-  expect(resolveIntervalMs(undefined, {})).toBe(30_000);
-  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: '1' })).toBe(10_000);
-  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: '9999999' })).toBe(300_000);
-  expect(resolveIntervalMs(undefined, { SM_DISPATCH_LOOP_INTERVAL_MS: 'abc' })).toBe(30_000);
-  expect(resolveIntervalMs(45_000, {})).toBe(45_000);
-});
-
-test('ticks on the interval and stop() clears the timer', async () => {
-  const tick = vi.fn(async () => {});
-  const h = startDispatchLoop({ tick });
-  await vi.advanceTimersByTimeAsync(90_000);
-  expect(tick).toHaveBeenCalledTimes(3);
-  h.stop();
-  expect(vi.getTimerCount()).toBe(0);
-  await vi.advanceTimersByTimeAsync(90_000);
-  expect(tick).toHaveBeenCalledTimes(3);
-});
-
-test('skips a pass while the previous one is still running', async () => {
-  let release;
-  const tick = vi.fn(() => new Promise((r) => { release = r; }));
-  const h = startDispatchLoop({ tick, intervalMs: 10_000 });
-  await vi.advanceTimersByTimeAsync(50_000);
-  expect(tick).toHaveBeenCalledTimes(1);
-  release();
-  await vi.advanceTimersByTimeAsync(10_000);
-  expect(tick).toHaveBeenCalledTimes(2);
-  h.stop();
-});
-
-test('a throwing/rejecting tick is isolated, reported, and the loop keeps running', async () => {
-  const onError = vi.fn();
-  let n = 0;
-  const tick = vi.fn(async () => { n++; if (n === 1) throw new Error('boom'); if (n === 2) throw new Error('boom2'); });
-  const h = startDispatchLoop({ tick, intervalMs: 10_000, onError });
-  await vi.advanceTimersByTimeAsync(40_000);
-  expect(tick).toHaveBeenCalledTimes(4);
-  expect(onError).toHaveBeenCalledTimes(2);
-  h.stop();
-});
-
-test('SM_DISPATCH_LOOP_DISABLE=1 never arms the loop', async () => {
-  process.env.SM_DISPATCH_LOOP_DISABLE = '1';
-  const tick = vi.fn();
-  const h = startDispatchLoop({ tick });
-  expect(vi.getTimerCount()).toBe(0);
-  await vi.advanceTimersByTimeAsync(600_000);
-  expect(tick).not.toHaveBeenCalled();
-  h.stop();
-});

package/src/main/lib/__tests__/effectiveModelInfo.test.cjs

@@ -1,244 +0,0 @@
-/**
- * effectiveModelInfo.test.cjs — the main-process half of "what will this
- * Epic actually run as": overlay-aware persona alias resolution plus
- * evidence-based concrete model id (scheduler run log, then session
- * transcript), never fabricated when there's no evidence.
- *
- * All fixtures live under a per-test mkdtemp'd $HOME (never the real
- * ~/.claude) so persona lookup (which reads os.homedir()), scheduler run
- * logs, and transcripts all resolve consistently.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/effectiveModelInfo.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const path = require('node:path');
-const os = require('node:os');
-const { encodeCwd } = require('../encodeCwd.cjs');
-const { resolveEffectiveModelInfo, isConcreteModelId, computeEffortEnvReachable } = require('../effectiveModelInfo.cjs');
-// config.cjs's `allowedRoots` is a module-level singleton seeded from
-// os.homedir() at FIRST require — since this test's HOME changes every test
-// (fresh mkdtemp), a persona lookup (getPersonaBody -> validatePath) would
-// only pass for whichever tmpHome happened to be active the first time
-// config.cjs got lazily required. addAllowedRoot mutates the live Set
-// instead, so every test's own tmpHome is explicitly admitted.
-const { addAllowedRoot } = require('../../config.cjs');
-
-let tmpHome;
-let originalHome;
-let cwd;
-
-beforeEach(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-effective-model-home-'));
-  process.env.HOME = tmpHome;
-  addAllowedRoot(tmpHome);
-  cwd = path.join(tmpHome, 'project');
-  fs.mkdirSync(cwd, { recursive: true });
-});
-
-afterEach(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function writePersona(dir, name, frontmatterLines) {
-  fs.mkdirSync(dir, { recursive: true });
-  const lines = ['---', ...frontmatterLines, '---', 'Body text.'];
-  fs.writeFileSync(path.join(dir, `${name}.md`), lines.join('\n'));
-}
-
-function writeGlobalPersona(name, frontmatterLines) {
-  writePersona(path.join(tmpHome, '.claude', 'agents'), name, frontmatterLines);
-}
-
-function writeOverlayPersona(name, frontmatterLines) {
-  writePersona(path.join(cwd, '.claude', 'agents'), name, frontmatterLines);
-}
-
-function writeActiveIndex(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 writeQueueJobs(jobs) {
-  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'queue.json'), JSON.stringify({ jobs }, null, 2));
-}
-
-function writeHistoryEntries(entries) {
-  const dir = path.join(cwd, 'session-manager-operations', 'scheduler', 'state');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, 'history.jsonl'), entries.map((e) => JSON.stringify(e)).join('\n') + '\n');
-}
-
-function writeRunLog(runId, slug, text) {
-  const dir = path.join(tmpHome, '.claude', 'session-manager', 'scheduled-plans', 'runs', runId);
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${slug}.log`), text);
-}
-
-function writeTranscript(sessionId, lines) {
-  const dir = path.join(tmpHome, '.claude', 'projects', encodeCwd(cwd));
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${sessionId}.jsonl`), lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-}
-
-// ---------- persona alias resolution ----------
-
-test('resolves a global persona alias with modelSource "persona" and no fabricated evidence', async () => {
-  writeGlobalPersona('writer', ['model: sonnet']);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'writer' });
-  expect(info.modelAlias).toBe('sonnet');
-  expect(info.modelSource).toBe('persona');
-  expect(info.resolvedModelId).toBeNull();
-  expect(info.resolvedFrom).toBeNull();
-});
-
-test('a persona model of "inherit" reports modelAlias null and modelSource "inherit"', async () => {
-  writeGlobalPersona('inheriting', ['model: inherit']);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'inheriting' });
-  expect(info.modelAlias).toBeNull();
-  expect(info.modelSource).toBe('inherit');
-});
-
-test('a persona with no model field at all is treated the same as inherit', async () => {
-  writeGlobalPersona('bare', []);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'bare' });
-  expect(info.modelAlias).toBeNull();
-  expect(info.modelSource).toBe('inherit');
-});
-
-test('a persona pinned to an already-concrete model id echoes it back with resolvedFrom null, ignoring conflicting evidence', async () => {
-  writeGlobalPersona('pinned', ['model: claude-opus-5-2027']);
-  // Conflicting scheduler evidence exists but must never override an
-  // already-concrete alias — no evidence lookup should even be attempted.
-  writeQueueJobs([{ slug: 'x', runId: 'r1', agentType: 'pinned', finishedAt: new Date().toISOString() }]);
-  writeRunLog('r1', 'x', '[scheduler] agentType=pinned persona=/whatever model=claude-sonnet-1\n');
-
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'pinned' });
-  expect(info.modelAlias).toBe('claude-opus-5-2027');
-  expect(info.modelSource).toBe('persona');
-  expect(info.resolvedModelId).toBe('claude-opus-5-2027');
-  expect(info.resolvedFrom).toBeNull();
-});
-
-test('a project-overlay persona wins over the global definition and reports modelSource "persona-overlay"', async () => {
-  writeGlobalPersona('shared-name', ['model: sonnet']);
-  writeOverlayPersona('shared-name', ['model: opus']);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'shared-name' });
-  expect(info.modelAlias).toBe('opus');
-  expect(info.modelSource).toBe('persona-overlay');
-});
-
-test('a dangling agentType (no persona file anywhere) resolves modelSource "fallback" without throwing', async () => {
-  await expect(resolveEffectiveModelInfo({ cwd, agentType: 'ghost-persona' })).resolves.toBeTruthy();
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'ghost-persona' });
-  expect(info.modelAlias).toBeNull();
-  expect(info.modelSource).toBe('fallback');
-  expect(info.resolvedModelId).toBeNull();
-});
-
-// ---------- concrete-model-id evidence ----------
-
-test('evidence hit via the scheduler run record: reads the model logged in the most recent matching job\'s run log', async () => {
-  writeGlobalPersona('runner', ['model: sonnet']);
-  writeQueueJobs([
-    { slug: 'older', runId: 'run-older', agentType: 'runner', finishedAt: '2026-01-01T00:00:00.000Z' },
-    { slug: 'newer', runId: 'run-newer', agentType: 'runner', finishedAt: '2026-02-01T00:00:00.000Z' },
-  ]);
-  writeRunLog('run-older', 'older', '[scheduler] agentType=runner persona=/p/runner.md model=claude-old-1\n');
-  writeRunLog('run-newer', 'newer', '[scheduler] agentType=runner persona=/p/runner.md model=claude-sonnet-5\n');
-
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'runner' });
-  expect(info.resolvedModelId).toBe('claude-sonnet-5');
-  expect(info.resolvedFrom).toBe('scheduler-run');
-});
-
-test('scheduler-run evidence also matches jobs already archived into history.jsonl', async () => {
-  writeGlobalPersona('archived-runner', ['model: opus']);
-  writeHistoryEntries([
-    { slug: 'old-hist', runId: 'run-hist', agentType: 'archived-runner', finishedAt: '2026-01-01T00:00:00.000Z' },
-  ]);
-  writeRunLog('run-hist', 'old-hist', '[scheduler] agentType=archived-runner persona=/p/x.md model=claude-opus-5\n');
-
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'archived-runner' });
-  expect(info.resolvedModelId).toBe('claude-opus-5');
-  expect(info.resolvedFrom).toBe('scheduler-run');
-});
-
-test('evidence hit via transcript when no scheduler run exists: takes the LAST "model" occurrence', async () => {
-  writeGlobalPersona('chatty', ['model: opus']);
-  writeActiveIndex({
-    'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', agentType: 'chatty', createdAt: '2026-03-01T00:00:00.000Z' },
-  });
-  writeTranscript('sess-1', [
-    { type: 'assistant', message: { model: 'claude-opus-4' } },
-    { type: 'assistant', message: { model: 'claude-opus-5' } },
-  ]);
-
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'chatty' });
-  expect(info.resolvedModelId).toBe('claude-opus-5');
-  expect(info.resolvedFrom).toBe('transcript');
-});
-
-test('transcript evidence prefers the most recently created matching Epic', async () => {
-  writeGlobalPersona('multi-epic', ['model: haiku']);
-  writeActiveIndex({
-    'epic-old': { id: 'epic-old', claudeSessionId: 'sess-old', agentType: 'multi-epic', createdAt: '2026-01-01T00:00:00.000Z' },
-    'epic-new': { id: 'epic-new', claudeSessionId: 'sess-new', agentType: 'multi-epic', createdAt: '2026-05-01T00:00:00.000Z' },
-  });
-  writeTranscript('sess-old', [{ model: 'claude-haiku-old' }]);
-  writeTranscript('sess-new', [{ model: 'claude-haiku-new' }]);
-
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'multi-epic' });
-  expect(info.resolvedModelId).toBe('claude-haiku-new');
-  expect(info.resolvedFrom).toBe('transcript');
-});
-
-test('evidence miss (no scheduler run, no transcript) reports resolvedModelId/resolvedFrom as null — never a guessed pricing-key fallback', async () => {
-  writeGlobalPersona('unseen', ['model: haiku']);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'unseen' });
-  expect(info.resolvedModelId).toBeNull();
-  expect(info.resolvedFrom).toBeNull();
-});
-
-// ---------- edge cases ----------
-
-test('never throws for a missing cwd/agentType', async () => {
-  await expect(resolveEffectiveModelInfo({})).resolves.toMatchObject({
-    modelAlias: null,
-    modelSource: 'fallback',
-    resolvedModelId: null,
-    resolvedFrom: null,
-  });
-});
-
-test('isConcreteModelId treats known CLI aliases as non-concrete and everything else as concrete', () => {
-  expect(isConcreteModelId('opus')).toBe(false);
-  expect(isConcreteModelId('sonnet')).toBe(false);
-  expect(isConcreteModelId('haiku')).toBe(false);
-  expect(isConcreteModelId('opus[1m]')).toBe(false);
-  expect(isConcreteModelId('best')).toBe(false);
-  expect(isConcreteModelId('opusplan')).toBe(false);
-  expect(isConcreteModelId('default')).toBe(false);
-  expect(isConcreteModelId('claude-opus-4-7[1m]')).toBe(true);
-  expect(isConcreteModelId('fable')).toBe(false);
-  expect(isConcreteModelId(null)).toBe(false);
-  expect(isConcreteModelId('claude-opus-5')).toBe(true);
-});
-
-test('effortEnvReachable is always false for an app-launched session — cleanChildEnv strips CLAUDE_EFFORT and CLAUDE_CODE_* before a child ever sees them', () => {
-  expect(computeEffortEnvReachable({})).toBe(false);
-});
-
-test('resolveEffectiveModelInfo surfaces effortEnvReachable alongside the model fields', async () => {
-  writeGlobalPersona('any', ['model: sonnet']);
-  const info = await resolveEffectiveModelInfo({ cwd, agentType: 'any' });
-  expect(info.effortEnvReachable).toBe(false);
-});

package/src/main/lib/__tests__/ephemeralCwd.test.cjs

@@ -1,91 +0,0 @@
-/**
- * ephemeralCwd.test.cjs — isEphemeralCwd(cwd) must refuse a cwd that
- * resolves to os.tmpdir() itself, into a managed worktree root, or onto a
- * linked git worktree's own root — and must allow an ordinary project cwd.
- *
- * See ephemeralCwd.cjs's header for the live incident (2026-09-01) this
- * predicate closes: queueStore.writeSplit materializing scheduler state
- * inside an ephemeral epic worktree, torn down with the Epic and silently
- * losing the write.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/ephemeralCwd.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 { isEphemeralCwd } = require('../ephemeralCwd.cjs');
-const { KIND_CONFIG } = require('../gitWorktree.cjs');
-
-const tmpDirs = [];
-
-afterEach(async () => {
-  while (tmpDirs.length) {
-    await fsp.rm(tmpDirs.pop(), { recursive: true, force: true }).catch(() => {});
-  }
-});
-
-// A real project must never itself live under /tmp — only ephemeral fixtures
-// (worktree checkouts) do. `test-results/` is already gitignored.
-const NON_TMP_SCRATCH_ROOT = path.join(process.cwd(), 'test-results', 'ephemeral-cwd-fixtures');
-
-async function mkNonTmpDir(prefix) {
-  fs.mkdirSync(NON_TMP_SCRATCH_ROOT, { recursive: true });
-  return fsp.mkdtemp(path.join(NON_TMP_SCRATCH_ROOT, prefix));
-}
-
-async function makeWorktreeFixture() {
-  const main = await mkNonTmpDir('sm-ephemeral-main-');
-  tmpDirs.push(main);
-  fs.mkdirSync(path.join(main, '.git'), { recursive: true });
-  const worktree = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-ephemeral-worktree-'));
-  tmpDirs.push(worktree);
-  const worktreeName = 'sm-epic-abc123';
-  const worktreeGitFile = path.join(worktree, '.git');
-  const adminDir = path.join(main, '.git', 'worktrees', worktreeName);
-  fs.mkdirSync(adminDir, { recursive: true });
-  fs.writeFileSync(path.join(adminDir, 'gitdir'), `${worktreeGitFile}\n`, 'utf8');
-  fs.writeFileSync(worktreeGitFile, `gitdir: ${adminDir}\n`, 'utf8');
-  return { main, worktree };
-}
-
-test('isEphemeralCwd refuses os.tmpdir() itself', () => {
-  expect(isEphemeralCwd(os.tmpdir())).toBe(true);
-});
-
-test('isEphemeralCwd refuses a cwd under the managed epic worktree root', () => {
-  const cwd = path.join(KIND_CONFIG.epic.root, 'some-hash', 'some-epic-slug');
-  expect(isEphemeralCwd(cwd)).toBe(true);
-});
-
-test('isEphemeralCwd refuses a cwd under the managed job worktree root', () => {
-  const cwd = path.join(KIND_CONFIG.job.root, 'some-job-id');
-  expect(isEphemeralCwd(cwd)).toBe(true);
-});
-
-test('isEphemeralCwd refuses a linked git worktree root anywhere on disk', async () => {
-  const { worktree } = await makeWorktreeFixture();
-  expect(isEphemeralCwd(worktree)).toBe(true);
-});
-
-test('isEphemeralCwd allows an ordinary project cwd (the worktree fixture\'s own main tree)', async () => {
-  const { main } = await makeWorktreeFixture();
-  expect(isEphemeralCwd(main)).toBe(false);
-});
-
-test('isEphemeralCwd allows an ordinary tmpdir-adjacent fixture used by other test suites (not os.tmpdir() itself, not a managed worktree root, not a linked worktree)', async () => {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-some-other-test-fixture-'));
-  tmpDirs.push(cwd);
-  expect(isEphemeralCwd(cwd)).toBe(false);
-});
-
-test('isEphemeralCwd is false for non-absolute or missing input, never throws', () => {
-  expect(isEphemeralCwd('relative/path')).toBe(false);
-  expect(isEphemeralCwd('')).toBe(false);
-  expect(isEphemeralCwd(null)).toBe(false);
-  expect(isEphemeralCwd(undefined)).toBe(false);
-});

package/src/main/lib/__tests__/epicDelegationStats.test.cjs

@@ -1,137 +0,0 @@
-/**
- * epicDelegationStats.test.cjs — unit tests for the derived-at-read-time
- * "did this Epic delegate?" counters (prdsQueued from the Epic's own live
- * PRD dir, inlineEdits from its interactive claude session transcript).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicDelegationStats.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const {
-  computeEpicDelegationStats,
-  countPrdsQueued,
-  countInlineEdits,
-  isApplicationSourcePath,
-} = require('../epicDelegationStats.cjs');
-const { encodeCwd } = require('../encodeCwd.cjs');
-
-const tmpDirs = [];
-function makeTmpCwd() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'epic-delegation-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-afterEach(() => {
-  while (tmpDirs.length) {
-    fs.rmSync(tmpDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-function makeTmpHome() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'epic-delegation-home-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function writeTranscript(homeDir, cwd, sessionId, lines) {
-  const dir = path.join(homeDir, '.claude', 'projects', encodeCwd(cwd));
-  fs.mkdirSync(dir, { recursive: true });
-  const filePath = path.join(dir, `${sessionId}.jsonl`);
-  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
-  return filePath;
-}
-
-function toolUseLine(name, filePath) {
-  return {
-    type: 'assistant',
-    message: { content: [{ type: 'tool_use', name, id: 't1', input: { file_path: filePath } }] },
-  };
-}
-
-test('countPrdsQueued counts only .md files in the Epic own live prds dir', () => {
-  const cwd = makeTmpCwd();
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'epic-1', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, '01-foo.md'), '# foo');
-  fs.writeFileSync(path.join(prdsDir, '02-bar.md'), '# bar');
-  fs.writeFileSync(path.join(prdsDir, '.reserved-03'), '');
-  expect(countPrdsQueued(cwd, 'epic-1')).toBe(2);
-});
-
-test('countPrdsQueued returns 0 when the prds dir does not exist', () => {
-  const cwd = makeTmpCwd();
-  expect(countPrdsQueued(cwd, 'missing-epic')).toBe(0);
-});
-
-test('isApplicationSourcePath matches src/scripts/plugins/bin, rejects everything else', () => {
-  const cwd = '/repo';
-  expect(isApplicationSourcePath(cwd, '/repo/src/main/index.cjs')).toBe(true);
-  expect(isApplicationSourcePath(cwd, '/repo/scripts/hooks/foo.cjs')).toBe(true);
-  expect(isApplicationSourcePath(cwd, '/repo/plugins/dev/skill.md')).toBe(true);
-  expect(isApplicationSourcePath(cwd, '/repo/bin/cli.cjs')).toBe(true);
-  expect(isApplicationSourcePath(cwd, '/repo/session-manager-operations/scheduler/epics/e1/prds/01.md')).toBe(false);
-  expect(isApplicationSourcePath(cwd, '/repo/README.md')).toBe(false);
-  expect(isApplicationSourcePath(cwd, '/outside/src/index.cjs')).toBe(false);
-  expect(isApplicationSourcePath(cwd, undefined)).toBe(false);
-});
-
-test('countInlineEdits counts Write/Edit/NotebookEdit tool_use blocks under application source only', () => {
-  const cwd = makeTmpCwd();
-  const homeDir = makeTmpHome();
-  writeTranscript(homeDir, cwd, 'sess-1', [
-    toolUseLine('Write', path.join(cwd, 'src', 'main', 'foo.cjs')),
-    toolUseLine('Edit', path.join(cwd, 'src', 'main', 'foo.cjs')),
-    toolUseLine('Read', path.join(cwd, 'src', 'main', 'foo.cjs')),
-    toolUseLine('Write', path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'e1', 'prds', '01.md')),
-    toolUseLine('NotebookEdit', path.join(cwd, 'scripts', 'nb.ipynb')),
-  ]);
-  expect(countInlineEdits(cwd, 'sess-1', { homeDir })).toBe(3);
-});
-
-test('countInlineEdits returns 0 when the transcript file does not exist', () => {
-  const cwd = makeTmpCwd();
-  const homeDir = makeTmpHome();
-  expect(countInlineEdits(cwd, 'no-such-session', { homeDir })).toBe(0);
-});
-
-test('countInlineEdits returns 0 when claudeSessionId is missing', () => {
-  const cwd = makeTmpCwd();
-  expect(countInlineEdits(cwd, null)).toBe(0);
-});
-
-test('countInlineEdits tolerates a malformed trailing line', () => {
-  const cwd = makeTmpCwd();
-  const homeDir = makeTmpHome();
-  const dir = path.join(homeDir, '.claude', 'projects', encodeCwd(cwd));
-  fs.mkdirSync(dir, { recursive: true });
-  const filePath = path.join(dir, 'sess-2.jsonl');
-  fs.writeFileSync(
-    filePath,
-    JSON.stringify(toolUseLine('Write', path.join(cwd, 'src', 'a.ts'))) + '\n{not json\n',
-  );
-  expect(countInlineEdits(cwd, 'sess-2', { homeDir })).toBe(1);
-});
-
-test('computeEpicDelegationStats combines both counters and never throws on missing state', () => {
-  const cwd = makeTmpCwd();
-  const homeDir = makeTmpHome();
-  expect(computeEpicDelegationStats(cwd, 'ghost-epic', 'ghost-session', { homeDir })).toEqual({
-    prdsQueued: 0,
-    inlineEdits: 0,
-  });
-
-  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'epic-2', 'prds');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, '01-foo.md'), '# foo');
-  writeTranscript(homeDir, cwd, 'sess-3', [toolUseLine('Edit', path.join(cwd, 'src', 'x.ts'))]);
-  expect(computeEpicDelegationStats(cwd, 'epic-2', 'sess-3', { homeDir })).toEqual({
-    prdsQueued: 1,
-    inlineEdits: 1,
-  });
-});