claude-code-session-manager 0.57.1 → 0.59.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__/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), []);
 });

package/src/main/__tests__/scheduler-effective-concurrency.test.cjs

@@ -2,6 +2,12 @@
  * scheduler-effective-concurrency.test.cjs — unit tests for the
  * effectiveConcurrency field on buildScheduleStatePayload.
  *
+ * The scheduler's private `concurrencyCap` is retired: the machine-wide
+ * sessionSlots pool is the ONLY concurrency limit, so effectiveConcurrency
+ * now reports the pool (and its SM_SESSION_SLOTS override), not a config
+ * field. See lib/sessionSlots.cjs's charter — caps belong to Session-Manager,
+ * not to each consumer.
+ *
  * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-effective-concurrency.test.cjs
  */
 
@@ -9,23 +15,26 @@
 
 import { test, expect, beforeEach, afterEach } from 'vitest';
 const { buildScheduleStatePayload } = require('../scheduler.cjs');
+const sessionSlots = require('../lib/sessionSlots.cjs');
 
-const ENV_KEY = 'SM_SCHEDULER_MAX_CONCURRENCY';
+const ENV_KEY = 'SM_SESSION_SLOTS';
 let savedEnv;
 
 beforeEach(() => {
   savedEnv = process.env[ENV_KEY];
   delete process.env[ENV_KEY];
+  sessionSlots.__resetForTests();
 });
 
 afterEach(() => {
   if (savedEnv === undefined) delete process.env[ENV_KEY];
   else process.env[ENV_KEY] = savedEnv;
+  sessionSlots.__resetForTests();
 });
 
-function fakeState(concurrencyCap) {
+function fakeState() {
   return {
-    config: { concurrencyCap },
+    config: {},
     jobs: [],
     scheduledFor: null,
     lastRunAt: null,
@@ -33,19 +42,30 @@ function fakeState(concurrencyCap) {
   };
 }
 
-test('effectiveConcurrency is config-sourced when env var is unset', () => {
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 5, source: 'config' });
+test('effectiveConcurrency reports the pool when no env override is set', () => {
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency.source).toBe('pool');
+  expect(payload.effectiveConcurrency.cap).toBe(sessionSlots.totalSlots());
+  expect(payload.effectiveConcurrency.free).toBe(sessionSlots.available());
 });
 
-test('effectiveConcurrency is env-sourced and wins over config when env var is set', () => {
+test('effectiveConcurrency is env-sourced when SM_SESSION_SLOTS is set', () => {
   process.env[ENV_KEY] = '7';
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 7, source: 'env' });
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 7, free: 7, source: 'env' });
 });
 
-test('effectiveConcurrency clamps env var into [1, 20]', () => {
+test('effectiveConcurrency clamps the env var into the pool range [0, 10]', () => {
   process.env[ENV_KEY] = '999';
-  const payload = buildScheduleStatePayload(fakeState(5));
-  expect(payload.effectiveConcurrency).toEqual({ cap: 20, source: 'env' });
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 10, free: 10, source: 'env' });
+});
+
+test('free is net of held slots — a chat run shrinks it without changing cap', () => {
+  process.env[ENV_KEY] = '5';
+  const token = sessionSlots.acquire('chat:test-tab');
+  expect(token).toBeTruthy();
+  const payload = buildScheduleStatePayload(fakeState());
+  expect(payload.effectiveConcurrency).toEqual({ cap: 5, free: 4, source: 'env' });
+  sessionSlots.release(token);
 });