claude-code-session-manager 0.98.0 → 0.101.0

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

@@ -1,160 +0,0 @@
-/**
- * prdUpdateDependsOn.test.cjs — PRD 1124: scheduler.remote.updatePrd accepts
- * a `dependsOn` array patch, validates it write-time against the SAME
- * resolver (depSlugResolve.cjs) scheduler_create_prd's prdCreate.cjs uses,
- * and accepts an explicit empty array to CLEAR the dependency.
- *
- * Mirrors scheduler-reconcile-quarantine.test.cjs's HOME-isolation fixture.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/prdUpdateDependsOn.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeAll, afterAll } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-let tmpHome;
-let originalHome;
-let scheduler;
-let queueStore;
-let config;
-
-beforeAll(() => {
-  originalHome = process.env.HOME;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-update-prd-dependson-home-'));
-  process.env.HOME = tmpHome;
-
-  scheduler = require('../scheduler.cjs');
-  queueStore = require('../lib/queueStore.cjs');
-  config = require('../config.cjs');
-
-  if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
-    throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
-  }
-});
-
-afterAll(() => {
-  process.env.HOME = originalHome;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function registerActiveProject(cwd) {
-  const projectsDir = path.join(tmpHome, '.claude', 'projects');
-  const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
-  fs.mkdirSync(slugDir, { recursive: true });
-  fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
-}
-
-function makeFixtureProject(prefix) {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  registerActiveProject(cwd);
-  // updatePrd writes through config.writeTextAtomic, which enforces
-  // validatePath's allowed-write-root boundary (os.homedir() by default).
-  // The live app widens this via pty.cjs's spawn / activeIndexMerge.cjs's
-  // boot registration as a side effect of opening the project; a test that
-  // never spawns a PTY has to register it explicitly, same as
-  // prdCreate.cjs's own createPrd does for a chat-only Epic.
-  config.addAllowedRoot(cwd);
-  const opsRoot = path.join(cwd, 'session-manager-operations');
-  const prdsDir = path.join(opsRoot, 'scheduler', 'epics', 'test-epic-1', 'prds');
-  const stateDir = path.join(opsRoot, 'scheduler', 'state');
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.mkdirSync(stateDir, { recursive: true });
-  fs.writeFileSync(path.join(stateDir, 'queue.json'), JSON.stringify({ jobs: [] }, null, 2), 'utf8');
-  queueStore.bustCwdCache();
-  return { cwd, prdsDir, stateDir };
-}
-
-function writePrd(prdsDir, filename, cwd, extraFrontmatter = '') {
-  fs.writeFileSync(
-    path.join(prdsDir, filename),
-    `---\ntitle: ${filename}\ncwd: ${cwd}\nestimateMinutes: 10\ncreatedVia: scheduler-api\n${extraFrontmatter}---\n\n# Goal\nDo the thing.\n`,
-    'utf8',
-  );
-}
-
-test('updatePrd patches dependsOn to a new valid list naming an existing bare slug', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-valid-');
-  try {
-    writePrd(prdsDir, '3-widget-base.md', cwd);
-    writePrd(prdsDir, '4-widget-follow-up.md', cwd);
-
-    const result = await scheduler.remote.updatePrd({
-      slug: '4-widget-follow-up',
-      cwd,
-      frontmatter: { dependsOn: ['widget-base'] },
-    });
-
-    expect(result.ok).toBe(true);
-    const written = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
-    expect(written).toMatch(/^dependsOn: \[widget-base\]$/m);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('updatePrd refuses a dependsOn entry that resolves to no existing PRD, with a near-match suggestion, and writes nothing', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-invalid-');
-  try {
-    writePrd(prdsDir, '3-widget-base.md', cwd);
-    writePrd(prdsDir, '4-widget-follow-up.md', cwd);
-    const before = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
-
-    const result = await scheduler.remote.updatePrd({
-      slug: '4-widget-follow-up',
-      cwd,
-      frontmatter: { dependsOn: ['wigdet-bsae'] },
-    });
-
-    expect(result.ok).toBe(false);
-    expect(result.error).toMatch(/does not resolve to any existing PRD/);
-    expect(result.error).toMatch(/widget-base/);
-    const after = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
-    expect(after).toBe(before);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('updatePrd patches dependsOn to an explicit empty array, clearing a previously-set dependency without validation', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-clear-');
-  try {
-    writePrd(prdsDir, '3-widget-base.md', cwd);
-    writePrd(prdsDir, '4-widget-follow-up.md', cwd, 'dependsOn: [widget-base]\n');
-
-    const result = await scheduler.remote.updatePrd({
-      slug: '4-widget-follow-up',
-      cwd,
-      frontmatter: { dependsOn: [] },
-    });
-
-    expect(result.ok).toBe(true);
-    const written = fs.readFileSync(path.join(prdsDir, '4-widget-follow-up.md'), 'utf8');
-    expect(written).not.toContain('dependsOn');
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});
-
-test('updatePrd patching an unrelated field leaves a PRD with no dependsOn unaffected', async () => {
-  const { cwd, prdsDir } = makeFixtureProject('sm-update-dependson-unrelated-');
-  try {
-    writePrd(prdsDir, '3-standalone.md', cwd);
-
-    const result = await scheduler.remote.updatePrd({
-      slug: '3-standalone',
-      cwd,
-      frontmatter: { estimateMinutes: 25 },
-    });
-
-    expect(result.ok).toBe(true);
-    const written = fs.readFileSync(path.join(prdsDir, '3-standalone.md'), 'utf8');
-    expect(written).not.toContain('dependsOn');
-    expect(written).toMatch(/^estimateMinutes: 25$/m);
-  } finally {
-    fs.rmSync(cwd, { recursive: true, force: true });
-  }
-});

package/src/main/__tests__/proc-role-env.test.cjs

@@ -1,125 +0,0 @@
-/**
- * proc-role-env.test.cjs — SM_PROC_ROLE attribution env + scripts/sm-ps.cjs.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/proc-role-env.test.cjs
- */
-'use strict';
-
-import { test, expect, describe, beforeEach, afterEach } from 'vitest';
-
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawn, spawnSync } = require('node:child_process');
-
-const { cleanChildEnv, withProcRole, inferProcRole } = require('../lib/cleanEnv.cjs');
-const { runClaudeP } = require('../lib/runClaudeP.cjs');
-const { runDocEdit } = require('../docEdit.cjs');
-
-const SM_PS = path.join(__dirname, '..', '..', '..', 'scripts', 'sm-ps.cjs');
-
-let tmp;
-let savedBin;
-beforeEach(() => {
-  tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-proc-role-'));
-  savedBin = process.env.SM_CLAUDE_BIN;
-});
-afterEach(() => {
-  if (savedBin === undefined) delete process.env.SM_CLAUDE_BIN; else process.env.SM_CLAUDE_BIN = savedBin;
-  fs.rmSync(tmp, { recursive: true, force: true });
-});
-
-/** Stub `claude` that prints {"after":"<SM_PROC_ROLE>"} — valid for both runClaudeP and docEdit. */
-function writeStub() {
-  const bin = path.join(tmp, 'claude-stub.sh');
-  fs.writeFileSync(bin, '#!/bin/sh\nprintf \'{"after":"%s"}\' "$SM_PROC_ROLE"\n', { mode: 0o755 });
-  return bin;
-}
-
-describe('cleanChildEnv role stamping', () => {
-  test('explicit role wins; inference from existing attribution vars; default aux', () => {
-    expect(cleanChildEnv({ SM_PROC_ROLE: 'shell' }).SM_PROC_ROLE).toBe('shell');
-    expect(inferProcRole({ SM_SCHEDULER_JOB_SLUG: 's' })).toBe('job');
-    expect(inferProcRole({ SM_CHAT_SESSION_ID: 'c' })).toBe('chat');
-    expect(inferProcRole({ SM_CHAT_SESSION_ID: 'c', SESSION_MANAGER_TAB_ID: 'c' })).toBe('shell');
-    expect(cleanChildEnv().SM_PROC_ROLE).toBe('aux');
-  });
-
-  test('is additive: existing attribution vars survive and SM_PROC_ROOT is untouched', () => {
-    const env = cleanChildEnv({ SM_SCHEDULER_JOB_SLUG: 'slug-1', SM_CHAT_SESSION_ID: 'chat-1', SM_PROJECT_ROOT: '/p' });
-    expect(env).toMatchObject({ SM_PROC_ROLE: 'job', SM_SCHEDULER_JOB_SLUG: 'slug-1', SM_CHAT_SESSION_ID: 'chat-1', SM_PROJECT_ROOT: '/p' });
-    expect('SM_PROC_ROOT' in env).toBe(process.env.SM_PROC_ROOT !== undefined);
-  });
-
-  test('withProcRole returns a copy and does not mutate its input', () => {
-    const base = { A: '1' };
-    expect(withProcRole(base, 'aux')).toEqual({ A: '1', SM_PROC_ROLE: 'aux' });
-    expect(base).toEqual({ A: '1' });
-  });
-});
-
-describe('real spawn paths carry SM_PROC_ROLE', () => {
-  test('runClaudeP (bypasses cleanChildEnv)', async () => {
-    process.env.SM_CLAUDE_BIN = writeStub();
-    const r = await runClaudeP('hi');
-    expect(r.ok).toBe(true);
-    expect(JSON.parse(r.out).after).toBe('aux');
-  });
-
-  test('docEdit runClaude (bypasses cleanChildEnv)', async () => {
-    process.env.SM_CLAUDE_BIN = writeStub();
-    const r = await runDocEdit({ path: path.join(os.homedir(), 'x.md'), before: 'a', instruction: 'b', documentText: '' });
-    expect(r).toEqual({ ok: true, after: 'aux' });
-  });
-
-  test('cleanChildEnv-built env reaches a spawned child', async () => {
-    const out = await new Promise((resolve) => {
-      const c = spawn('/bin/sh', ['-c', 'printf %s "$SM_PROC_ROLE"'], { env: cleanChildEnv({ SM_SCHEDULER_JOB_SLUG: 'x' }) });
-      let s = '';
-      c.stdout.on('data', (d) => { s += d; });
-      c.on('close', () => resolve(s));
-    });
-    expect(out).toBe('job');
-  });
-});
-
-describe('scripts/sm-ps.cjs', () => {
-  test('--json lists a tagged stub child (and its descendant) with role, slug, project root', async () => {
-    const env = cleanChildEnv({ SM_SCHEDULER_JOB_SLUG: 'fixture-slug', SM_PROJECT_ROOT: '/fixture/root' });
-    // outer sh forks an inner sleep, so we also assert descendants are included
-    const child = spawn('/bin/sh', ['-c', 'sleep 30 & wait'], { env, stdio: 'ignore' });
-    try {
-      await new Promise((r) => setTimeout(r, 300));
-      const res = spawnSync(process.execPath, [SM_PS, '--json'], { encoding: 'utf8', timeout: 20000 });
-      expect(res.status).toBe(0);
-      const { processes } = JSON.parse(res.stdout);
-      const hit = processes.find((p) => p.pid === child.pid);
-      expect(hit).toMatchObject({ role: 'job', slug: 'fixture-slug', projectRoot: '/fixture/root', attributed: true });
-      expect(processes.some((p) => p.ppid === child.pid)).toBe(true);
-    } finally {
-      try { process.kill(-child.pid); } catch { /* */ }
-      child.kill('SIGKILL');
-    }
-  });
-
-  test('exits 0 with an empty result set when nothing is running (empty proc root)', () => {
-    const root = path.join(tmp, 'proc');
-    fs.mkdirSync(root);
-    const res = spawnSync(process.execPath, [SM_PS, '--json', '--proc-root', root], { encoding: 'utf8' });
-    expect(res.status).toBe(0);
-    expect(JSON.parse(res.stdout)).toEqual({ processes: [] });
-  });
-
-  test('degrades without attribution on unreadable environ / mid-scan exit, never crashes', () => {
-    const root = path.join(tmp, 'proc');
-    fs.mkdirSync(path.join(root, '100'), { recursive: true }); // comm-named ours, environ absent
-    fs.writeFileSync(path.join(root, '100', 'stat'), '100 (sm-watchdog) S 1 0 0');
-    fs.writeFileSync(path.join(root, '100', 'cmdline'), 'node\0x.js\0');
-    fs.mkdirSync(path.join(root, '101')); // vanished: no stat at all
-    const res = spawnSync(process.execPath, [SM_PS, '--json', '--proc-root', root], { encoding: 'utf8' });
-    expect(res.status).toBe(0);
-    const { processes } = JSON.parse(res.stdout);
-    expect(processes).toHaveLength(1);
-    expect(processes[0]).toMatchObject({ pid: 100, comm: 'sm-watchdog', role: null, attributed: false });
-  });
-});

package/src/main/__tests__/procname-claude-spawn-sites.test.cjs

@@ -1,304 +0,0 @@
-/**
- * procname-claude-spawn-sites.test.cjs — PRD pn-02: every `claude` spawn site
- * execs a role alias (sm-claude-job/-chat/-aux) with a labelled argv0, WITHOUT
- * breaking the four /\bclaude\b/ cmdline gates the reapers depend on.
- *
- * HOME is redirected BEFORE procName/claudeBin/scheduler load (ALIAS_ROOT is
- * computed at require time) — never the real ~/.claude. Linux-only for the
- * /proc readbacks; the stubs never touch process.cwd().
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/procname-claude-spawn-sites.test.cjs
- */
-'use strict';
-
-import { describe, it, expect, beforeAll, afterAll, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawn } = require('node:child_process');
-
-const HAS_PROC = process.platform === 'linux' && fs.existsSync('/proc/self/comm');
-
-let tmpHome;
-let realHome;
-let realClaudeBin;
-let procName;
-let claudeBin;
-let scheduler;
-let reaper;
-let cr;
-let childWithLog;
-let procIdentity;
-
-beforeAll(() => {
-  realHome = process.env.HOME;
-  realClaudeBin = process.env.SM_CLAUDE_BIN;
-  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pn02-'));
-  process.env.HOME = tmpHome;
-  for (const m of ['procName', 'claudeBin']) {
-    delete require.cache[require.resolve(`../lib/${m}.cjs`)];
-  }
-  procName = require('../lib/procName.cjs');
-  claudeBin = require('../lib/claudeBin.cjs');
-  scheduler = require('../scheduler.cjs');
-  reaper = require('../lib/reaperHelpers.cjs');
-  cr = require('../chatRunner.cjs');
-  childWithLog = require('../lib/childWithLog.cjs');
-  procIdentity = require('../lib/procIdentity.cjs');
-});
-
-afterAll(() => {
-  process.env.HOME = realHome;
-  if (realClaudeBin === undefined) delete process.env.SM_CLAUDE_BIN;
-  else process.env.SM_CLAUDE_BIN = realClaudeBin;
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-afterEach(() => {
-  delete process.env.SM_CLAUDE_BIN;
-  if (cr) { cr.__resetQueueForTests(); cr.attachWindow(null); }
-});
-
-// Stub `claude`: reports its OWN comm + cmdline (+ prompt) to `capturePath`,
-// emits one stream-json result and exits 0. With `linger` it stays alive so a
-// test can inspect it from outside.
-function writeStub({ capturePath, linger = false } = {}) {
-  const stubPath = path.join(tmpHome, `stub-${Math.floor(Math.random() * 1e9)}.cjs`);
-  const body = `
-    const fs = require('fs');
-    ${capturePath ? `fs.writeFileSync(${JSON.stringify(capturePath)}, JSON.stringify({
-      comm: fs.readFileSync('/proc/self/comm', 'utf8').trim(),
-      cmdline: fs.readFileSync('/proc/self/cmdline', 'utf8').replace(/\\0/g, ' ').trim(),
-    }));` : ''}
-    process.stdout.write(JSON.stringify({ type: 'result', subtype: 'success', result: 'ok' }) + '\\n');
-    ${linger ? 'setTimeout(() => process.exit(0), 30000);' : 'process.exit(0);'}
-  `;
-  fs.writeFileSync(stubPath, `#!${process.execPath}\n${body}\n`, { mode: 0o755 });
-  return stubPath;
-}
-
-async function waitFor(fn, timeoutMs = 8000) {
-  const start = Date.now();
-  for (;;) {
-    const v = fn();
-    if (v) return v;
-    if (Date.now() - start > timeoutMs) throw new Error('waitFor timed out');
-    await new Promise((r) => setTimeout(r, 25));
-  }
-}
-
-function setupProject() {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pn02-project-'));
-  fs.mkdirSync(path.join(tmpHome, '.claude'), { recursive: true });
-  const runDir = fs.mkdtempSync(path.join(tmpHome, '.claude', 'pn02-run-'));
-  return { projectCwd, runDir };
-}
-
-function writePrd(projectCwd, slug) {
-  const dir = path.join(projectCwd, 'session-manager-operations', 'scheduler', 'prds');
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${slug}.md`), 'do the thing', 'utf8');
-}
-
-// Regexes replicated from the live gates; the reaperHelpers functions are ALSO
-// exercised for real below.
-const GATE = /\bclaude\b/;
-
-describe('claudeSpawnTarget', () => {
-  it('skips aliasing entirely and returns the raw value when SM_CLAUDE_BIN is set', () => {
-    process.env.SM_CLAUDE_BIN = '/tmp/some stub/with spaces';
-    expect(claudeBin.claudeSpawnTarget('job', 'slug')).toEqual({ command: '/tmp/some stub/with spaces' });
-  });
-
-  it('aliases each role to its comm and labels argv0 (SM_CLAUDE_BIN unset)', () => {
-    const real = writeStub();
-    for (const [role, alias] of [['job', 'sm-claude-job'], ['chat', 'sm-claude-chat'], ['aux', 'sm-claude-aux']]) {
-      const t = claudeBin.claudeSpawnTarget(role, 'abc', real);
-      expect(path.basename(t.command)).toBe(alias);
-      expect(t.argv0).toBe(`sm-claude-${role}:abc`);
-      expect(fs.readlinkSync(t.command)).toBe(real);
-    }
-  });
-
-  it('every real alias name and argv0 label satisfies /\\bclaude\\b/ (round-trip)', () => {
-    for (const alias of ['sm-claude-job', 'sm-claude-chat', 'sm-claude-aux']) {
-      expect(GATE.test(alias)).toBe(true);
-      expect(GATE.test(path.join(procName.procnamesRoot(), alias))).toBe(true);
-    }
-    for (const role of ['job', 'chat', 'aux']) {
-      expect(GATE.test(procName.smArgv0(role, 'a-slug'))).toBe(true);
-      expect(GATE.test(procName.smArgv0(role, undefined))).toBe(true);
-    }
-  });
-
-  it('falls back to the unchanged bin with NO argv0 when aliasing fails open', () => {
-    expect(claudeBin.claudeSpawnTarget('job', 's', 'definitely-not-a-real-cmd-xyz')).toEqual({ command: 'definitely-not-a-real-cmd-xyz' });
-  });
-});
-
-describe.skipIf(!HAS_PROC)('real aliased processes vs the reaper gates', () => {
-  const kids = [];
-  afterAll(() => { for (const k of kids) { try { process.kill(-k.pid, 'SIGKILL'); } catch { /* gone */ } } });
-
-  function spawnAliased(role, detail, { detached = true } = {}) {
-    const real = writeStub({ linger: true });
-    const t = claudeBin.claudeSpawnTarget(role, detail, real);
-    const child = spawn(t.command, ['-p', `prompt mentioning ${detail}`], {
-      cwd: os.tmpdir(), stdio: 'ignore', detached, ...(t.argv0 ? { argv0: t.argv0 } : {}),
-    });
-    kids.push(child);
-    return child;
-  }
-
-  const comm = (pid) => { try { return fs.readFileSync(`/proc/${pid}/comm`, 'utf8').trim(); } catch { return null; } };
-  const cmdline = (pid) => fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ');
-
-  it('kernel comm is the alias, cmdline carries the label + slug, and all four gates match', async () => {
-    const slug = `pn02-slug-${process.pid}-${Date.now()}`;
-    const child = spawnAliased('job', slug);
-    await waitFor(() => comm(child.pid) === 'sm-claude-job');
-    const cmd = cmdline(child.pid);
-    // A shebang stub's cmdline[0] is the interpreter and [1] the ALIAS PATH (the
-    // kernel rewrites argv for scripts, so argv0 is not visible); a native
-    // binary shows the label instead — see the ELF test below.
-    expect(cmd.includes(path.join(procName.procnamesRoot(), 'sm-claude-job'))).toBe(true);
-    expect(cmd.includes(slug)).toBe(true);
-    // scheduler.cjs killOrphanClaudePid + reaperHelpers.cjs:31 / :105 / :107 regexes
-    expect(GATE.test(cmd)).toBe(true);
-    expect(reaper.claudePidAlive(child.pid)).toBe(true);
-    expect(reaper.findLiveProcessForJob({ slug })).toBe(child.pid);
-  });
-
-  it('a native (ELF) binary shows the smArgv0 label as cmdline[0] and passes every gate', async () => {
-    const sleepBin = ['/bin/sleep', '/usr/bin/sleep'].find((p) => fs.existsSync(p));
-    if (!sleepBin) return;
-    const slug = `pn02-elf-${process.pid}-${Date.now()}`;
-    const t = claudeBin.claudeSpawnTarget('job', slug, sleepBin);
-    const child = spawn(t.command, ['30'], { cwd: os.tmpdir(), stdio: 'ignore', detached: true, argv0: t.argv0 });
-    kids.push(child);
-    await waitFor(() => comm(child.pid) === 'sm-claude-job');
-    const cmd = cmdline(child.pid);
-    expect(cmd.startsWith(`sm-claude-job:${slug}`)).toBe(true);
-    expect(GATE.test(cmd)).toBe(true);
-    expect(reaper.claudePidAlive(child.pid)).toBe(true);
-    expect(reaper.findLiveProcessForJob({ slug })).toBe(child.pid);
-    expect(scheduler.killOrphanClaudePid(child.pid)).toBe('killed');
-  });
-
-  it('findLiveProcessForJob still finds the job by slug when the argv0 label is absent (fail-open path)', async () => {
-    const slug = 'pn02-noargv0-slug';
-    const real = writeStub({ linger: true });
-    const child = spawn(real, ['-p', `claude prompt ${slug}`], { cwd: os.tmpdir(), stdio: 'ignore', detached: true });
-    kids.push(child);
-    await waitFor(() => { try { return cmdline(child.pid).includes(slug); } catch { return false; } });
-    expect(reaper.findLiveProcessForJob({ slug })).toBe(child.pid);
-  });
-
-  it('killOrphanClaudePid kills an aliased process group', async () => {
-    const child = spawnAliased('job', 'pn02-kill');
-    await waitFor(() => comm(child.pid) === 'sm-claude-job');
-    expect(scheduler.killOrphanClaudePid(child.pid)).toBe('killed');
-    await waitFor(() => child.exitCode !== null || child.signalCode !== null);
-  });
-
-  it('pid-recycling migration: identity recorded pre-alias OR post-alias for the same pid never vetoes its own kill', async () => {
-    // Legacy (unaliased) process, identity recorded "before", kill compared "after".
-    const legacyReal = writeStub({ linger: true });
-    const legacy = spawn(legacyReal, ['-p', 'claude legacy'], { cwd: os.tmpdir(), stdio: 'ignore', detached: true });
-    kids.push(legacy);
-    await waitFor(() => { try { return cmdline(legacy.pid).includes('legacy'); } catch { return false; } });
-    const recordedLegacy = procIdentity.identity(legacy.pid);
-    expect(recordedLegacy.complete).toBe(true);
-    expect(scheduler.killOrphanClaudePid(legacy.pid, recordedLegacy)).toBe('killed');
-
-    const aliased = spawnAliased('job', 'pn02-mig');
-    await waitFor(() => comm(aliased.pid) === 'sm-claude-job');
-    const recorded = procIdentity.identity(aliased.pid);
-    expect(procIdentity.isDifferentProcess(recorded, procIdentity.identity(aliased.pid))).toBe(false);
-    expect(scheduler.killOrphanClaudePid(aliased.pid, recorded)).toBe('killed');
-    // A genuinely recycled pid (different cmdline/starttime) is still vetoed.
-    expect(procIdentity.isDifferentProcess({ ...recorded, cmdline: '/usr/bin/claude -p old' }, { ...recorded, cmdline: 'sm-claude-job:new' })).toBe(true);
-  });
-
-  it('process-group semantics unchanged: detached child leads its own group; killTree/cancel reaps it', async () => {
-    const real = writeStub({ linger: true });
-    const t = claudeBin.claudeSpawnTarget('job', 'pn02-pgid', real);
-    const fd = fs.openSync(path.join(tmpHome, 'pgid.log'), 'a');
-    let exit = null;
-    const { child } = childWithLog.withChildAndLog({
-      fd, logPath: path.join(tmpHome, 'pgid.log'), safeLog() {}, closeFd() { try { fs.closeSync(fd); } catch { /* */ } },
-      spawn: { command: t.command, args: ['-p', 'claude x'], options: { cwd: os.tmpdir(), detached: true, ...(t.argv0 ? { argv0: t.argv0 } : {}) } },
-      onExit(info) { exit = info; },
-    });
-    await waitFor(() => comm(child.pid) === 'sm-claude-job');
-    const stat = fs.readFileSync(`/proc/${child.pid}/stat`, 'utf8');
-    const pgrp = Number(stat.slice(stat.lastIndexOf(')') + 2).split(' ')[2]);
-    expect(pgrp).toBe(child.pid);
-    process.kill(-child.pid, 'SIGTERM');
-    await waitFor(() => exit);
-    expect(exit.signal).toBe('SIGTERM');
-    expect(exit.leakedDescendants).toEqual([]);
-  });
-});
-
-describe.skipIf(!HAS_PROC)('comm assertions through the real runners', () => {
-  it('executeJob: the spawned claude has comm sm-claude-job', async () => {
-    const { projectCwd, runDir } = setupProject();
-    try {
-      const slug = `pn02-comm-${process.pid}-${Math.floor(Math.random() * 1e6)}`;
-      writePrd(projectCwd, slug);
-      const capturePath = path.join(runDir, 'cap.json');
-      const stub = writeStub({ capturePath });
-      // SM_CLAUDE_BIN skips aliasing by design; the test aliases explicitly.
-      process.env.SM_CLAUDE_BIN = procName.aliasBinFor(stub, 'sm-claude-job');
-      expect(path.basename(process.env.SM_CLAUDE_BIN)).toBe('sm-claude-job');
-      const result = await scheduler.executeJob({ slug, cwd: projectCwd }, runDir, projectCwd, () => Promise.resolve());
-      expect(result.exitCode).toBe(0);
-      expect(JSON.parse(fs.readFileSync(capturePath, 'utf8')).comm).toBe('sm-claude-job');
-    } finally {
-      fs.rmSync(projectCwd, { recursive: true, force: true });
-      fs.rmSync(runDir, { recursive: true, force: true });
-    }
-  });
-
-  it('chatRunner: the spawned claude has comm sm-claude-chat', async () => {
-    const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-pn02-chat-'));
-    try {
-      const capturePath = path.join(tmpHome, 'chat-cap.json');
-      const stub = writeStub({ capturePath });
-      process.env.SM_CLAUDE_BIN = procName.aliasBinFor(stub, 'sm-claude-chat');
-      cr.run({ tabId: 'pn02-tab', sessionId: `pn02-sess-${process.pid}`, prompt: 'hello', cwd, resume: false });
-      await waitFor(() => fs.existsSync(capturePath));
-      expect(JSON.parse(fs.readFileSync(capturePath, 'utf8')).comm).toBe('sm-claude-chat');
-    } finally {
-      fs.rmSync(cwd, { recursive: true, force: true });
-    }
-  });
-
-  it('fail-open: an unusable ALIAS_ROOT still lets the job run to completion', async () => {
-    const { projectCwd, runDir } = setupProject();
-    fs.rmSync(procName.procnamesRoot(), { recursive: true, force: true });
-    fs.mkdirSync(path.dirname(procName.procnamesRoot()), { recursive: true });
-    fs.writeFileSync(procName.procnamesRoot(), 'not a directory'); // mkdir/symlink under it must fail
-    try {
-      const slug = `pn02-failopen-${process.pid}`;
-      writePrd(projectCwd, slug);
-      const capturePath = path.join(runDir, 'cap.json');
-      const stub = writeStub({ capturePath });
-      const aliased = procName.aliasBinFor(stub, 'sm-claude-job');
-      expect(aliased).toBe(stub); // failed open
-      process.env.SM_CLAUDE_BIN = aliased;
-      const result = await scheduler.executeJob({ slug, cwd: projectCwd }, runDir, projectCwd, () => Promise.resolve());
-      expect(result.exitCode).toBe(0);
-      // Unaliased: comm is the stub's own basename, not an sm-claude-* name.
-      expect(JSON.parse(fs.readFileSync(capturePath, 'utf8')).comm).not.toMatch(/^sm-claude-/);
-      // And the target helper degrades to the raw bin with no argv0.
-      delete process.env.SM_CLAUDE_BIN;
-      expect(claudeBin.claudeSpawnTarget('job', slug, stub)).toEqual({ command: stub });
-    } finally {
-      fs.rmSync(procName.procnamesRoot(), { force: true });
-      fs.rmSync(projectCwd, { recursive: true, force: true });
-      fs.rmSync(runDir, { recursive: true, force: true });
-    }
-  });
-});