npm - claude-code-session-manager - Versions diffs - 0.35.15 → 0.35.17 - Mend

claude-code-session-manager 0.35.15 → 0.35.17

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/dist/assets/{TiptapBody-B7PHDZwk.js → TiptapBody-BM9Kz1Nm.js} +1 -1
package/dist/assets/index-DX2w2YhJ.css +32 -0
package/dist/assets/index-DuoC6oCy.js +3559 -0
package/dist/index.html +2 -2
package/package.json +2 -1
package/src/main/__tests__/adminServer.test.cjs +205 -0
package/src/main/__tests__/chat-queue.test.cjs +27 -0
package/src/main/__tests__/health-tick-liveness.test.cjs +143 -0
package/src/main/__tests__/prd-group-allocator.test.cjs +119 -0
package/src/main/__tests__/prdCreate.test.cjs +82 -0
package/src/main/__tests__/runVerify.test.cjs +146 -0
package/src/main/__tests__/scheduler-committed-in-window.test.cjs +5 -3
package/src/main/__tests__/scheduler-tick-cancel-token.test.cjs +54 -0
package/src/main/__tests__/scheduler-transient-failure.test.cjs +141 -0
package/src/main/adminServer.cjs +87 -2
package/src/main/browserCapture.cjs +21 -7
package/src/main/chatRunner.cjs +5 -1
package/src/main/health.cjs +114 -3
package/src/main/hives.cjs +2 -1
package/src/main/ipcSchemas.cjs +33 -4
package/src/main/lib/kebabCase.cjs +12 -0
package/src/main/lib/memorySlug.cjs +10 -0
package/src/main/lib/prdCreate.cjs +73 -0
package/src/main/memoryAggregate.cjs +1 -1
package/src/main/memoryTool.cjs +2 -1
package/src/main/pty.cjs +2 -1
package/src/main/runVerify.cjs +119 -6
package/src/main/scheduler/prdParser.cjs +88 -0
package/src/main/scheduler.cjs +176 -9
package/src/main/templates/PRD_AUTHORING.md +126 -0
package/src/main/usage.cjs +4 -0
package/src/main/webRemote.cjs +13 -18
package/src/preload/api.d.ts +1 -0
package/dist/assets/index-B39Qiq0n.css +0 -32
package/dist/assets/index-DRSHENEg.js +0 -3559

package/dist/index.html CHANGED Viewed

@@ -7,10 +7,10 @@
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
     <link href="https://fonts.googleapis.com/css2?family=Newsreader:ital,opsz,wght@0,6..72,400;0,6..72,500;0,6..72,600;0,6..72,700;1,6..72,400&family=Geist:wght@300;400;500;600;700&family=IBM+Plex+Mono:wght@400;500;600&display=swap" rel="stylesheet">
-    <script type="module" crossorigin src="./assets/index-DRSHENEg.js"></script>
+    <script type="module" crossorigin src="./assets/index-DuoC6oCy.js"></script>
     <link rel="modulepreload" crossorigin href="./assets/monaco-editor-BW5C4Iv1.js">
     <link rel="stylesheet" crossorigin href="./assets/monaco-editor-BTnBOi8r.css">
-    <link rel="stylesheet" crossorigin href="./assets/index-B39Qiq0n.css">
+    <link rel="stylesheet" crossorigin href="./assets/index-DX2w2YhJ.css">
   </head>
   <body class="bg-bg text-fg font-sans antialiased">
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "claude-code-session-manager",
-  "version": "0.35.15",
+  "version": "0.35.17",
   "description": "Local cockpit for the Claude Code CLI — multi-tab terminal, full config surface, scheduler, voice dictation, and live observability.",
   "type": "module",
   "main": "src/main/index.cjs",
@@ -120,6 +120,7 @@
     "@vitejs/plugin-react": "^4.3.3",
     "autoprefixer": "^10.4.20",
     "concurrently": "^9.1.0",
+    "jsdom": "^29.1.1",
     "postcss": "^8.4.49",
     "react": "^18.3.1",
     "react-dom": "^18.3.1",

package/src/main/__tests__/adminServer.test.cjs CHANGED Viewed

@@ -9,7 +9,12 @@
 const { test } = require('node:test');
 const assert = require('node:assert/strict');
 const http = require('node:http');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
 const { createAdminServer } = require('../adminServer.cjs');
+const config = require('../config.cjs');
 function request(port, { method = 'GET', path: reqPath, token, body }) {
   return new Promise((resolve, reject) => {
@@ -173,3 +178,203 @@ test('server binds only to 127.0.0.1', async () => {
     await admin.stop();
   }
 });
+// ──────────────────────────────────────────── create-prd
+const prdParser = require('../scheduler/prdParser.cjs');
+// config.cjs's validateWrite only allows writes under a registered non-home
+// allowedRoot's `.claude/` subtree (mirrors the real ROOT layout, which is
+// $HOME/.claude/session-manager/...) — so the temp prdsDir must live under
+// `<root>/.claude/...`, not directly under the temp root itself.
+async function mkTmpPrdsDir() {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-admin-create-prd-'));
+  config.addAllowedRoot(root);
+  const prdsDir = path.join(root, '.claude', 'prds');
+  await fsp.mkdir(prdsDir, { recursive: true });
+  return prdsDir;
+}
+// Mirrors scheduler.cjs's real `remote.allocateParallelGroup` / `remote.writePrd`
+// (same underlying prdParser.allocateParallelGroup + config.writeTextAtomic
+// calls) but pointed at a throwaway temp dir instead of the user's real
+// scheduled-plans/prds — so these tests never touch $HOME/.claude.
+function makeFakeRemoteWithPrdsDir(prdsDir) {
+  return {
+    async allocateParallelGroup() {
+      return prdParser.allocateParallelGroup(prdsDir);
+    },
+    async readPrd(slug) {
+      try {
+        const text = await fsp.readFile(path.join(prdsDir, `${slug}.md`), 'utf8');
+        return { ok: true, text };
+      } catch (e) {
+        return { ok: false, error: e?.message };
+      }
+    },
+    async writePrd(slug, body) {
+      try {
+        const filePath = path.join(prdsDir, `${slug}.md`);
+        await config.writeTextAtomic(filePath, body);
+        return { ok: true };
+      } catch (e) {
+        return { ok: false, error: e?.message };
+      }
+    },
+  };
+}
+function validCreateBody(overrides = {}) {
+  return {
+    title: 'Add widget frobnication',
+    cwd: os.homedir(),
+    estimateMinutes: 15,
+    goal: 'Add frobnication to the widget subsystem.',
+    acceptanceCriteria: ['widget frobnicates on click', 'timeout 300 npm run typecheck passes'],
+    implementationNotes: 'See src/widget.cjs:10.',
+    outOfScope: ['not touching gadgets'],
+    ...overrides,
+  };
+}
+test('POST /admin/scheduler/create-prd without token returns 401', async () => {
+  const remote = makeFakeRemote();
+  const admin = createAdminServer(remote);
+  const { port } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', body: validCreateBody(),
+    });
+    assert.strictEqual(res.status, 401);
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd with a valid payload writes a file with frontmatter + standards appended, returns {nn, filename, status}', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token, body: validCreateBody(),
+    });
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.json.status, 'queued');
+    assert.strictEqual(typeof res.json.nn, 'number');
+    assert.match(res.json.filename, /^\d+-add-widget-frobnication\.md$/);
+    const written = await fsp.readFile(path.join(prdsDir, res.json.filename), 'utf8');
+    assert.match(written, /^---\n/);
+    assert.match(written, /title: Add widget frobnication/);
+    assert.match(written, /cwd: .+/);
+    assert.match(written, /estimateMinutes: 15/);
+    assert.match(written, /# Goal/);
+    assert.match(written, /# Acceptance criteria/);
+    assert.match(written, /- \[ \] widget frobnicates on click/);
+    assert.match(written, /# Implementation notes/);
+    assert.match(written, /# Out of scope/);
+    assert.match(written, /## Engineering standards/);
+    assert.ok(written.includes('Execution discipline'), 'must inline standards.md verbatim');
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd with malformed frontmatter (missing acceptanceCriteria) is rejected and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const body = validCreateBody();
+    delete body.acceptanceCriteria;
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token, body,
+    });
+    assert.strictEqual(res.status, 400);
+    assert.strictEqual(res.json.ok, false);
+    const entries = await fsp.readdir(prdsDir);
+    assert.strictEqual(entries.filter((f) => f.endsWith('.md')).length, 0);
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd with cwd outside allowed roots is rejected and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ cwd: '/etc/passwd-adjacent-outside-home' }),
+    });
+    assert.strictEqual(res.status, 400);
+    assert.strictEqual(res.json.ok, false);
+    const entries = await fsp.readdir(prdsDir);
+    assert.strictEqual(entries.filter((f) => f.endsWith('.md')).length, 0);
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd rejects a title containing a newline (frontmatter-injection guard) and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ title: 'Legit title\n---\nEvil: injected' }),
+    });
+    assert.strictEqual(res.status, 400);
+    assert.strictEqual(res.json.ok, false);
+    const entries = await fsp.readdir(prdsDir);
+    assert.strictEqual(entries.filter((f) => f.endsWith('.md')).length, 0);
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd with an explicit parallelGroup+slug that already exists on disk returns 409 and does not clobber the file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    await fsp.writeFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'ORIGINAL CONTENT\n');
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ slug: 'my-explicit-slug', parallelGroup: 777 }),
+    });
+    assert.strictEqual(res.status, 409);
+    assert.strictEqual(res.json.ok, false);
+    const stillThere = await fsp.readFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'utf8');
+    assert.strictEqual(stillThere, 'ORIGINAL CONTENT\n', 'existing PRD file must not be overwritten');
+  } finally {
+    await admin.stop();
+  }
+});
+test('POST /admin/scheduler/create-prd honors an explicit slug + parallelGroup instead of deriving/allocating', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const admin = createAdminServer(remote);
+  const { port, token } = await admin.start();
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ slug: 'my-explicit-slug', parallelGroup: 777 }),
+    });
+    assert.strictEqual(res.status, 200);
+    assert.strictEqual(res.json.nn, 777);
+    assert.strictEqual(res.json.filename, '777-my-explicit-slug.md');
+    assert.ok(fs.existsSync(path.join(prdsDir, '777-my-explicit-slug.md')));
+  } finally {
+    await admin.stop();
+  }
+});

package/src/main/__tests__/chat-queue.test.cjs CHANGED Viewed

@@ -68,3 +68,30 @@ test('cancelling a queued run drops it without executing', async () => {
   cr.__setExecutor(null);
 });
+test('a queued silent run never broadcasts chat:run:queued (silent runs stay invisible to the renderer)', async () => {
+  const sent = [];
+  cr.attachWindow({
+    isDestroyed: () => false,
+    webContents: { isDestroyed: () => false, send: (channel, payload) => sent.push({ channel, payload }) },
+  });
+  cr.__setExecutor((j) => new Promise((res) => setImmediate(res)));
+  // P and Q take the two lanes under the default cap; R queues behind them —
+  // this is the only path that ever populates chatRunner's `waiting` list,
+  // and every job on it is silent (manual runs bypass the queue entirely).
+  cr.run(job('P'));
+  cr.run(job('Q'));
+  cr.run(job('R'));
+  for (let i = 0; i < 8; i++) await tick();
+  assert.equal(
+    sent.filter((s) => s.channel === 'chat:run:queued').length,
+    0,
+    'no chat:run:queued broadcast for a silent (automated probe) run',
+  );
+  cr.__setExecutor(null);
+  cr.attachWindow(null);
+});

package/src/main/__tests__/health-tick-liveness.test.cjs ADDED Viewed

@@ -0,0 +1,143 @@
+/**
+ * health-tick-liveness.test.cjs — tick-liveness assertion for the
+ * scheduler_queue health check (PRD: health stayed GREEN through the
+ * 2026-07-14 16.5h scheduler-tick stall while PRD 544 sat pending with free
+ * capacity). Exercises evaluateTickLiveness()/readFreshHeartbeat() directly
+ * since they're pure/fs-isolated — no need to mock os.homedir() through the
+ * full check() to cover the liveness logic.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/health-tick-liveness.test.cjs
+ */
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  evaluateTickLiveness,
+  readFreshHeartbeat,
+  TICK_STALL_THRESHOLD_MS,
+} = require('../health.cjs');
+// Real incident fixture, verified at triage (PRD notes): queue.json had one
+// job pending, running:0, concurrencyCap:3, paused:null, enabled:true, and
+// lastRunAt frozen at the moment the tick died.
+const STALL_LAST_RUN_AT = '2026-07-14T14:40:39.274Z';
+const NOW = Date.parse(STALL_LAST_RUN_AT) + 16.5 * 60 * 60_000; // 16.5h later
+function baseQueue(overrides = {}) {
+  return {
+    config: {
+      concurrencyCap: 3,
+      firePolicy: 'when-available',
+      utilizationThreshold: 90,
+      enabled: true,
+    },
+    jobs: [
+      { slug: '544-stuck-job', status: 'pending' },
+    ],
+    lastRunAt: STALL_LAST_RUN_AT,
+    paused: null,
+    ...overrides,
+  };
+}
+test('reports stalled: pending job, free capacity, not paused, enabled, tick silent for 16.5h (heartbeat confirms utilization is not the explanation)', () => {
+  const heartbeat = { ts: NOW - 30_000, utilization: 0 };
+  const result = evaluateTickLiveness(baseQueue(), heartbeat, NOW);
+  assert.strictEqual(result.stalled, true);
+  assert.strictEqual(result.oldestPendingSlug, '544-stuck-job');
+  assert.ok(result.tickAgeMs > TICK_STALL_THRESHOLD_MS);
+});
+test('no false positive: queue is paused (incl. rate-limit auto-pause)', () => {
+  const result = evaluateTickLiveness(
+    baseQueue({ paused: { reason: 'rate-limit', resumeAt: '2099-01-01T00:00:00.000Z' } }),
+    null,
+    NOW
+  );
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.reason, 'paused');
+});
+test('no false positive: running is already at concurrencyCap', () => {
+  const q = baseQueue({
+    jobs: [
+      { slug: 'running-1', status: 'running' },
+      { slug: 'running-2', status: 'running' },
+      { slug: 'running-3', status: 'running' },
+      { slug: '544-stuck-job', status: 'pending' },
+    ],
+  });
+  const result = evaluateTickLiveness(q, null, NOW);
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.reason, 'at-capacity');
+});
+test('no false positive: scheduler disabled', () => {
+  const q = baseQueue({ config: { ...baseQueue().config, enabled: false } });
+  const result = evaluateTickLiveness(q, null, NOW);
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.reason, 'disabled');
+});
+test('no false positive: billing utilization at/above utilizationThreshold (when-available is designed to hold)', () => {
+  const heartbeat = { ts: NOW - 30_000, utilization: 95 };
+  const result = evaluateTickLiveness(baseQueue(), heartbeat, NOW);
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.reason, 'utilization-at-threshold');
+});
+test('no false positive: no pending jobs at all', () => {
+  const q = baseQueue({ jobs: [] });
+  const result = evaluateTickLiveness(q, null, NOW);
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.reason, 'no-pending-jobs');
+});
+test('degrades honestly: heartbeat missing/stale means utilization cannot be ruled out — caveat, not a confident stall', () => {
+  const result = evaluateTickLiveness(baseQueue(), null, NOW);
+  assert.strictEqual(result.stalled, false);
+  assert.strictEqual(result.caveat, true);
+  assert.strictEqual(result.reason, 'cannot-verify-utilization');
+});
+test('does not caveat when firePolicy is not when-available (utilization is irrelevant, so no heartbeat needed)', () => {
+  const q = baseQueue({ config: { ...baseQueue().config, firePolicy: 'manual' } });
+  const result = evaluateTickLiveness(q, null, NOW);
+  assert.strictEqual(result.stalled, true);
+});
+test('readFreshHeartbeat: returns null for missing file', () => {
+  const result = readFreshHeartbeat(path.join(os.tmpdir(), 'sm-health-test-nonexistent.log'));
+  assert.strictEqual(result, null);
+});
+test('readFreshHeartbeat: returns null for a stale (old) heartbeat line', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-health-heartbeat-'));
+  const p = path.join(dir, 'heartbeat.log');
+  try {
+    fs.writeFileSync(p, `${JSON.stringify({ ts: Date.now() - 60 * 60_000, utilization: 10 })}\n`);
+    assert.strictEqual(readFreshHeartbeat(p), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+test('readFreshHeartbeat: returns the parsed last line when fresh', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-health-heartbeat-'));
+  const p = path.join(dir, 'heartbeat.log');
+  try {
+    fs.writeFileSync(
+      p,
+      `${JSON.stringify({ ts: Date.now() - 5 * 60_000, utilization: 10 })}\n${JSON.stringify({ ts: Date.now(), utilization: 42 })}\n`
+    );
+    const entry = readFreshHeartbeat(p);
+    assert.strictEqual(entry.utilization, 42);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/src/main/__tests__/prd-group-allocator.test.cjs ADDED Viewed

@@ -0,0 +1,119 @@
+/**
+ * prd-group-allocator.test.cjs — regression test for gh-issue-4 / PRD
+ * (allocateParallelGroup): two projects authoring PRDs concurrently under
+ * the shared prds/ directory both computed the same max-NN and allocated
+ * the same new parallel group (05-11 vs 06-09 on 2026-07-14, then 545 vs
+ * 545 again on 2026-07-15 between session-manager and sigma). NN is both
+ * the filename counter and the parallel-group key the scheduler parses,
+ * so a collision silently merges two unrelated projects' PRDs into one
+ * group.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/prd-group-allocator.test.cjs
+ */
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const {
+  allocateParallelGroup,
+  maxParallelGroupInUse,
+  parsePrdRaw,
+  _resetCache,
+} = require('../scheduler/prdParser.cjs');
+function mkTmpPrdsDir() {
+  return fsp.mkdtemp(path.join(os.tmpdir(), 'sm-prd-alloc-'));
+}
+test('allocateParallelGroup returns max+1 on an empty directory', async () => {
+  const dir = await mkTmpPrdsDir();
+  const nn = await allocateParallelGroup(dir);
+  assert.strictEqual(nn, 1);
+});
+test('allocateParallelGroup scans the FULL directory, not a narrowed glob — reproduces the 577-PRD/max-544 live directory shape', async () => {
+  const dir = await mkTmpPrdsDir();
+  // Live directory (2026-07-18) holds an unpadded legacy name and a max of 544.
+  await fsp.writeFile(path.join(dir, '54-scheduler-memory-guard-cap3.md'), '# x\n');
+  await fsp.writeFile(path.join(dir, '110-some-slug.md'), '# x\n'); // would be missed by '^10[0-9]'
+  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
+  await fsp.writeFile(path.join(dir, '9-old-single-digit.md'), '# x\n');
+  const max = await maxParallelGroupInUse(dir);
+  assert.strictEqual(max, 544, 'must see 544 as the max even though 110 sorts before it lexically and 54/9 are unpadded');
+  const nn = await allocateParallelGroup(dir);
+  assert.strictEqual(nn, 545);
+});
+test('two concurrent allocateParallelGroup callers never receive the same new NN (the core race from the incident)', async () => {
+  const dir = await mkTmpPrdsDir();
+  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
+  const CONCURRENCY = 12;
+  const results = await Promise.all(
+    Array.from({ length: CONCURRENCY }, () => allocateParallelGroup(dir)),
+  );
+  const distinct = new Set(results);
+  assert.strictEqual(distinct.size, CONCURRENCY, `expected ${CONCURRENCY} distinct NNs, got collisions: ${results.join(',')}`);
+  for (const nn of results) {
+    assert.ok(nn > 544, `allocated NN ${nn} must not collide with existing on-disk NN 544`);
+  }
+});
+test('reservation markers are counted toward max-NN so a crash mid-allocation cannot be re-issued by a later caller', async () => {
+  const dir = await mkTmpPrdsDir();
+  await fsp.writeFile(path.join(dir, '544-latest-prd.md'), '# x\n');
+  const first = await allocateParallelGroup(dir); // 545, leaves .reserved-545 on disk
+  assert.strictEqual(first, 545);
+  // Simulate the caller never authoring 545-slug.md (crash between reserve
+  // and author). A later allocation must still move past 545, not reissue it.
+  const second = await allocateParallelGroup(dir);
+  assert.strictEqual(second, 546);
+});
+test('deliberate parallel siblings sharing one existing NN are unaffected by the allocator (main regression risk)', async () => {
+  const dir = await mkTmpPrdsDir();
+  // Three independent PRDs deliberately opting into the SAME group, exactly
+  // as /develop's SKILL.md contract allows — authored directly by filename,
+  // never through allocateParallelGroup.
+  await fsp.writeFile(path.join(dir, '545-scheduler-tick-stall-after-job-failure.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody A\n');
+  await fsp.writeFile(path.join(dir, '545-filetree-show-hidden-default-and-persist.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody B\n');
+  await fsp.writeFile(path.join(dir, '545-editor-tab-close-shortcut-and-close-right.md'), '---\ncwd: ~/Projects/session-manager\n---\nBody C\n');
+  const files = await fsp.readdir(dir);
+  const parsed = await Promise.all(
+    files.filter((f) => f.endsWith('.md')).map((f) => parsePrdRaw(path.join(dir, f))),
+  );
+  assert.strictEqual(parsed.length, 3);
+  for (const p of parsed) {
+    assert.strictEqual(p.parallelGroup, 545, 'siblings must keep sharing group 545 — the allocator must not renumber existing files');
+  }
+  // A brand-new PRD (not a deliberate sibling) allocated afterward must NOT
+  // land in 545 — it gets the next free group instead.
+  const nn = await allocateParallelGroup(dir);
+  assert.strictEqual(nn, 546);
+});
+test('module-level PRD dir-mtime cache in prdParser is unaffected by reservation markers (hidden files stay invisible to listPrdFiles)', async () => {
+  const dir = await mkTmpPrdsDir();
+  _resetCache();
+  await fsp.writeFile(path.join(dir, '1-a.md'), '# x\n');
+  const { listPrdFiles } = require('../scheduler/prdParser.cjs');
+  const before = await listPrdFiles(dir);
+  assert.strictEqual(before.length, 1);
+  await allocateParallelGroup(dir); // writes a .reserved-2 marker
+  _resetCache();
+  const after = await listPrdFiles(dir);
+  assert.strictEqual(after.length, 1, 'reservation markers must not appear as PRD files');
+});

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

@@ -0,0 +1,82 @@
+/**
+ * prdCreate.test.cjs — unit tests for the create-PRD body builder (PRD 549,
+ * gh-issue-6). Pure-function tests only; the HTTP route + auth/cwd-boundary
+ * behavior is covered by adminServer.test.cjs.
+ *
+ * Run: timeout 120 node --test src/main/__tests__/prdCreate.test.cjs
+ */
+'use strict';
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const {
+  deriveSlugFromTitle,
+  buildPrdBody,
+  readStandards,
+  PRD_CREATE_SLUG_RE,
+} = require('../lib/prdCreate.cjs');
+test('deriveSlugFromTitle lowercases, kebab-cases, and strips non-alnum runs', () => {
+  assert.strictEqual(deriveSlugFromTitle('Add Foo Bar!! Baz'), 'add-foo-bar-baz');
+  assert.strictEqual(deriveSlugFromTitle('  leading/trailing  '), 'leading-trailing');
+});
+test('deriveSlugFromTitle output always satisfies PRD_CREATE_SLUG_RE', () => {
+  const slug = deriveSlugFromTitle('Some Title 123');
+  assert.ok(PRD_CREATE_SLUG_RE.test(slug));
+});
+test('readStandards reads the real standards.md and returns non-empty text', async () => {
+  const text = await readStandards();
+  assert.ok(text.includes('Execution discipline'));
+});
+test('buildPrdBody emits required frontmatter keys and body sections in order', async () => {
+  const standards = await readStandards();
+  const body = buildPrdBody({
+    title: 'Do the thing',
+    cwd: '~/Projects/session-manager',
+    estimateMinutes: 15,
+    goal: 'Build the thing.',
+    acceptanceCriteria: ['thing exists', 'tests pass'],
+    implementationNotes: 'See file.cjs:10.',
+    outOfScope: ['not this'],
+  }, standards);
+  assert.ok(body.startsWith('---\n'));
+  assert.match(body, /title: Do the thing/);
+  assert.match(body, /cwd: ~\/Projects\/session-manager/);
+  assert.match(body, /estimateMinutes: 15/);
+  const goalIdx = body.indexOf('# Goal');
+  const acIdx = body.indexOf('# Acceptance criteria');
+  const implIdx = body.indexOf('# Implementation notes');
+  const oosIdx = body.indexOf('# Out of scope');
+  const standardsIdx = body.indexOf('## Engineering standards');
+  assert.ok(goalIdx > 0 && goalIdx < acIdx && acIdx < implIdx && implIdx < oosIdx && oosIdx < standardsIdx,
+    'sections must appear in Goal -> AC -> Implementation notes -> Out of scope -> Engineering standards order');
+  assert.match(body, /- \[ \] thing exists/);
+  assert.match(body, /- \[ \] tests pass/);
+  assert.match(body, /- not this/);
+  assert.ok(body.includes('Execution discipline'), 'must inline the standards.md content verbatim');
+});
+test('buildPrdBody omits parallelGroup frontmatter key when not supplied', () => {
+  const body = buildPrdBody({
+    title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
+    acceptanceCriteria: ['a'], implementationNotes: 'n',
+  }, 'standards text');
+  assert.ok(!/parallelGroup:/.test(body));
+});
+test('readStandards result is byte-identical to the on-disk file (single source of truth)', async () => {
+  const path = require('node:path');
+  const onDisk = fs.readFileSync(
+    path.join(__dirname, '..', '..', '..', 'plugins', 'session-manager-dev', 'skills', 'develop', 'standards.md'),
+    'utf8',
+  );
+  assert.strictEqual(await readStandards(), onDisk);
+});