claude-code-session-manager 0.40.2 → 0.41.0

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

@@ -78,44 +78,37 @@ function baseJob(overrides = {}) {
 
 // ─── dedupe / new-runId ───────────────────────────────────────────────────────
 
-test('fileRcaFeedback: second call with same (slug, runId) is a no-op', async () => {
-  const cwd = makeProjectWithInbox();
-  const runDir = path.join(tmpHome, 'run1');
-  writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
+// ─── proposal filing (replaced the feedback-file inbox) ──────────────────────
 
-  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
-  expect(first.filed).toBe(true);
-
-  const second = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
-  expect(second.filed).toBe(false);
-  expect(second.reason).toBe('duplicate');
-
-  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
-  expect(files.length).toBe(1);
-});
+function readSessions(cwd) {
+  const p = path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json');
+  if (!fs.existsSync(p)) return {};
+  return JSON.parse(fs.readFileSync(p, 'utf8')).sessions ?? {};
+}
 
-test('fileRcaFeedback: new runId for the same slug files a new RCA', async () => {
+test('fileRcaFeedback: files a PROPOSED Epic carrying the RCA as its opening prompt', async () => {
   const cwd = makeProjectWithInbox();
-  const runDir1 = path.join(tmpHome, 'run1');
-  const runDir2 = path.join(tmpHome, 'run2');
-  writeRun(runDir1, 'testslug');
-  writeRun(runDir2, 'testslug');
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
   writePrd(cwd, 'testslug');
 
-  const r1 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-aaa' }), runDir: runDir1, verdict: 'transcript_errors' });
-  const r2 = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd, runId: 'run-bbb' }), runDir: runDir2, verdict: 'transcript_errors' });
-
-  expect(r1.filed).toBe(true);
-  expect(r2.filed).toBe(true);
-  expect(r1.path).not.toBe(r2.path);
+  const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  expect(res.filed).toBe(true);
+  expect(res.created).toBe(true);
 
-  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
-  expect(files.length).toBe(2);
+  const sessions = readSessions(cwd);
+  const epic = sessions[res.epicId];
+  // Nothing may auto-run: the whole point is a human gate.
+  expect(epic.status).toBe('proposed');
+  expect(epic.tag).toBe('bug');
+  expect(epic.goalText).toContain('testslug');
+  // Short title for the list, full RCA body for the first prompt.
+  expect(epic.goalText.split('\n').length).toBe(1);
+  expect(epic.openingPrompt).toContain('Root cause');
+  expect(epic.openingPrompt).toContain('prdSlug: testslug');
 });
 
-test('fileRcaFeedback: a duplicate is still detected after /process-feedback archives the file into processed/', async () => {
+test('fileRcaFeedback: a re-trigger for the same failure joins the proposal instead of duplicating it', async () => {
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
@@ -123,193 +116,35 @@ test('fileRcaFeedback: a duplicate is still detected after /process-feedback arc
   const job = baseJob({ cwd });
 
   const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
-  expect(first.filed).toBe(true);
-
-  const feedbackDir = path.join(cwd, 'session-manager-operations', 'feedback');
-  const processedDir = path.join(feedbackDir, 'processed');
-  fs.mkdirSync(processedDir, { recursive: true });
-  const fileName = path.basename(first.path);
-  fs.renameSync(first.path, path.join(processedDir, fileName));
-
   const second = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
-  expect(second.filed).toBe(false);
-  expect(second.reason).toBe('duplicate');
-  expect(second.path).toBe(path.join(processedDir, fileName));
-
-  expect(fs.existsSync(path.join(feedbackDir, fileName))).toBe(false);
-  const liveFiles = fs.readdirSync(feedbackDir).filter((f) => f !== 'processed');
-  expect(liveFiles.length).toBe(0);
-  expect(fs.readdirSync(processedDir).length).toBe(1);
+
+  expect(first.created).toBe(true);
+  expect(second.created).toBe(false);
+  expect(second.epicId).toBe(first.epicId);
+  expect(Object.keys(readSessions(cwd)).length).toBe(1);
 });
 
-test('fileRcaFeedback: investigationText updates the file in processed/ in place instead of duplicating it in the live dir', async () => {
+test('fileRcaFeedback: a different verdict for the same slug is its own proposal', async () => {
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
   writePrd(cwd, 'testslug');
-  const job = baseJob({ cwd });
-
-  const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
-  expect(first.filed).toBe(true);
-
-  const feedbackDir = path.join(cwd, 'session-manager-operations', 'feedback');
-  const processedDir = path.join(feedbackDir, 'processed');
-  fs.mkdirSync(processedDir, { recursive: true });
-  const fileName = path.basename(first.path);
-  const processedPath = path.join(processedDir, fileName);
-  fs.renameSync(first.path, processedPath);
-
-  const second = await rcaFeedbackHook.fileRcaFeedback({
-    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
-  });
-  expect(second.filed).toBe(true);
-  expect(second.updated).toBe(true);
-  expect(second.path).toBe(processedPath);
 
-  const after = fs.readFileSync(processedPath, 'utf8');
-  expect(after).toContain('## Investigation analysis');
-  expect(fs.existsSync(path.join(feedbackDir, fileName))).toBe(false);
-});
-
-// ─── failure-class matching ───────────────────────────────────────────────────
-
-test('classifyFailure: detects stuck-loop from an until/while-true/sleep tail', () => {
-  const logTail = ['doing work', 'until curl -s http://x | jq .uptime; do sleep 5; done', 'still waiting'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('stuck-loop');
-});
-
-test('classifyFailure: detects post-ac-overrun when work continues well past the last AC checkbox with no PASS', () => {
-  const lines = ['- [x] first AC item done', '- [x] last AC item done'];
-  for (let i = 0; i < 30; i++) lines.push(`extra post-AC work line ${i}`);
-  const logTail = lines.join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('post-ac-overrun');
-});
-
-test('classifyFailure: falls back to uncommitted-changes for that verdict', () => {
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'uncommitted_changes', logTail: 'no special markers here' })).toBe('uncommitted-changes');
-});
-
-test('classifyFailure: falls back to no-sentinel for no_verdict_sentinel/pass_no_commit', () => {
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail: 'clean tail, no loops' })).toBe('no-sentinel');
-});
+  const a = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+  const b = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'pass_no_commit' });
 
-test('classifyFailure: falls back to transcript-errors for transcript_errors/verify_unavailable', () => {
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'transcript_errors', logTail: 'Traceback (most recent call last)' })).toBe('transcript-errors');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'verify_unavailable', logTail: 'verifier threw' })).toBe('transcript-errors');
+  expect(a.epicId).not.toBe(b.epicId);
+  expect(Object.keys(readSessions(cwd)).length).toBe(2);
 });
 
-test('classifyFailure: unknown verdict with no matching markers falls back to unknown', () => {
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'halt', logTail: 'nothing special' })).toBe('unknown');
-});
-
-test('classifyFailure: detects self-queue from a "Launching skill: session-manager-dev:develop" tail', () => {
-  const logTail = ['doing setup', 'Launching skill: session-manager-dev:develop', 'skill running'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
-});
-
-test('classifyFailure: detects self-queue from a "Launching skill: session-manager-dev:process-feedback" tail', () => {
-  const logTail = ['doing setup', 'Launching skill: session-manager-dev:process-feedback', 'skill running'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
-});
-
-test('classifyFailure: detects self-queue from a ScheduleWakeup tool_use even when the tail also contains "sleep" (PRD 771 regression)', () => {
-  const logTail = [
-    'launching background build: eas-cli build --wait',
-    'the app will sleep between polls',
-    '{"type":"tool_use","name":"ScheduleWakeup","input":{"delaySeconds":600}}',
-  ].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('self-queue');
-});
-
-test('classifyFailure: detects already-shipped from a pass_no_commit tail citing a prior commit', () => {
-  const logTail = ['re-verified acceptance criteria', 'this work was already committed in 9cf0384', 'nothing left to change'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('already-shipped');
-});
-
-test('classifyFailure: detects already-shipped from a pass_no_commit tail with "nothing new to commit"', () => {
-  const logTail = ['checked the diff', 'nothing new to commit for this PRD', 'exiting clean'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('already-shipped');
-});
-
-test('classifyFailure: ALREADY_SHIPPED is checked before SELF_QUEUE, so a no_verdict_sentinel tail with both markers classifies as already-shipped', () => {
-  const logTail = [
-    'Launching skill: session-manager-dev:develop',
-    'the acceptance criteria were already implemented',
-  ].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail })).toBe('already-shipped');
-});
-
-test('classifyFailure: pass_no_commit tail with no already-shipped phrasing still falls back to no-sentinel (regression)', () => {
-  const logTail = ['ran the tests', 'everything looked fine', 'printed PASS'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'pass_no_commit', logTail })).toBe('no-sentinel');
-});
-
-test('classifyFailure: STUCK_LOOP/POST_AC_OVERRUN reordering does not change classification when no self-queue marker is present', () => {
-  const stuckLoopTail = ['doing work', 'until curl -s http://x | jq .uptime; do sleep 5; done', 'still waiting'].join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: stuckLoopTail })).toBe('stuck-loop');
-
-  const postAcLines = ['- [x] first AC item done', '- [x] last AC item done'];
-  for (let i = 0; i < 30; i++) postAcLines.push(`extra post-AC work line ${i}`);
-  const postAcTail = postAcLines.join('\n');
-  expect(rcaFeedbackHook.classifyFailure({ verdict: 'no_verdict_sentinel', logTail: postAcTail })).toBe('post-ac-overrun');
-});
-
-// ─── AC extraction ─────────────────────────────────────────────────────────────
-
-test('extractAcceptanceCriteria: pulls the section body between the heading and the next heading', () => {
-  const body = ['# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', '- [ ] one', '- [ ] two', '', '# Out of scope', '', '- N/A'].join('\n');
-  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBe('- [ ] one\n- [ ] two');
-});
-
-test('extractAcceptanceCriteria: returns null when no such heading exists', () => {
-  const body = ['# Goal', '', 'Do the thing.'].join('\n');
-  expect(rcaFeedbackHook.extractAcceptanceCriteria(body)).toBeNull();
-});
-
-// ─── investigation <RCA> block extraction ──────────────────────────────────────
-
-test('extractRcaBlock: pulls plain-text block content', () => {
-  const log = 'preamble\n<RCA>\nForgot to bound the poll loop.\n</RCA>\npostamble';
-  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.');
-});
-
-test('extractRcaBlock: unescapes JSON-escaped newlines from a stream-json transcript', () => {
-  const log = '{"text":"<RCA>\\nForgot to bound the poll loop.\\nSee scheduler.cjs:1509.\\n</RCA>"}';
-  expect(rcaFeedbackHook.extractRcaBlock(log)).toBe('Forgot to bound the poll loop.\nSee scheduler.cjs:1509.');
-});
-
-test('extractRcaBlock: returns null when no block is present', () => {
-  expect(rcaFeedbackHook.extractRcaBlock('no block here')).toBeNull();
-});
-
-// ─── destination resolution ────────────────────────────────────────────────────
-
-test('resolveDestination: uses the job cwd inbox when it exists', () => {
-  const cwd = makeProjectWithInbox();
-  const dest = rcaFeedbackHook.resolveDestination({ cwd });
-  expect(dest.dir).toBe(path.join(cwd, 'session-manager-operations', 'feedback'));
-  expect(dest.targetProjectNote).toBeNull();
-});
-
-test('resolveDestination: falls back to the session-manager repo inbox when the target has none', () => {
-  const cwd = makeProjectWithoutInbox();
-  const dest = rcaFeedbackHook.resolveDestination({ cwd });
-  expect(dest.dir).toBe(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR);
-  expect(dest.targetProjectNote).toContain(cwd);
-});
-
-test('fileRcaFeedback: actually writes into the fallback dir when the target inbox is missing', async () => {
+test('fileRcaFeedback: files into the job\'s own project, no feedback dir required', async () => {
   const cwd = makeProjectWithoutInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
-  writePrd(cwd, 'testslug');
 
   const res = await rcaFeedbackHook.fileRcaFeedback({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
   expect(res.filed).toBe(true);
-  expect(res.path.startsWith(rcaFeedbackHook.SM_REPO_FEEDBACK_DIR)).toBe(true);
-  const content = fs.readFileSync(res.path, 'utf8');
-  expect(content).toContain(cwd);
+  expect(readSessions(cwd)[res.epicId].status).toBe('proposed');
 });
 
 test('fileRcaFeedback: rejects a slug containing path-traversal segments', async () => {
@@ -339,7 +174,7 @@ test('fileRcaFeedback: SM_RCA_DISABLE=1 skips without writing', async () => {
 
 // ─── investigation-text enrichment ──────────────────────────────────────────────
 
-test('fileRcaFeedback: investigationText updates the existing RCA instead of duplicating it', async () => {
+test('fileRcaFeedback: investigationText enriches the pending proposal in place', async () => {
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');
   writeRun(runDir, 'testslug');
@@ -348,20 +183,17 @@ test('fileRcaFeedback: investigationText updates the existing RCA instead of dup
 
   const first = await rcaFeedbackHook.fileRcaFeedback({ job, runDir, verdict: 'transcript_errors' });
   expect(first.filed).toBe(true);
-  const before = fs.readFileSync(first.path, 'utf8');
-  expect(before).not.toContain('## Investigation analysis');
+  expect(readSessions(cwd)[first.epicId].openingPrompt).not.toContain('## Investigation analysis');
 
   const second = await rcaFeedbackHook.fileRcaFeedback({
     job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
   });
-  expect(second.filed).toBe(true);
+  expect(second.epicId).toBe(first.epicId);
   expect(second.updated).toBe(true);
-  expect(second.path).toBe(first.path);
-
-  const after = fs.readFileSync(second.path, 'utf8');
-  expect(after).toContain('## Investigation analysis');
-  expect(after).toContain('forgot to bound the poll loop');
 
-  const files = fs.readdirSync(path.join(cwd, 'session-manager-operations', 'feedback'));
-  expect(files.length).toBe(1);
+  const enriched = readSessions(cwd)[second.epicId];
+  expect(enriched.openingPrompt).toContain('## Investigation analysis');
+  expect(enriched.openingPrompt).toContain('forgot to bound the poll loop');
+  expect(enriched.status).toBe('proposed');
+  expect(Object.keys(readSessions(cwd)).length).toBe(1);
 });

package/src/main/__tests__/scheduler-archived-twin-guard.test.cjs

@@ -18,6 +18,7 @@ const fs = require('node:fs');
 const os = require('node:os');
 const path = require('node:path');
 const { archivedTwinExists, archivedPrdPathForJob, prdDirForCwd } = require('../scheduler.cjs');
+const { listArchivedPrdDirs } = require('../lib/prdLocations.cjs');
 
 const tmpDirs = [];
 
@@ -90,3 +91,65 @@ test('archivedPrdPathForJob does not escape prds-archived/ for a well-formed slu
   const archiveDir = path.resolve(path.join(prdDirForCwd(cwd), '..', 'prds-archived'));
   expect(resolved.startsWith(archiveDir + path.sep)).toBe(true);
 });
+
+test('archivedTwinExists returns true when the twin lives in an EPIC\'s prds-archived dir', async () => {
+  // Regression cover for job 865: every new PRD is Epic-scoped, and
+  // archiveCompletedPrd archives into the Epic's own sibling prds-archived/,
+  // not the retired flat one. A queue row whose PRD moved there must still
+  // be recognized as stale.
+  const cwd = makeFixtureCwd();
+  const slug = '865-paste-image-in-chat-does-not-work';
+  const epicArchiveDir = path.join(
+    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-fixture-1', 'prds-archived',
+  );
+  fs.mkdirSync(epicArchiveDir, { recursive: true });
+  fs.writeFileSync(path.join(epicArchiveDir, `${slug}.md`), '# Goal\n\nshipped\n', 'utf8');
+
+  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(true);
+});
+
+test('archivedTwinExists still returns true for a flat-layout twin', async () => {
+  const cwd = makeFixtureCwd();
+  const slug = 'test-flat-layout-twin';
+  const archivedDir = path.join(prdDirForCwd(cwd), '..', 'prds-archived');
+  fs.mkdirSync(archivedDir, { recursive: true });
+  fs.writeFileSync(path.join(archivedDir, `${slug}.md`), '# Goal\n\nshipped\n', 'utf8');
+
+  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(true);
+});
+
+test('archivedTwinExists returns false when no twin exists in any layout', async () => {
+  const cwd = makeFixtureCwd();
+  const slug = 'test-no-twin-anywhere';
+  fs.mkdirSync(prdDirForCwd(cwd), { recursive: true });
+
+  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(false);
+});
+
+test('listArchivedPrdDirs returns the flat dir plus every existing epic archive dir', () => {
+  const cwd = makeFixtureCwd();
+  const epicArchiveDir1 = path.join(
+    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-a', 'prds-archived',
+  );
+  const epicArchiveDir2 = path.join(
+    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-b', 'prds-archived',
+  );
+  // psess-c has no prds-archived dir yet — should be excluded.
+  fs.mkdirSync(path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-c', 'prds'), { recursive: true });
+  fs.mkdirSync(epicArchiveDir1, { recursive: true });
+  fs.mkdirSync(epicArchiveDir2, { recursive: true });
+
+  const dirs = listArchivedPrdDirs(cwd);
+  const flatDir = path.join(prdDirForCwd(cwd), '..', 'prds-archived');
+  expect(dirs).toContain(flatDir);
+  expect(dirs).toContain(epicArchiveDir1);
+  expect(dirs).toContain(epicArchiveDir2);
+  expect(dirs).not.toContain(path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-c', 'prds-archived'));
+});
+
+test('listArchivedPrdDirs never throws for a cwd with no session-manager-operations/ at all', () => {
+  const cwd = makeFixtureCwd();
+  expect(() => listArchivedPrdDirs(cwd)).not.toThrow();
+  const dirs = listArchivedPrdDirs(cwd);
+  expect(dirs.length).toBe(1);
+});

package/src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs

@@ -0,0 +1,86 @@
+/**
+ * scheduler-notify-originating-tab-transcript.test.cjs — unit tests for the
+ * PRD 863 addition to notifyOriginatingTab: persisting the job's real
+ * result text (read from the run's log) to the durable per-Epic transcript
+ * store, independent of the existing short-status-chip notification.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-notify-originating-tab-transcript.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, vi } from 'vitest';
+const { notifyOriginatingTab, extractResultTextFromLog } = require('../scheduler.cjs');
+
+test('extractResultTextFromLog returns null for a missing log path', () => {
+  expect(extractResultTextFromLog(null)).toBeNull();
+  expect(extractResultTextFromLog('/does/not/exist.log')).toBeNull();
+});
+
+test('appends the job result text to the transcript store when sourcePromptId is known', async () => {
+  const appendTranscriptTurn = vi.fn(async () => true);
+  const readResultFromLog = vi.fn(() => 'the real agent result text');
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
+
+  await notifyOriginatingTab(
+    { slug: '863-transcript', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
+    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
+  );
+
+  expect(appendTranscriptTurn).toHaveBeenCalledTimes(1);
+  expect(appendTranscriptTurn).toHaveBeenCalledWith('/some/cwd', 'psess-abc', {
+    role: 'assistant',
+    text: 'the real agent result text',
+  });
+});
+
+test('falls back to the short status message when the run log has no result text', async () => {
+  const appendTranscriptTurn = vi.fn(async () => true);
+  const readResultFromLog = vi.fn(() => null);
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
+
+  await notifyOriginatingTab(
+    { slug: '863-fallback', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
+    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
+  );
+
+  expect(appendTranscriptTurn).toHaveBeenCalledWith(
+    '/some/cwd',
+    'psess-abc',
+    expect.objectContaining({ text: expect.stringContaining('863-fallback') }),
+  );
+});
+
+test('a throwing transcript append never breaks the existing notification path', async () => {
+  const appendTranscriptTurn = vi.fn(async () => {
+    throw new Error('disk full');
+  });
+  const readResultFromLog = vi.fn(() => 'result text');
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
+
+  await expect(
+    notifyOriginatingTab(
+      { slug: '863-safe', status: 'completed', cwd: '/some/cwd', runId: 'run-1' },
+      { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
+    ),
+  ).resolves.toBeUndefined();
+
+  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
+});
+
+test('no cwd on the job skips the transcript append but does not throw', async () => {
+  const appendTranscriptTurn = vi.fn(async () => true);
+  const readResultFromLog = vi.fn(() => 'result text');
+  const appendResponseEvent = vi.fn(async () => true);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-abc' }));
+
+  await notifyOriginatingTab(
+    { slug: '863-nocwd', status: 'completed', cwd: null, runId: 'run-1' },
+    { parsePrdRaw, appendResponseEvent, appendTranscriptTurn, readResultFromLog },
+  );
+
+  expect(appendTranscriptTurn).not.toHaveBeenCalled();
+});

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -150,6 +150,27 @@ test('falls back to the tab-external-ticket path when the PRD has no sourcePromp
   expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
 });
 
+// PRD 854: a PRD dispatched straight from an Epic's own composer
+// (dispatchPromptSessionToPrd) never sets sourceTabId — only sourcePromptId.
+// If the Epic has since gone completed (appendResponseEvent returns false),
+// the fallback must still target sourcePromptId itself as the chat:external-
+// send id, since the renderer now resolves that id against known Epics too.
+test('falls back to sourcePromptId as the external-send target when sourceTabId is absent', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => false);
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'epic-1', sourceTabId: null }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '854-notify', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalled();
+  expect(loadSessions).not.toHaveBeenCalled();
+  expect(sendPrompt).toHaveBeenCalledWith('epic-1', expect.stringContaining('854-notify'));
+});
+
 test('falls back to the tab-external-ticket path when appendResponseEvent itself throws', async () => {
   const sendPrompt = vi.fn();
   const appendResponseEvent = vi.fn(async () => { throw new Error('disk error'); });

package/src/main/__tests__/scheduler-writeprd-epic-rollback.test.cjs

@@ -0,0 +1,78 @@
+/**
+ * scheduler-writeprd-epic-rollback.test.cjs — PRD 851: when remote.writePrd
+ * mints a brand-new Epic via ensureEpic (epicMint.cjs) but the PRD file write
+ * itself then fails, cleanupEmptyMintedEpic must roll back BOTH the on-disk
+ * empty epic dir AND the Epic's active-index.json entry (sessions/events) —
+ * otherwise an orphaned seed-prompt-only Epic lingers forever in the Epics
+ * nav with no PRDs and no cleanup path.
+ *
+ * The rollback must only fire for a call that minted a FRESH Epic
+ * (ensureEpic's `created: true`); a PRD write that joins an existing Epic
+ * and then fails must leave that Epic's history untouched.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-writeprd-epic-rollback.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { remote } = require('../scheduler.cjs');
+const { ensureEpic, readActiveIndex } = require('../lib/epicMint.cjs');
+
+const tmpDirs = [];
+
+function makeFixtureCwd() {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-writeprd-epic-rollback-'));
+  tmpDirs.push(cwd);
+  return cwd;
+}
+
+afterEach(() => {
+  while (tmpDirs.length) {
+    const dir = tmpDirs.pop();
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// A slug that escapes safeSlugPathIn's containment check, tripping the
+// "invalid slug" branch of writePrd (scheduler.cjs ~4188-4191) after
+// ensureEpic has already minted+persisted the Epic.
+const ESCAPING_SLUG = '../escape-attempt';
+
+test('writePrd: invalid-slug failure after a fresh Epic mint leaves zero residual active-index.json entries', async () => {
+  const cwd = makeFixtureCwd();
+  const body = '---\ntitle: Freshly minted epic goal\n---\n\nbody text\n';
+
+  const result = await remote.writePrd(ESCAPING_SLUG, body, cwd);
+
+  expect(result.ok).toBe(false);
+  expect(result.error).toBe('invalid slug');
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(0);
+  expect(Object.keys(index.events)).toHaveLength(0);
+});
+
+test('writePrd: invalid-slug failure when joining a pre-existing Epic leaves that Epic untouched', async () => {
+  const cwd = makeFixtureCwd();
+
+  const preexisting = await ensureEpic(cwd, { goalText: 'pre-existing epic goal' });
+  expect(preexisting.created).toBe(true);
+
+  const beforeIndex = readActiveIndex(cwd);
+  expect(Object.keys(beforeIndex.sessions)).toEqual([preexisting.epicId]);
+
+  const body = `---\ntitle: Joins the existing epic\nsourcePromptId: ${preexisting.epicId}\n---\n\nbody text\n`;
+  const result = await remote.writePrd(ESCAPING_SLUG, body, cwd);
+
+  expect(result.ok).toBe(false);
+  expect(result.error).toBe('invalid slug');
+
+  const afterIndex = readActiveIndex(cwd);
+  expect(Object.keys(afterIndex.sessions)).toEqual([preexisting.epicId]);
+  expect(afterIndex.sessions[preexisting.epicId]).toEqual(beforeIndex.sessions[preexisting.epicId]);
+  expect(afterIndex.events[preexisting.epicId]).toEqual(beforeIndex.events[preexisting.epicId]);
+});

package/src/main/browserView.cjs

@@ -836,7 +836,7 @@ function registerBrowserView({ mainWindow, ipcMain }) {
   ipcMain.handle('browser:stop-find', validated(schemas.browserViewId, (payload) => stopFind(payload)));
   ipcMain.handle('browser:save-binary', validated(schemas.browserSaveBinary, (payload) => {
     const { writeBinaryAtomic } = require('./config.cjs');
-    return writeBinaryAtomic(payload.path, Buffer.from(payload.base64, 'base64'))
+    return writeBinaryAtomic(payload.path, Buffer.from(payload.base64, 'base64'), { writer: payload.writer })
       .then(() => ({ ok: true }))
       .catch((e) => ({ ok: false, error: e && e.message ? e.message : String(e) }));
   }));