claude-code-session-manager 0.58.0 → 0.60.0

package/dist/index.html

@@ -7,10 +7,10 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DEQzGYa6.js"></script>
+    <script type="module" crossorigin src="./assets/index-DtNip-Zx.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-DwUffaDq.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-CPMP2XZ_.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.58.0",
+  "version": "0.60.0",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",

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

@@ -8,21 +8,29 @@
 
 import { test, expect } from 'vitest';
 
-const { classifyLine, trimContentArray, makeRaw, MAX_RAW_STR, EXEMPT_TYPES } = require('../lib/classifyTranscriptLine.cjs');
+const {
+  classifyLine,
+  trimContentArray,
+  makeRaw,
+  buildPreviewText,
+  MAX_RAW_STR,
+  PREVIEW_CHARS,
+  EXEMPT_TYPES,
+} = require('../lib/classifyTranscriptLine.cjs');
 
-test('classifyLine returns null for non-object input', () => {
-  expect(classifyLine(null)).toBeNull();
-  expect(classifyLine('not an object')).toBeNull();
+test('classifyLine returns [] for non-object input', () => {
+  expect(classifyLine(null)).toEqual([]);
+  expect(classifyLine('not an object')).toEqual([]);
 });
 
 test('classifyLine tags usage events', () => {
-  const ev = classifyLine({ usage: { input_tokens: 10, output_tokens: 5 } });
+  const [ev] = classifyLine({ usage: { input_tokens: 10, output_tokens: 5 } });
   expect(ev.kind).toBe('usage');
   expect(ev.data).toEqual({ input_tokens: 10, output_tokens: 5 });
 });
 
 test('classifyLine tags TodoWrite tool_use as todo_write', () => {
-  const ev = classifyLine({
+  const [ev] = classifyLine({
     message: { content: [{ type: 'tool_use', name: 'TodoWrite', input: { todos: [{ content: 'x' }] } }] },
   });
   expect(ev.kind).toBe('todo_write');
@@ -30,14 +38,14 @@ test('classifyLine tags TodoWrite tool_use as todo_write', () => {
 });
 
 test('classifyLine tags ExitPlanMode as plan', () => {
-  const ev = classifyLine({
+  const [ev] = classifyLine({
     message: { content: [{ type: 'tool_use', name: 'ExitPlanMode', input: { plan: 'do things' } }] },
   });
   expect(ev.kind).toBe('plan');
 });
 
 test('classifyLine tags Agent/Task tool_use as agent_spawn with toolUseId', () => {
-  const ev = classifyLine({
+  const [ev] = classifyLine({
     message: { content: [{ type: 'tool_use', name: 'Agent', id: 'tool-1', input: { description: 'do work' } }] },
   });
   expect(ev.kind).toBe('agent_spawn');
@@ -45,7 +53,7 @@ test('classifyLine tags Agent/Task tool_use as agent_spawn with toolUseId', () =
 });
 
 test('classifyLine tags generic tool_use blocks', () => {
-  const ev = classifyLine({
+  const [ev] = classifyLine({
     message: { content: [{ type: 'tool_use', name: 'Bash', id: 'tool-2', input: { command: 'ls' } }] },
   });
   expect(ev.kind).toBe('tool_use');
@@ -53,18 +61,62 @@ test('classifyLine tags generic tool_use blocks', () => {
 });
 
 test('classifyLine tags tool_result blocks with toolUseId', () => {
-  const ev = classifyLine({
+  const [ev] = classifyLine({
     message: { content: [{ type: 'tool_result', tool_use_id: 'tool-1' }] },
   });
   expect(ev.kind).toBe('tool_result');
   expect(ev.data).toEqual({ toolUseId: 'tool-1' });
 });
 
-test('classifyLine falls back to message kind', () => {
-  const ev = classifyLine({ type: 'assistant', message: { content: 'hello' } });
+test('classifyLine falls back to message kind for non-array content', () => {
+  const [ev] = classifyLine({ type: 'assistant', message: { content: 'hello' } });
   expect(ev.kind).toBe('assistant');
 });
 
+test('CORE: a content array of [text, tool_use, tool_use] emits exactly 3 events, not 1', () => {
+  const events = classifyLine({
+    type: 'assistant',
+    message: {
+      content: [
+        { type: 'text', text: 'doing two things' },
+        { type: 'tool_use', name: 'Bash', id: 'tu-1', input: { command: 'ls' } },
+        { type: 'tool_use', name: 'Bash', id: 'tu-2', input: { command: 'pwd' } },
+      ],
+    },
+  });
+  expect(events).toHaveLength(3);
+  expect(events[0].kind).toBe('assistant'); // text block inherits the message's own type
+  expect(events[0].data).toBe('doing two things');
+  expect(events[1].kind).toBe('tool_use');
+  expect(events[1].data.id).toBe('tu-1');
+  expect(events[2].kind).toBe('tool_use');
+  expect(events[2].data.id).toBe('tu-2');
+});
+
+test('CORE: a message carrying both usage AND non-empty content emits the usage event AND the content event(s)', () => {
+  const events = classifyLine({
+    type: 'assistant',
+    usage: { input_tokens: 100, output_tokens: 40 },
+    message: { content: [{ type: 'text', text: 'hello' }] },
+  });
+  expect(events).toHaveLength(2);
+  expect(events.map((e) => e.kind).sort()).toEqual(['assistant', 'usage']);
+  const usageEv = events.find((e) => e.kind === 'usage');
+  expect(usageEv.data).toEqual({ input_tokens: 100, output_tokens: 40 });
+  const textEv = events.find((e) => e.kind === 'assistant');
+  expect(textEv.data).toBe('hello');
+});
+
+test('unknown/future content block types are surfaced, not dropped', () => {
+  const events = classifyLine({
+    type: 'assistant',
+    message: { content: [{ type: 'server_tool_use', id: 'x', input: {} }] },
+  });
+  expect(events).toHaveLength(1);
+  expect(events[0].kind).toBe('content_server_tool_use');
+  expect(events[0].data).toEqual({ type: 'server_tool_use', id: 'x', input: {} });
+});
+
 test('trimContentArray passes through non-array input', () => {
   expect(trimContentArray('not-an-array')).toBe('not-an-array');
 });
@@ -76,15 +128,74 @@ test('trimContentArray truncates long text fields past MAX_RAW_STR', () => {
   expect(block.text.endsWith('…')).toBe(true);
 });
 
-test('trimContentArray leaves EXEMPT_TYPES blocks untouched', () => {
-  expect(EXEMPT_TYPES.has('tool_result')).toBe(true);
-  expect(EXEMPT_TYPES.has('tool_use')).toBe(true);
+test('trimContentArray now trims tool_use/tool_result blocks too (EXEMPT_TYPES is empty — orchestrator.ts/race.ts, the sole prior consumers, were deleted 2026-07-30)', () => {
+  expect(EXEMPT_TYPES.size).toBe(0);
   const longText = 'a'.repeat(MAX_RAW_STR + 100);
   const [block] = trimContentArray([{ type: 'tool_use', text: longText }]);
-  expect(block.text.length).toBe(longText.length);
+  expect(block.text.length).toBe(MAX_RAW_STR + 1);
+  expect(block.text.endsWith('…')).toBe(true);
 });
 
-test('makeRaw builds slim projection from message content', () => {
+test('makeRaw builds a projection from message content', () => {
   const raw = makeRaw({ message: { content: [{ type: 'text', text: 'hi' }] } });
   expect(raw.message.content).toEqual([{ type: 'text', text: 'hi' }]);
 });
+
+test('CORE: makeRaw preserves every top-level field on the line, not just message.content', () => {
+  const line = {
+    type: 'assistant',
+    message: { content: [{ type: 'text', text: 'hi' }] },
+    attributionSkill: 'develop',
+    attributionPlugin: 'session-manager-dev',
+    attributionMcpServer: 'some-server',
+    attributionMcpTool: 'some_tool',
+    effort: 'high',
+    gitBranch: 'main',
+    isSidechain: false,
+    isMeta: true,
+    requestId: 'req-123',
+    isApiErrorMessage: false,
+    interruptedByShutdown: false,
+    permissionMode: 'default',
+    promptSource: 'user',
+    toolUseResult: { ok: true },
+  };
+  const raw = makeRaw(line);
+  for (const key of [
+    'attributionSkill',
+    'attributionPlugin',
+    'attributionMcpServer',
+    'attributionMcpTool',
+    'effort',
+    'gitBranch',
+    'isSidechain',
+    'isMeta',
+    'requestId',
+    'isApiErrorMessage',
+    'interruptedByShutdown',
+    'permissionMode',
+    'promptSource',
+    'toolUseResult',
+  ]) {
+    expect(raw[key]).toEqual(line[key]);
+  }
+});
+
+test('CORE: every event carries a bounded previewText and, when a ref is passed, the ref survives untouched', () => {
+  const ref = { filePath: '/tmp/fake.jsonl', byteOffset: 128, byteLength: 64 };
+  const [ev] = classifyLine({ type: 'user', message: { content: 'a'.repeat(PREVIEW_CHARS + 500) } }, ref);
+  expect(ev.ref).toEqual(ref);
+  expect(ev.previewText.length).toBeLessThanOrEqual(PREVIEW_CHARS + 1);
+  expect(ev.previewText.endsWith('…')).toBe(true);
+});
+
+test('classifyLine omits ref (null) when the caller has no file context', () => {
+  const [ev] = classifyLine({ usage: { input_tokens: 1, output_tokens: 1 } });
+  expect(ev.ref).toBeNull();
+});
+
+test('buildPreviewText caps at PREVIEW_CHARS', () => {
+  const s = buildPreviewText('x'.repeat(PREVIEW_CHARS + 50));
+  expect(s.length).toBe(PREVIEW_CHARS + 1);
+  expect(s.endsWith('…')).toBe(true);
+});

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

@@ -13,7 +13,7 @@ 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 { 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');
@@ -98,3 +98,43 @@ test('maxChars smaller than goalText alone clamps the header itself, never excee
   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');
+  }
+});

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

@@ -0,0 +1,291 @@
+/**
+ * epicValidationHook.test.cjs — PRD 986: a PRD check-in triggers validation
+ * in the authoring Epic; it never asserts the PRD is done.
+ *
+ * Covers the PRD's five required cases:
+ *   (a) a completed check-in enqueues exactly one validation prompt naming
+ *       the PRD slug;
+ *   (b) a check-in for a non-active Epic enqueues nothing;
+ *   (c) a second check-in for the same (epicId, prdSlug) enqueues nothing;
+ *   (d) the enqueued prompt contains the PRD's absolute path and the
+ *       VERIFIED/REFUTED instruction (plus the not-evidence warning and the
+ *       git diff --stat / empty-diff-is-REFUTED rule);
+ *   (e) LOOP GUARD — an appended event that is a validation result never
+ *       enqueues a further prompt.
+ * Plus: the SM_EPIC_VALIDATION_DISABLE kill-switch, the born-'unvalidated'
+ * stamp, and end-to-end wiring through notifyOriginatingTab.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/epicValidationHook.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi, beforeEach, afterEach } from 'vitest';
+const {
+  maybeEnqueueValidationPrompt,
+  buildValidationPrompt,
+  __resetForTests,
+} = require('../lib/epicValidationHook.cjs');
+const { notifyOriginatingTab } = require('../scheduler.cjs');
+
+const EPIC = 'epic-986';
+const SLUG = '986-example-prd';
+const PRD_PATH = '/abs/path/to/session-manager-operations/scheduler/epics/epic-986/prds-archived/986-example-prd.md';
+
+/** An active-index snapshot AS IT LOOKS RIGHT AFTER the scheduler's check-in
+ *  append: exactly one validation-stamped response event for this prdSlug. */
+function indexAfterCheckin({ status = 'active', extraEvents = [] } = {}) {
+  return {
+    sessions: { [EPIC]: { id: EPIC, status } },
+    events: {
+      [EPIC]: [
+        { id: 'e1', promptSessionId: EPIC, kind: 'prompt', causedByEventId: null, at: '2026-08-02T00:00:00Z', text: 'goal' },
+        {
+          id: 'e2', promptSessionId: EPIC, kind: 'response', causedByEventId: 'e1',
+          at: '2026-08-02T01:00:00Z', text: `PRD ${SLUG} finished: completed.`,
+          prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated',
+        },
+        ...extraEvents,
+      ],
+    },
+  };
+}
+
+function callArgs(overrides = {}) {
+  return {
+    cwd: '/some/cwd',
+    epicId: EPIC,
+    prdSlug: SLUG,
+    prdPath: PRD_PATH,
+    outcome: 'completed',
+    eventValidation: 'unvalidated',
+    ...overrides,
+  };
+}
+
+beforeEach(() => {
+  __resetForTests();
+  delete process.env.SM_EPIC_VALIDATION_DISABLE;
+});
+
+afterEach(() => {
+  delete process.env.SM_EPIC_VALIDATION_DISABLE;
+});
+
+// ─── (a) completed check-in → exactly one prompt naming the slug ────────────
+
+test('(a) a completed check-in enqueues exactly one validation prompt naming the PRD slug', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res.enqueued).toBe(true);
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+  expect(sendPrompt).toHaveBeenCalledWith(EPIC, expect.stringContaining(SLUG));
+});
+
+// ─── (b) non-active Epic → nothing ──────────────────────────────────────────
+
+test('(b) a check-in for a completed (non-active) Epic enqueues nothing', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin({ status: 'completed' }));
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'epic-not-active' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('(b) an unknown Epic (no active-index entry) enqueues nothing — join-only, never creates an Epic', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => ({ sessions: {}, events: {} }));
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'epic-not-active' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+// ─── (c) second check-in for the same (epicId, prdSlug) → nothing ───────────
+
+test('(c) a second check-in for the same (epicId, prdSlug) enqueues nothing (in-memory guard)', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  expect(maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex }).enqueued).toBe(true);
+  const second = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(second).toEqual({ enqueued: false, reason: 'already-fired' });
+  expect(sendPrompt).toHaveBeenCalledTimes(1);
+});
+
+test('(c) durable guard: two validation-stamped check-in events already on the chain skip even after a process restart emptied the in-memory set', () => {
+  const sendPrompt = vi.fn();
+  // Chain carries the current check-in PLUS an earlier one for the same slug
+  // (a re-notify after restart appends a second response event).
+  const readActiveIndex = vi.fn(() => indexAfterCheckin({
+    extraEvents: [{
+      id: 'e3', promptSessionId: EPIC, kind: 'response', causedByEventId: 'e2',
+      at: '2026-08-02T02:00:00Z', text: `PRD ${SLUG} finished: completed.`,
+      prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated',
+    }],
+  }));
+
+  __resetForTests(); // simulate the restart: in-memory set is empty
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'already-fired-durable' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('(c) a different PRD slug for the same Epic still fires — the guard is per (epicId, prdSlug) pair, not per Epic', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  expect(maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex }).enqueued).toBe(true);
+  const other = maybeEnqueueValidationPrompt(
+    callArgs({ prdSlug: '987-other-prd', prdPath: '/abs/987-other-prd.md' }),
+    { sendPrompt, readActiveIndex: vi.fn(() => ({ sessions: { [EPIC]: { id: EPIC, status: 'active' } }, events: { [EPIC]: [{ id: 'x', kind: 'response', prdSlug: '987-other-prd', validation: 'unvalidated' }] } })) },
+  );
+
+  expect(other.enqueued).toBe(true);
+  expect(sendPrompt).toHaveBeenCalledTimes(2);
+});
+
+// ─── (d) prompt content ─────────────────────────────────────────────────────
+
+test('(d) the enqueued prompt contains the PRD absolute path, the unverified-claim label, and the VERIFIED/REFUTED instruction', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  const prompt = sendPrompt.mock.calls[0][1];
+  expect(prompt).toContain(PRD_PATH);
+  expect(prompt).toContain(SLUG);
+  expect(prompt).toContain('UNVERIFIED CLAIM');
+  expect(prompt).toContain('"completed"');
+  expect(prompt).toContain('VERIFIED or REFUTED');
+  expect(prompt).toMatch(/file:line|command output/);
+  // AC #3: the not-evidence warning + the git diff --stat / empty-diff rule.
+  expect(prompt).toContain('exit code of 0');
+  expect(prompt).toContain('NOT evidence');
+  expect(prompt).toContain('git diff --stat');
+  expect(prompt).toMatch(/empty diff.*REFUTED/i);
+  // Acceptance-criteria-against-working-tree instruction.
+  expect(prompt).toMatch(/Acceptance criteria/i);
+  expect(prompt).toMatch(/working tree/i);
+});
+
+test('(d) buildValidationPrompt degrades gracefully when the PRD path could not be resolved', () => {
+  const prompt = buildValidationPrompt({ prdSlug: SLUG, prdPath: null, outcome: 'failed' });
+  expect(prompt).toContain(SLUG);
+  expect(prompt).toContain('path could not be resolved');
+  expect(prompt).toContain('"failed"');
+});
+
+// ─── (e) LOOP GUARD ─────────────────────────────────────────────────────────
+
+test('(e) LOOP GUARD: an appended event that is a validation result never enqueues a further prompt', () => {
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  for (const eventValidation of ['verified', 'refuted', 'validating', undefined]) {
+    const res = maybeEnqueueValidationPrompt(callArgs({ eventValidation }), { sendPrompt, readActiveIndex });
+    expect(res).toEqual({ enqueued: false, reason: 'not-a-checkin' });
+  }
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+// ─── kill-switch ────────────────────────────────────────────────────────────
+
+test('SM_EPIC_VALIDATION_DISABLE=1 turns the hook off entirely', () => {
+  process.env.SM_EPIC_VALIDATION_DISABLE = '1';
+  const sendPrompt = vi.fn();
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+
+  const res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex });
+
+  expect(res).toEqual({ enqueued: false, reason: 'disabled' });
+  expect(sendPrompt).not.toHaveBeenCalled();
+  expect(readActiveIndex).not.toHaveBeenCalled();
+});
+
+// ─── never throws ───────────────────────────────────────────────────────────
+
+test('a sendPrompt that throws is swallowed and logged, never propagated (fire-and-forget contract)', () => {
+  const sendPrompt = vi.fn(() => { throw new Error('IPC gone'); });
+  const readActiveIndex = vi.fn(() => indexAfterCheckin());
+  const log = { error: vi.fn() };
+
+  let res;
+  expect(() => {
+    res = maybeEnqueueValidationPrompt(callArgs(), { sendPrompt, readActiveIndex, log });
+  }).not.toThrow();
+  expect(res).toEqual({ enqueued: false, reason: 'error' });
+  expect(log.error).toHaveBeenCalled();
+});
+
+// ─── wiring through notifyOriginatingTab ────────────────────────────────────
+
+test('notifyOriginatingTab: a routed check-in stamps validation:unvalidated and fires the validation hook once with the Epic id + slug', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn(() => ({ enqueued: true }));
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, path: PRD_PATH }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: SLUG, status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledWith(
+    '/some/cwd', EPIC, expect.stringContaining(SLUG),
+    expect.objectContaining({ prdSlug: SLUG, outcome: 'completed', validation: 'unvalidated' }),
+  );
+  expect(enqueueValidation).toHaveBeenCalledTimes(1);
+  expect(enqueueValidation).toHaveBeenCalledWith(
+    expect.objectContaining({
+      cwd: '/some/cwd',
+      epicId: EPIC,
+      prdSlug: SLUG,
+      outcome: 'completed',
+      eventValidation: 'unvalidated',
+    }),
+    expect.objectContaining({ sendPrompt }),
+  );
+  // The check-in routed into the Epic chain — no tab-prompt fallback fires.
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('notifyOriginatingTab: a REFUSED append (unknown/completed Epic) never fires the validation hook', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => false);
+  const enqueueValidation = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, sourceTabId: 'tab-x' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: SLUG, status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+  );
+
+  expect(enqueueValidation).not.toHaveBeenCalled();
+});
+
+test('notifyOriginatingTab: a validation hook that throws never blocks the notification path', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn(() => { throw new Error('boom'); });
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: EPIC, path: PRD_PATH }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: SLUG, status: 'failed', cwd: '/some/cwd' },
+      { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation },
+    ),
+  ).resolves.not.toThrow();
+});