claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,174 +0,0 @@
-/**
- * epicContextDigest.test.cjs — unit tests for buildContextDigest
- * (lib/epicContextDigest.cjs), which composes an Epic's goalText
- * (active-index.json, via epicMint.cjs) with its most-recent transcript
- * turns (promptSessionTranscript.cjs) into a bounded, real digest string.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/epicContextDigest.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { buildContextDigest, composeExecutorPrompt } = require('../lib/epicContextDigest.cjs');
-const { ensureEpic, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-const { appendTurn } = require('../promptSessionTranscript.cjs');
-const config = require('../config.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epiccontextdigest-cwd-'));
-  config.addAllowedRoot(cwd);
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-test('normal digest: goalText followed by recent turns', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, { goalText: 'Fix the flaky login test', status: 'proposed', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-  await appendTurn(cwd, epicId, { role: 'user', text: 'Please investigate the flaky test.' });
-  await appendTurn(cwd, epicId, { role: 'assistant', text: 'Found the race condition, fixing now.' });
-
-  const digest = await buildContextDigest({ cwd, epicId });
-  expect(digest).toContain('Fix the flaky login test');
-  expect(digest).toContain('[user] Please investigate the flaky test.');
-  expect(digest).toContain('[assistant] Found the race condition, fixing now.');
-});
-
-test('missing epicId returns empty string', async () => {
-  const cwd = await mkCwd();
-  expect(await buildContextDigest({ cwd, epicId: '' })).toBe('');
-  expect(await buildContextDigest({ cwd })).toBe('');
-});
-
-test('epicId absent from active-index.json returns empty string', async () => {
-  const cwd = await mkCwd();
-  const digest = await buildContextDigest({ cwd, epicId: 'psess-does-not-exist' });
-  expect(digest).toBe('');
-});
-
-test('empty transcript still returns goalText only, no throw', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, { goalText: 'Empty transcript epic', status: 'proposed', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-
-  const digest = await buildContextDigest({ cwd, epicId });
-  expect(digest).toBe('Empty transcript epic');
-});
-
-test('maxChars truncation drops the oldest turns first, never a mid-turn slice', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, { goalText: 'Truncation epic', status: 'proposed', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-  await appendTurn(cwd, epicId, { role: 'user', text: 'oldest turn text goes here' });
-  await appendTurn(cwd, epicId, { role: 'assistant', text: 'middle turn text goes here' });
-  await appendTurn(cwd, epicId, { role: 'user', text: 'newest turn text goes here' });
-
-  // Small enough that only the newest turn (plus goalText) can fit.
-  const digest = await buildContextDigest({ cwd, epicId, maxChars: 80 });
-
-  expect(digest.length).toBeLessThanOrEqual(80);
-  expect(digest).toContain('newest turn text goes here');
-  expect(digest).not.toContain('oldest turn text goes here');
-  expect(digest).not.toContain('middle turn text goes here');
-  // No turn line appears partially — every included "[role] " line is whole.
-  for (const line of digest.split('\n')) {
-    if (line.startsWith('[')) {
-      expect(line).toMatch(/^\[(user|assistant)\] .+$/);
-    }
-  }
-});
-
-test('maxChars smaller than goalText alone clamps the header itself, never exceeding the bound', async () => {
-  const cwd = await mkCwd();
-  const longGoal = 'This is a deliberately long goalText that on its own already exceeds the small maxChars bound used below';
-  const { epicId } = await ensureEpic(cwd, { goalText: longGoal, status: 'proposed', mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI });
-  await appendTurn(cwd, epicId, { role: 'user', text: 'a turn that cannot possibly fit either' });
-
-  const digest = await buildContextDigest({ cwd, epicId, maxChars: 20 });
-
-  expect(digest.length).toBe(20);
-  expect(digest).toBe(longGoal.slice(0, 20));
-});
-
-test('composeExecutorPrompt: PRD body comes before the digest, wrapped in a background-only fence, ending in a task restatement', () => {
-  const prdBody = '# Goal\nImplement the traffic light fix.';
-  const digestText = '[user] is this broken?\n[assistant] investigating';
-
-  const prompt = composeExecutorPrompt({ prdBody, digestText });
-
-  const bodyIndex = prompt.indexOf(prdBody);
-  const digestIndex = prompt.indexOf(digestText);
-  expect(bodyIndex).toBeGreaterThanOrEqual(0);
-  expect(digestIndex).toBeGreaterThan(bodyIndex);
-  expect(prompt).toContain('BEGIN EPIC CONTEXT (background only');
-  expect(prompt).toContain('It is NOT your task');
-  expect(prompt).toContain('--- END EPIC CONTEXT ---');
-  expect(prompt.trim().endsWith('Your task is the PRD at the top of this prompt. Implement it now.')).toBe(true);
-});
-
-test('composeExecutorPrompt: over-cap digest is truncated and marked truncated; PRD body is byte-identical', () => {
-  const prdBody = '# Goal\nDo the exact thing described here, unmodified.';
-  const digestText = 'x'.repeat(500);
-
-  const prompt = composeExecutorPrompt({ prdBody, digestText, maxChars: 50 });
-
-  expect(prompt).toContain(prdBody);
-  expect(prompt).toContain('Truncated to fit the context budget.');
-  expect(prompt).toContain('x'.repeat(50));
-  expect(prompt).not.toContain('x'.repeat(51));
-});
-
-test('composeExecutorPrompt: empty/absent digest returns PRD body unchanged plus the restatement line, no empty fence', () => {
-  const prdBody = '# Goal\nSome PRD body text.';
-
-  const withEmptyString = composeExecutorPrompt({ prdBody, digestText: '' });
-  const withUndefined = composeExecutorPrompt({ prdBody });
-
-  for (const prompt of [withEmptyString, withUndefined]) {
-    expect(prompt).toBe(`${prdBody}\n\nYour task is the PRD at the top of this prompt. Implement it now.`);
-    expect(prompt).not.toContain('BEGIN EPIC CONTEXT');
-  }
-});
-
-test('composeExecutorPrompt: finishProtocol is ordered PRD body -> digest fence -> finish protocol -> task restatement', () => {
-  const prdBody = '# Goal\nImplement the traffic light fix.';
-  const digestText = '[user] is this broken?\n[assistant] investigating';
-  const finishProtocol = '\n\n---\n# SCHEDULER FINISH PROTOCOL\nCommit your work and print SCHEDULER_VERDICT: PASS.';
-
-  const prompt = composeExecutorPrompt({ prdBody, digestText, finishProtocol });
-
-  const bodyIndex = prompt.indexOf(prdBody);
-  const digestIndex = prompt.indexOf(digestText);
-  const fenceEndIndex = prompt.indexOf('--- END EPIC CONTEXT ---');
-  const finishIndex = prompt.indexOf('SCHEDULER FINISH PROTOCOL');
-  const restatementIndex = prompt.indexOf('Your task is the PRD at the top of this prompt. Implement it now.');
-
-  expect(bodyIndex).toBe(0);
-  expect(digestIndex).toBeGreaterThan(bodyIndex);
-  expect(fenceEndIndex).toBeGreaterThan(digestIndex);
-  expect(finishIndex).toBeGreaterThan(fenceEndIndex);
-  expect(restatementIndex).toBeGreaterThan(finishIndex);
-  expect(prompt.trim().endsWith('Your task is the PRD at the top of this prompt. Implement it now.')).toBe(true);
-});
-
-test('composeExecutorPrompt: finishProtocol with no digest is byte-identical to prdBody + finishProtocol', () => {
-  const prdBody = '# Goal\nSome PRD body text.';
-  const finishProtocol = '\n\n---\n# SCHEDULER FINISH PROTOCOL\nCommit your work and print SCHEDULER_VERDICT: PASS.';
-
-  const withEmptyDigest = composeExecutorPrompt({ prdBody, digestText: '', finishProtocol });
-  const withNoDigestKey = composeExecutorPrompt({ prdBody, finishProtocol });
-
-  for (const prompt of [withEmptyDigest, withNoDigestKey]) {
-    expect(prompt).toBe(prdBody + finishProtocol);
-    expect(prompt).not.toContain('BEGIN EPIC CONTEXT');
-  }
-});

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

@@ -1,332 +0,0 @@
-/**
- * epicMint.test.cjs — unit tests for ensureEpic's two behaviors: JOIN (every
- * automated caller, by explicit epicId) and MINT (the New Epic UI alone, via
- * mintAuthority — epicMint.cjs's SINGLE-CREATOR LAW).
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/epicMint.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 { ensureEpic, removeEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicmint-cwd-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-/** The New Epic UI's call shape — the only caller allowed to mint. */
-function mint(cwd, opts = {}, deps = {}) {
-  return ensureEpic(cwd, { mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI, ...opts }, deps);
-}
-
-function writeIndex(cwd, index) {
-  fs.writeFileSync(
-    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-    JSON.stringify(index, null, 2),
-  );
-}
-
-function readAuditRecordsForCwd(auditLog, cwd) {
-  if (!fs.existsSync(auditLog.auditLogPath())) return [];
-  return fs.readFileSync(auditLog.auditLogPath(), 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
-    .filter((record) => record && record.cwd === cwd);
-}
-
-// ─── SINGLE-CREATOR LAW ──────────────────────────────────────────────────────
-
-test('ensureEpic refuses to mint without mintAuthority, and appends an epic_mint_refused audit event', async () => {
-  const cwd = await mkCwd();
-  const auditLog = require('../lib/auditLog.cjs');
-
-  await expect(ensureEpic(cwd, { goalText: 'agent wants work done' }))
-    .rejects.toThrow(/no open Epic to join/);
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-  const records = readAuditRecordsForCwd(auditLog, cwd);
-  expect(records).toHaveLength(1);
-  expect(records[0].kind).toBe('epic_mint_refused');
-});
-
-test('ensureEpic refuses to mint when mintAuthority is a wrong/guessed value', async () => {
-  const cwd = await mkCwd();
-
-  await expect(ensureEpic(cwd, { goalText: 'sneaky', mintAuthority: 'agent' }))
-    .rejects.toThrow(/no open Epic to join/);
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-});
-
-test('ensureEpic mints when the New Epic UI presents mintAuthority', async () => {
-  const cwd = await mkCwd();
-
-  const minted = await mint(cwd, { goalText: 'human-created epic' });
-
-  expect(minted.created).toBe(true);
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[minted.epicId].status).toBe('proposed');
-  expect(index.events[minted.epicId]).toHaveLength(1);
-});
-
-test('a mint never joins a near-identical open Epic — the human asked for a new one', async () => {
-  const cwd = await mkCwd();
-
-  const first = await mint(cwd, { goalText: 'Fix the login button color' });
-  const second = await mint(cwd, { goalText: 'Fix login button colour issue' });
-
-  expect(second.created).toBe(true);
-  expect(second.epicId).not.toBe(first.epicId);
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(2);
-});
-
-// ─── JOIN ────────────────────────────────────────────────────────────────────
-
-test('ensureEpic joins the existing Epic when explicit epicId equals its promptSessionId', async () => {
-  const cwd = await mkCwd();
-
-  const first = await mint(cwd, { goalText: 'initial epic goal' });
-  const second = await ensureEpic(cwd, { goalText: 'a different PRD title', epicId: first.epicId });
-
-  expect(second.created).toBe(false);
-  expect(second.epicId).toBe(first.epicId);
-  expect(second.prdDir).toBe(first.prdDir);
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
-});
-
-test('ensureEpic joins an already-active Epic via explicit epicId', async () => {
-  const cwd = await mkCwd();
-  const first = await mint(cwd, { goalText: 'already running epic' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'active';
-  writeIndex(cwd, index);
-
-  const second = await ensureEpic(cwd, { goalText: 'unrelated text', epicId: first.epicId });
-
-  expect(second.created).toBe(false);
-  expect(second.epicId).toBe(first.epicId);
-});
-
-test('ensureEpic refuses to join a completed Epic and does NOT mint a replacement', async () => {
-  const cwd = await mkCwd();
-  const first = await mint(cwd, { goalText: 'completed epic' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'completed';
-  writeIndex(cwd, index);
-  const auditLog = require('../lib/auditLog.cjs');
-
-  await expect(ensureEpic(cwd, { goalText: 'follow-up work', epicId: first.epicId }))
-    .rejects.toThrow(/no open Epic to join/);
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
-  const refusal = readAuditRecordsForCwd(auditLog, cwd).find((r) => r.kind === 'epic_mint_refused');
-  expect(refusal).toBeDefined();
-});
-
-test('ensureEpic refuses an unknown explicit epicId rather than minting a sibling', async () => {
-  const cwd = await mkCwd();
-
-  await expect(ensureEpic(cwd, { goalText: 'do the thing', epicId: 'ticket-abc123' }))
-    .rejects.toThrow(/no open Epic to join/);
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-});
-
-// A plain object's bracket lookup with a prototype-chain key like
-// "__proto__"/"constructor" returns a truthy Object.prototype member even
-// when no such Epic was ever written — without an own-property check, this
-// would make the join gate falsely report a match.
-for (const pollutedKey of ['__proto__', 'constructor', 'toString', 'hasOwnProperty']) {
-  test(`ensureEpic refuses to "join" the prototype-chain key "${pollutedKey}"`, async () => {
-    const cwd = await mkCwd();
-
-    await expect(ensureEpic(cwd, { epicId: pollutedKey })).rejects.toThrow(/no open Epic to join/);
-
-    expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-  });
-}
-
-// ─── removeEpic ──────────────────────────────────────────────────────────────
-
-test('removeEpic deletes a minted Epic from both sessions and events maps', async () => {
-  const cwd = await mkCwd();
-  const minted = await mint(cwd, { goalText: 'to be rolled back' });
-
-  const removed = await removeEpic(cwd, minted.epicId);
-
-  expect(removed).toBe(true);
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[minted.epicId]).toBeUndefined();
-  expect(index.events[minted.epicId]).toBeUndefined();
-});
-
-test('removeEpic is a no-op (returns false) for an unknown epicId', async () => {
-  const cwd = await mkCwd();
-  await mint(cwd, { goalText: 'unrelated epic' });
-
-  expect(await removeEpic(cwd, 'nonexistent-epic-id')).toBe(false);
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
-});
-
-test('removeEpic refuses to report success for the prototype-chain key "__proto__"', async () => {
-  const cwd = await mkCwd();
-  expect(await removeEpic(cwd, '__proto__')).toBe(false);
-});
-
-// ─── written record ──────────────────────────────────────────────────────────
-
-test('ensureEpic persists the passed source onto the written active-index.json session record', async () => {
-  const cwd = await mkCwd();
-  const source = { producer: 'new-epic-ui' };
-
-  const minted = await mint(cwd, { goalText: 'epic with source', source });
-
-  expect(readActiveIndex(cwd).sessions[minted.epicId].source).toEqual(source);
-});
-
-test('ensureEpic omits source from the written record when not passed', async () => {
-  const cwd = await mkCwd();
-
-  const minted = await mint(cwd, { goalText: 'sourceless epic' });
-
-  expect('source' in readActiveIndex(cwd).sessions[minted.epicId]).toBe(false);
-});
-
-test('ensureEpic mints successfully for a real-world call shape carrying tag, openingPrompt, and source', async () => {
-  const cwd = await mkCwd();
-
-  const minted = await mint(cwd, {
-    goalText: 'Fix the merge validation',
-    tag: 'bug',
-    openingPrompt: 'full opening prompt text',
-    source: { producer: 'new-epic-ui' },
-  });
-
-  const session = readActiveIndex(cwd).sessions[minted.epicId];
-  expect(session.tag).toBe('bug');
-  expect(session.openingPrompt).toBe('full opening prompt text');
-  expect(session.source).toEqual({ producer: 'new-epic-ui' });
-});
-
-// ─── BORN-PROPOSED LAW ───────────────────────────────────────────────────────
-
-test('ensureEpic mints with status "proposed" by default', async () => {
-  const cwd = await mkCwd();
-
-  const minted = await mint(cwd, { goalText: 'default status epic' });
-
-  expect(readActiveIndex(cwd).sessions[minted.epicId].status).toBe('proposed');
-});
-
-test('ensureEpic throws when a mint is requested with status "active", and appends an audit event', async () => {
-  const cwd = await mkCwd();
-  const auditLog = require('../lib/auditLog.cjs');
-
-  await expect(mint(cwd, { goalText: 'should never mint active', status: 'active' }))
-    .rejects.toThrow(/born 'proposed'/);
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-  const records = readAuditRecordsForCwd(auditLog, cwd);
-  expect(records).toHaveLength(1);
-  expect(records[0].kind).toBe('epic_mint_refused');
-  expect(records[0].status).toBe('active');
-});
-
-test('ensureEpic refuses the mint and appends an epic_mint_refused audit event when the constructed session object fails schema validation', async () => {
-  const cwd = await mkCwd();
-  const auditLog = require('../lib/auditLog.cjs');
-  const schema = require('../lib/promptSessionSchema.cjs');
-
-  // The real construction in ensureEpic is hardcoded and always produces a
-  // valid PromptSession, so to exercise the fail-closed wiring we simulate
-  // a corrupted construction by monkeypatching the schema module's exported
-  // validator in place — epicMint.cjs reads `schema.assertValidPromptSession`
-  // off the same exports object at call time (property lookup, not a
-  // destructured copy), so mutating it here is visible to ensureEpic.
-  const original = schema.assertValidPromptSession;
-  schema.assertValidPromptSession = () => {
-    throw new Error('assertValidPromptSession: invalid PromptSession shape — forced test failure');
-  };
-  try {
-    await expect(mint(cwd, { goalText: 'should be refused by schema validation' }))
-      .rejects.toThrow(/forced test failure/);
-  } finally {
-    schema.assertValidPromptSession = original;
-  }
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-  const records = readAuditRecordsForCwd(auditLog, cwd);
-  expect(records).toHaveLength(1);
-  expect(records[0].kind).toBe('epic_mint_refused');
-  expect(records[0].reason).toMatch(/forced test failure/);
-});
-
-// ─── AGENTTYPE → PERSONA FK (write-time existence check) ────────────────────
-// "throw on write, report on read" — a mint whose agentType names a persona
-// that doesn't resolve is refused outright; a persona that goes dangling
-// LATER (renamed/deleted after the Epic was minted) is legitimate history,
-// left to agentModelResolve.cjs's readOverlayAwarePersonaModel (stays
-// permissive) and the ops-hygiene sweep to report.
-
-test('minting with an unknown agentType throws and names the two paths checked', async () => {
-  const cwd = await mkCwd();
-
-  await expect(mint(cwd, { goalText: 'bad persona ref', agentType: 'no-such-persona' }))
-    .rejects.toThrow(/no-such-persona/);
-  await expect(mint(cwd, { goalText: 'bad persona ref', agentType: 'no-such-persona' }))
-    .rejects.toThrow(new RegExp(path.join(cwd, '.claude', 'agents', 'no-such-persona.md').replace(/[.*+?^${}()|[\]\\]/g, '\\$&')));
-
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
-});
-
-test('minting with a valid (globally-resolvable) agentType succeeds via an injected personaExists dep', async () => {
-  const cwd = await mkCwd();
-
-  const minted = await mint(cwd, {
-    goalText: 'good persona ref',
-    agentType: 'architect',
-  }, { personaExists: () => true });
-
-  expect(minted.created).toBe(true);
-  expect(readActiveIndex(cwd).sessions[minted.epicId].agentType).toBe('architect');
-});
-
-test('minting with a project-overlay-only persona succeeds', async () => {
-  const cwd = await mkCwd();
-  const overlayDir = path.join(cwd, '.claude', 'agents');
-  fs.mkdirSync(overlayDir, { recursive: true });
-  fs.writeFileSync(path.join(overlayDir, 'overlay-only.md'), '---\nname: overlay-only\n---\nbody\n');
-
-  const minted = await mint(cwd, { goalText: 'overlay persona ref', agentType: 'overlay-only' });
-
-  expect(minted.created).toBe(true);
-  expect(readActiveIndex(cwd).sessions[minted.epicId].agentType).toBe('overlay-only');
-});
-
-test('minting with no agentType at all is unaffected by the persona check', async () => {
-  const cwd = await mkCwd();
-  const minted = await mint(cwd, { goalText: 'no persona at all' });
-  expect(minted.created).toBe(true);
-});

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

@@ -1,64 +0,0 @@
-/**
- * epicMintTelemetryTap.test.cjs — ensureEpic() fires the 'epic.create'
- * counter exactly once on a genuine mint (created: true), and not when an
- * existing open Epic is joined instead.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/epicMintTelemetryTap.test.cjs
- */
-'use strict';
-
-import { test, expect, afterEach, beforeEach } from 'vitest';
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const countersPath = require.resolve('../lib/telemetryCounters.cjs');
-const epicMintPath = require.resolve('../lib/epicMint.cjs');
-
-let calls;
-const tmpDirs = [];
-
-beforeEach(() => {
-  calls = [];
-  require.cache[countersPath] = {
-    id: countersPath,
-    filename: countersPath,
-    loaded: true,
-    exports: { trackEpicCreate: () => calls.push(true) },
-  };
-  delete require.cache[epicMintPath];
-});
-
-afterEach(async () => {
-  delete require.cache[countersPath];
-  delete require.cache[epicMintPath];
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-epicmint-telemetry-cwd-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-test('a genuine mint fires epic.create exactly once', async () => {
-  const { ensureEpic, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-  const cwd = await mkCwd();
-  const result = await ensureEpic(cwd, { mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI, goalText: 'do the thing' });
-  expect(result.created).toBe(true);
-  expect(calls).toEqual([true]);
-});
-
-test('joining an existing open Epic does NOT fire epic.create', async () => {
-  const { ensureEpic, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-  const cwd = await mkCwd();
-  const minted = await ensureEpic(cwd, { mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI, goalText: 'do the thing' });
-  calls.length = 0;
-
-  const joined = await ensureEpic(cwd, { epicId: minted.epicId, goalText: 'do the thing' });
-  expect(joined.created).toBe(false);
-  expect(calls).toEqual([]);
-});

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

@@ -1,110 +0,0 @@
-/**
- * epicStatusMirror.test.cjs — every write path that changes an Epic's status
- * in active-index.json must leave the SAME status mirrored onto
- * prompt-sessions/<id>.json (epicStatusMirror.cjs), so a lost/clobbered index
- * can be reconstructed (activeIndexRebuild.cjs) without silently erasing
- * open Epics.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/epicStatusMirror.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 { ensureEpic, removeEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
-const { mergeActiveIndex } = require('../lib/activeIndexMerge.cjs');
-const { epicMirrorPath } = require('../lib/epicStatusMirror.cjs');
-const config = require('../config.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-async function mkCwd() {
-  const cwd = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-statusmirror-cwd-'));
-  config.addAllowedRoot(cwd);
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-function readMirror(cwd, epicId) {
-  return JSON.parse(fs.readFileSync(epicMirrorPath(cwd, epicId), 'utf8'));
-}
-
-test('minting an Epic leaves the file\'s status equal to the index row\'s', async () => {
-  const cwd = await mkCwd();
-
-  const { epicId } = await ensureEpic(cwd, {
-    goalText: 'a fresh Epic',
-    mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI,
-  });
-
-  const index = readActiveIndex(cwd);
-  const mirror = readMirror(cwd, epicId);
-  expect(mirror.status).toBe(index.sessions[epicId].status);
-  expect(mirror.status).toBe('proposed');
-  expect(mirror.cwd).toBe(cwd);
-  expect(mirror.goalText).toBe('a fresh Epic');
-  expect(typeof mirror.indexedAt).toBe('string');
-  expect(mirror.archivedAt).toBeNull();
-});
-
-test('the approve/start transition (mergeActiveIndex) updates the file\'s status to match', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, {
-    goalText: 'to be started',
-    mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI,
-  });
-
-  const proposedIndex = readActiveIndex(cwd);
-  const activated = { ...proposedIndex.sessions[epicId], status: 'active' };
-  await mergeActiveIndex(cwd, {
-    sessions: { [epicId]: activated },
-    events: proposedIndex.events,
-  });
-
-  const index = readActiveIndex(cwd);
-  const mirror = readMirror(cwd, epicId);
-  expect(index.sessions[epicId].status).toBe('active');
-  expect(mirror.status).toBe('active');
-  expect(mirror.status).toBe(index.sessions[epicId].status);
-});
-
-test('removeEpic (mint rollback) deletes the mirror file too, leaving no orphan', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, {
-    goalText: 'will be rolled back',
-    mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI,
-  });
-  expect(fs.existsSync(epicMirrorPath(cwd, epicId))).toBe(true);
-
-  await removeEpic(cwd, epicId);
-
-  expect(fs.existsSync(epicMirrorPath(cwd, epicId))).toBe(false);
-  expect(readActiveIndex(cwd).sessions[epicId]).toBeUndefined();
-});
-
-test('a merge that tombstones an Epic leaves its prior mirror file in place (rebuild excludes it via the tombstone, not file deletion)', async () => {
-  const cwd = await mkCwd();
-  const { epicId } = await ensureEpic(cwd, {
-    goalText: 'to be removed',
-    mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI,
-  });
-
-  await mergeActiveIndex(cwd, { sessions: {}, events: {}, removedIds: [epicId] });
-
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[epicId]).toBeUndefined();
-  expect(index.tombstones[epicId]).toBeDefined();
-  // The mirror file is untouched — activeIndexRebuild.cjs is what must keep
-  // this id out, by consulting tombstones, not by the file being gone.
-  expect(fs.existsSync(epicMirrorPath(cwd, epicId))).toBe(true);
-});