claude-code-session-manager 0.98.0 → 0.100.0

package/src/main/__tests__/scheduler-archived-twin-guard.test.cjs

@@ -1,155 +0,0 @@
-/**
- * scheduler-archived-twin-guard.test.cjs — unit tests for archivedTwinExists
- * (PRD 822-promptsession-prd-trace-events recurrence fix): a queue row whose
- * PRD `.md` has already been moved to the sibling `prds-archived/` dir (work
- * shipped out-of-band) must be recognized as stale, not a genuine missing-PRD
- * failure.
- *
- * Uses a temp cwd fixture (`prdDirForCwd` is a pure path join off `cwd`) so
- * this never touches the real `~/.claude/session-manager/` tree.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-archived-twin-guard.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { archivedTwinExists, archivedPrdPathForJob, prdDirForCwd } = require('../scheduler.cjs');
-const { listArchivedPrdDirs } = require('../lib/prdLocations.cjs');
-
-const tmpDirs = [];
-
-function makeFixtureCwd() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-archived-twin-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-afterEach(() => {
-  while (tmpDirs.length) {
-    const dir = tmpDirs.pop();
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('archivedTwinExists returns true when the archived twin exists and the live PRD does not', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-shipped-and-archived';
-  const prdsDir = prdDirForCwd(cwd);
-  const archivedDir = path.join(prdsDir, '..', 'prds-archived');
-  fs.mkdirSync(archivedDir, { recursive: true });
-  fs.writeFileSync(path.join(archivedDir, `${slug}.md`), '# Goal\n\nshipped\n', 'utf8');
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(true);
-});
-
-test('archivedTwinExists returns false when neither the live PRD nor an archived twin exists', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-genuinely-missing';
-  fs.mkdirSync(prdDirForCwd(cwd), { recursive: true });
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(false);
-});
-
-test('archivedTwinExists returns false for a slug whose archived twin belongs to a different cwd', async () => {
-  const cwd = makeFixtureCwd();
-  const otherCwd = makeFixtureCwd();
-  const slug = 'test-cross-cwd-twin';
-  const otherArchivedDir = path.join(prdDirForCwd(otherCwd), '..', 'prds-archived');
-  fs.mkdirSync(otherArchivedDir, { recursive: true });
-  fs.writeFileSync(path.join(otherArchivedDir, `${slug}.md`), '# Goal\n\nother project\n', 'utf8');
-  fs.mkdirSync(prdDirForCwd(cwd), { recursive: true });
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(false);
-});
-
-test('archivedTwinExists returns false when the PRD is still live in prds/ (never short-circuits a normal run)', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-still-live';
-  const prdsDir = prdDirForCwd(cwd);
-  fs.mkdirSync(prdsDir, { recursive: true });
-  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), '# Goal\n\nlive\n', 'utf8');
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(false);
-});
-
-test('archivedPrdPathForJob resolves to the sibling prds-archived/<slug>.md for a job cwd', () => {
-  const cwd = makeFixtureCwd();
-  const job = { cwd, slug: 'my-slug' };
-  const prdsDir = prdDirForCwd(cwd);
-  const expected = path.join(prdsDir, '..', 'prds-archived', 'my-slug.md');
-  expect(archivedPrdPathForJob(job)).toBe(expected);
-});
-
-test('archivedPrdPathForJob does not escape prds-archived/ for a well-formed slug', () => {
-  const cwd = makeFixtureCwd();
-  const job = { cwd, slug: 'well-formed-slug' };
-  const resolved = path.resolve(archivedPrdPathForJob(job));
-  const archiveDir = path.resolve(path.join(prdDirForCwd(cwd), '..', 'prds-archived'));
-  expect(resolved.startsWith(archiveDir + path.sep)).toBe(true);
-});
-
-test('archivedTwinExists returns true when the twin lives in an EPIC\'s prds-archived dir', async () => {
-  // Regression cover for job 865: every new PRD is Epic-scoped, and
-  // archiveCompletedPrd archives into the Epic's own sibling prds-archived/,
-  // not the retired flat one. A queue row whose PRD moved there must still
-  // be recognized as stale.
-  const cwd = makeFixtureCwd();
-  const slug = '865-paste-image-in-chat-does-not-work';
-  const epicArchiveDir = path.join(
-    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-fixture-1', 'prds-archived',
-  );
-  fs.mkdirSync(epicArchiveDir, { recursive: true });
-  fs.writeFileSync(path.join(epicArchiveDir, `${slug}.md`), '# Goal\n\nshipped\n', 'utf8');
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(true);
-});
-
-test('archivedTwinExists still returns true for a flat-layout twin', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-flat-layout-twin';
-  const archivedDir = path.join(prdDirForCwd(cwd), '..', 'prds-archived');
-  fs.mkdirSync(archivedDir, { recursive: true });
-  fs.writeFileSync(path.join(archivedDir, `${slug}.md`), '# Goal\n\nshipped\n', 'utf8');
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(true);
-});
-
-test('archivedTwinExists returns false when no twin exists in any layout', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-no-twin-anywhere';
-  fs.mkdirSync(prdDirForCwd(cwd), { recursive: true });
-
-  await expect(archivedTwinExists({ slug, cwd })).resolves.toBe(false);
-});
-
-test('listArchivedPrdDirs returns the flat dir plus every existing epic archive dir', () => {
-  const cwd = makeFixtureCwd();
-  const epicArchiveDir1 = path.join(
-    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-a', 'prds-archived',
-  );
-  const epicArchiveDir2 = path.join(
-    cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-b', 'prds-archived',
-  );
-  // psess-c has no prds-archived dir yet — should be excluded.
-  fs.mkdirSync(path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-c', 'prds'), { recursive: true });
-  fs.mkdirSync(epicArchiveDir1, { recursive: true });
-  fs.mkdirSync(epicArchiveDir2, { recursive: true });
-
-  const dirs = listArchivedPrdDirs(cwd);
-  const flatDir = path.join(prdDirForCwd(cwd), '..', 'prds-archived');
-  expect(dirs).toContain(flatDir);
-  expect(dirs).toContain(epicArchiveDir1);
-  expect(dirs).toContain(epicArchiveDir2);
-  expect(dirs).not.toContain(path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', 'psess-c', 'prds-archived'));
-});
-
-test('listArchivedPrdDirs never throws for a cwd with no session-manager-operations/ at all', () => {
-  const cwd = makeFixtureCwd();
-  expect(() => listArchivedPrdDirs(cwd)).not.toThrow();
-  const dirs = listArchivedPrdDirs(cwd);
-  expect(dirs.length).toBe(1);
-});

package/src/main/__tests__/scheduler-autofix-outcome.test.cjs

@@ -1,188 +0,0 @@
-/**
- * scheduler-autofix-outcome.test.cjs — self-heal terminal-state gap fix.
- *
- * spawnInvestigation's onExit used to stamp autoFixOutcome only in the
- * no-plan branch; a job whose probe erred, spawn-failed, or produced a plan
- * that never became a queue row ended up autoFixAttempted:true with no
- * outcome — permanently excluded from both retry AND the exhausted-retry
- * annotation. This file is a vitest-runnable (npm run test:unit) home for
- * the scenarios the PRD's acceptance criteria enumerate; the pure-logic
- * coverage in scheduler-autofix-select.test.cjs (node --test) exercises the
- * same helpers in more granular detail.
- *
- * PRD 1129 added one sub-shape to case (d): "outcome 'plan' WITH a queue
- * row is neither retried nor annotated" only holds while that queue row
- * (the fix-plan child) is still alive. Once the child itself reaches a
- * terminal, non-completed status, isFixPlanDead makes the parent eligible
- * for exactly one further attempt (stamped autoFixReopened: true), after
- * which it is permanently excluded and annotated again.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-autofix-outcome.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const {
-  selectAutoFixTargets, isExhaustedAutoFix, isPlanUnqueued, isFixPlanDead, fixSlugFor,
-} = require('../scheduler.cjs');
-
-const noSiblingOnDisk = () => false;
-
-function makeJob(overrides = {}) {
-  return {
-    slug: '05-my-feature',
-    status: 'needs_review',
-    runId: '2026-06-16T10-00-00-000Z',
-    parallelGroup: 5,
-    ...overrides,
-  };
-}
-
-function isTarget(job) {
-  return selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug);
-}
-
-function isAnnotatable(job, queuedSlugs = new Set()) {
-  return isExhaustedAutoFix(job) || isPlanUnqueued(job, queuedSlugs);
-}
-
-// (a) attempted + no outcome → eligible once, then annotated when the retry is spent.
-test('(a) attempted with unstamped outcome and an unspent retry is eligible, not annotated', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 0 });
-  expect(isTarget(job)).toBe(true);
-  expect(isAnnotatable(job)).toBe(false);
-});
-
-test('(a) attempted with unstamped outcome and a spent retry is annotated, not eligible', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1 });
-  expect(isTarget(job)).toBe(false);
-  expect(isAnnotatable(job)).toBe(true);
-});
-
-// (b) outcome 'error' → eligible once.
-test("(b) outcome 'error' with an unspent retry is eligible", () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 0 });
-  expect(isTarget(job)).toBe(true);
-  expect(isAnnotatable(job)).toBe(false);
-});
-
-test("(b) outcome 'error' with a spent retry is annotated, not eligible", () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 1 });
-  expect(isTarget(job)).toBe(false);
-  expect(isAnnotatable(job)).toBe(true);
-});
-
-// (c) outcome 'plan' with no queue row → annotated autofix_plan_unqueued, NOT retried.
-test("(c) outcome 'plan' with the fix slug absent from the queue is annotated, never retried", () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  expect(isTarget(job)).toBe(false);
-  expect(isPlanUnqueued(job, new Set())).toBe(true);
-  expect(isExhaustedAutoFix(job)).toBe(false);
-});
-
-// (d) outcome 'plan' WITH a queue row → neither retried nor annotated.
-test("(d) outcome 'plan' with the fix slug present in the queue is neither retried nor annotated", () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  const queuedSlugs = new Set([fixSlugFor(job)]);
-  expect(isTarget(job)).toBe(false);
-  expect(isAnnotatable(job, queuedSlugs)).toBe(false);
-});
-
-// (e) dead fix-plan child: outcome 'plan' whose fix-plan row itself died —
-// the parent is eligible again, exactly once.
-test('(e) a dead fix-plan child makes the parent eligible for one further attempt', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
-  const jobs = [job, deadChild];
-  expect(isFixPlanDead(job, jobs)).toBe(true);
-  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(true);
-  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
-});
-
-test('(e) a failed, quarantined, or skipped fix-plan child also counts as dead', () => {
-  for (const status of ['failed', 'quarantined', 'skipped']) {
-    const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-    const deadChild = { slug: fixSlugFor(job), status, parallelGroup: job.parallelGroup };
-    expect(isFixPlanDead(job, [job, deadChild])).toBe(true);
-  }
-});
-
-test('(e) an already-reopened parent is annotated, never eligible again — even with another dead child', () => {
-  const job = makeJob({
-    autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 1, autoFixReopened: true,
-  });
-  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
-  const jobs = [job, deadChild];
-  expect(isFixPlanDead(job, jobs)).toBe(false);
-  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
-  expect(isExhaustedAutoFix(job)).toBe(true);
-  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(true);
-});
-
-test('(e) a reopened parent whose second attempt is still in flight (outcome cleared) is untouched — not re-eligible, not yet annotated', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1, autoFixReopened: true });
-  expect(isFixPlanDead(job, [job])).toBe(false);
-  expect(selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
-  expect(isExhaustedAutoFix(job)).toBe(false);
-});
-
-test('(e) a fix-plan child that is still pending leaves the parent untouched', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  const pendingChild = { slug: fixSlugFor(job), status: 'pending', parallelGroup: job.parallelGroup };
-  const jobs = [job, pendingChild];
-  expect(isFixPlanDead(job, jobs)).toBe(false);
-  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
-  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
-});
-
-test('(e) a fix-plan child that is still running leaves the parent untouched', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  const runningChild = { slug: fixSlugFor(job), status: 'running', parallelGroup: job.parallelGroup };
-  const jobs = [job, runningChild];
-  expect(isFixPlanDead(job, jobs)).toBe(false);
-  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
-  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
-});
-
-test('(e) a fix-plan child that completed leaves the parent untouched (unchanged from today)', () => {
-  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
-  const completedChild = { slug: fixSlugFor(job), status: 'completed', parallelGroup: job.parallelGroup };
-  const jobs = [job, completedChild];
-  expect(isFixPlanDead(job, jobs)).toBe(false);
-  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
-  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
-});
-
-// (invariant) every needs_review job is either an auto-fix target or
-// annotatable (would receive a non-null verifierVerdict) — never both false.
-test('invariant: fresh, retry-eligible, exhausted, and plan-unqueued jobs are always selected or annotatable', () => {
-  const jobs = [
-    makeJob({ slug: '01-fresh' }),
-    makeJob({ slug: '02-unstamped-retry', autoFixAttempted: true, autoFixRetries: 0 }),
-    makeJob({ slug: '03-unstamped-exhausted', autoFixAttempted: true, autoFixRetries: 1 }),
-    makeJob({ slug: '04-error-retry', autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 0 }),
-    makeJob({ slug: '05-error-exhausted', autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 1 }),
-    makeJob({ slug: '06-plan-unqueued', autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 }),
-  ];
-  const planJob = jobs.find((j) => j.slug === '06-plan-unqueued');
-  const planQueuedJob = makeJob({
-    slug: '07-plan-queued', parallelGroup: 7, autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0,
-  });
-  jobs.push(planQueuedJob);
-  const queuedSlugs = new Set([fixSlugFor(planQueuedJob)]);
-
-  const targets = new Set(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).map((j) => j.slug));
-  for (const job of jobs) {
-    const selected = targets.has(job.slug);
-    const annotated = isAnnotatable(job, queuedSlugs);
-    if (job.slug === '07-plan-queued') {
-      // The good path: waiting on the fix-plan job itself, no action here.
-      expect(selected).toBe(false);
-      expect(annotated).toBe(false);
-      continue;
-    }
-    expect(selected || annotated).toBe(true);
-  }
-  expect(isPlanUnqueued(planJob, queuedSlugs)).toBe(true);
-});