claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,109 +0,0 @@
-/**
- * opsErrorLog.test.cjs — appendError() is the sole writer of the `logs` ops
- * namespace (single-writer law, opsOwnership.cjs). Verifies: writes a tagged
- * JSONL line to <cwd>/session-manager-operations/logs/errors-<date>.jsonl,
- * redacts sensitive meta keys, and no-ops (never throws) with no cwd.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/opsErrorLog.test.cjs
- */
-
-'use strict';
-
-import { test } from 'vitest';
-import assert from 'node:assert/strict';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const opsErrorLog = require('../lib/opsErrorLog.cjs');
-
-function mkTmpProject() {
-  return fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-test-'));
-}
-
-function readLines(cwd) {
-  const dir = opsErrorLog.logsDir(cwd);
-  const file = opsErrorLog.todayFile(cwd);
-  if (!fs.existsSync(file)) return [];
-  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-}
-
-test('appendError writes a tagged JSONL line', () => {
-  const cwd = mkTmpProject();
-  opsErrorLog.appendError({
-    cwd,
-    scope: 'pty',
-    tabId: 'tab-123',
-    tags: ['spawn-failed'],
-    message: 'pty.spawn threw: boom',
-  });
-  const lines = readLines(cwd);
-  assert.equal(lines.length, 1);
-  const [line] = lines;
-  assert.equal(line.level, 'error');
-  assert.equal(line.scope, 'pty');
-  assert.equal(line.tabId, 'tab-123');
-  assert.equal(line.message, 'pty.spawn threw: boom');
-  assert.ok(line.tags.includes('level:error'));
-  assert.ok(line.tags.includes('scope:pty'));
-  assert.ok(line.tags.includes('tab:tab-123'));
-  assert.ok(line.tags.includes('spawn-failed'));
-  assert.ok(typeof line.ts === 'string' && !Number.isNaN(Date.parse(line.ts)));
-});
-
-test('appendError redacts sensitive meta keys', () => {
-  const cwd = mkTmpProject();
-  opsErrorLog.appendError({
-    cwd,
-    scope: 'chatRunner',
-    message: 'run failed',
-    meta: { token: 'sk-secret', sessionId: 'abc', password: 'hunter2' },
-  });
-  const [line] = readLines(cwd);
-  assert.equal(line.meta.token, '[redacted]');
-  assert.equal(line.meta.password, '[redacted]');
-  assert.equal(line.meta.sessionId, 'abc');
-});
-
-test('appendError is a no-op with no cwd', () => {
-  // Must not throw, and there is nowhere to assert a file was NOT written
-  // since no cwd means no path — this just proves it never throws.
-  assert.doesNotThrow(() => opsErrorLog.appendError({ scope: 'x', message: 'y' }));
-});
-
-test('appendError merges caller tags without duplicating auto-derived ones', () => {
-  const cwd = mkTmpProject();
-  opsErrorLog.appendError({
-    cwd,
-    scope: 'chatRunner',
-    tabId: 'tab-9',
-    tags: ['level:error', 'silent-probe'], // deliberately duplicates an auto tag
-    message: 'probe failed',
-  });
-  const [line] = readLines(cwd);
-  const count = line.tags.filter((t) => t === 'level:error').length;
-  assert.equal(count, 1);
-  assert.ok(line.tags.includes('silent-probe'));
-});
-
-test('under vitest, a real project root is refused: no file written, no telemetry', () => {
-  const repoRoot = path.resolve(__dirname, '..', '..', '..');
-  const logsBefore = fs.existsSync(path.join(repoRoot, 'session-manager-operations', 'logs'))
-    ? fs.readdirSync(path.join(repoRoot, 'session-manager-operations', 'logs')).map((f) => [f, fs.statSync(path.join(repoRoot, 'session-manager-operations', 'logs', f)).mtimeMs])
-    : null;
-  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
-  const saved = require.cache[telemetryPath];
-  let calls = 0;
-  require.cache[telemetryPath] = { id: telemetryPath, filename: telemetryPath, loaded: true, exports: { reportError: () => { calls++; }, logLine: () => { calls++; } } };
-  try {
-    opsErrorLog.appendError({ cwd: repoRoot, scope: 'chatRunner', tabId: 'T', message: 'fixture' });
-    opsErrorLog.appendError({ cwd: repoRoot, scope: 'chatRunner', level: 'warn', message: 'fixture' });
-  } finally {
-    if (saved) require.cache[telemetryPath] = saved; else delete require.cache[telemetryPath];
-  }
-  const logsAfter = fs.existsSync(path.join(repoRoot, 'session-manager-operations', 'logs'))
-    ? fs.readdirSync(path.join(repoRoot, 'session-manager-operations', 'logs')).map((f) => [f, fs.statSync(path.join(repoRoot, 'session-manager-operations', 'logs', f)).mtimeMs])
-    : null;
-  assert.deepEqual(logsAfter, logsBefore);
-  assert.equal(calls, 0);
-});

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

@@ -1,173 +0,0 @@
-/**
- * opsErrorLogTelemetryTap.test.cjs — unit tests for appendError()'s telemetry
- * mirror. Kept separate from opsErrorLog.test.cjs (whose pre-existing tests
- * stay unmodified in intent) since this is new behavior this PRD adds.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/opsErrorLogTelemetryTap.test.cjs
- */
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-
-const opsErrorLog = require('../lib/opsErrorLog.cjs');
-
-const tmpDirs = [];
-let originalHome;
-let originalSmTelemetrySpool;
-let originalWorktreeRoot;
-
-afterEach(async () => {
-  if (originalHome !== undefined) process.env.HOME = originalHome;
-  if (originalSmTelemetrySpool === undefined) delete process.env.SM_TELEMETRY_SPOOL; else process.env.SM_TELEMETRY_SPOOL = originalSmTelemetrySpool;
-  if (originalWorktreeRoot !== undefined) {
-    if (originalWorktreeRoot === null) delete process.env.SM_WORKTREE_ROOT; else process.env.SM_WORKTREE_ROOT = originalWorktreeRoot;
-    originalWorktreeRoot = undefined;
-  }
-  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
-  delete require.cache[telemetryPath];
-  const activeSessionsPath = require.resolve('../lib/activeSessions.cjs');
-  delete require.cache[activeSessionsPath];
-  while (tmpDirs.length) {
-    const d = tmpDirs.pop();
-    await fsp.rm(d, { recursive: true, force: true });
-  }
-});
-
-function mkTmpProject() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-telemetry-'));
-  tmpDirs.push(dir);
-  return dir;
-}
-
-function readLines(cwd) {
-  const file = opsErrorLog.todayFile(cwd);
-  if (!fs.existsSync(file)) return [];
-  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l));
-}
-
-function stubTelemetryClient(exportsObj) {
-  const telemetryPath = require.resolve('../lib/telemetryClient.cjs');
-  require.cache[telemetryPath] = { id: telemetryPath, filename: telemetryPath, loaded: true, exports: exportsObj };
-}
-
-// ─── AFTER local write, never blocks it ──────────────────────────────────
-
-test('a throwing telemetry stub never prevents or corrupts the local JSONL write', () => {
-  const cwd = mkTmpProject();
-  stubTelemetryClient({
-    reportError: () => { throw new Error('telemetry boom'); },
-    logLine: () => { throw new Error('telemetry boom'); },
-  });
-
-  expect(() => opsErrorLog.appendError({ cwd, scope: 'pty', message: 'boom happened' })).not.toThrow();
-
-  const lines = readLines(cwd);
-  expect(lines.length).toBe(1);
-  expect(lines[0].message).toBe('boom happened');
-});
-
-test('level "warn" routes to telemetryClient.logLine, default "error" routes to reportError', () => {
-  const cwd = mkTmpProject();
-  const reportErrorCalls = [];
-  const logLineCalls = [];
-  stubTelemetryClient({
-    reportError: (o) => reportErrorCalls.push(o),
-    logLine: (o) => logLineCalls.push(o),
-  });
-
-  opsErrorLog.appendError({ cwd, scope: 'chatRunner', level: 'warn', message: 'careful' });
-  expect(logLineCalls).toHaveLength(1);
-  expect(reportErrorCalls).toHaveLength(0);
-
-  opsErrorLog.appendError({ cwd, scope: 'chatRunner', message: 'broke' });
-  expect(reportErrorCalls).toHaveLength(1);
-});
-
-// ─── ephemeral cwd: local refused, telemetry still fires ─────────────────
-
-test('an ephemeral cwd yields zero local lines but one telemetry record, with a normalized projectHash', () => {
-  // Why this test depends on the process tmpdir: ephemeral classification
-  // (cwdClassify.classifyCwd, via ephemeralCwd.isEphemeralCwd) is an exact match
-  // on os.tmpdir() plus a prefix match on the managed job/epic worktree roots,
-  // and those roots are <SM_WORKTREE_ROOT || os.tmpdir()>/session-manager-*-worktrees
-  // (schedulerPaths.worktreeRoot). The sandbox globalSetup mkdtemp's that base under
-  // the tmpdir it saw at startup, so a relocated TMPDIR / prior env mutation changes
-  // where KIND_CONFIG.epic.root points. Pin SM_WORKTREE_ROOT to a fixture dir this
-  // test owns and derive the cwd from KIND_CONFIG, so expected and actual roots
-  // resolve through the same code path regardless of TMPDIR.
-  originalWorktreeRoot = process.env.SM_WORKTREE_ROOT === undefined ? null : process.env.SM_WORKTREE_ROOT;
-  process.env.SM_WORKTREE_ROOT = mkTmpProject();
-  const { KIND_CONFIG } = require('../lib/gitWorktree.cjs');
-  const worktreeCwd = path.join(KIND_CONFIG.epic.root, 'fakehash', 'fake-epic-id');
-  const realRoot = '/home/bilko/Projects/real-project';
-
-  const activeSessionsPath = require.resolve('../lib/activeSessions.cjs');
-  const original = require('../lib/activeSessions.cjs');
-  require.cache[activeSessionsPath] = {
-    id: activeSessionsPath,
-    filename: activeSessionsPath,
-    loaded: true,
-    exports: { ...original, projectRootOf: (p) => (p === worktreeCwd ? realRoot : p) },
-  };
-
-  const reportErrorCalls = [];
-  stubTelemetryClient({ reportError: (o) => reportErrorCalls.push(o), logLine: () => {} });
-
-  opsErrorLog.appendError({ cwd: worktreeCwd, scope: 'chatRunner', message: 'worktree err' });
-
-  // resolveProjectRoot now consumes cwdClassify (not the stubbed projectRootOf):
-  // an ephemeral worktree cwd is refused outright, so no local path is even built.
-  expect(() => opsErrorLog.todayFile(worktreeCwd)).toThrow(/ephemeral/);
-  expect(reportErrorCalls).toHaveLength(1);
-  expect(reportErrorCalls[0].context.cwd).toBe(realRoot);
-  expect(reportErrorCalls[0].context.cwd).not.toBe(worktreeCwd);
-});
-
-// ─── PII: no prompt text, no absolute path ────────────────────────────────
-
-test('a realistic error with an absolute path and a prompt-like string never reaches the telemetry payload verbatim', async () => {
-  originalHome = process.env.HOME;
-  originalSmTelemetrySpool = process.env.SM_TELEMETRY_SPOOL;
-  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-opslog-telemetry-home-'));
-  tmpDirs.push(home);
-  process.env.HOME = home;
-  // Explicit opt-in: overrides the test-environment no-op guard so this
-  // test's real telemetryClient call actually persists into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
-
-  for (const p of ['../lib/telemetryClient.cjs', '../config.cjs', '../lib/telemetrySettings.cjs', '../lib/machineProfile.cjs']) {
-    const resolved = require.resolve(p);
-    delete require.cache[resolved];
-  }
-  const client = require('../lib/telemetryClient.cjs');
-  client._setMachineProfileBuilder(async () => ({
-    appVersion: '0.83.0', platform: 'linux', arch: 'x64', machineDigest: 'deadbeefcafe',
-  }));
-
-  const cwd = mkTmpProject();
-  const absPath = `${home}/Projects/super-secret-client/src/main/index.cjs`;
-  const promptLike = 'write me a function that deletes all files matching *.secret and email me the results';
-  opsErrorLog.appendError({
-    cwd,
-    scope: 'chatRunner',
-    message: `run failed while processing "${promptLike}" at ${absPath}`,
-  });
-
-  // The telemetry write is fire-and-forget async; poll (bounded) for the queue
-  // file instead of a fixed sleep, which raced under load.
-  const deadline = Date.now() + 5000;
-  while (!fs.existsSync(client.queuePath()) && Date.now() < deadline) {
-    await new Promise((r) => setTimeout(r, 25));
-  }
-  await new Promise((r) => setTimeout(r, 50));
-
-  const raw = await fsp.readFile(client.queuePath(), 'utf8');
-  expect(raw).not.toContain(home);
-  expect(raw).not.toContain(absPath);
-  expect(raw).not.toContain(promptLike);
-  client.shutdown();
-});

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

@@ -1,169 +0,0 @@
-/**
- * personaMerge.test.cjs — overlay-over-global persona MERGE (lib/personaMerge.cjs)
- * and every reader that goes through it.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/personaMerge.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const fsp = require('node:fs/promises');
-const os = require('node:os');
-const path = require('node:path');
-const { resolveMergedPersona } = require('../lib/personaMerge.cjs');
-const { readOverlayAwarePersonaModel, resolvePrdPersonaForSpawn } = require('../lib/agentModelResolve.cjs');
-const { resolveEpicEffort } = require('../lib/agentEffortResolve.cjs');
-const { resolveEffectiveModelInfo } = require('../lib/effectiveModelInfo.cjs');
-const { getPersonaBody, listPersonas } = require('../agentLibrary.cjs');
-
-const tmpDirs = [];
-afterEach(async () => {
-  while (tmpDirs.length) await fsp.rm(tmpDirs.pop(), { recursive: true, force: true });
-});
-
-function mk(prefix) {
-  const d = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tmpDirs.push(d);
-  return d;
-}
-
-const noop = (p) => p;
-
-function persona(dir, name, fmLines, body) {
-  fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${name}.md`), ['---', ...fmLines, '---', body].join('\n'));
-}
-
-function setup({ global, overlay }) {
-  const cwd = mk('sm-pm-cwd-');
-  const globalDir = mk('sm-pm-global-');
-  if (global) persona(globalDir, 'dev-lead', global.fm, global.body);
-  if (overlay) persona(path.join(cwd, '.claude', 'agents'), 'dev-lead', overlay.fm, overlay.body);
-  return { cwd, globalDir, deps: { globalDir, validatePath: noop } };
-}
-
-const GLOBAL = { fm: ['name: dev-lead', 'description: d', 'model: sonnet', 'effort: low'], body: 'Global body.' };
-
-test('frontmatter-only overlay overrides model', () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
-  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('claude-opus-4-6');
-  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
-  expect(m.provenance.model).toBe('overlay');
-  expect(m.provenance.description).toBe('global');
-});
-
-test('frontmatter-only overlay overrides effort; source reports persona-overlay', () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['effort: high'], body: '' } });
-  expect(resolveEpicEffort({ cwd, agentType: 'dev-lead', deps })).toEqual({ effort: 'high', source: 'persona-overlay' });
-});
-
-test('a key absent from the overlay falls back to the global (model stays global, effort from overlay)', () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['effort: high'], body: '' } });
-  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('sonnet');
-  // and the reverse: effort absent from overlay -> global effort, sourced 'persona'
-  const s2 = setup({ global: GLOBAL, overlay: { fm: ['model: opus'], body: '' } });
-  expect(resolveEpicEffort({ cwd: s2.cwd, agentType: 'dev-lead', deps: s2.deps })).toEqual({ effort: 'low', source: 'persona' });
-});
-
-test('an overlay with no body uses the global body', () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: opus'], body: '\n  \n' } });
-  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
-  expect(m.body.trim()).toBe('Global body.');
-  expect(m.bodySource).toBe('global');
-});
-
-test('a full-body overlay replaces the body wholesale and keeps its raw text byte-identical', () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['name: dev-lead', 'model: haiku'], body: 'Overlay body.' } });
-  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
-  expect(m.body.trim()).toBe('Overlay body.');
-  expect(m.bodySource).toBe('overlay');
-  expect(m.text).toBe(fs.readFileSync(path.join(cwd, '.claude', 'agents', 'dev-lead.md'), 'utf8'));
-});
-
-test("this repo's three full-body overlays resolve byte-identically (text + body + path)", async () => {
-  const repoAgents = path.resolve(__dirname, '..', '..', '..', '.claude', 'agents');
-  const globalDir = mk('sm-pm-global-');
-  for (const name of ['bilko-host-publisher', 'builder', 'project-home-builder']) {
-    persona(globalDir, name, [`name: ${name}`, 'description: g', 'model: opus'], 'global body');
-    const overlayFile = path.join(repoAgents, `${name}.md`);
-    const raw = fs.readFileSync(overlayFile, 'utf8');
-    const m = resolveMergedPersona(path.resolve(repoAgents, '..', '..'), name, { globalDir, validatePath: noop });
-    expect(m.text).toBe(raw);
-    expect(m.path).toBe(overlayFile);
-    expect(m.body).toBe(require('../lib/prdFrontmatter.cjs').splitFrontmatter(raw).body);
-    const viaLib = await getPersonaBody({ cwd: path.resolve(repoAgents, '..', '..'), name, globalDir, validatePath: noop });
-    expect(viaLib.text).toBe(raw);
-  }
-});
-
-test('malformed overlay frontmatter degrades to the global persona, never throws, and is reported', () => {
-  const { cwd, globalDir } = setup({ global: GLOBAL });
-  fs.mkdirSync(path.join(cwd, '.claude', 'agents'), { recursive: true });
-  fs.writeFileSync(path.join(cwd, '.claude', 'agents', 'dev-lead.md'), '---\nmodel: claude-opus-4-6\nno closing fence');
-  const deps = { globalDir, validatePath: noop };
-  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
-  expect(m.fm.model).toBe('sonnet');
-  expect(m.fromOverlay).toBe(false);
-  expect(m.overlayIssue).toMatch(/malformed/);
-  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('sonnet');
-  const { todayFile } = require('../lib/opsErrorLog.cjs');
-  expect(fs.readFileSync(todayFile(cwd), 'utf8')).toMatch(/malformed frontmatter/);
-});
-
-test('an overlay with no global counterpart works standalone', () => {
-  const { cwd, deps } = setup({ overlay: { fm: ['name: dev-lead', 'model: opus'], body: 'Solo body.' } });
-  const m = resolveMergedPersona(cwd, 'dev-lead', deps);
-  expect(m.body.trim()).toBe('Solo body.');
-  expect(m.globalPath).toBeNull();
-  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('opus');
-});
-
-test("overlay `model: inherit` defers to the settings default — it does NOT fall back to the global model", async () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: inherit'], body: '' } });
-  expect(readOverlayAwarePersonaModel('dev-lead', { ...deps, cwd })).toBe('inherit');
-  const r = await resolvePrdPersonaForSpawn({ cwd, agentType: 'dev-lead', fallbackModel: 'sonnet-fallback', deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) } });
-  expect(r.model).toBe('sonnet-fallback');
-});
-
-test('resolvePrdPersonaForSpawn hands the executor the merged model AND the global body for a frontmatter-only overlay', async () => {
-  const { cwd, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
-  const r = await resolvePrdPersonaForSpawn({ cwd, agentType: 'dev-lead', deps: { getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }) } });
-  expect(r.model).toBe('claude-opus-4-6');
-  expect(r.systemPrompt).toBe('Global body.');
-});
-
-test('a crafted agentType is rejected by every reader (PERSONA_NAME_RE traversal guard)', async () => {
-  const { cwd, deps } = setup({ global: GLOBAL });
-  const evil = '../../other-project/CLAUDE';
-  expect(resolveMergedPersona(cwd, evil, deps)).toBeNull();
-  expect(readOverlayAwarePersonaModel(evil, { ...deps, cwd })).toBeNull();
-  expect(await getPersonaBody({ cwd, name: evil, ...deps })).toBeNull();
-});
-
-test('getPersonaBody / effectiveModelInfo / listPersonas report per-field provenance, not a whole-file boolean', async () => {
-  const { cwd, globalDir, deps } = setup({ global: GLOBAL, overlay: { fm: ['model: claude-opus-4-6'], body: '' } });
-  const body = await getPersonaBody({ cwd, name: 'dev-lead', ...deps });
-  expect(body.provenance.model).toBe('overlay');
-  expect(body.provenance.effort).toBe('global');
-
-  const info = await resolveEffectiveModelInfo({
-    cwd,
-    agentType: 'dev-lead',
-    deps: {
-      ...deps,
-      activeSessions: { projectRootOf: (p) => p },
-      getPersonaBody: (a) => getPersonaBody({ ...a, ...deps }),
-    },
-  });
-  expect(info.modelAlias).toBe('claude-opus-4-6');
-  expect(info.modelSource).toBe('persona-overlay');
-  expect(info.personaProvenance.effort).toBe('global');
-  expect(info.personaEffortSource).toBe('persona');
-
-  const list = await listPersonas({ globalDir, validatePath: noop, loadSessions: async () => ({ tabs: [{ cwd }] }) });
-  const dev = list.find((p) => p.name === 'dev-lead');
-  expect(dev.overridingProjects).toEqual([path.basename(cwd)]);
-  expect(dev.overrideDetails[0]).toMatchObject({ fields: ['model'], bodyOverridden: false, issue: null });
-});

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

@@ -1,125 +0,0 @@
-/**
- * planValidator.test.cjs — unit tests for hasDownstreamValidator (PRD 1408).
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/planValidator.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { hasDownstreamValidator } = require('../lib/planValidator.cjs');
-
-test('true when a pending validator row depends on the job', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['111-alpha'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(true);
-});
-
-test('true when the depending validator row is running', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '999-validate', agentType: 'validator', status: 'running', dependsOn: ['111-alpha'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(true);
-});
-
-test('false when the job itself is a validator', () => {
-  const job = { slug: '999-validate', agentType: 'validator' };
-  const jobs = [
-    job,
-    { slug: '998-other-validate', agentType: 'validator', status: 'pending', dependsOn: ['999-validate'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('false for null/undefined job or jobs', () => {
-  expect(hasDownstreamValidator(null, [{ slug: 'x' }])).toBe(false);
-  expect(hasDownstreamValidator(undefined, [{ slug: 'x' }])).toBe(false);
-  expect(hasDownstreamValidator({ slug: '111-alpha' }, null)).toBe(false);
-  expect(hasDownstreamValidator({ slug: '111-alpha' }, undefined)).toBe(false);
-});
-
-test('false when the validator row does not depend on this job', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['222-beta'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('false when the depending row is a completed validator', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '999-validate', agentType: 'validator', status: 'completed', dependsOn: ['111-alpha'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('false when the depending row is not agentType validator', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '999-other', agentType: 'dev-lead', status: 'pending', dependsOn: ['111-alpha'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('true when a pending validator reaches the job transitively via one sink (2-hop)', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '150-sink', agentType: 'dev-lead', status: 'pending', dependsOn: ['111-alpha'] },
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['150-sink'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(true);
-});
-
-test('true when a pending validator reaches the job transitively via two intermediate sinks (3-hop)', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '140-mid', agentType: 'dev-lead', status: 'pending', dependsOn: ['111-alpha'] },
-    { slug: '150-sink', agentType: 'dev-lead', status: 'pending', dependsOn: ['140-mid'] },
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['150-sink'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(true);
-});
-
-test('false when the validator only reaches an unrelated branch', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '222-beta', agentType: 'dev-lead', status: 'pending', dependsOn: [] },
-    { slug: '150-sink', agentType: 'dev-lead', status: 'pending', dependsOn: ['222-beta'] },
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['150-sink'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('cycle in dependsOn terminates and returns false when the job is not reachable', () => {
-  const job = { slug: '111-alpha' };
-  const jobs = [
-    job,
-    { slug: '200-a', agentType: 'dev-lead', status: 'pending', dependsOn: ['201-b'] },
-    { slug: '201-b', agentType: 'dev-lead', status: 'pending', dependsOn: ['200-a'] },
-    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['200-a'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});
-
-test('false when a same-named validator/sink pair belongs to a different project (cwd)', () => {
-  const job = { slug: '011-alpha', cwd: '/projectA' };
-  const jobs = [
-    job,
-    { slug: '012-sink', cwd: '/projectA', agentType: 'dev-lead', status: 'pending', dependsOn: [] },
-    { slug: '512-sink', cwd: '/projectB', agentType: 'dev-lead', status: 'pending', dependsOn: ['011-alpha'] },
-    { slug: '999-validate', cwd: '/projectB', agentType: 'validator', status: 'pending', dependsOn: ['sink'] },
-  ];
-  expect(hasDownstreamValidator(job, jobs)).toBe(false);
-});