claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,283 +0,0 @@
-/**
- * epicSpawnCwd.test.cjs — unit tests for resolveEpicSpawnCwd, the shared
- * spawn-cwd resolver both pty.cjs's Terminal spawn and chatRunner.cjs's
- * headless spawn use to point an Epic's actual child process at its
- * isolated git worktree (PRD 1033), while every other cwd usage stays the
- * real project cwd (see the module's own "ops-root hazard" header comment).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicSpawnCwd.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi } from 'vitest';
-const { resolveEpicSpawnCwd } = require('../epicSpawnCwd.cjs');
-
-function stubReadActiveIndex(sessions) {
-  return () => ({ sessions });
-}
-
-// resolveEpicSpawnCwd stats worktree.dir before returning it (a persisted
-// path outlives its checkout across a reboot/tmp sweep, a clone onto another
-// machine, or a manual prune). These fixtures name paths that don't exist on
-// the test host, so inject a stat stub saying they do; the "vanished dir"
-// tests at the bottom exercise the real fallback.
-const statOk = () => ({ isDirectory: () => true });
-const statGone = () => { throw Object.assign(new Error('ENOENT'), { code: 'ENOENT' }); };
-
-test('returns worktree.dir when the matching Epic (by claudeSessionId) has one', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': {
-          id: 'epic-1',
-          claudeSessionId: 'sess-1',
-          worktree: { dir: '/tmp/sm-epic-worktrees/abc/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo', status: 'active' },
-        },
-      }),
-      statSync: statOk,
-    },
-  });
-  expect(result).toBe('/tmp/sm-epic-worktrees/abc/epic-1');
-});
-
-test('falls back to cwd unchanged when the matching Epic has no worktree field', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1' },
-      }),
-    },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('falls back to cwd unchanged when no session matches claudeSessionId (non-Epic tab)', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'some-other-session',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': {
-          id: 'epic-1',
-          claudeSessionId: 'sess-1',
-          worktree: { dir: '/tmp/sm-epic-worktrees/abc/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo', status: 'active' },
-        },
-      }),
-      statSync: statOk,
-    },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('falls back to cwd unchanged when cwd or claudeSessionId is missing', () => {
-  expect(resolveEpicSpawnCwd({ cwd: '/projects/foo', claudeSessionId: '' })).toBe('/projects/foo');
-  expect(resolveEpicSpawnCwd({ cwd: '', claudeSessionId: 'sess-1' })).toBe('');
-  expect(resolveEpicSpawnCwd({})).toBeUndefined();
-});
-
-test('returns worktree.dir for a conflicted (needs_merge_resolution) Epic too — same PTY-into-worktree path a human uses to resolve it manually (PRD 1034)', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': {
-          id: 'epic-1',
-          claudeSessionId: 'sess-1',
-          worktree: {
-            dir: '/tmp/sm-epic-worktrees/abc/epic-1',
-            branch: 'sm-epic/epic-1',
-            baseCwd: '/projects/foo',
-            status: 'needs_merge_resolution',
-          },
-        },
-      }),
-      statSync: statOk,
-    },
-  });
-  expect(result).toBe('/tmp/sm-epic-worktrees/abc/epic-1');
-});
-
-test('never throws when the active-index read itself throws — falls back to cwd', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: () => { throw new Error('disk read failed'); },
-    },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-// ─── persisted worktree.dir outliving its checkout (2026-08-13) ─────────────
-//
-// worktree.dir is an absolute os.tmpdir() path persisted onto the Epic record
-// in active-index.json — a git-TRACKED file. It therefore routinely names a
-// directory that no longer exists: /tmp is cleared on boot on most Linux
-// distros and macOS (this host: `D /tmp 1777 root root 30d`), Epics are
-// deliberately long-lived, and a clone on another machine carries a path built
-// from the ORIGINAL machine's tmpdir and a sha1 of its project cwd. Handing
-// that to node-pty/child_process as a spawn cwd fails the spawn outright, so
-// the resolver falls back to the shared project tree instead.
-
-const WORKTREE_SESSIONS = {
-  'epic-1': {
-    id: 'epic-1',
-    claudeSessionId: 'sess-1',
-    worktree: {
-      dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1',
-      branch: 'sm-epic/epic-1',
-      baseCwd: '/projects/foo',
-      status: 'active',
-    },
-  },
-};
-
-test('falls back to the project cwd when the persisted worktree dir no longer exists (reboot / tmp sweep)', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: { readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS), statSync: statGone },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('falls back when worktree.dir exists but is a FILE, not a directory', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS),
-      statSync: () => ({ isDirectory: () => false }),
-    },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('a stat that throws something other than ENOENT still falls back rather than propagating', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS),
-      statSync: () => { throw Object.assign(new Error('EACCES'), { code: 'EACCES' }); },
-    },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('a real, existing directory IS returned — the check gates on disk state, not on the field being set', () => {
-  const os = require('node:os');
-  const fs = require('node:fs');
-  const realDir = fs.mkdtempSync(require('node:path').join(os.tmpdir(), 'sm-epicspawn-real-'));
-  try {
-    const result = resolveEpicSpawnCwd({
-      cwd: '/projects/foo',
-      claudeSessionId: 'sess-1',
-      deps: {
-        readActiveIndex: stubReadActiveIndex({
-          'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: realDir, branch: 'b', baseCwd: '/projects/foo', status: 'active' } },
-        }),
-        // no statSync stub — exercises the real fs.statSync default
-      },
-    });
-    expect(result).toBe(realDir);
-  } finally {
-    fs.rmSync(realDir, { recursive: true, force: true });
-  }
-});
-
-// ─── spawn-side: a vanished worktree is restored at the SAME path, never swapped for cwd ───
-
-test('restore:true re-attaches the worktree and returns the recorded dir (transcript encoding unchanged)', () => {
-  const calls = [];
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS),
-      statSync: statGone,
-      restore: true,
-      restoreWorktree: (a) => { calls.push(a); return true; },
-    },
-  });
-  expect(result).toBe('/tmp/session-manager-epic-worktrees/deadbeef/epic-1');
-  expect(calls).toEqual([{ dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', baseCwd: '/projects/foo' }]);
-});
-
-test('restore:true with a failed restore returns the project cwd — never a dead recorded dir', () => {
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: { readActiveIndex: stubReadActiveIndex(WORKTREE_SESSIONS), statSync: statGone, restore: true, restoreWorktree: () => false },
-  });
-  expect(result).toBe('/projects/foo');
-});
-
-test('a merged Epic with a missing dir returns the project cwd and never attempts a restore', () => {
-  const spy = vi.fn(() => true);
-  for (const status of ['merged', 'disabled']) {
-    const result = resolveEpicSpawnCwd({
-      cwd: '/projects/foo',
-      claudeSessionId: 'sess-1',
-      deps: {
-        readActiveIndex: stubReadActiveIndex({
-          'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', status } },
-        }),
-        statSync: statGone,
-        restore: true,
-        restoreWorktree: spy,
-      },
-    });
-    expect(result).toBe('/projects/foo');
-  }
-  expect(spy).not.toHaveBeenCalled();
-});
-
-test('an active Epic with a missing dir attempts a restore and returns the project cwd when it fails', () => {
-  const spy = vi.fn(() => false);
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1', status: 'active' } },
-      }),
-      statSync: statGone,
-      restore: true,
-      restoreWorktree: spy,
-    },
-  });
-  expect(spy).toHaveBeenCalledTimes(1);
-  expect(result).toBe('/projects/foo');
-});
-
-test('a worktree record with no status key is restore-eligible and does not throw', () => {
-  const spy = vi.fn(() => true);
-  const result = resolveEpicSpawnCwd({
-    cwd: '/projects/foo',
-    claudeSessionId: 'sess-1',
-    deps: {
-      readActiveIndex: stubReadActiveIndex({
-        'epic-1': { id: 'epic-1', claudeSessionId: 'sess-1', worktree: { dir: '/tmp/session-manager-epic-worktrees/deadbeef/epic-1', branch: 'sm-epic/epic-1' } },
-      }),
-      statSync: statGone,
-      restore: true,
-      restoreWorktree: spy,
-    },
-  });
-  expect(spy).toHaveBeenCalledTimes(1);
-  expect(result).toBe('/tmp/session-manager-epic-worktrees/deadbeef/epic-1');
-});
-
-test('restoreEpicWorktree refuses dirs outside an epic-worktrees segment and non sm-epic branches', () => {
-  const { restoreEpicWorktree } = require('../epicSpawnCwd.cjs');
-  expect(restoreEpicWorktree({ dir: '/etc/evil', branch: 'sm-epic/x', baseCwd: '/projects/foo' })).toBe(false);
-  expect(restoreEpicWorktree({ dir: '/tmp/session-manager-epic-worktrees/a/b', branch: 'main; rm -rf', baseCwd: '/projects/foo' })).toBe(false);
-  expect(restoreEpicWorktree({ dir: 'relative/session-manager-epic-worktrees/a', branch: 'sm-epic/x', baseCwd: '/projects/foo' })).toBe(false);
-});

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

@@ -1,196 +0,0 @@
-/**
- * epicSpawnPlan.test.cjs — PRD 1319: spawn cwd + --resume flag are decided together; a session
- * whose transcript is stranded under a dead worktree encoding is refused BEFORE any CLI spawn
- * with an actionable message, later requests are refused cheaply, closed Epics are refused.
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicSpawnPlan.test.cjs
- */
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { EventEmitter } = require('node:events');
-const { encodeCwd } = require('../encodeCwd.cjs');
-const { planEpicSpawn, __resetForTests } = require('../epicSpawnPlan.cjs');
-const { __resetCacheForTests } = require('../epicTranscriptPath.cjs');
-
-const SID = '00ff31cb-56b6-421c-829c-012ef95b15e2';
-const PROJECT = '/projects/starry-night-ships';
-const DEAD = '/tmp/session-manager-epic-worktrees/abc123/blender-epic-442d711d';
-
-let home;
-beforeEach(() => {
-  __resetForTests();
-  __resetCacheForTests();
-  home = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-home-'));
-});
-afterEach(() => fs.rmSync(home, { recursive: true, force: true }));
-
-function transcriptUnder(dir) {
-  const d = path.join(home, '.claude', 'projects', encodeCwd(dir));
-  fs.mkdirSync(d, { recursive: true });
-  const f = path.join(d, `${SID}.jsonl`);
-  fs.writeFileSync(f, '{"type":"user"}\n');
-  return f;
-}
-const epic = (extra = {}) => ({ e1: { id: 'e1', claudeSessionId: SID, status: 'active', worktree: { dir: DEAD, branch: 'sm-epic/e1', baseCwd: PROJECT, status: 'active' }, ...extra } });
-
-test('transcript under a dead worktree encoding + restore failure => refused, names the worktree, no raw CLI text', () => {
-  transcriptUnder(DEAD);
-  const plan = planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: epic() }), restoreWorktree: () => false } });
-  expect(plan.ok).toBe(false);
-  expect(plan.code).toBe('session_unreachable');
-  expect(plan.message).toContain(DEAD);
-  expect(plan.message).not.toMatch(/already in use/i);
-});
-
-test('circuit breaker: 2nd..Nth request refused without re-running restore', () => {
-  transcriptUnder(DEAD);
-  let restores = 0;
-  const deps = { homeDir: home, readActiveIndex: () => ({ sessions: epic() }), restoreWorktree: () => { restores++; return false; } };
-  const first = planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps });
-  for (let i = 0; i < 4; i++) expect(planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps })).toEqual(first);
-  expect(restores).toBe(1);
-});
-
-test('worktree re-attached at the same path => ok, resume, spawn cwd is the worktree', () => {
-  transcriptUnder(DEAD);
-  const live = new Set();
-  const statSync = (p) => (live.has(p) ? { isDirectory: () => true } : fs.statSync(p));
-  const plan = planEpicSpawn({
-    cwd: PROJECT, claudeSessionId: SID,
-    deps: { homeDir: home, readActiveIndex: () => ({ sessions: epic() }), statSync, restoreWorktree: ({ dir }) => { live.add(dir); return true; } },
-  });
-  expect(plan.ok).toBe(true);
-  expect(plan.useResume).toBe(true);
-  expect(plan.execCwd).toBe(DEAD);
-});
-
-test('transcript under the project encoding, no worktree => ok, resume from project cwd', () => {
-  transcriptUnder(PROJECT);
-  const plan = planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: epic({ worktree: undefined }) }), statSync: (p) => (p === PROJECT ? { isDirectory: () => true } : fs.statSync(p)) } });
-  expect(plan).toMatchObject({ ok: true, useResume: true, execCwd: PROJECT });
-});
-
-test('merged worktree (dir gone), transcript only under project encoding => ok, resume from project cwd (reported incident)', () => {
-  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
-  try {
-    const sid = SID;
-    const d = path.join(home, '.claude', 'projects', encodeCwd(proj));
-    fs.mkdirSync(d, { recursive: true });
-    fs.writeFileSync(path.join(d, `${sid}.jsonl`), '{"type":"user"}\n');
-    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
-    const deps = { homeDir: home, readActiveIndex: () => ({ sessions: merged }) };
-    const first = planEpicSpawn({ cwd: proj, claudeSessionId: sid, deps });
-    expect(first).toMatchObject({ ok: true, execCwd: proj, useResume: true });
-    // No circuit-breaker entry from the fallback: a second call is also ok.
-    expect(planEpicSpawn({ cwd: proj, claudeSessionId: sid, deps })).toMatchObject({ ok: true, execCwd: proj, useResume: true });
-  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
-});
-
-test('merged worktree, no transcript anywhere => ok, real directory, no resume', () => {
-  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
-  try {
-    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
-    const plan = planEpicSpawn({ cwd: proj, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: merged }) } });
-    expect(plan.ok).toBe(true);
-    expect(plan.useResume).toBe(false);
-    expect(fs.statSync(plan.execCwd).isDirectory()).toBe(true);
-  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
-});
-
-test('merged worktree, transcript only under dead encoding => refused, no git worktree add command', () => {
-  const proj = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-realproj-'));
-  try {
-    transcriptUnder(DEAD);
-    const merged = epic({ worktree: { dir: DEAD, branch: 'sm-epic/e1', status: 'merged' } });
-    const plan = planEpicSpawn({ cwd: proj, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: merged }) } });
-    expect(plan).toMatchObject({ ok: false, code: 'session_unreachable' });
-    expect(plan.message).toMatch(/merged to main/);
-    expect(plan.message).not.toMatch(/git worktree add/);
-    expect(plan.message).not.toMatch(/swept from \/tmp/);
-  } finally { fs.rmSync(proj, { recursive: true, force: true }); }
-});
-
-test('closed (completed) Epic is refused with its own message', () => {
-  const plan = planEpicSpawn({ cwd: PROJECT, claudeSessionId: SID, deps: { homeDir: home, readActiveIndex: () => ({ sessions: epic({ status: 'completed' }) }) } });
-  expect(plan).toMatchObject({ ok: false, code: 'epic_closed' });
-  expect(plan.message).toMatch(/closed/i);
-});
-
-test('chatRunner: dead-encoding transcript => zero CLI spawns, exactly one clear error event', async () => {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-proj-'));
-  const prevHome = process.env.HOME;
-  process.env.HOME = home;
-  try {
-    const idxDir = path.join(project, 'session-manager-operations', 'prompt-sessions');
-    fs.mkdirSync(idxDir, { recursive: true });
-    fs.writeFileSync(path.join(idxDir, 'active-index.json'), JSON.stringify({ sessions: epic() }));
-    transcriptUnder(DEAD);
-    const cp = require('node:child_process');
-    const realSpawn = cp.spawn;
-    let spawns = 0;
-    cp.spawn = () => { spawns++; const c = new EventEmitter(); c.stdout = new EventEmitter(); c.stderr = new EventEmitter(); c.pid = 1; c.kill = () => {}; return c; };
-    const chatRunner = require('../../chatRunner.cjs');
-    chatRunner.__resetQueueForTests();
-    const sent = [];
-    chatRunner.attachWindow({ isDestroyed: () => false, webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) } });
-    try {
-      for (let i = 0; i < 3; i++) chatRunner.run({ tabId: `t${i}`, sessionId: SID, prompt: 'hi', cwd: project, resume: true });
-      await new Promise((r) => setTimeout(r, 100));
-    } finally { cp.spawn = realSpawn; }
-    const errs = sent.filter((e) => e.channel === 'chat:run:error');
-    expect(spawns).toBe(0);
-    expect(errs.length).toBe(3);
-    for (const e of errs) expect(e.payload.message).toContain(DEAD);
-    // Single-writer law: the rescued session's ops write (error log) lands under the PROJECT root.
-    const logsDir = path.join(project, 'session-manager-operations', 'logs');
-    expect(fs.existsSync(logsDir)).toBe(true);
-    expect(fs.readdirSync(logsDir).some((n) => n.startsWith('errors-'))).toBe(true);
-    expect(fs.existsSync(path.join(DEAD, 'session-manager-operations'))).toBe(false);
-  } finally {
-    process.env.HOME = prevHome;
-    fs.rmSync(project, { recursive: true, force: true });
-  }
-});
-
-test('chatRunner: silent run refused by planEpicSpawn => onSilentError with the refusal, no broadcasts, no spawn', async () => {
-  const project = fs.mkdtempSync(path.join(os.tmpdir(), 'plan-proj-'));
-  const prevHome = process.env.HOME;
-  process.env.HOME = home;
-  try {
-    const idxDir = path.join(project, 'session-manager-operations', 'prompt-sessions');
-    fs.mkdirSync(idxDir, { recursive: true });
-    fs.writeFileSync(path.join(idxDir, 'active-index.json'), JSON.stringify({ sessions: epic({ status: 'completed' }) }));
-    const cp = require('node:child_process');
-    const realSpawn = cp.spawn;
-    let spawns = 0;
-    cp.spawn = () => { spawns++; throw new Error('must not spawn'); };
-    const chatRunner = require('../../chatRunner.cjs');
-    chatRunner.__resetQueueForTests();
-    const sent = [];
-    chatRunner.attachWindow({ isDestroyed: () => false, webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) } });
-    const errors = [];
-    const results = [];
-    try {
-      chatRunner.run({
-        tabId: 'silent1', sessionId: SID, prompt: 'hi', cwd: project, resume: true, silent: true,
-        onSilentResult: (t) => results.push(t),
-        onSilentError: (message, code) => errors.push({ message, code }),
-      });
-      // no timer: delivery is a few microtasks after run()
-      await Promise.resolve(); await Promise.resolve(); await Promise.resolve();
-    } finally { cp.spawn = realSpawn; }
-    expect(spawns).toBe(0);
-    expect(results).toEqual([]);
-    expect(errors.length).toBe(1);
-    expect(errors[0].code).toBe('epic_closed');
-    expect(errors[0].message).toMatch(/closed/i);
-    expect(sent.filter((e) => e.channel.startsWith('chat:run:'))).toEqual([]);
-  } finally {
-    process.env.HOME = prevHome;
-    fs.rmSync(project, { recursive: true, force: true });
-  }
-});

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

@@ -1,163 +0,0 @@
-/**
- * epicTranscriptPath.test.cjs — resolver for where an Epic session's JSONL
- * transcript actually lives (worktree encoding vs project encoding).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/epicTranscriptPath.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { resolveEpicTranscriptPath, __resetCacheForTests } = require('../epicTranscriptPath.cjs');
-const { encodeCwd } = require('../encodeCwd.cjs');
-const { readActiveIndex } = require('../epicMint.cjs');
-
-const SID = 'sess-1';
-let root, home, cwd, wtDir;
-
-const projFile = (dir) => path.join(home, '.claude', 'projects', encodeCwd(dir), `${SID}.jsonl`);
-function put(p, body = '{"a":1}\n', mtimeSec) {
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  fs.writeFileSync(p, body);
-  if (mtimeSec) fs.utimesSync(p, mtimeSec, mtimeSec);
-}
-const promptDir = () => path.join(cwd, 'session-manager-operations', 'prompt-sessions');
-function writeIndex(sessions) {
-  fs.mkdirSync(promptDir(), { recursive: true });
-  fs.writeFileSync(path.join(promptDir(), 'active-index.json'), JSON.stringify({ sessions, events: {} }));
-}
-const epic = (extra = {}) => ({ id: 'epic-1', claudeSessionId: SID, worktree: { dir: wtDir, branch: 'b', baseCwd: cwd, status: 'active' }, ...extra });
-const resolve = (deps = {}) => resolveEpicTranscriptPath({ cwd, claudeSessionId: SID, deps: { homeDir: home, ...deps } });
-
-beforeEach(() => {
-  __resetCacheForTests();
-  root = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-etp-'));
-  home = path.join(root, 'home');
-  cwd = path.join(root, 'project');
-  wtDir = path.join(root, 'wt', 'epic-1');
-  fs.mkdirSync(cwd, { recursive: true });
-});
-afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
-
-test('worktree transcript is found when the worktree dir exists', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  put(projFile(wtDir));
-  const r = resolve();
-  expect(r.path).toBe(projFile(wtDir));
-  expect(r.existsAnywhere).toBe(true);
-  expect(r.candidates).toEqual([projFile(wtDir), projFile(cwd)]);
-});
-
-test('worktree swept from disk but transcript survives — still returned', () => {
-  writeIndex({ e: epic() });
-  put(projFile(wtDir));
-  const r = resolve();
-  expect(r.path).toBe(projFile(wtDir));
-  expect(r.candidates).toContain(projFile(wtDir));
-});
-
-test('project-encoding-only transcript', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  put(projFile(cwd));
-  const r = resolve();
-  expect(r.path).toBe(projFile(cwd));
-  expect(r.existingPaths).toEqual([projFile(cwd)]);
-});
-
-test('nothing anywhere: path is the spawn-cwd candidate, existsAnywhere false', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  const r = resolve();
-  expect(r.path).toBe(projFile(wtDir));
-  expect(r.existsAnywhere).toBe(false);
-  expect(r.existingPaths).toEqual([]);
-});
-
-test('non-Epic tab returns exactly the project path with a single candidate', () => {
-  writeIndex({ e: epic({ claudeSessionId: 'other' }) });
-  put(projFile(cwd));
-  const r = resolve();
-  expect(r.candidates).toEqual([projFile(cwd)]);
-  expect(r.path).toBe(projFile(cwd));
-});
-
-test('dir exists but holds only a tool-results sidecar — does not win', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  fs.mkdirSync(path.join(path.dirname(projFile(wtDir)), SID, 'tool-results'), { recursive: true });
-  put(projFile(cwd));
-  const r = resolve();
-  expect(r.path).toBe(projFile(cwd));
-  expect(r.existingPaths).toEqual([projFile(cwd)]);
-});
-
-test('a directory named <id>.jsonl is not a transcript', () => {
-  writeIndex({ e: epic() });
-  fs.mkdirSync(projFile(wtDir), { recursive: true });
-  expect(resolve().existsAnywhere).toBe(false);
-});
-
-test('zero-byte file counts as existing but loses to a non-empty one', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  put(projFile(wtDir), '');
-  let r = resolve();
-  expect(r.existsAnywhere).toBe(true);
-  expect(r.path).toBe(projFile(wtDir));
-  put(projFile(cwd), '{"a":1}\n', 1000);
-  r = resolve();
-  expect(r.path).toBe(projFile(cwd));
-  expect(r.existingPaths.length).toBe(2);
-});
-
-test('duplicate under two encodings: newest mtime wins', () => {
-  fs.mkdirSync(wtDir, { recursive: true });
-  writeIndex({ e: epic() });
-  put(projFile(wtDir), 'x\n', 2000);
-  put(projFile(cwd), 'x\n', 3000);
-  let r = resolve();
-  expect(r.existingPaths.length).toBe(2);
-  expect(r.path).toBe(projFile(cwd));
-  put(projFile(wtDir), 'x\n', 4000);
-  r = resolve();
-  expect(r.path).toBe(projFile(wtDir));
-});
-
-test('completed Epic (absent from index) resolved from its archive', () => {
-  writeIndex({});
-  fs.writeFileSync(path.join(promptDir(), 'done-epic-abcd1234.json'), JSON.stringify({ session: epic(), events: [], transcript: '', archivedAt: 'x' }));
-  put(projFile(wtDir));
-  const r = resolve();
-  expect(r.path).toBe(projFile(wtDir));
-});
-
-test('malformed archive JSON and unreadable index never throw', () => {
-  writeIndex({});
-  fs.writeFileSync(path.join(promptDir(), 'bad.json'), '{not json');
-  expect(() => resolve()).not.toThrow();
-  const r = resolve({ readActiveIndex: () => { throw new Error('boom'); } });
-  expect(r.candidates).toEqual([projFile(cwd)]);
-});
-
-test('blank/missing/unsafe inputs return a safe result', () => {
-  for (const args of [{}, { cwd: '', claudeSessionId: SID }, { cwd, claudeSessionId: '' }, { cwd, claudeSessionId: '../x' }]) {
-    const r = resolveEpicTranscriptPath({ ...args, deps: { homeDir: home } });
-    expect(r).toEqual({ path: null, candidates: [], existsAnywhere: false, existingPaths: [] });
-  }
-});
-
-test('index read once across N calls when unchanged; re-read after a touch', () => {
-  writeIndex({ e: epic() });
-  let reads = 0;
-  const deps = { readActiveIndex: (c) => { reads++; return readActiveIndex(c); } };
-  for (let i = 0; i < 20; i++) resolve(deps);
-  expect(reads).toBe(1);
-  writeIndex({ e: epic(), f: epic({ id: 'epic-2', claudeSessionId: 'zzz' }) });
-  resolve(deps);
-  expect(reads).toBe(2);
-});