claude-code-session-manager 0.40.3 → 0.41.1

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

@@ -23,6 +23,7 @@ const {
   PRD_CREATE_SLUG_RE,
   registerAdminRoute,
   createPrd,
+  resolveSourcePromptIdFromClaudeSession,
 } = require('../lib/prdCreate.cjs');
 const { createAdminHttp } = require('../lib/localAdminHttp.cjs');
 const config = require('../config.cjs');
@@ -171,7 +172,7 @@ function makeFakeRemoteWithPrdsDir(prdsDir) {
     async writePrd(slug, body) {
       try {
         const filePath = path.join(prdsDir, `${slug}.md`);
-        await config.writeTextAtomic(filePath, body);
+        await config.writeTextAtomic(filePath, body, { writer: 'scheduler' });
         return { ok: true };
       } catch (e) {
         return { ok: false, error: e?.message };
@@ -413,7 +414,8 @@ test('validateWrite allows writes under <root>/session-manager-operations/schedu
   await fsp.mkdir(prdsDir, { recursive: true });
   const filePath = path.join(prdsDir, '1-do-thing.md');
 
-  await config.writeTextAtomic(filePath, 'PRD body\n');
+  // Writes into scheduler/ must declare the owning surface (single-writer law).
+  await config.writeTextAtomic(filePath, 'PRD body\n', { writer: 'scheduler' });
 
   expect(fs.existsSync(filePath)).toBeTruthy();
   expect(await fsp.readFile(filePath, 'utf8')).toBe('PRD body\n');
@@ -437,6 +439,57 @@ test('createPrd normalizes a `~`-prefixed cwd via expandHome before calling remo
   }
 });
 
+// ──────────────────────────────────────────── PRD 862: register cwd as an
+// allowed write root at createPrd() time, not only at pty.spawn() time
+//
+// Before this fix, config.cjs's allowedRoots (the write-boundary allowlist)
+// only ever grew via pty.cjs's addAllowedRoot call inside pty.spawn(). A
+// chat-only Epic (headless `claude -p --resume`, no Terminal PTY ever
+// spawned for its project cwd) reached createPrd() -> remote.writePrd() ->
+// config.writeTextAtomic() -> config.validateWrite() and failed with "Write
+// outside allowed write boundaries", purely because no PTY had registered
+// that cwd yet in this process's lifetime. This test reproduces that exact
+// scenario: a brand-new project root that has NEVER had config.addAllowedRoot
+// called for it (mirroring pty.spawn() never having run), writing through the
+// real config.writeTextAtomic into the real session-manager-operations/
+// scheduler/ subtree (not the mocked-remote temp dirs the other tests here
+// use, which pre-register their root via addAllowedRoot in mkTmpPrdsDir).
+test('createPrd registers cwd as an allowed write root itself, so a chat-only Epic (no Terminal PTY ever spawned for this cwd) can still write its PRD', async () => {
+  // Must live under $HOME: validatePath's read boundary is home-dir-wide
+  // regardless of allowedRoots registration (matching every real project
+  // cwd, which checkInsideHome forces inside $HOME) — the bug this test
+  // reproduces is specifically about the *write* boundary (validateWrite),
+  // not the read one.
+  const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-chat-only-epic-'));
+  // Deliberately do NOT call config.addAllowedRoot(root) here — pty.spawn()
+  // is the only other caller of addAllowedRoot, and it never runs for a
+  // chat-only Epic. createPrd() itself must perform this registration.
+  const prdsEpicDir = path.join(root, 'session-manager-operations', 'scheduler', 'epics', 'chat-only-epic', 'prds');
+
+  try {
+    const remote = {
+      async allocateParallelGroup() { return 1; },
+      async readPrd() { return { ok: false }; },
+      async writePrd(slug, body) {
+        await fsp.mkdir(prdsEpicDir, { recursive: true });
+        const filePath = path.join(prdsEpicDir, `${slug}.md`);
+        // Real config.cjs write path — this is what threw
+        // "Write outside allowed write boundaries" before the fix.
+        await config.writeTextAtomic(filePath, body, { writer: 'scheduler' });
+        return { ok: true };
+      },
+    };
+
+    const result = await createPrd(validCreateBody({ cwd: root }), remote);
+
+    expect(result.ok).toBe(true);
+    const written = await fsp.readFile(path.join(prdsEpicDir, result.filename), 'utf8');
+    expect(written).toMatch(/title: Add widget frobnication/);
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});
+
 test('POST /admin/scheduler/create-prd with sourcePromptId writes it into the created PRD frontmatter', async () => {
   const prdsDir = await mkTmpPrdsDir();
   const remote = makeFakeRemoteWithPrdsDir(prdsDir);
@@ -453,3 +506,72 @@ test('POST /admin/scheduler/create-prd with sourcePromptId writes it into the cr
     await admin.stop();
   }
 });
+
+// ──────────────────────────────────────────── originClaudeSessionId fallback
+// (2026-08-01 fix: a PRD queued via the scheduler_create_prd MCP tool from
+// inside an Epic's own chat session, without an explicit sourcePromptId,
+// must still join that Epic rather than mint an unrelated sibling one.)
+
+async function writeActiveIndexFixture(cwd, sessions) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  await fsp.mkdir(dir, { recursive: true });
+  await fsp.writeFile(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events: {} }, null, 2));
+}
+
+test('resolveSourcePromptIdFromClaudeSession finds the Epic whose claudeSessionId matches', async () => {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-resolve-epic-'));
+  try {
+    await writeActiveIndexFixture(root, {
+      'psess-abc123': { id: 'psess-abc123', claudeSessionId: 'claude-sess-1', status: 'active' },
+    });
+    expect(resolveSourcePromptIdFromClaudeSession(root, 'claude-sess-1')).toBe('psess-abc123');
+    expect(resolveSourcePromptIdFromClaudeSession(root, 'claude-sess-unknown')).toBeNull();
+    expect(resolveSourcePromptIdFromClaudeSession(root, null)).toBeNull();
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});
+
+test('createPrd resolves sourcePromptId from originClaudeSessionId when the caller omitted sourcePromptId', async () => {
+  const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-epic-'));
+  config.addAllowedRoot(root);
+  try {
+    await writeActiveIndexFixture(root, {
+      'psess-always-select-tab': { id: 'psess-always-select-tab', claudeSessionId: 'claude-sess-epic-1', status: 'active' },
+    });
+    const prdsDir = path.join(root, 'session-manager-operations', 'scheduler', 'epics', 'psess-always-select-tab', 'prds');
+    const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+    const result = await createPrd(
+      validCreateBody({ cwd: root, slug: 'joins-the-epic', originClaudeSessionId: 'claude-sess-epic-1' }),
+      remote,
+    );
+
+    expect(result.ok).toBe(true);
+    const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+    expect(written).toMatch(/sourcePromptId: psess-always-select-tab/);
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});
+
+test('createPrd leaves sourcePromptId unset when originClaudeSessionId matches no known Epic (plain SessionTab chat)', async () => {
+  const root = await fsp.mkdtemp(path.join(os.homedir(), '.sm-origin-session-no-match-'));
+  config.addAllowedRoot(root);
+  try {
+    await writeActiveIndexFixture(root, {});
+    const prdsDir = path.join(root, 'session-manager-operations', 'scheduler', 'prds');
+    const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+
+    const result = await createPrd(
+      validCreateBody({ cwd: root, slug: 'no-epic-match', originClaudeSessionId: 'claude-sess-not-an-epic' }),
+      remote,
+    );
+
+    expect(result.ok).toBe(true);
+    const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
+    expect(!/sourcePromptId:/.test(written)).toBeTruthy();
+  } finally {
+    await fsp.rm(root, { recursive: true, force: true });
+  }
+});

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

@@ -9,13 +9,18 @@
 
 'use strict';
 
-import { test, expect, beforeEach } from 'vitest';
+import { test, expect, beforeEach, vi } from 'vitest';
 const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
 const path = require('node:path');
 const config = require('../config.cjs');
-const { appendResponseEventIfKnown, promptSessionActiveIndexPath } = require('../promptSessionEvents.cjs');
+const {
+  appendResponseEventIfKnown,
+  promptSessionActiveIndexPath,
+  attachWindow,
+  EVENT_APPENDED_CHANNEL,
+} = require('../promptSessionEvents.cjs');
 
 let cwd;
 
@@ -104,3 +109,52 @@ test('returns false (never throws) when cwd or sourcePromptId is missing', async
   await expect(appendResponseEventIfKnown(null, 'psess-1', 'hi')).resolves.toBe(false);
   await expect(appendResponseEventIfKnown(cwd, null, 'hi')).resolves.toBe(false);
 });
+
+test('broadcasts EVENT_APPENDED_CHANNEL to the attached window on a successful append', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+      ],
+    },
+  });
+
+  const send = vi.fn();
+  const fakeWindow = { isDestroyed: () => false, webContents: { isDestroyed: () => false, send } };
+  attachWindow(fakeWindow);
+  try {
+    const routed = await appendResponseEventIfKnown(cwd, 'psess-1', 'PRD finished');
+    expect(routed).toBe(true);
+    expect(send).toHaveBeenCalledTimes(1);
+    const [channel, payload] = send.mock.calls[0];
+    expect(channel).toBe(EVENT_APPENDED_CHANNEL);
+    expect(payload.cwd).toBe(cwd);
+    expect(payload.promptSessionId).toBe('psess-1');
+    expect(payload.event.kind).toBe('response');
+    expect(payload.event.text).toBe('PRD finished');
+    expect(payload.event.causedByEventId).toBe('pevt-1');
+  } finally {
+    attachWindow(null);
+  }
+});
+
+test('does not throw broadcasting before a window is attached, or after it is destroyed', async () => {
+  await writeIndex({
+    sessions: { 'psess-1': { id: 'psess-1', cwd, status: 'active' } },
+    events: {
+      'psess-1': [
+        { id: 'pevt-1', promptSessionId: 'psess-1', kind: 'prompt', causedByEventId: null, at: '2026-01-01T00:00:00.000Z' },
+      ],
+    },
+  });
+
+  attachWindow(null);
+  await expect(appendResponseEventIfKnown(cwd, 'psess-1', 'no window yet')).resolves.toBe(true);
+
+  const destroyedWindow = { isDestroyed: () => true, webContents: { isDestroyed: () => false, send: vi.fn() } };
+  attachWindow(destroyedWindow);
+  await expect(appendResponseEventIfKnown(cwd, 'psess-1', 'window destroyed')).resolves.toBe(true);
+  expect(destroyedWindow.webContents.send).not.toHaveBeenCalled();
+  attachWindow(null);
+});

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);
+});