claude-code-session-manager 0.58.0 → 0.59.0

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

package/src/main/__tests__/scheduler-heal-refusal.test.cjs

@@ -0,0 +1,61 @@
+/**
+ * scheduler-heal-refusal.test.cjs — PRD 983.
+ *
+ * Guards the needs_review → completed self-heal in reverifyNeedsReview.
+ *
+ * Incident being regression-tested: job 972 (2026-08-03) ran 34 s, edited zero
+ * files, exited 0. verifyRun correctly raised `no_verdict_sentinel` /
+ * downgradeTo 'needs_review'. One minute later the self-heal pass promoted it
+ * to `completed` and the false green shipped. Cause: the rescan recomputes
+ * `committedDuringRun` from `committedInWindow`, a repo-wide
+ * `git log --all --since --until` with no author/message/slug filter — a
+ * CONCURRENT job's commit inside the window was credited to this job, which
+ * suppressed the no_verdict_sentinel check on re-verify and let the verdict
+ * conclude `clean`.
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/scheduler-heal-refusal.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { healRefusalReason } = require('../scheduler.cjs');
+
+const CLEAN = { verdict: 'clean', reason: 'no issues detected' };
+
+test('REGRESSION (PRD 983): a no_verdict_sentinel job with no landedCommit is NOT healed, even on a clean re-verify', () => {
+  const job = { slug: '972-notify', verifierVerdict: 'no_verdict_sentinel', landedCommit: null };
+  const refusal = healRefusalReason(job, CLEAN, true);
+  expect(refusal).toBeTruthy();
+  expect(refusal).toContain('no job-attributable commit');
+});
+
+test('a no_verdict_sentinel job WITH its own landedCommit is allowed to heal', () => {
+  const job = { slug: '900-real', verifierVerdict: 'no_verdict_sentinel', landedCommit: 'abc1234' };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('other verdict classes are untouched — transcript_errors still heals on a clean re-verify', () => {
+  const job = { slug: '901-transcript', verifierVerdict: 'transcript_errors', landedCommit: null };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('verify_unavailable (the other pre-sentinel-heal class) is untouched', () => {
+  const job = { slug: '902-unavailable', verifierVerdict: 'verify_unavailable', landedCommit: null };
+  expect(healRefusalReason(job, CLEAN, true)).toBeNull();
+});
+
+test('a non-completed-equivalent re-verify verdict is left to the existing path, not refused here', () => {
+  const job = { slug: '903-still-bad', verifierVerdict: 'no_verdict_sentinel', landedCommit: null };
+  expect(healRefusalReason(job, { verdict: 'transcript_errors', reason: 'x' }, false)).toBeNull();
+});
+
+test('an honest no-op exemption verdict still heals when the job recorded its own commit', () => {
+  const job = { slug: '904-shipped', verifierVerdict: 'no_verdict_sentinel', landedCommit: 'deadbee' };
+  expect(healRefusalReason(job, { verdict: 'pass_no_commit_already_shipped', reason: 'x' }, false)).toBeNull();
+});
+
+test('null/missing inputs never throw and never refuse', () => {
+  expect(healRefusalReason(null, CLEAN, true)).toBeNull();
+  expect(healRefusalReason({ slug: 'x' }, null, true)).toBeNull();
+});

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

@@ -116,6 +116,7 @@ test('routes into the known PromptSession event chain and never falls back to a
     '/some/cwd',
     'psess-1',
     expect.stringContaining('814-notify'),
+    { prdSlug: '814-notify', outcome: 'completed', validation: 'unvalidated' },
   );
   expect(sendPrompt).not.toHaveBeenCalled();
 });
@@ -186,3 +187,76 @@ test('falls back to the tab-external-ticket path when appendResponseEvent itself
 
   expect(sendPrompt).toHaveBeenCalledWith('tab-x', expect.stringContaining('814-notify'));
 });
+
+// ─── PRD 985: real path resolution ───────────────────────────────────────────
+// Every test above injects a stubbed `parsePrdRaw`, which is exactly why the
+// bug PRD 985 fixes shipped green: notifyOriginatingTab resolved its PRD via
+// prdPathForJob → the RETIRED flat `scheduler/prds/` dir (today only
+// `.reserved-NNN` stubs, no PRDs), and archiveCompletedPrd renames the file
+// into `prds-archived/` immediately BEFORE notify runs anyway. `prd` was
+// therefore always null on the completed path and no response event was ever
+// appended. These two tests use the REAL parsePrdRaw against a temp tree so
+// the resolution logic itself is covered, not mocked away.
+
+const fs = require('node:fs');
+const os = require('node:os');
+const nodePath = require('node:path');
+
+function makeEpicTree({ epicId, slug, archived }) {
+  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-'));
+  const dir = nodePath.join(
+    cwd, 'session-manager-operations', 'scheduler', 'epics', epicId,
+    archived ? 'prds-archived' : 'prds',
+  );
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(
+    nodePath.join(dir, `${slug}.md`),
+    `---\ntitle: notify 985\ncwd: ${cwd}\nsourcePromptId: ${epicId}\n---\n\nbody\n`,
+    'utf8',
+  );
+  return cwd;
+}
+
+test('PRD 985: an ARCHIVED-only PRD still routes its check-in to the authoring Epic', async () => {
+  const epicId = 'psess-985-archived';
+  const slug = '985-archived-twin';
+  const cwd = makeEpicTree({ epicId, slug, archived: true });
+
+  const appendResponseEvent = vi.fn(async () => true);
+  const appendTranscriptTurn = vi.fn(async () => {});
+  const sendPrompt = vi.fn();
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  // NOTE: no parsePrdRaw override — the real one runs against the temp tree.
+  await notifyOriginatingTab(
+    { slug, status: 'completed', cwd, epicId: null },
+    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
+  expect(appendResponseEvent).toHaveBeenCalledWith(
+    cwd, epicId, expect.stringContaining(slug),
+    expect.objectContaining({ prdSlug: slug, outcome: 'completed' }),
+  );
+  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, epicId, expect.anything());
+  expect(sendPrompt).not.toHaveBeenCalled();
+});
+
+test('PRD 985: a PRD missing entirely still routes via the job row\'s own epicId', async () => {
+  const cwd = fs.mkdtempSync(nodePath.join(os.tmpdir(), 'sm-notify-985-none-'));
+  const appendResponseEvent = vi.fn(async () => true);
+  const appendTranscriptTurn = vi.fn(async () => {});
+  const sendPrompt = vi.fn();
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+
+  await notifyOriginatingTab(
+    { slug: '985-no-prd-on-disk', status: 'failed', cwd, epicId: 'psess-985-from-queue-row' },
+    { loadSessions, sendPrompt, appendResponseEvent, appendTranscriptTurn, readResultFromLog: () => null },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledWith(
+    cwd, 'psess-985-from-queue-row', expect.stringContaining('985-no-prd-on-disk'),
+    expect.objectContaining({ prdSlug: '985-no-prd-on-disk', outcome: 'failed' }),
+  );
+  expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, 'psess-985-from-queue-row', expect.anything());
+});

package/src/main/__tests__/transcripts-doFlush-array.test.cjs

@@ -0,0 +1,118 @@
+/**
+ * transcripts-doFlush-array.test.cjs — unit tests for transcripts.cjs's
+ * doFlush()/readDelta() handling of classifyLine's array-of-events shape.
+ *
+ * Covers: one line producing several events all land in the getBuffer()
+ * drain flattened (not nested per line), a session with far more than the
+ * old 500-entry ring cap still returns every event via the line-offset
+ * index (the cap is gone), and each event's byte `ref` correctly points
+ * back at its own line in the transcript file on disk.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-doFlush-array.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');
+
+const { subscribe, getBuffer, closeTab, transcriptPath } = require('../transcripts.cjs');
+
+let cwd;
+
+beforeEach(() => {
+  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-doflush-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(cwd, { recursive: true, force: true });
+});
+
+function writeTranscript(cwdArg, sessionId, lines) {
+  const filePath = transcriptPath(cwdArg, sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+  return filePath;
+}
+
+test('a single multi-block line flattens into multiple buffered events', async () => {
+  const sessionId = 'sess-multi';
+  const tabId = 'tab-multi';
+  writeTranscript(cwd, sessionId, [
+    {
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: 'doing two things' },
+          { type: 'tool_use', name: 'Bash', id: 'tu-1', input: { command: 'ls' } },
+          { type: 'tool_use', name: 'Bash', id: 'tu-2', input: { command: 'pwd' } },
+        ],
+      },
+    },
+  ]);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const buf = await getBuffer(tabId);
+  expect(buf).toHaveLength(3);
+  expect(buf.map((e) => e.kind)).toEqual(['assistant', 'tool_use', 'tool_use']);
+  closeTab(tabId);
+});
+
+test('a session with far more than the old 500-entry cap still returns every event — the ring cap is gone', async () => {
+  const sessionId = 'sess-cap';
+  const tabId = 'tab-cap';
+  // 200 lines * 3 events each = 600 events > the old 500 cap.
+  const lines = Array.from({ length: 200 }, (_, i) => ({
+    type: 'assistant',
+    message: {
+      content: [
+        { type: 'text', text: `line ${i}` },
+        { type: 'tool_use', name: 'Bash', id: `tu-${i}-a`, input: { command: 'ls' } },
+        { type: 'tool_use', name: 'Bash', id: `tu-${i}-b`, input: { command: 'pwd' } },
+      ],
+    },
+  }));
+  writeTranscript(cwd, sessionId, lines);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const buf = await getBuffer(tabId);
+  expect(buf).toHaveLength(600);
+  // Nothing evicted — both the genuine first and last events survive.
+  expect(buf[0].data).toBe('line 0');
+  expect(buf[buf.length - 1].data.id).toBe('tu-199-b');
+  closeTab(tabId);
+});
+
+test('each event ref points at its own line — re-reading those bytes reproduces that exact line', async () => {
+  const sessionId = 'sess-ref';
+  const tabId = 'tab-ref';
+  const filePath = writeTranscript(cwd, sessionId, [
+    { type: 'user', message: { content: 'first line — some unicode: héllo 🎉' } },
+    { type: 'assistant', message: { content: 'second line' } },
+  ]);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const buf = await getBuffer(tabId);
+  expect(buf).toHaveLength(2);
+
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    for (const ev of buf) {
+      expect(ev.ref).toBeTruthy();
+      expect(ev.ref.filePath).toBe(filePath);
+      const readBuf = Buffer.alloc(ev.ref.byteLength);
+      fs.readSync(fd, readBuf, 0, ev.ref.byteLength, ev.ref.byteOffset);
+      const parsed = JSON.parse(readBuf.toString('utf8'));
+      expect(parsed.type).toBe(ev.kind);
+    }
+  } finally {
+    fs.closeSync(fd);
+  }
+  closeTab(tabId);
+});

package/src/main/__tests__/transcripts-paged-reads.test.cjs

@@ -0,0 +1,233 @@
+/**
+ * transcripts-paged-reads.test.cjs — unit tests for the line-offset index +
+ * paged-read API that replaced transcripts.cjs's 500-entry ring buffer
+ * (PRD 979). Covers:
+ *  - scrolling to the top of a >500-event session returns the genuine first
+ *    event via readPage/pageEvents, not a truncated window
+ *  - paging is a bounded positional read, never a whole-file materialization
+ *  - bounded memory: indexing a huge number of lines (plus one multi-MB
+ *    line) keeps the persisted index far smaller than the raw content
+ *  - inode-change rotation and truncation invalidate and rebuild the index
+ *  - a partial trailing line is never indexed until it completes
+ *  - a malformed JSON line still occupies its index slot (line numbering
+ *    stays correct)
+ *  - release()/re-subscribe fast-resume preserves the index, not just offset
+ *  - paging never re-emits to OTEL (only the live doFlush ingest path does)
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/transcripts-paged-reads.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach, afterEach, vi } from 'vitest';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const { subscribe, release, closeTab, transcriptPath, pageEvents } = require('../transcripts.cjs');
+const otel = require('../otel.cjs');
+
+let cwd;
+
+beforeEach(() => {
+  cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-paged-test-'));
+});
+
+afterEach(() => {
+  fs.rmSync(cwd, { recursive: true, force: true });
+});
+
+function writeTranscript(cwdArg, sessionId, lines) {
+  const filePath = transcriptPath(cwdArg, sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+  return filePath;
+}
+
+test('paging to line 0 of a >500-event session returns the genuine first event', async () => {
+  const sessionId = 'sess-page-top';
+  const tabId = 'tab-page-top';
+  const lines = Array.from({ length: 800 }, (_, i) => ({
+    type: 'user',
+    message: { content: [{ type: 'text', text: `event number ${i}` }] },
+  }));
+  writeTranscript(cwd, sessionId, lines);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+
+  const top = await pageEvents(tabId, 0, 0);
+  expect(top.totalLines).toBe(800);
+  expect(top.events).toHaveLength(1);
+  expect(top.events[0].data).toBe('event number 0');
+  expect(top.events[0].lineNumber).toBe(0);
+
+  const bottom = await pageEvents(tabId, 799, 799);
+  expect(bottom.events[0].data).toBe('event number 799');
+
+  closeTab(tabId);
+});
+
+test('bounded memory: indexing many lines plus one multi-MB line keeps the index far smaller than the raw content', async () => {
+  const sessionId = 'sess-bounded';
+  const tabId = 'tab-bounded';
+  const NUM_LINES = 20000;
+  const bigLineIndex = 10000;
+  const bigText = 'x'.repeat(5 * 1024 * 1024); // 5MB single line
+  const lines = Array.from({ length: NUM_LINES }, (_, i) => {
+    if (i === bigLineIndex) {
+      return { type: 'user', message: { content: [{ type: 'text', text: bigText }] } };
+    }
+    return { type: 'user', message: { content: [{ type: 'text', text: `line ${i}` }] } };
+  });
+  writeTranscript(cwd, sessionId, lines);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+
+  const sub = require('../transcripts.cjs').__getSubForTest?.(tabId);
+  // Fall back to reading the module's internal state via pageEvents' totalLines
+  // if the internal accessor isn't exported; either way, assert the ceiling on
+  // what actually persists: the index itself, not the file content.
+  const { totalLines } = await pageEvents(tabId, 0, 0);
+  expect(totalLines).toBe(NUM_LINES);
+
+  // Each index entry is two small integers (byteOffset, byteLength). Even a
+  // generous 64 bytes/entry ceiling for NUM_LINES entries is three orders of
+  // magnitude below the 5MB+ raw content of the one huge line — proving the
+  // index never holds the line's actual text.
+  const CEILING_BYTES = NUM_LINES * 64;
+  expect(CEILING_BYTES).toBeLessThan(bigText.length);
+  if (sub) {
+    const approxIndexBytes = sub.lineIndex.length * 16; // 2 numbers/entry
+    expect(approxIndexBytes).toBeLessThan(CEILING_BYTES);
+    // The big line's text must not appear anywhere in the index entries.
+    for (const entry of sub.lineIndex) {
+      expect(Object.keys(entry).sort()).toEqual(['byteLength', 'byteOffset']);
+    }
+  }
+
+  closeTab(tabId);
+});
+
+test('inode-change rotation invalidates and rebuilds the index — no stale offsets served', async () => {
+  const sessionId = 'sess-rotate';
+  const tabId = 'tab-rotate';
+  const filePath = writeTranscript(cwd, sessionId, [
+    { type: 'user', message: { content: [{ type: 'text', text: 'old-a' }] } },
+    { type: 'user', message: { content: [{ type: 'text', text: 'old-b' }] } },
+  ]);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  let page = await pageEvents(tabId, 0, 1);
+  expect(page.totalLines).toBe(2);
+
+  // Simulate log rotation: unlink + recreate (new inode) with different content.
+  fs.unlinkSync(filePath);
+  fs.writeFileSync(filePath, [{ type: 'user', message: { content: [{ type: 'text', text: 'new-a' }] } }].map((l) => JSON.stringify(l)).join('\n') + '\n');
+
+  // The chokidar watcher on the live sub picks up the rotation and rebuilds
+  // the index via readDelta's inode-change reset — poll (bounded) rather
+  // than assume a fixed debounce delay.
+  const deadline = Date.now() + 5000;
+  while (Date.now() < deadline) {
+    page = await pageEvents(tabId, 0, 0);
+    if (page.totalLines === 1 && page.events[0]?.data === 'new-a') break;
+    await new Promise((r) => setTimeout(r, 50));
+  }
+  expect(page.totalLines).toBe(1);
+  expect(page.events[0].data).toBe('new-a');
+  closeTab(tabId);
+}, 10000);
+
+test('a partial trailing line is not indexed until it completes', async () => {
+  const sessionId = 'sess-partial';
+  const tabId = 'tab-partial';
+  const filePath = transcriptPath(cwd, sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const complete = JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'first' }] } });
+  // No trailing newline — this line is "still being written".
+  fs.writeFileSync(filePath, complete + '\n' + '{"type":"user","message":{"content":[{"type":"text","text":"unfinishe');
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  let page = await pageEvents(tabId, 0, 10);
+  expect(page.totalLines).toBe(1);
+  expect(page.events[0].data).toBe('first');
+
+  closeTab(tabId);
+});
+
+test('a malformed JSON line still occupies its index slot — line numbering stays correct', async () => {
+  const sessionId = 'sess-malformed';
+  const tabId = 'tab-malformed';
+  const filePath = transcriptPath(cwd, sessionId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  const body = [
+    JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'ok-0' }] } }),
+    'not valid json {{{',
+    JSON.stringify({ type: 'user', message: { content: [{ type: 'text', text: 'ok-2' }] } }),
+  ].join('\n') + '\n';
+  fs.writeFileSync(filePath, body);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const page = await pageEvents(tabId, 0, 2);
+  expect(page.totalLines).toBe(3);
+  // Malformed line 1 produces no event, but line 2's numbering is unaffected.
+  expect(page.events.map((e) => e.lineNumber)).toEqual([0, 2]);
+  expect(page.events[1].data).toBe('ok-2');
+
+  closeTab(tabId);
+});
+
+test('release()/re-subscribe fast-resume preserves the index rather than re-reading from byte 0', async () => {
+  const sessionId = 'sess-resume';
+  const tabId = 'tab-resume';
+  writeTranscript(cwd, sessionId, [
+    { type: 'user', message: { content: [{ type: 'text', text: 'a' }] } },
+    { type: 'user', message: { content: [{ type: 'text', text: 'b' }] } },
+  ]);
+
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const before = await pageEvents(tabId, 0, 1);
+  expect(before.totalLines).toBe(2);
+
+  release(tabId); // view-switch away — sub stays cached
+  // Re-subscribing the same tab should promote it back from the LRU cache
+  // rather than re-reading the transcript from scratch.
+  const res2 = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res2.ok).toBe(true);
+  const after = await pageEvents(tabId, 0, 1);
+  expect(after.totalLines).toBe(2);
+  expect(after.events.map((e) => e.data)).toEqual(['a', 'b']);
+
+  closeTab(tabId);
+});
+
+test('paging never re-emits to OTEL — only the live doFlush ingest path records', async () => {
+  const sessionId = 'sess-otel';
+  const tabId = 'tab-otel';
+  writeTranscript(cwd, sessionId, [
+    { type: 'user', message: { content: 'one' } },
+    { type: 'user', message: { content: 'two' } },
+  ]);
+
+  const spy = vi.spyOn(otel, 'recordTranscriptEvent');
+  const res = await subscribe({ tabId, cwd, sessionUuid: sessionId });
+  expect(res.ok).toBe(true);
+  const callsAfterSubscribe = spy.mock.calls.length;
+  expect(callsAfterSubscribe).toBeGreaterThan(0); // initial drain recorded both events
+
+  // Page over the same range repeatedly — must not add more OTEL calls.
+  await pageEvents(tabId, 0, 1);
+  await pageEvents(tabId, 0, 1);
+  await pageEvents(tabId, 0, 0);
+  expect(spy.mock.calls.length).toBe(callsAfterSubscribe);
+
+  spy.mockRestore();
+  closeTab(tabId);
+});

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

@@ -95,12 +95,17 @@ describe('pickForProject dependsOn eligibility (PRD 832)', () => {
     expect(res.reason).toContain('854-base');
   });
 
-  it('legacy same-NN pending jobs keep their wave order untouched', () => {
+  // Contract change: parallelGroup no longer gates batch membership at all
+  // (it was a wave number; PRD 832 made it unique per PRD, which silently
+  // reduced every batch to one job). Legacy same-NN rows are simply eligible
+  // like anything else with no blocking dependsOn — the 828 row is no longer
+  // held back merely for carrying a higher number.
+  it('legacy same-NN pending jobs are eligible alongside higher-numbered ones', () => {
     const a = job('827-one', 'pending', 827);
     const b = job('827-two', 'pending', 827);
     const later = job('828-three', 'pending', 828);
     const res = pickForProject([a, b, later], new Set(), 3);
-    expect(res.batch.map((j) => j.slug).sort()).toEqual(['827-one', '827-two']);
+    expect(res.batch.map((j) => j.slug).sort()).toEqual(['827-one', '827-two', '828-three']);
   });
 });
 

package/src/main/health.cjs

@@ -78,7 +78,11 @@ function evaluateTickLiveness(queueState, heartbeat, now, runningCount) {
   const pending = jobs.filter((j) => j.status === 'pending');
   const running = runningCount ?? jobs.filter((j) => j.status === 'running').length;
   const config = queueState.config || {};
-  const concurrencyCap = config.concurrencyCap ?? Infinity;
+  // The scheduler's private concurrencyCap is retired — the machine-wide
+  // sessionSlots pool is the only limit. Read it lazily so this stays a pure
+  // function of its args when a caller supplies slotCap explicitly.
+  const concurrencyCap = queueState.slotCap
+    ?? (() => { try { return require('./lib/sessionSlots.cjs').totalSlots(); } catch { return Infinity; } })();
 
   if (pending.length === 0) return { stalled: false, reason: 'no-pending-jobs' };
   if (queueState.paused) return { stalled: false, reason: 'paused' };

package/src/main/index.cjs

@@ -1021,7 +1021,7 @@ app.whenReady().then(async () => {
     "img-src 'self' data: blob: smfile:",
     "font-src 'self' data: https://fonts.gstatic.com",
     // schemastore.org is used by Monaco for JSON schema validation
-    // (settings.json, keybindings.json — see App.tsx::installMonacoSchemas).
+    // (settings.json — see App.tsx::installMonacoSchemas).
     // The json.schemastore.org URL redirects to www.schemastore.org, so both
     // hosts must be in the allowlist or CSP blocks the redirect.
     "connect-src 'self' https://api.anthropic.com https://registry.npmjs.org https://json.schemastore.org https://www.schemastore.org",