claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,82 +0,0 @@
-/**
- * prdDeclaredPaths.test.cjs — extracting a PRD's declared file paths for the
- * reverify self-heal pass's widened evidence window (PRD 1102).
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/prdDeclaredPaths.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-const assert = require('node:assert/strict');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { extractDeclaredPaths, declaredPathsForPrd } = require('../prdDeclaredPaths.cjs');
-
-test('extracts backtick-quoted paths from Implementation notes', () => {
-  const body = [
-    '# Implementation notes',
-    '',
-    'Edit `src/main/scheduler.cjs` and `src/main/lib/gitWorktree.cjs`.',
-    '',
-    '# Out of scope',
-    'Do not touch `src/main/should-not-appear.cjs` here.',
-  ].join('\n');
-  const paths = extractDeclaredPaths(body);
-  assert.deepStrictEqual(paths, ['src/main/scheduler.cjs', 'src/main/lib/gitWorktree.cjs']);
-});
-
-test('extracts paths from Acceptance criteria and strips trailing :line', () => {
-  const body = [
-    '# Acceptance criteria',
-    '- [ ] Fix the bug in `src/main/scheduler.cjs:490`',
-  ].join('\n');
-  assert.deepStrictEqual(extractDeclaredPaths(body), ['src/main/scheduler.cjs']);
-});
-
-test('dedupes paths mentioned in both sections', () => {
-  const body = [
-    '# Acceptance criteria',
-    '- [ ] Fix `src/main/scheduler.cjs`',
-    '# Implementation notes',
-    'See `src/main/scheduler.cjs` again.',
-  ].join('\n');
-  assert.deepStrictEqual(extractDeclaredPaths(body), ['src/main/scheduler.cjs']);
-});
-
-test('never fabricates a path — no match anywhere returns []', () => {
-  const body = [
-    '# Implementation notes',
-    'Just prose, no backticked paths here.',
-    '# Acceptance criteria',
-    '- [ ] npm run typecheck passes',
-  ].join('\n');
-  assert.deepStrictEqual(extractDeclaredPaths(body), []);
-});
-
-test('empty/non-string body returns []', () => {
-  assert.deepStrictEqual(extractDeclaredPaths(''), []);
-  assert.deepStrictEqual(extractDeclaredPaths(null), []);
-});
-
-test('declaredPathsForPrd reads a real file and strips frontmatter', () => {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'prd-declared-paths-'));
-  const prdPath = path.join(dir, '01-test.md');
-  fs.writeFileSync(prdPath, [
-    '---',
-    'title: Test',
-    '---',
-    '# Implementation notes',
-    'Touch `src/main/scheduler.cjs`.',
-  ].join('\n'));
-  assert.deepStrictEqual(declaredPathsForPrd(prdPath), ['src/main/scheduler.cjs']);
-});
-
-test('declaredPathsForPrd on a missing file returns [] without throwing', () => {
-  assert.deepStrictEqual(declaredPathsForPrd('/nonexistent/path/does-not-exist.md'), []);
-});
-
-test('declaredPathsForPrd with null path returns []', () => {
-  assert.deepStrictEqual(declaredPathsForPrd(null), []);
-});

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

@@ -1,224 +0,0 @@
-/**
- * prdDisposition.test.cjs — pure logic behind the scheduler wave-disposition
- * PRD: does a new PRD wave extend an Epic's existing dependsOn chain
- * ('append', gaining a dependsOn on the chain's current terminal PRD(s)) or
- * start an independent, parallel-eligible root ('new-head')? And, after the
- * fact, can a human safely rewrite that choice from the Scheduler UI?
- *
- * Run: timeout 120 npx vitest run src/main/lib/__tests__/prdDisposition.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-
-const {
-  isIncomplete,
-  resolveChainTerminals,
-  wouldCreateCycle,
-  computeDispositionRewrite,
-} = require('../prdDisposition.cjs');
-
-function row(overrides) {
-  return { slug: 'x', status: 'pending', dependsOn: [], ...overrides };
-}
-
-// ─────────────────────────────────────────── isIncomplete
-
-test('isIncomplete: completed is the only complete status', () => {
-  expect(isIncomplete('completed')).toBe(false);
-  for (const status of [null, undefined, 'pending', 'running', 'needs_review', 'failed', 'quarantined']) {
-    expect(isIncomplete(status)).toBe(true);
-  }
-});
-
-// ─────────────────────────────────────────── resolveChainTerminals
-
-test('resolveChainTerminals: a lone root is its own terminal', () => {
-  const rows = [row({ slug: 'a' })];
-  expect(resolveChainTerminals(rows)).toEqual(['a']);
-});
-
-test('resolveChainTerminals: a linear chain terminates at its tail', () => {
-  const rows = [
-    row({ slug: 'a' }),
-    row({ slug: 'b', dependsOn: ['a'] }),
-    row({ slug: 'c', dependsOn: ['b'] }),
-  ];
-  expect(resolveChainTerminals(rows)).toEqual(['c']);
-});
-
-test('resolveChainTerminals: a fork yields both leaves', () => {
-  const rows = [
-    row({ slug: 'a' }),
-    row({ slug: 'b', dependsOn: ['a'] }),
-    row({ slug: 'c', dependsOn: ['a'] }),
-  ];
-  expect(resolveChainTerminals(rows).sort()).toEqual(['b', 'c']);
-});
-
-test('resolveChainTerminals: two independent roots are both terminals (existing multi-head Epic)', () => {
-  const rows = [row({ slug: 'a' }), row({ slug: 'z' })];
-  expect(resolveChainTerminals(rows).sort()).toEqual(['a', 'z']);
-});
-
-test('resolveChainTerminals: a dependsOn cycle contributes no terminal', () => {
-  const rows = [
-    row({ slug: 'a', dependsOn: ['b'] }),
-    row({ slug: 'b', dependsOn: ['a'] }),
-  ];
-  expect(resolveChainTerminals(rows)).toEqual([]);
-});
-
-test('resolveChainTerminals: empty input yields no terminals', () => {
-  expect(resolveChainTerminals([])).toEqual([]);
-});
-
-// ─────────────────────────────────────────── wouldCreateCycle
-
-test('wouldCreateCycle: false for a fresh, unrelated edge', () => {
-  const rows = [row({ slug: 'a' }), row({ slug: 'b' })];
-  expect(wouldCreateCycle(rows, 'b', ['a'])).toBe(false);
-});
-
-test('wouldCreateCycle: true when the target already (transitively) depends on the source', () => {
-  // a depends on b; proposing b depends on a closes the loop.
-  const rows = [
-    row({ slug: 'a', dependsOn: ['b'] }),
-    row({ slug: 'b' }),
-  ];
-  expect(wouldCreateCycle(rows, 'b', ['a'])).toBe(true);
-});
-
-test('wouldCreateCycle: true for a direct self-reference', () => {
-  const rows = [row({ slug: 'a' })];
-  expect(wouldCreateCycle(rows, 'a', ['a'])).toBe(true);
-});
-
-test('wouldCreateCycle: false through an unrelated third row', () => {
-  const rows = [
-    row({ slug: 'a' }),
-    row({ slug: 'b', dependsOn: ['a'] }),
-    row({ slug: 'c' }),
-  ];
-  expect(wouldCreateCycle(rows, 'c', ['b'])).toBe(false);
-});
-
-// ─────────────────────────────────────────── computeDispositionRewrite
-
-test('append sets the expected edges', () => {
-  const rows = [
-    row({ slug: 'wave1-tail' }),
-    row({ slug: 'wave2-root' }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'wave2-root',
-    disposition: 'append',
-    dependsOn: ['wave1-tail'],
-    rows,
-  });
-  expect(result).toEqual({ ok: true, dependsOn: ['wave1-tail'] });
-});
-
-test('new-head sets none', () => {
-  const rows = [
-    row({ slug: 'wave1-tail' }),
-    row({ slug: 'wave2-root', dependsOn: ['wave1-tail'] }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'wave2-root',
-    disposition: 'new-head',
-    dependsOn: [],
-    rows,
-  });
-  expect(result).toEqual({ ok: true, dependsOn: [] });
-});
-
-test('promoting a wave to a head removes exactly its root edges', () => {
-  const rows = [
-    row({ slug: 'wave1-tail' }),
-    row({ slug: 'other-head' }),
-    row({ slug: 'wave2-root', dependsOn: ['wave1-tail'] }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'wave2-root',
-    disposition: 'new-head',
-    dependsOn: [],
-    rows,
-  });
-  expect(result.ok).toBe(true);
-  expect(result.dependsOn).toEqual([]);
-  // The unrelated head's own row is untouched — this function only ever
-  // returns the target row's new dependsOn, never mutates `rows`.
-  expect(rows.find((r) => r.slug === 'other-head').dependsOn).toEqual([]);
-});
-
-test('a change that would create a cycle is rejected', () => {
-  const rows = [
-    row({ slug: 'a', dependsOn: ['b'] }),
-    row({ slug: 'b' }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'b',
-    disposition: 'append',
-    dependsOn: ['a'],
-    rows,
-  });
-  expect(result.ok).toBe(false);
-  expect(result.error).toMatch(/cycle/i);
-});
-
-test('running rows are untouched', () => {
-  const rows = [
-    row({ slug: 'wave1-tail' }),
-    row({ slug: 'wave2-root', status: 'running', dependsOn: ['wave1-tail'] }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'wave2-root',
-    disposition: 'new-head',
-    dependsOn: [],
-    rows,
-  });
-  expect(result.ok).toBe(false);
-  expect(result.error).toMatch(/running/i);
-});
-
-test('completed rows are untouched', () => {
-  const rows = [
-    row({ slug: 'wave1-tail' }),
-    row({ slug: 'wave2-root', status: 'completed', dependsOn: ['wave1-tail'] }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'wave2-root',
-    disposition: 'append',
-    dependsOn: ['wave1-tail'],
-    rows,
-  });
-  expect(result.ok).toBe(false);
-  expect(result.error).toMatch(/completed/i);
-});
-
-test('refuses to rewrite a row whose existing blocker has already completed', () => {
-  const rows = [
-    row({ slug: 'blocker', status: 'completed' }),
-    row({ slug: 'dependent', status: 'pending', dependsOn: ['blocker'] }),
-  ];
-  const result = computeDispositionRewrite({
-    slug: 'dependent',
-    disposition: 'new-head',
-    dependsOn: [],
-    rows,
-  });
-  expect(result.ok).toBe(false);
-  expect(result.error).toMatch(/already completed|satisfied/i);
-});
-
-test('unknown slug is refused, not silently ignored', () => {
-  const result = computeDispositionRewrite({
-    slug: 'ghost',
-    disposition: 'new-head',
-    dependsOn: [],
-    rows: [row({ slug: 'a' })],
-  });
-  expect(result.ok).toBe(false);
-});

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

@@ -1,119 +0,0 @@
-// PRD: fail-closed process identity so a recycled pid can never pin
-// instanceLock ownership or dodge killOrphanClaudePid's veto. Stat parsing is
-// exercised against fixture files under SM_PROC_ROOT (never real /proc) so a
-// synthetic `comm` containing parens/spaces can be asserted precisely.
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const { identity, isDifferentProcess } = require('../procIdentity.cjs');
-
-let dir;
-
-function writeProcEntry(root, pid, { stat, cmdline }) {
-  const entryDir = path.join(root, String(pid));
-  fs.mkdirSync(entryDir, { recursive: true });
-  if (stat !== undefined) fs.writeFileSync(path.join(entryDir, 'stat'), stat);
-  if (cmdline !== undefined) fs.writeFileSync(path.join(entryDir, 'cmdline'), cmdline);
-}
-
-// Real /proc/<pid>/stat line, comm replaced with one containing a space and
-// an embedded ')' — field 22 (starttime) is `124686`, at the position AFTER
-// the LAST ')', not the first.
-function statLine(comm, startTicks) {
-  return `12345 (${comm}) R 1 12345 12345 0 -1 4194304 118 0 0 0 0 0 0 0 32 12 1 0 ${startTicks} 18698240 440 0 0 0 0 0 0 0 0 0 0 0 17 7 0 0 0 0 0 0 0 0 0 0 0 0\n`;
-}
-
-beforeEach(() => {
-  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-proc-identity-'));
-  process.env.SM_PROC_ROOT = dir;
-});
-
-afterEach(() => {
-  delete process.env.SM_PROC_ROOT;
-  fs.rmSync(dir, { recursive: true, force: true });
-});
-
-describe('procIdentity.identity — /proc parsing', () => {
-  it('parses field 22 located after the LAST ")" when comm contains a paren and a space', () => {
-    writeProcEntry(dir, 4242, {
-      stat: statLine('claude (worker)', 999888),
-      cmdline: 'node\0claude\0--session-id\0abc\0',
-    });
-    const id = identity(4242);
-    expect(id.pid).toBe(4242);
-    expect(id.startTicks).toBe(999888);
-    expect(id.cmdline).toBe('node claude --session-id abc');
-    expect(id.complete).toBe(true);
-  });
-
-  it('reads the live node process itself from real /proc (sanity check against production code path)', () => {
-    delete process.env.SM_PROC_ROOT;
-    const id = identity(process.pid);
-    expect(id.pid).toBe(process.pid);
-    expect(typeof id.startTicks).toBe('number');
-    expect(id.startTicks).toBeGreaterThan(0);
-    expect(typeof id.cmdline).toBe('string');
-    expect(id.cmdline.length).toBeGreaterThan(0);
-    expect(id.complete).toBe(true);
-    process.env.SM_PROC_ROOT = dir; // restore for afterEach
-  });
-
-  it('tri-state: missing stat file → incomplete (startTicks null) even though cmdline is readable', () => {
-    writeProcEntry(dir, 5001, { cmdline: 'node\0claude\0' });
-    const id = identity(5001);
-    expect(id.startTicks).toBeNull();
-    expect(id.cmdline).toBe('node claude');
-    expect(id.complete).toBe(false);
-  });
-
-  it('tri-state: missing cmdline file → incomplete (cmdline null) even though stat is readable', () => {
-    writeProcEntry(dir, 5002, { stat: statLine('claude', 111) });
-    const id = identity(5002);
-    expect(id.startTicks).toBe(111);
-    expect(id.cmdline).toBeNull();
-    expect(id.complete).toBe(false);
-  });
-
-  it('tri-state: neither file exists (pid never existed / already reaped) → incomplete, never throws', () => {
-    const id = identity(999999);
-    expect(id.startTicks).toBeNull();
-    expect(id.cmdline).toBeNull();
-    expect(id.complete).toBe(false);
-  });
-
-  it('rejects a non-positive-integer pid without touching the filesystem', () => {
-    expect(identity(-1).complete).toBe(false);
-    expect(identity(0).complete).toBe(false);
-    expect(identity(NaN).complete).toBe(false);
-  });
-});
-
-describe('procIdentity.isDifferentProcess — fail-closed decision', () => {
-  const complete = (over = {}) => ({ pid: 100, startTicks: 555, cmdline: 'node claude', complete: true, ...over });
-
-  it('true only when both sides are complete AND a field differs', () => {
-    expect(isDifferentProcess(complete(), complete({ startTicks: 999 }))).toBe(true);
-    expect(isDifferentProcess(complete(), complete({ cmdline: 'node other' }))).toBe(true);
-    expect(isDifferentProcess(complete(), complete())).toBe(false);
-  });
-
-  it('an incomplete recorded or live side never reads as different (fail closed)', () => {
-    const incomplete = { pid: 100, startTicks: null, cmdline: null, complete: false };
-    expect(isDifferentProcess(incomplete, complete())).toBe(false);
-    expect(isDifferentProcess(complete(), incomplete)).toBe(false);
-    expect(isDifferentProcess(incomplete, incomplete)).toBe(false);
-  });
-
-  it('a null/undefined probe (unreadable /proc, process gone) never reads as different', () => {
-    expect(isDifferentProcess(complete(), null)).toBe(false);
-    expect(isDifferentProcess(null, complete())).toBe(false);
-    expect(isDifferentProcess(undefined, undefined)).toBe(false);
-  });
-
-  it('a legacy record with no identity fields at all never reads as different', () => {
-    const legacy = { pid: 100 }; // e.g. an old {pid, startedAt}-only lock body
-    expect(isDifferentProcess(legacy, complete())).toBe(false);
-  });
-});

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

@@ -1,92 +0,0 @@
-// PRD pn-01: procName primitive. HOME is redirected to a temp dir for the whole file
-// (procnamesRoot() resolves lazily from HOME) — never the real ~/.claude.
-import { describe, it, expect, afterAll } from 'vitest';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-
-const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'procname-'));
-const realHome = process.env.HOME;
-process.env.HOME = tmpHome; // stays redirected: procnamesRoot() resolves lazily
-const { aliasBinFor, smArgv0, procnamesRoot, pruneStaleAliases } = require('../procName.cjs');
-
-afterAll(() => {
-  process.env.HOME = realHome;
-  try { fs.chmodSync(procnamesRoot(), 0o700); } catch { /* absent */ }
-  fs.rmSync(tmpHome, { recursive: true, force: true });
-});
-
-function fakeBin(name) {
-  const p = path.join(tmpHome, name);
-  fs.writeFileSync(p, '#!/bin/sh\nexit 0\n', { mode: 0o755 });
-  return p;
-}
-
-describe('procName', () => {
-  it('procnamesRoot() lives under the temp HOME machine-state root', () => {
-    expect(procnamesRoot()).toBe(path.join(tmpHome, '.claude', 'session-manager', 'procnames'));
-  });
-
-  it('creates a symlink and returns the alias path', () => {
-    const bin = fakeBin('bin-a');
-    const out = aliasBinFor(bin, 'sm-claude-job');
-    expect(out).toBe(path.join(procnamesRoot(), 'sm-claude-job'));
-    expect(fs.readlinkSync(out)).toBe(bin);
-  });
-
-  it('self-repairs a drifted link', () => {
-    const a = fakeBin('bin-b1');
-    const b = fakeBin('bin-b2');
-    aliasBinFor(a, 'sm-claude-chat');
-    const out = aliasBinFor(b, 'sm-claude-chat');
-    expect(fs.readlinkSync(out)).toBe(b);
-  });
-
-  it('throws on an alias longer than 15 chars', () => {
-    expect(() => aliasBinFor(fakeBin('bin-c'), 'sm-claude-toolong-x')).toThrow(/TASK_COMM_LEN/);
-    expect(() => aliasBinFor(fakeBin('bin-c'), 'session-manager')).not.toThrow();
-  });
-
-  it('returns the original bin for an unresolvable bare name', () => {
-    expect(aliasBinFor('definitely-not-a-real-cmd-xyz', 'sm-claude-aux')).toBe('definitely-not-a-real-cmd-xyz');
-  });
-
-  it.skipIf(process.getuid && process.getuid() === 0)('fails open when procnamesRoot() is read-only', () => {
-    const bin = fakeBin('bin-d');
-    fs.mkdirSync(procnamesRoot(), { recursive: true });
-    fs.chmodSync(procnamesRoot(), 0o500);
-    try {
-      expect(aliasBinFor(bin, 'sm-shell')).toBe(bin);
-    } finally {
-      fs.chmodSync(procnamesRoot(), 0o700);
-    }
-  });
-
-  it('smArgv0 shape, sanitisation, and length bound', () => {
-    expect(smArgv0('job', 'prd 12/x!')).toBe('sm-claude-job:prd12x');
-    expect(smArgv0('job', 'a'.repeat(500)).length).toBeLessThanOrEqual(120);
-  });
-
-  it('smArgv0 always matches the live /\\bclaude\\b/ gates for every role', () => {
-    // Replicated verbatim from scheduler.cjs killOrphanClaudePid & reaperHelpers.cjs claudePidAlive.
-    const gate = /\bclaude\b/;
-    for (const role of ['job', 'chat', 'aux', 'helper', '', undefined, '!!!', 'x'.repeat(300)]) {
-      for (const detail of ['abc', '', undefined, null, '///', 'y'.repeat(300)]) {
-        const label = smArgv0(role, detail);
-        expect(gate.test(label)).toBe(true);
-        expect(label.length).toBeLessThanOrEqual(120);
-      }
-    }
-  });
-
-  it('pruneStaleAliases removes dead links and keeps live ones', () => {
-    const live = fakeBin('bin-live');
-    const dead = fakeBin('bin-dead');
-    const liveAlias = aliasBinFor(live, 'sm-live');
-    const deadAlias = aliasBinFor(dead, 'sm-dead');
-    fs.rmSync(dead);
-    expect(() => pruneStaleAliases()).not.toThrow();
-    expect(fs.existsSync(liveAlias)).toBe(true);
-    expect(fs.lstatSync(deadAlias, { throwIfNoEntry: false })).toBeUndefined();
-  });
-});