claude-code-session-manager 0.43.0 → 0.45.0

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

@@ -14,7 +14,7 @@ const fs = require('node:fs');
 const fsp = require('node:fs/promises');
 const os = require('node:os');
 const path = require('node:path');
-const { ensureEpic, removeEpic, readActiveIndex } = require('../lib/epicMint.cjs');
+const { ensureEpic, removeEpic, readActiveIndex, findJoinableEpic } = require('../lib/epicMint.cjs');
 
 const tmpDirs = [];
 afterEach(async () => {
@@ -83,3 +83,134 @@ test('removeEpic is a no-op (returns false) for an unknown epicId', async () =>
   expect(removed).toBe(false);
   expect(Object.keys(readActiveIndex(cwd).sessions)).toHaveLength(1);
 });
+
+// A plain object's bracket lookup with a prototype-chain key like
+// "__proto__"/"constructor" returns a truthy Object.prototype member even
+// when no such Epic was ever written — without an own-property check, this
+// would make mintIfMissing:false's "join an existing Epic" gate falsely
+// report a match, defeating the restriction that a PRD write may only join
+// a real, already-approved Epic.
+for (const pollutedKey of ['__proto__', 'constructor', 'toString', 'hasOwnProperty']) {
+  test(`ensureEpic refuses to "join" the prototype-chain key "${pollutedKey}" (mintIfMissing:false)`, async () => {
+    const cwd = await mkCwd();
+
+    await expect(
+      ensureEpic(cwd, { epicId: pollutedKey, mintIfMissing: false }),
+    ).rejects.toThrow(/no existing Epic found/);
+
+    const index = readActiveIndex(cwd);
+    expect(Object.keys(index.sessions)).toHaveLength(0);
+  });
+}
+
+test('removeEpic refuses to report success for the prototype-chain key "__proto__"', async () => {
+  const cwd = await mkCwd();
+  const removed = removeEpic(cwd, '__proto__');
+  expect(removed).toBe(false);
+});
+
+test('ensureEpic persists the passed source onto the written active-index.json session record', async () => {
+  const cwd = await mkCwd();
+  const source = { producer: 'rca-hook', prdSlug: 'x', runId: 'y' };
+
+  const minted = await ensureEpic(cwd, { goalText: 'auto-filed epic', source });
+
+  const index = readActiveIndex(cwd);
+  expect(index.sessions[minted.epicId].source).toEqual(source);
+});
+
+test('ensureEpic omits source from the written record when not passed', async () => {
+  const cwd = await mkCwd();
+
+  const minted = await ensureEpic(cwd, { goalText: 'human-filed epic' });
+
+  const index = readActiveIndex(cwd);
+  expect('source' in index.sessions[minted.epicId]).toBe(false);
+});
+
+test('ensureEpic joins an existing open Epic when goalText is a near-identical paraphrase (no preferEpicId)', async () => {
+  const cwd = await mkCwd();
+
+  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  expect(first.created).toBe(true);
+
+  const second = await ensureEpic(cwd, { goalText: 'Fix login button colour issue' });
+
+  expect(second.created).toBe(false);
+  expect(second.epicId).toBe(first.epicId);
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(1);
+});
+
+test('ensureEpic mints a distinct Epic when goalText is genuinely unrelated', async () => {
+  const cwd = await mkCwd();
+
+  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  expect(first.created).toBe(true);
+
+  const second = await ensureEpic(cwd, { goalText: 'Add CSV export to History tab' });
+
+  expect(second.created).toBe(true);
+  expect(second.epicId).not.toBe(first.epicId);
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(2);
+});
+
+test('findJoinableEpic joins the preferEpicId Epic even when goalText similarity is near-zero', async () => {
+  const cwd = await mkCwd();
+
+  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  expect(first.created).toBe(true);
+
+  const joined = findJoinableEpic(cwd, {
+    goalText: 'Completely unrelated topic about database migrations',
+    preferEpicId: first.epicId,
+  });
+
+  expect(joined).toEqual({ epicId: first.epicId, matchedBy: 'preferEpicId' });
+});
+
+test('findJoinableEpic falls through to the similarity check when preferEpicId points at a completed Epic', async () => {
+  const cwd = await mkCwd();
+
+  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  const index = readActiveIndex(cwd);
+  index.sessions[first.epicId].status = 'completed';
+  fs.writeFileSync(
+    path.join(cwd, 'session-manager-operations', 'prompt-sessions', 'active-index.json'),
+    JSON.stringify(index, null, 2),
+  );
+
+  // No other open Epic shares tokens with the completed one, so the
+  // fall-through similarity check finds nothing rather than joining the
+  // dead (completed) preferEpicId Epic.
+  const joined = findJoinableEpic(cwd, { goalText: 'Fix login button colour issue', preferEpicId: first.epicId });
+
+  expect(joined).toBeNull();
+});
+
+test('findJoinableEpic falls through to the similarity check when preferEpicId points at a nonexistent Epic, and can still find a match there', async () => {
+  const cwd = await mkCwd();
+  const sibling = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+
+  const joined = findJoinableEpic(cwd, { goalText: 'Fix login button colour issue', preferEpicId: 'nonexistent-epic-id' });
+
+  expect(joined).toEqual({ epicId: sibling.epicId, matchedBy: 'similarity', score: expect.any(Number) });
+});
+
+test('ensureEpic with forceNewEpic:true mints even when a near-identical open Epic exists', async () => {
+  const cwd = await mkCwd();
+
+  const first = await ensureEpic(cwd, { goalText: 'Fix the login button color' });
+  expect(first.created).toBe(true);
+
+  const second = await ensureEpic(cwd, { goalText: 'Fix login button colour issue', forceNewEpic: true });
+
+  expect(second.created).toBe(true);
+  expect(second.epicId).not.toBe(first.epicId);
+
+  const index = readActiveIndex(cwd);
+  expect(Object.keys(index.sessions)).toHaveLength(2);
+});

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

@@ -147,6 +147,87 @@ test('fileRcaFeedback: files into the job\'s own project, no feedback dir requir
   expect(readSessions(cwd)[res.epicId].status).toBe('proposed');
 });
 
+// ─── epic targeting (job.epicId → preferred join target) ───────────────────
+
+function writeActiveIndex(cwd, sessions) {
+  const dir = path.join(cwd, 'session-manager-operations', 'prompt-sessions');
+  fs.mkdirSync(dir, { recursive: true });
+  const events = {};
+  for (const id of Object.keys(sessions)) {
+    events[id] = [{ id: `${id}-e0`, promptSessionId: id, kind: 'prompt', causedByEventId: null, at: new Date(0).toISOString(), text: sessions[id].goalText }];
+  }
+  fs.writeFileSync(path.join(dir, 'active-index.json'), JSON.stringify({ sessions, events }));
+}
+
+test('fileRcaFeedback: joins the job\'s known origin Epic when it is still open, and tags source', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  writeActiveIndex(cwd, {
+    'origin-epic-1': { id: 'origin-epic-1', cwd, goalText: 'Unrelated title text', status: 'proposed', createdAt: new Date(0).toISOString(), completedAt: null },
+  });
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({
+    job: baseJob({ cwd, epicId: 'origin-epic-1' }), runDir, verdict: 'transcript_errors',
+  });
+
+  expect(res.filed).toBe(true);
+  expect(res.epicId).toBe('origin-epic-1');
+  expect(res.created).toBe(false);
+  expect(Object.keys(readSessions(cwd)).length).toBe(1);
+});
+
+test('fileRcaFeedback: does not join a completed origin Epic, falls through to mint', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  writeActiveIndex(cwd, {
+    'origin-epic-1': { id: 'origin-epic-1', cwd, goalText: 'Unrelated title text', status: 'completed', createdAt: new Date(0).toISOString(), completedAt: new Date(0).toISOString() },
+  });
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({
+    job: baseJob({ cwd, epicId: 'origin-epic-1' }), runDir, verdict: 'transcript_errors',
+  });
+
+  expect(res.filed).toBe(true);
+  expect(res.epicId).not.toBe('origin-epic-1');
+  expect(res.created).toBe(true);
+  const sessions = readSessions(cwd);
+  expect(sessions[res.epicId].source).toEqual({ producer: 'rca-hook', prdSlug: 'testslug', runId: baseJob().runId });
+});
+
+test('fileRcaFeedback: a nonexistent job.epicId falls through to mint without erroring', async () => {
+  const cwd = makeProjectWithInbox();
+  const runDir = path.join(tmpHome, 'run1');
+  writeRun(runDir, 'testslug');
+  writePrd(cwd, 'testslug');
+
+  const res = await rcaFeedbackHook.fileRcaFeedback({
+    job: baseJob({ cwd, epicId: 'does-not-exist' }), runDir, verdict: 'transcript_errors',
+  });
+
+  expect(res.filed).toBe(true);
+  expect(res.epicId).not.toBe('does-not-exist');
+  expect(res.created).toBe(true);
+});
+
+test('fileRcaFeedback: no job.epicId preserves current mint-or-reuseByGoal behavior', async () => {
+  const cwd = makeProjectWithInbox();
+  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.created).toBe(true);
+  const sessions = readSessions(cwd);
+  expect(sessions[res.epicId].source).toEqual({ producer: 'rca-hook', prdSlug: 'testslug', runId: baseJob().runId });
+});
+
 test('fileRcaFeedback: rejects a slug containing path-traversal segments', async () => {
   const cwd = makeProjectWithInbox();
   const runDir = path.join(tmpHome, 'run1');

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

@@ -1,14 +1,13 @@
 /**
- * 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.
+ * scheduler-writeprd-epic-rollback.test.cjs — remote.writePrd may only JOIN
+ * an existing, already-human-approved Epic (via `sourcePromptId`); it must
+ * never mint a new one (mintIfMissing:false, see epicMint.cjs's ensureEpic).
+ * A write with no resolvable Epic fails outright with zero residual
+ * active-index.json entries — no orphaned Epic can ever be left behind by
+ * this path because none is ever created by it.
  *
- * 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.
+ * A PRD write that joins a pre-existing Epic and then fails (e.g. an invalid
+ * slug) must leave that Epic's history untouched.
  *
  * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-writeprd-epic-rollback.test.cjs
  */
@@ -21,6 +20,7 @@ const os = require('node:os');
 const path = require('node:path');
 const { remote } = require('../scheduler.cjs');
 const { ensureEpic, readActiveIndex } = require('../lib/epicMint.cjs');
+const config = require('../config.cjs');
 
 const tmpDirs = [];
 
@@ -38,18 +38,20 @@ afterEach(() => {
 });
 
 // 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.
+// "invalid slug" branch of writePrd (scheduler.cjs's writePrd). Only the
+// second test below (joining a pre-existing Epic) actually reaches this
+// check — the first test fails earlier, at Epic resolution, before the slug
+// is ever considered.
 const ESCAPING_SLUG = '../escape-attempt';
 
-test('writePrd: invalid-slug failure after a fresh Epic mint leaves zero residual active-index.json entries', async () => {
+test('writePrd: no sourcePromptId refuses to write (no Epic to join) and mints nothing', async () => {
   const cwd = makeFixtureCwd();
-  const body = '---\ntitle: Freshly minted epic goal\n---\n\nbody text\n';
+  const body = '---\ntitle: No epic given\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');
+  expect(result.error).toMatch(/no existing Epic to join/);
 
   const index = readActiveIndex(cwd);
   expect(Object.keys(index.sessions)).toHaveLength(0);
@@ -76,3 +78,28 @@ test('writePrd: invalid-slug failure when joining a pre-existing Epic leaves tha
   expect(afterIndex.sessions[preexisting.epicId]).toEqual(beforeIndex.sessions[preexisting.epicId]);
   expect(afterIndex.events[preexisting.epicId]).toEqual(beforeIndex.events[preexisting.epicId]);
 });
+
+// Provenance (PRD 905): writePrd's ensureEpic call passes
+// source: { producer: 'scheduler-dispatch', prdSlug }, but this call is
+// join-only (mintIfMissing:false, explicit epicId) — ensureEpic's
+// explicitEpicId branch returns before ever reading `source`, so a
+// successful join must NOT write/alter the joined Epic's `source` field.
+test('writePrd: successful join does not write a source field onto the pre-existing Epic (join-only no-op)', async () => {
+  // Must live under the home dir — config.cjs's writeTextAtomic validates
+  // paths against allowedRoots=home dir, unlike the failure-path tests above
+  // (which never reach the write) os.tmpdir() is not sufficient here.
+  const cwd = fs.mkdtempSync(path.join(os.homedir(), '.sm-writeprd-epic-source-'));
+  tmpDirs.push(cwd);
+  config.addAllowedRoot(cwd);
+
+  const preexisting = await ensureEpic(cwd, { goalText: 'pre-existing epic goal for join' });
+  expect(preexisting.created).toBe(true);
+
+  const body = `---\ntitle: Joins the existing epic\nsourcePromptId: ${preexisting.epicId}\n---\n\nbody text\n`;
+  const result = await remote.writePrd('valid-slug', body, cwd);
+
+  expect(result.ok).toBe(true);
+
+  const index = readActiveIndex(cwd);
+  expect('source' in index.sessions[preexisting.epicId]).toBe(false);
+});

package/src/main/ipcSchemas.cjs

@@ -377,6 +377,14 @@ const setConfigSchema = z.object({
   }).optional(),
 }).strict();
 
+// Machine-wide claude -p slot pool cap (sessionSlots.cjs) — deliberately its own
+// schema/channel rather than folded into setConfigSchema: it governs the shared
+// process pool, not any one project's scheduler config, and its range (0-10, 0
+// pauses new launches) differs from concurrencyCap's (1-20).
+const setSessionSlotsSchema = z.object({
+  cap: z.number().int().min(0).max(10),
+}).strict();
+
 // ──────────────────────────────────────────── Memory tool (Bundle C, cycle 3)
 // Workspace-scoped markdown store at ~/.claude/projects/<ws>/memory/.
 // Slug regex is shared with memoryTool.cjs/memoryAggregate.cjs via lib/memorySlug.cjs;
@@ -754,9 +762,6 @@ const READ_COMMANDS = new Set([
 // Sensitive reads — return user data; require SAS confirmation same as MUTATE.
 const SAS_GATED_READS = new Set([
   'cmd:sessions:load',
-  'cmd:schedule:state',
-  'cmd:schedule:read-prd',
-  'cmd:schedule:read-log',
   'cmd:history:aggregate',
   // subscribe initiates a live stream of session state/summary — sensitive.
   'cmd:session:subscribe',
@@ -764,6 +769,12 @@ const SAS_GATED_READS = new Set([
   // no dispatch handler for it, so an allowlist entry would only fail closed with
   // an opaque reject. Re-add here together with the handler when remote exchanges
   // are wired, so the allowlist always mirrors an actual capability.
+  //
+  // Scheduler/Epics commands (cmd:schedule:*) were removed here deliberately
+  // (core scheduler/Epics redesign) — Remote no longer reaches into scheduler
+  // internals at all; a future Remote rebuild will talk to Scheduler/Epics
+  // through whatever higher-level surface that redesign lands on, not this
+  // per-command allowlist.
 ]);
 
 const MUTATE_COMMANDS = new Set([
@@ -776,10 +787,6 @@ const MUTATE_COMMANDS = new Set([
   // mobile mirror has no business killing or resizing the desktop's session.
   'cmd:pty:kill',
   'cmd:pty:resize',
-  'cmd:schedule:write-prd',
-  'cmd:schedule:reset-job',
-  'cmd:schedule:run-now',
-  'cmd:schedule:set-config',
   // Pushes a prompt into an open tab's chat queue — a real mutation of that
   // tab's session, same tier as pty:write.
   'cmd:chat:send',
@@ -839,6 +846,7 @@ module.exports = {
     scheduleArchivePrd,
     scheduleRetagPrd,
     setConfigSchema,
+    setSessionSlotsSchema,
     shellOpen,
     archiveProject,
     historyAggregate,

package/src/main/lib/__tests__/sessionSlots.test.cjs

@@ -1,36 +1,80 @@
 // sessionSlots.cjs — the Session-Manager-owned machine-wide claude -p pool.
 // vitest globals (test/beforeEach/afterEach) — same convention as the other .cjs tests.
 const assert = require('node:assert');
+const fs = require('node:fs');
 const slots = require('../sessionSlots.cjs');
 
-beforeEach(() => slots.__resetForTests());
+// Same real-homedir convention as queueStore.cjs's own tests — no path override exists
+// for this module, so keep the persisted file removed except where a test deliberately
+// wants it, and restore it to unset afterward.
+const CONFIG_PATH = require('node:path').join(require('node:os').homedir(), '.claude', 'session-manager', 'session-slots-config.json');
+function removeConfig() {
+  try { fs.unlinkSync(CONFIG_PATH); } catch { /* already absent */ }
+}
+
+beforeEach(() => {
+  slots.__resetForTests();
+  removeConfig();
+});
 afterEach(() => {
   slots.__resetForTests();
   delete process.env.SM_SESSION_SLOTS;
+  removeConfig();
 });
 
-test('pool defaults to 3 slots and exhausts', () => {
-  assert.equal(slots.totalSlots(), 3);
-  const t1 = slots.acquire('a');
-  const t2 = slots.acquire('b');
-  const t3 = slots.acquire('c');
-  assert.ok(t1 && t2 && t3);
+test('pool defaults to 5 slots and exhausts', () => {
+  assert.equal(slots.totalSlots(), 5);
+  const tokens = ['a', 'b', 'c', 'd', 'e'].map((o) => slots.acquire(o));
+  assert.ok(tokens.every(Boolean));
   assert.equal(slots.available(), 0);
-  assert.equal(slots.acquire('d'), null, 'fourth acquire must be refused');
-  slots.release(t2);
+  assert.equal(slots.acquire('f'), null, 'sixth acquire must be refused');
+  slots.release(tokens[1]);
   assert.equal(slots.available(), 1);
-  assert.ok(slots.acquire('d'));
+  assert.ok(slots.acquire('f'));
 });
 
-test('SM_SESSION_SLOTS overrides, clamped to [1,3]', () => {
+test('SM_SESSION_SLOTS overrides, clamped to [0, 10]', () => {
   process.env.SM_SESSION_SLOTS = '1';
   assert.equal(slots.totalSlots(), 1);
-  process.env.SM_SESSION_SLOTS = '9';
-  assert.equal(slots.totalSlots(), 3, 'clamped high');
+  process.env.SM_SESSION_SLOTS = '20';
+  assert.equal(slots.totalSlots(), 10, 'clamped high');
   process.env.SM_SESSION_SLOTS = '0';
-  assert.equal(slots.totalSlots(), 1, 'clamped low');
+  assert.equal(slots.totalSlots(), 0, '0 is a legal explicit value (pauses new launches)');
+  process.env.SM_SESSION_SLOTS = '-5';
+  assert.equal(slots.totalSlots(), 0, 'clamped low');
   process.env.SM_SESSION_SLOTS = 'junk';
-  assert.equal(slots.totalSlots(), 3, 'non-numeric falls back to default');
+  assert.equal(slots.totalSlots(), 5, 'non-numeric falls back to default');
+});
+
+test('cap of 0 pauses all new acquisitions without touching existing holders', () => {
+  const t = slots.acquire('a');
+  assert.ok(t);
+  process.env.SM_SESSION_SLOTS = '0';
+  assert.equal(slots.acquire('b'), null);
+  assert.equal(slots.inUse(), 1, 'existing holder is untouched by the pause');
+  slots.release(t);
+  assert.equal(slots.inUse(), 0);
+});
+
+test('setCap persists a value that totalSlots() picks up without an env override', () => {
+  slots.setCap(8);
+  assert.equal(slots.totalSlots(), 8);
+  slots.setCap(0);
+  assert.equal(slots.totalSlots(), 0);
+});
+
+test('setCap rejects out-of-range or non-integer values', () => {
+  assert.throws(() => slots.setCap(11));
+  assert.throws(() => slots.setCap(-1));
+  assert.throws(() => slots.setCap(2.5));
+});
+
+test('setCap notifies subscribers so a raised cap can wake waiting consumers', () => {
+  let notified = 0;
+  const unsub = slots.subscribe(() => { notified += 1; });
+  slots.setCap(7);
+  assert.equal(notified, 1);
+  unsub();
 });
 
 test('release is idempotent and notifies subscribers exactly on real releases', () => {