claude-code-session-manager 0.57.1 → 0.58.0

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

@@ -0,0 +1,100 @@
+/**
+ * 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 } = 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));
+});

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

@@ -1,8 +1,7 @@
 /**
- * epicMint.test.cjs — unit tests for ensureEpic's sourcePromptId join
- * semantics (see PRD authoring notes: sourcePromptId must be an existing
- * Epic's promptSessionId, i.e. its active-index.json sessions key — NOT a
- * PromptTicket.id).
+ * 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
  */
@@ -14,7 +13,7 @@ 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, findJoinableEpic } = require('../lib/epicMint.cjs');
+const { ensureEpic, removeEpic, readActiveIndex, MINT_AUTHORITY_NEW_EPIC_UI } = require('../lib/epicMint.cjs');
 
 const tmpDirs = [];
 afterEach(async () => {
@@ -30,297 +29,256 @@ async function mkCwd() {
   return cwd;
 }
 
-test('ensureEpic mints a new Epic when explicit epicId matches no existing Epic (documents current behavior for a stray PromptTicket.id)', async () => {
-  const cwd = await mkCwd();
-  const notAPromptSessionId = 'ticket-abc123';
+/** The New Epic UI's call shape — the only caller allowed to mint. */
+function mint(cwd, opts = {}) {
+  return ensureEpic(cwd, { mintAuthority: MINT_AUTHORITY_NEW_EPIC_UI, ...opts });
+}
 
-  const result = await ensureEpic(cwd, { goalText: 'do the thing', epicId: notAPromptSessionId });
+function writeIndex(cwd, index) {
+  fs.writeFileSync(
+    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
+    JSON.stringify(index, null, 2),
+  );
+}
 
-  expect(result.created).toBe(true);
-  expect(result.epicId).not.toBe(notAPromptSessionId);
+function readAuditRecordsForCwd(auditLog, cwd) {
+  if (!fs.existsSync(auditLog.AUDIT_LOG_PATH)) return [];
+  return fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter((record) => record && record.cwd === cwd);
+}
 
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[notAPromptSessionId]).toBeUndefined();
-  expect(index.sessions[result.epicId]).toBeDefined();
-  expect(Object.keys(index.sessions)).toHaveLength(1);
-});
+// ─── SINGLE-CREATOR LAW ──────────────────────────────────────────────────────
 
-test('ensureEpic joins the existing Epic when explicit epicId equals its promptSessionId', async () => {
+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');
 
-  const first = await ensureEpic(cwd, { goalText: 'initial epic goal' });
-  expect(first.created).toBe(true);
-
-  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);
+  await expect(ensureEpic(cwd, { goalText: 'agent wants work done' }))
+    .rejects.toThrow(/no open Epic to join/);
 
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(1);
+  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('removeEpic deletes a minted Epic from both sessions and events maps', async () => {
+test('ensureEpic refuses to mint when mintAuthority is a wrong/guessed value', async () => {
   const cwd = await mkCwd();
-  const minted = await ensureEpic(cwd, { goalText: 'to be rolled back' });
-  expect(readActiveIndex(cwd).sessions[minted.epicId]).toBeDefined();
 
-  const removed = await removeEpic(cwd, minted.epicId);
+  await expect(ensureEpic(cwd, { goalText: 'sneaky', mintAuthority: 'agent' }))
+    .rejects.toThrow(/no open Epic to join/);
 
-  expect(removed).toBe(true);
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[minted.epicId]).toBeUndefined();
-  expect(index.events[minted.epicId]).toBeUndefined();
+  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
 });
 
-test('removeEpic is a no-op (returns false) for an unknown epicId', async () => {
+test('ensureEpic mints when the New Epic UI presents mintAuthority', async () => {
   const cwd = await mkCwd();
-  await ensureEpic(cwd, { goalText: 'unrelated epic' });
-
-  const removed = await removeEpic(cwd, 'nonexistent-epic-id');
-
-  expect(removed).toBe(false);
-  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
-});
 
-// 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 mintIfMissing:false's "join an existing Epic" gate falsely
-// report a match, defeating the restriction that a PRD write may only join
-// a real, already-approved Epic.
-for (const pollutedKey of ['__proto__', 'constructor', 'toString', 'hasOwnProperty']) {
-  test(`ensureEpic refuses to "join" the prototype-chain key "${pollutedKey}" (mintIfMissing:false)`, async () => {
-    const cwd = await mkCwd();
-
-    await expect(
-      ensureEpic(cwd, { epicId: pollutedKey, mintIfMissing: false }),
-    ).rejects.toThrow(/no existing Epic found/);
+  const minted = await mint(cwd, { goalText: 'human-created epic' });
 
-    const index = readActiveIndex(cwd);
-    expect(Object.keys(index.sessions)).toHaveLength(0);
-  });
-}
-
-test('removeEpic refuses to report success for the prototype-chain key "__proto__"', async () => {
-  const cwd = await mkCwd();
-  const removed = await removeEpic(cwd, '__proto__');
-  expect(removed).toBe(false);
+  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('ensureEpic persists the passed source onto the written active-index.json session record', async () => {
+test('a mint never joins a near-identical open Epic — the human asked for a new one', async () => {
   const cwd = await mkCwd();
-  const source = { producer: 'rca-hook', prdSlug: 'x', runId: 'y' };
 
-  const minted = await ensureEpic(cwd, { goalText: 'auto-filed epic', source });
+  const first = await mint(cwd, { goalText: 'Fix the login button color' });
+  const second = await mint(cwd, { goalText: 'Fix login button colour issue' });
 
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[minted.epicId].source).toEqual(source);
+  expect(second.created).toBe(true);
+  expect(second.epicId).not.toBe(first.epicId);
+  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(2);
 });
 
-test('ensureEpic omits source from the written record when not passed', async () => {
+// ─── JOIN ────────────────────────────────────────────────────────────────────
+
+test('ensureEpic joins the existing Epic when explicit epicId equals its promptSessionId', async () => {
   const cwd = await mkCwd();
 
-  const minted = await ensureEpic(cwd, { goalText: 'human-filed epic' });
+  const first = await mint(cwd, { goalText: 'initial epic goal' });
+  const second = await ensureEpic(cwd, { goalText: 'a different PRD title', epicId: first.epicId });
 
-  const index = readActiveIndex(cwd);
-  expect('source' in index.sessions[minted.epicId]).toBe(false);
+  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 existing open Epic when goalText is a near-identical paraphrase (no preferEpicId)', async () => {
+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 first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
-  expect(first.created).toBe(true);
-
-  const second = await ensureEpic(cwd, { goalText: 'Fix login button colour issue' });
+  const second = await ensureEpic(cwd, { goalText: 'unrelated text', epicId: first.epicId });
 
   expect(second.created).toBe(false);
   expect(second.epicId).toBe(first.epicId);
-
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(1);
 });
 
-test('ensureEpic mints a distinct Epic when goalText is genuinely unrelated', async () => {
+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');
 
-  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
-  expect(first.created).toBe(true);
+  await expect(ensureEpic(cwd, { goalText: 'follow-up work', epicId: first.epicId }))
+    .rejects.toThrow(/no open Epic to join/);
 
-  const second = await ensureEpic(cwd, { goalText: 'Add CSV export to History tab' });
+  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
+  const refusal = readAuditRecordsForCwd(auditLog, cwd).find((r) => r.kind === 'epic_mint_refused');
+  expect(refusal).toBeDefined();
+});
 
-  expect(second.created).toBe(true);
-  expect(second.epicId).not.toBe(first.epicId);
+test('ensureEpic refuses an unknown explicit epicId rather than minting a sibling', async () => {
+  const cwd = await mkCwd();
 
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(2);
+  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);
 });
 
-test('findJoinableEpic joins the preferEpicId Epic even when goalText similarity is near-zero', async () => {
-  const cwd = await mkCwd();
+// 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();
 
-  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
-  expect(first.created).toBe(true);
+    await expect(ensureEpic(cwd, { epicId: pollutedKey })).rejects.toThrow(/no open Epic to join/);
 
-  const joined = findJoinableEpic(cwd, {
-    goalText: 'Completely unrelated topic about database migrations',
-    preferEpicId: first.epicId,
+    expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
   });
+}
 
-  expect(joined).toEqual({ epicId: first.epicId, matchedBy: 'preferEpicId' });
-});
+// ─── removeEpic ──────────────────────────────────────────────────────────────
 
-test('findJoinableEpic falls through to the similarity check when preferEpicId points at a completed Epic', async () => {
+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 first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'completed';
-  fs.writeFileSync(
-    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-    JSON.stringify(index, null, 2),
-  );
-
-  // No other open Epic shares tokens with the completed one, so the
-  // fall-through similarity check finds nothing rather than joining the
-  // dead (completed) preferEpicId Epic.
-  const joined = findJoinableEpic(cwd, { goalText: 'Fix login button colour issue', preferEpicId: first.epicId });
+  const removed = await removeEpic(cwd, minted.epicId);
 
-  expect(joined).toBeNull();
+  expect(removed).toBe(true);
+  const index = readActiveIndex(cwd);
+  expect(index.sessions[minted.epicId]).toBeUndefined();
+  expect(index.events[minted.epicId]).toBeUndefined();
 });
 
-test('findJoinableEpic falls through to the similarity check when preferEpicId points at a nonexistent Epic, and can still find a match there', async () => {
+test('removeEpic is a no-op (returns false) for an unknown epicId', async () => {
   const cwd = await mkCwd();
-  const sibling = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  await mint(cwd, { goalText: 'unrelated epic' });
 
-  const joined = findJoinableEpic(cwd, { goalText: 'Fix login button colour issue', preferEpicId: 'nonexistent-epic-id' });
+  expect(await removeEpic(cwd, 'nonexistent-epic-id')).toBe(false);
+  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
+});
 
-  expect(joined).toEqual({ epicId: sibling.epicId, matchedBy: 'similarity', score: expect.any(Number) });
+test('removeEpic refuses to report success for the prototype-chain key "__proto__"', async () => {
+  const cwd = await mkCwd();
+  expect(await removeEpic(cwd, '__proto__')).toBe(false);
 });
 
-test('ensureEpic mints with status "proposed" by default', async () => {
+// ─── 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 ensureEpic(cwd, { goalText: 'default status epic' });
+  const minted = await mint(cwd, { goalText: 'epic with source', source });
 
-  const index = readActiveIndex(cwd);
-  expect(index.sessions[minted.epicId].status).toBe('proposed');
+  expect(readActiveIndex(cwd).sessions[minted.epicId].source).toEqual(source);
 });
 
-test('ensureEpic throws when a mint is requested with status "active" (born-proposed law), and appends an audit event', async () => {
+test('ensureEpic omits source from the written record when not passed', async () => {
   const cwd = await mkCwd();
-  const auditLog = require('../lib/auditLog.cjs');
 
-  await expect(
-    ensureEpic(cwd, { goalText: 'should never mint active', status: 'active' }),
-  ).rejects.toThrow(/born 'proposed'/);
+  const minted = await mint(cwd, { goalText: 'sourceless epic' });
 
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(0);
-
-  const records = fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => JSON.parse(line))
-    .filter((r) => r.cwd === cwd);
-  expect(records).toHaveLength(1);
-  expect(records[0].kind).toBe('epic_mint_refused');
-  expect(records[0].status).toBe('active');
+  expect('source' in readActiveIndex(cwd).sessions[minted.epicId]).toBe(false);
 });
 
-test('ensureEpic still joins an existing active Epic via preferEpicId even when status:"active" is requested', async () => {
+test('ensureEpic mints successfully for a real-world call shape carrying tag, openingPrompt, and source', async () => {
   const cwd = await mkCwd();
-  const first = await ensureEpic(cwd, { goalText: 'already running epic' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'active';
-  fs.writeFileSync(
-    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-    JSON.stringify(index, null, 2),
-  );
 
-  const second = await ensureEpic(cwd, { goalText: 'unrelated text', epicId: first.epicId, status: 'active' });
+  const minted = await mint(cwd, {
+    goalText: 'Fix the merge validation',
+    tag: 'bug',
+    openingPrompt: 'full opening prompt text',
+    source: { producer: 'new-epic-ui' },
+  });
 
-  expect(second.created).toBe(false);
-  expect(second.epicId).toBe(first.epicId);
+  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' });
 });
 
-test('ensureEpic falls through to a "proposed" mint when explicit epicId is archived/completed, never throwing', async () => {
+// ─── BORN-PROPOSED LAW ───────────────────────────────────────────────────────
+
+test('ensureEpic mints with status "proposed" by default', async () => {
   const cwd = await mkCwd();
-  const first = await ensureEpic(cwd, { goalText: 'completed epic' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'completed';
-  fs.writeFileSync(
-    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-    JSON.stringify(index, null, 2),
-  );
 
-  const second = await ensureEpic(cwd, { goalText: 'totally unrelated goal text here', epicId: first.epicId });
+  const minted = await mint(cwd, { goalText: 'default status epic' });
 
-  expect(second.created).toBe(true);
-  expect(second.epicId).not.toBe(first.epicId);
-  const after = readActiveIndex(cwd);
-  expect(after.sessions[second.epicId].status).toBe('proposed');
+  expect(readActiveIndex(cwd).sessions[minted.epicId].status).toBe('proposed');
 });
 
-function readAuditRecordsForCwd(auditLog, cwd) {
-  if (!fs.existsSync(auditLog.AUDIT_LOG_PATH)) return [];
-  return fs.readFileSync(auditLog.AUDIT_LOG_PATH, 'utf8')
-    .split('\n')
-    .filter(Boolean)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return null;
-      }
-    })
-    .filter((record) => record && record.cwd === cwd);
-}
-
-test('mintIfMissing:false refusal appends an epic_mint_refused audit event', async () => {
+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(ensureEpic(cwd, { goalText: 'no epic yet', mintIfMissing: false })).rejects.toThrow();
+  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].cwd).toBe(cwd);
+  expect(records[0].status).toBe('active');
 });
 
-test('not-open explicit-epicId fall-through appends an epic_mint_refused audit event', async () => {
+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 first = await ensureEpic(cwd, { goalText: 'to be completed' });
-  const index = readActiveIndex(cwd);
-  index.sessions[first.epicId].status = 'completed';
-  fs.writeFileSync(
-    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
-    JSON.stringify(index, null, 2),
-  );
   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;
+  }
 
-  await ensureEpic(cwd, { goalText: 'unrelated fresh goal xyz', epicId: first.epicId });
-
+  expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(0);
   const records = readAuditRecordsForCwd(auditLog, cwd);
-  const refusal = records.find((r) => r.kind === 'epic_mint_refused');
-  expect(refusal).toBeDefined();
-  expect(refusal.epicId).toBe(first.epicId);
-});
-
-test('ensureEpic with forceNewEpic:true mints even when a near-identical open Epic exists', async () => {
-  const cwd = await mkCwd();
-
-  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
-  expect(first.created).toBe(true);
-
-  const second = await ensureEpic(cwd, { goalText: 'Fix login button colour issue', forceNewEpic: true });
-
-  expect(second.created).toBe(true);
-  expect(second.epicId).not.toBe(first.epicId);
-
-  const index = readActiveIndex(cwd);
-  expect(Object.keys(index.sessions)).toHaveLength(2);
+  expect(records).toHaveLength(1);
+  expect(records[0].kind).toBe('epic_mint_refused');
+  expect(records[0].reason).toMatch(/forced test failure/);
 });