claude-code-session-manager 0.57.0 → 0.58.0

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

@@ -0,0 +1,101 @@
+/**
+ * promptSessionSchema.test.cjs — unit tests for the canonical PromptSession
+ * zod schema and its assertValidPromptSession fail-closed helper.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/promptSessionSchema.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { PromptSessionSchema, assertValidPromptSession } = require('../lib/promptSessionSchema.cjs');
+
+test('a valid full record parses', () => {
+  const full = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    goalText: 'do the thing',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'proposed',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+    resumedFromId: 'old-epic-id',
+    tag: 'feature',
+    openingPrompt: 'full body of the first prompt',
+    source: {
+      producer: 'new-epic-ui',
+      prdSlug: '123-fix-thing',
+      runId: 'run-1',
+      sourceTabId: 'tab-1',
+    },
+    agentType: 'architect',
+  };
+  expect(() => assertValidPromptSession(full)).not.toThrow();
+  expect(PromptSessionSchema.safeParse(full).success).toBe(true);
+});
+
+test('a valid minimal record (only required fields) parses', () => {
+  const minimal = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    goalText: 'do the thing',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'active',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+  };
+  expect(() => assertValidPromptSession(minimal)).not.toThrow();
+});
+
+test('missing a required field fails', () => {
+  const missingGoalText = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'active',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+  };
+  expect(() => assertValidPromptSession(missingGoalText)).toThrow(/goalText/);
+});
+
+test('an invalid status value fails', () => {
+  const badStatus = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    goalText: 'do the thing',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'in-progress',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+  };
+  expect(() => assertValidPromptSession(badStatus)).toThrow(/status/);
+});
+
+test('an invalid tag value fails', () => {
+  const badTag = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    goalText: 'do the thing',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'active',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+    tag: 'not-a-real-tag',
+  };
+  expect(() => assertValidPromptSession(badTag)).toThrow(/tag/);
+});
+
+test('a source object missing its required producer fails', () => {
+  const badSource = {
+    id: 'epic-abc12345',
+    cwd: '/home/bilko/Projects/session-manager',
+    goalText: 'do the thing',
+    claudeSessionId: 'c1b2a3d4-0000-0000-0000-000000000000',
+    status: 'active',
+    createdAt: '2026-08-02T00:00:00.000Z',
+    completedAt: null,
+    source: { prdSlug: '123-fix-thing' },
+  };
+  expect(() => assertValidPromptSession(badSource)).toThrow(/producer/);
+});

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

@@ -0,0 +1,139 @@
+/**
+ * promptSessionsCreateEpicHandler.test.cjs — unit tests for the
+ * 'promptSessions:create-epic' IPC handler (lib/promptSessionsCreateEpic.cjs),
+ * PRD 953: an additive-only IPC channel letting the renderer mint an Epic
+ * through main's own ensureEpic() instead of hand-constructing the
+ * PromptSession record itself. Nothing in the app calls this yet.
+ *
+ * Exercises the handler the same way index.cjs wires it — schema validation
+ * (ipcSchemas.cjs's `validated` wrapper) in front of the business logic —
+ * without touching Electron's `ipcMain`, mirroring activeIndexMerge.test.cjs's
+ * pattern of testing the underlying function directly.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/promptSessionsCreateEpicHandler.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 { schemas, validated } = require('../ipcSchemas.cjs');
+const { createEpicViaIpc } = require('../lib/promptSessionsCreateEpic.cjs');
+const { readActiveIndex } = require('../lib/epicMint.cjs');
+const { PromptSessionSchema } = require('../lib/promptSessionSchema.cjs');
+const config = require('../config.cjs');
+
+const handler = validated(schemas.promptSessionsCreateEpic, ({ cwd, goalText, tag, agentType, source }) =>
+  createEpicViaIpc(cwd, { goalText, tag, agentType, source }));
+
+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-promptsessions-create-epic-'));
+  config.addAllowedRoot(cwd);
+  tmpDirs.push(cwd);
+  return cwd;
+}
+
+test('a valid request mints a new proposed Epic and returns a schema-valid session read back from disk', async () => {
+  const cwd = await mkCwd();
+  const result = await handler(null, {
+    cwd,
+    goalText: 'Ship the widget',
+    tag: 'feature',
+    agentType: 'architect',
+    source: { producer: 'scheduler-dispatch' },
+  });
+
+  expect(result.epicId).toBeTruthy();
+  expect(result.session.id).toBe(result.epicId);
+  expect(result.session.status).toBe('proposed');
+  expect(result.session.goalText).toBe('Ship the widget');
+  expect(result.session.tag).toBe('feature');
+  expect(result.session.agentType).toBe('architect');
+  expect(result.session.source).toEqual({ producer: 'scheduler-dispatch' });
+
+  // Response is the just-written record read back from disk, not a second
+  // independently re-derived copy.
+  const index = readActiveIndex(cwd);
+  expect(index.sessions[result.epicId]).toEqual(result.session);
+
+  const parsed = PromptSessionSchema.safeParse(result.session);
+  expect(parsed.success).toBe(true);
+});
+
+test('a request with no tag/agentType/source still mints and validates cleanly', async () => {
+  const cwd = await mkCwd();
+  const result = await handler(null, { cwd, goalText: 'Minimal request' });
+
+  expect(result.session.goalText).toBe('Minimal request');
+  expect(PromptSessionSchema.safeParse(result.session).success).toBe(true);
+});
+
+// ipcSchemas.cjs's `validated` wrapper calls schema.parse synchronously
+// before invoking the handler — a ZodError throws synchronously from the
+// call itself (not a rejected promise), which is exactly the "rejected
+// before ensureEpic ever runs" guarantee this test asserts.
+test('a request missing cwd is rejected by ipcSchemas validation before ensureEpic ever runs', () => {
+  expect(() => handler(null, { goalText: 'No cwd here' })).toThrow();
+});
+
+test('a request missing goalText is rejected by ipcSchemas validation before ensureEpic ever runs', async () => {
+  const cwd = await mkCwd();
+  expect(() => handler(null, { cwd })).toThrow();
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(0);
+});
+
+test('an unknown tag value is rejected by ipcSchemas validation', () => {
+  expect(() => handler(null, { cwd: '/tmp/whatever', goalText: 'x', tag: 'not-a-real-tag' })).toThrow();
+});
+
+test('an unknown source.producer value is rejected by ipcSchemas validation', () => {
+  expect(() => handler(null, {
+    cwd: '/tmp/whatever',
+    goalText: 'x',
+    source: { producer: 'bogus-producer' },
+  })).toThrow();
+});
+
+// createEpicViaIpc's whole point is forceNewEpic: true — it must never join
+// an existing Epic via ensureEpic's goalText-similarity join branch, even
+// when called twice with the identical goalText for the same cwd.
+test('two requests with identical goalText for the same cwd mint two distinct Epics, never joining', async () => {
+  const cwd = await mkCwd();
+  const first = await handler(null, { cwd, goalText: 'Same title both times' });
+  const second = await handler(null, { cwd, goalText: 'Same title both times' });
+
+  expect(first.epicId).not.toBe(second.epicId);
+  const index = readActiveIndex(cwd);
+  expect(index.sessions[first.epicId]).toBeDefined();
+  expect(index.sessions[second.epicId]).toBeDefined();
+});
+
+// The renderer can send an arbitrary `cwd` string over IPC — config.cjs's
+// validatePath (allowedRoots = home dir + every cwd a TAB has opened) is the
+// boundary every other renderer-facing path IPC already passes through
+// (config:read-json/write-json, lib/activeIndexMerge.cjs's own merge); this
+// handler must be gated by the same boundary rather than handing an
+// unvalidated path straight to epicMint.cjs's raw `fs` writes.
+test('a cwd outside every allowed root is rejected before anything is minted', async () => {
+  const unregistered = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-promptsessions-create-epic-unregistered-'));
+  tmpDirs.push(unregistered);
+
+  await expect(handler(null, { cwd: unregistered, goalText: 'Should never mint' })).rejects.toThrow(
+    /outside allowed boundaries/,
+  );
+
+  const index = readActiveIndex(unregistered);
+  expect(Object.keys(index.sessions)).toHaveLength(0);
+});

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

@@ -36,8 +36,20 @@ function old(overrides = {}) {
 }
 
 let queueHistory;
+let prevOverride;
 
 beforeEach(() => {
+  // Point HISTORY_PATH at an isolated tmpdir file (SM_HISTORY_PATH_OVERRIDE)
+  // instead of the real machine-global history.jsonl — a live Electron
+  // instance's scheduler.cjs writes that same global file concurrently,
+  // which races this suite's unlink/append calls and produces real
+  // production data in place of the expected empty state.
+  prevOverride = process.env.SM_HISTORY_PATH_OVERRIDE;
+  process.env.SM_HISTORY_PATH_OVERRIDE = path.join(
+    os.tmpdir(),
+    `queueHistory-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`
+  );
+
   // Fresh require per test so HISTORY_PATH's target file starts clean.
   delete require.cache[require.resolve('../lib/queueHistory.cjs')];
   queueHistory = require('../lib/queueHistory.cjs');
@@ -46,6 +58,8 @@ beforeEach(() => {
 
 afterEach(() => {
   try { fs.unlinkSync(queueHistory.HISTORY_PATH); } catch { /* ok if absent */ }
+  if (prevOverride === undefined) delete process.env.SM_HISTORY_PATH_OVERRIDE;
+  else process.env.SM_HISTORY_PATH_OVERRIDE = prevOverride;
 });
 
 // ---------- partitionJobs ----------

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

@@ -0,0 +1,188 @@
+/**
+ * rcaReport.test.cjs — unit tests for src/main/lib/rcaReport.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/rcaReport.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let realHome;
+let rcaReport;
+
+// config.cjs bakes os.homedir() into top-level consts at first require
+// (allowedRoots/WRITE_PREFIXES). Node's require cache must be purged per test
+// so each test's tmpHome takes effect — vi.resetModules() only resets vitest's
+// ESM graph, not require().
+const MODULES_TO_RELOAD = ['../lib/rcaReport.cjs', '../config.cjs'];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'rca-report-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_RCA_DISABLE;
+  purgeRequireCache();
+  rcaReport = require('../lib/rcaReport.cjs');
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_RCA_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+// ─── helpers ──────────────────────────────────────────────────────────────────
+
+function makeProject(name = 'proj') {
+  const cwd = path.join(tmpHome, name);
+  fs.mkdirSync(cwd, { recursive: true });
+  return cwd;
+}
+
+function writeRun(runDir, slug, { logLines = ['line1', 'line2'], exitCode = 1, durationMs = 1234 } = {}) {
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, `${slug}.log`), logLines.join('\n') + '\n');
+  fs.writeFileSync(path.join(runDir, `${slug}.meta.json`), JSON.stringify({ exitCode, durationMs }));
+}
+
+function writePrd(cwd, slug, { acBody = '- [ ] `timeout 10 echo ok` passes.' } = {}) {
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  const body = ['---', `title: ${slug}`, '---', '', '# Goal', '', 'Do the thing.', '', '# Acceptance criteria', '', acBody, '', '# Out of scope', '', '- N/A'].join('\n');
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), body);
+}
+
+function baseJob(overrides = {}) {
+  return { slug: 'testslug', runId: '2026-07-24T00-00-00-000Z', exitCode: 1, error: 'something broke', ...overrides };
+}
+
+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 ?? {};
+}
+
+// ─── report writing ──────────────────────────────────────────────────────────
+
+test('writeRcaReport: writes root-cause-<slug>.md into the run directory', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+
+  expect(res.filed).toBe(true);
+  expect(res.path).toBe(path.join(runDir, 'root-cause-testslug.md'));
+  const body = fs.readFileSync(res.path, 'utf8');
+  expect(body).toContain('prdSlug: testslug');
+  expect(body).toContain('# What happened');
+  expect(body).toContain('# The PRD\'s acceptance criteria');
+  expect(body).toContain('timeout 10 echo ok');
+  expect(res.summary).toContain('testslug');
+  expect(res.summary.split('\n')).toHaveLength(1);
+});
+
+test('writeRcaReport: creates no Epic — a parked job never opens work on its own', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+
+  expect(readSessions(cwd)).toEqual({});
+});
+
+test('writeRcaReport: a second call for the same run overwrites in place, never duplicates', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
+  const second = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
+
+  expect(second.path).toBe(first.path);
+  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(1);
+});
+
+test('writeRcaReport: investigationText enriches the report in place', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+  const job = baseJob({ cwd });
+
+  const first = await rcaReport.writeRcaReport({ job, runDir, verdict: 'transcript_errors' });
+  expect(fs.readFileSync(first.path, 'utf8')).not.toContain('## Investigation analysis');
+
+  const second = await rcaReport.writeRcaReport({
+    job, runDir, verdict: 'transcript_errors', investigationText: 'Root cause: forgot to bound the poll loop.',
+  });
+
+  expect(second.path).toBe(first.path);
+  const enriched = fs.readFileSync(second.path, 'utf8');
+  expect(enriched).toContain('## Investigation analysis');
+  expect(enriched).toContain('forgot to bound the poll loop');
+});
+
+test('writeRcaReport: works for a job whose PRD cannot be read (no acceptance criteria on record)', async () => {
+  const cwd = makeProject('bare-proj');
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+
+  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+
+  expect(res.filed).toBe(true);
+  expect(fs.readFileSync(res.path, 'utf8')).toContain('acceptance criteria not found');
+});
+
+// ─── skip paths ──────────────────────────────────────────────────────────────
+
+test('writeRcaReport: rejects a slug containing path-traversal segments', async () => {
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  fs.mkdirSync(runDir, { recursive: true });
+
+  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd, slug: '../../etc/passwd' }), runDir, verdict: 'transcript_errors' });
+
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('unsafe-slug');
+});
+
+test('writeRcaReport: skips when there is no run directory to write into', async () => {
+  const cwd = makeProject();
+
+  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), verdict: 'transcript_errors' });
+
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('no-run-dir');
+});
+
+test('writeRcaReport: SM_RCA_DISABLE=1 skips without writing', async () => {
+  process.env.SM_RCA_DISABLE = '1';
+  const cwd = makeProject();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  const res = await rcaReport.writeRcaReport({ job: baseJob({ cwd }), runDir, verdict: 'transcript_errors' });
+
+  expect(res.filed).toBe(false);
+  expect(res.reason).toBe('disabled');
+  expect(fs.readdirSync(runDir).filter((f) => f.startsWith('root-cause-'))).toHaveLength(0);
+});

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

@@ -25,7 +25,7 @@ const os = require('node:os');
 const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
-const { verifyRun } = require('../runVerify.cjs');
+const { verifyRun, parseLog } = require('../runVerify.cjs');
 
 // ─── helpers ──────────────────────────────────────────────────────────────────
 
@@ -792,6 +792,109 @@ test('harness tool error (<tool_use_error>) in final 20% → clean', async () =>
   } finally { rmdir(tmp); }
 });
 
+// ─── subagent-internal tool errors (incident: 955-route-epic-create-through-ipc, 2026-08-03) ──
+
+test('subagent-internal is_error (parent_tool_use_id set) in final 20% → clean', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '955-route-epic-create-through-ipc';
+    const events = [];
+    for (let k = 0; k < 8; k++) {
+      events.push({ type: 'assistant', message: { role: 'assistant', content: [
+        { type: 'tool_use', id: `t${k}`, name: 'Read', input: { description: `read ${k}` } }] } });
+      events.push({ type: 'user', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: `t${k}`, content: 'ok', is_error: false }] } });
+    }
+    // A code-reviewer Task subagent runs its own exploratory grep, which exits
+    // 1 (no matches) — this happened INSIDE the subagent, not the main agent.
+    events.push({
+      type: 'assistant',
+      parent_tool_use_id: 'toolu_task_001',
+      message: { role: 'assistant', content: [
+        { type: 'tool_use', id: 'tgrep', name: 'Bash', input: { description: 'grep for buildPromptSession' } }] },
+    });
+    events.push({
+      type: 'user',
+      parent_tool_use_id: 'toolu_task_001',
+      message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: 'tgrep', content: '', is_error: true }] },
+    });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.' });
+
+    writeLog(tmp, slug, events);
+    const prdPath = writePrd(tmp, slug, '# Route Epic create through IPC');
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
+    assert.equal(verdict.verdict, 'clean', `subagent-internal is_error must not flag, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally { rmdir(tmp); }
+});
+
+test('main-agent is_error (no parent_tool_use_id) in final 20% → still transcript_errors', async () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '955-main-agent-error-guard';
+    const events = [];
+    for (let k = 0; k < 8; k++) {
+      events.push({ type: 'assistant', message: { role: 'assistant', content: [
+        { type: 'tool_use', id: `t${k}`, name: 'Read', input: { description: `read ${k}` } }] } });
+      events.push({ type: 'user', message: { role: 'user', content: [
+        { type: 'tool_result', tool_use_id: `t${k}`, content: 'ok', is_error: false }] } });
+    }
+    events.push({ type: 'assistant', message: { role: 'assistant', content: [
+      { type: 'tool_use', id: 'tbad', name: 'Bash', input: { description: 'run tests' } }] } });
+    events.push({ type: 'user', message: { role: 'user', content: [
+      { type: 'tool_result', tool_use_id: 'tbad', content: 'FAILED: 1 test failed', is_error: true }] } });
+    events.push({ type: 'result', subtype: 'success', result: 'All acceptance criteria verified.' });
+
+    writeLog(tmp, slug, events);
+    const prdPath = writePrd(tmp, slug, '# Guard: main-agent errors still flag');
+    const verdict = await verifyRun({ runDir: tmp, prdPath, queueEntry: { slug, status: 'running' }, allJobs: [], committedDuringRun: true });
+    assert.equal(verdict.verdict, 'transcript_errors', `main-agent is_error must still flag, got ${verdict.verdict}: ${verdict.reason}`);
+  } finally { rmdir(tmp); }
+});
+
+test('parseLog populates parentToolUseId on tool_use and tool_result events, defaulting to null', () => {
+  const tmp = makeTmpDir();
+  try {
+    const slug = '955-parselog-parent-id';
+    const events = [
+      {
+        type: 'assistant',
+        parent_tool_use_id: 'toolu_parent_001',
+        message: { role: 'assistant', content: [
+          { type: 'tool_use', id: 'tchild', name: 'Bash', input: { description: 'grep in subagent' } }] },
+      },
+      {
+        type: 'user',
+        parent_tool_use_id: 'toolu_parent_001',
+        message: { role: 'user', content: [
+          { type: 'tool_result', tool_use_id: 'tchild', content: '', is_error: true }] },
+      },
+      {
+        type: 'assistant',
+        message: { role: 'assistant', content: [
+          { type: 'tool_use', id: 'ttop', name: 'Bash', input: { description: 'run in main agent' } }] },
+      },
+      {
+        type: 'user',
+        message: { role: 'user', content: [
+          { type: 'tool_result', tool_use_id: 'ttop', content: 'ok', is_error: false }] },
+      },
+    ];
+    writeLog(tmp, slug, events);
+    const { events: parsed } = parseLog(path.join(tmp, `${slug}.log`));
+
+    const childUse = parsed.find((ev) => ev.kind === 'tool_use' && ev.toolUseId === 'tchild');
+    const childResult = parsed.find((ev) => ev.kind === 'tool_result' && ev.toolUseId === 'tchild');
+    const topUse = parsed.find((ev) => ev.kind === 'tool_use' && ev.toolUseId === 'ttop');
+    const topResult = parsed.find((ev) => ev.kind === 'tool_result' && ev.toolUseId === 'ttop');
+
+    assert.equal(childUse.parentToolUseId, 'toolu_parent_001');
+    assert.equal(childResult.parentToolUseId, 'toolu_parent_001');
+    assert.equal(topUse.parentToolUseId, null);
+    assert.equal(topResult.parentToolUseId, null);
+  } finally { rmdir(tmp); }
+});
+
 test('isHarnessToolError detects wrapper and "No such tool available"', () => {
   const { isHarnessToolError } = require('../runVerify.cjs');
   assert.equal(isHarnessToolError('<tool_use_error>Error: No such tool available: bash</tool_use_error>'), true);
@@ -1145,8 +1248,8 @@ test('pass_no_commit: original PRD, PASS no commit, all deliverable paths alread
   const tmp = makeTmpDir();
   try {
     const slug = '655-needs-review-rca-feedback-hook';
-    writeLog(tmp, slug, noOpRunEvents('Verified rcaFeedbackHook.cjs already shipped in e13168d; typecheck + tests green; no commit needed.\nSCHEDULER_VERDICT: PASS'));
-    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/__tests__/rcaFeedbackHook.test.cjs`.');
+    writeLog(tmp, slug, noOpRunEvents('Verified rcaReport.cjs already shipped in e13168d; typecheck + tests green; no commit needed.\nSCHEDULER_VERDICT: PASS'));
+    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaReport.cjs` and `src/main/__tests__/rcaReport.test.cjs`.');
     const verdict = await verifyRun({
       runDir: tmp,
       prdPath,
@@ -1166,7 +1269,7 @@ test('pass_no_commit: original PRD, PASS no commit, one deliverable path untrack
   try {
     const slug = '655-needs-review-rca-feedback-hook';
     writeLog(tmp, slug, noOpRunEvents('Nothing to do here.\nSCHEDULER_VERDICT: PASS'));
-    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/lib/does-not-exist-xyz.cjs`.');
+    const prdPath = writePrd(tmp, slug, 'Deliverables: `src/main/lib/rcaReport.cjs` and `src/main/lib/does-not-exist-xyz.cjs`.');
     const verdict = await verifyRun({
       runDir: tmp,
       prdPath,
@@ -1227,9 +1330,9 @@ test('pass_no_commit: commit-guard-retry PRD naming scheduler.cjs + its committe
 });
 
 test('extractPrdDeliverablePaths: extracts backticked repo-relative paths, ignores prose', () => {
-  const body = 'Deliverables: `src/main/lib/rcaFeedbackHook.cjs` and `src/main/__tests__/rcaFeedbackHook.test.cjs`. Also see node_modules/foo/bar.js which should be excluded.';
+  const body = 'Deliverables: `src/main/lib/rcaReport.cjs` and `src/main/__tests__/rcaReport.test.cjs`. Also see node_modules/foo/bar.js which should be excluded.';
   const paths = extractPrdDeliverablePaths(body);
-  assert.deepEqual(paths, ['src/main/lib/rcaFeedbackHook.cjs', 'src/main/__tests__/rcaFeedbackHook.test.cjs']);
+  assert.deepEqual(paths, ['src/main/lib/rcaReport.cjs', 'src/main/__tests__/rcaReport.test.cjs']);
   assert.deepEqual(extractPrdDeliverablePaths(''), []);
   assert.deepEqual(extractPrdDeliverablePaths(undefined), []);
 });