claude-code-session-manager 0.97.0 → 0.100.0

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

@@ -1,355 +0,0 @@
-/**
- * queueHistory.test.cjs — unit tests for src/main/lib/queueHistory.cjs and
- * scheduler.cjs's selectHistoryJobs merge.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/queueHistory.test.cjs
- */
-
-'use strict';
-
-import { test, expect, beforeEach, afterEach } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-
-const RETENTION_MS = 7 * 24 * 60 * 60_000;
-const NOW = Date.parse('2026-07-24T12:00:00.000Z');
-
-function fresh(overrides = {}) {
-  return {
-    slug: '01-fresh',
-    status: 'completed',
-    runId: 'run-1',
-    finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString(), // 1h ago
-    ...overrides,
-  };
-}
-
-function old(overrides = {}) {
-  return {
-    slug: '02-old',
-    status: 'completed',
-    runId: 'run-2',
-    finishedAt: new Date(NOW - 10 * 24 * 60 * 60_000).toISOString(), // 10d ago
-    ...overrides,
-  };
-}
-
-let queueHistory;
-let prevOverride;
-
-beforeEach(() => {
-  // Point HISTORY_PATH at an isolated tmpdir file (SM_HISTORY_PATH_OVERRIDE)
-  // instead of the real machine-global history.jsonl — a live Electron
-  // instance's scheduler.cjs writes that same global file concurrently,
-  // which races this suite's unlink/append calls and produces real
-  // production data in place of the expected empty state.
-  prevOverride = process.env.SM_HISTORY_PATH_OVERRIDE;
-  process.env.SM_HISTORY_PATH_OVERRIDE = path.join(
-    os.tmpdir(),
-    `queueHistory-test-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}.jsonl`
-  );
-
-  // Fresh require per test so HISTORY_PATH's target file starts clean.
-  delete require.cache[require.resolve('../lib/queueHistory.cjs')];
-  queueHistory = require('../lib/queueHistory.cjs');
-  try { fs.unlinkSync(queueHistory.historyPath()); } catch { /* ok if absent */ }
-});
-
-afterEach(() => {
-  try { fs.unlinkSync(queueHistory.historyPath()); } catch { /* ok if absent */ }
-  if (prevOverride === undefined) delete process.env.SM_HISTORY_PATH_OVERRIDE;
-  else process.env.SM_HISTORY_PATH_OVERRIDE = prevOverride;
-});
-
-// ---------- partitionJobs ----------
-
-test('partitionJobs: fresh completed job stays hot', () => {
-  const { hot, toArchive } = queueHistory.partitionJobs([fresh()], NOW);
-  expect(hot.map((j) => j.slug)).toEqual(['01-fresh']);
-  expect(toArchive).toEqual([]);
-});
-
-test('partitionJobs: old completed job archives', () => {
-  const { hot, toArchive } = queueHistory.partitionJobs([old()], NOW);
-  expect(hot).toEqual([]);
-  expect(toArchive.map((j) => j.slug)).toEqual(['02-old']);
-});
-
-test('partitionJobs: old failed job archives', () => {
-  const j = old({ slug: '03-old-failed', status: 'failed', runId: 'run-3' });
-  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
-  expect(hot).toEqual([]);
-  expect(toArchive.map((x) => x.slug)).toEqual(['03-old-failed']);
-});
-
-test('partitionJobs: running and pending jobs never archive, regardless of age', () => {
-  const running = old({ slug: '04-running', status: 'running', runId: 'run-4', finishedAt: null });
-  const pending = old({ slug: '05-pending', status: 'pending', runId: null, finishedAt: null });
-  const { hot, toArchive } = queueHistory.partitionJobs([running, pending], NOW);
-  expect(toArchive).toEqual([]);
-  expect(hot.map((j) => j.slug).sort()).toEqual(['04-running', '05-pending']);
-});
-
-test('partitionJobs: old skipped job archives (never-ran rows must age out of the hot queue too)', () => {
-  const j = old({ slug: '03b-old-skipped', status: 'skipped', runId: 'run-3b' });
-  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
-  expect(hot).toEqual([]);
-  expect(toArchive.map((x) => x.slug)).toEqual(['03b-old-skipped']);
-});
-
-test('partitionJobs: needs_review jobs never archive', () => {
-  const j = old({ slug: '06-review', status: 'needs_review', runId: 'run-6' });
-  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
-  expect(toArchive).toEqual([]);
-  expect(hot.map((x) => x.slug)).toEqual(['06-review']);
-});
-
-test('partitionJobs: job with no/invalid finishedAt stays hot even if old status', () => {
-  const j = { slug: '07-nofinish', status: 'completed', runId: 'run-7', finishedAt: null };
-  const { hot, toArchive } = queueHistory.partitionJobs([j], NOW);
-  expect(toArchive).toEqual([]);
-  expect(hot.map((x) => x.slug)).toEqual(['07-nofinish']);
-});
-
-test('partitionJobs: fix-plan linkage keeps an old original hot while its fix is pending', () => {
-  const original = old({ slug: '08-thing', status: 'failed', runId: 'run-8' });
-  const fixPlan = { slug: '08-fix-thing', status: 'pending', runId: null, finishedAt: null };
-  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
-  expect(toArchive).toEqual([]);
-  expect(hot.map((x) => x.slug).sort()).toEqual(['08-fix-thing', '08-thing']);
-});
-
-test('partitionJobs: fix-plan linkage keeps an old original hot while its fix is running', () => {
-  const original = old({ slug: '09-thing', status: 'failed', runId: 'run-9' });
-  const fixPlan = { slug: '09-fix-thing', status: 'running', runId: 'run-9b', finishedAt: null };
-  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
-  expect(toArchive).toEqual([]);
-  expect(hot.map((x) => x.slug).sort()).toEqual(['09-fix-thing', '09-thing']);
-});
-
-test('partitionJobs: an old original with a COMPLETED fix-plan is free to archive (no longer protected)', () => {
-  const original = old({ slug: '10-thing', status: 'completed', runId: 'run-10' });
-  const fixPlan = old({ slug: '10-fix-thing', status: 'completed', runId: 'run-10b' });
-  const { hot, toArchive } = queueHistory.partitionJobs([original, fixPlan], NOW);
-  expect(hot).toEqual([]);
-  expect(toArchive.map((x) => x.slug).sort()).toEqual(['10-fix-thing', '10-thing']);
-});
-
-test('partitionJobs: respects opts.retentionMs override', () => {
-  const j = { slug: '11-recent', status: 'completed', runId: 'run-11', finishedAt: new Date(NOW - 2 * 60 * 60_000).toISOString() };
-  const { toArchive } = queueHistory.partitionJobs([j], NOW, { retentionMs: 60 * 60_000 }); // 1h retention
-  expect(toArchive.map((x) => x.slug)).toEqual(['11-recent']);
-});
-
-// ---------- appendHistory / readHistory ----------
-
-test('appendHistory writes entries, readHistory reads them back newest-first', async () => {
-  const a = old({ slug: 'a', runId: 'ra', finishedAt: new Date(NOW - 3 * 60 * 60_000).toISOString() });
-  const b = old({ slug: 'b', runId: 'rb', finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString() });
-  await queueHistory.appendHistory([a, b]);
-  const read = await queueHistory.readHistory({ limit: 10 });
-  // appended in file order a,b; readHistory reverses file order to newest-appended-first
-  expect(read.map((j) => j.slug)).toEqual(['b', 'a']);
-});
-
-test('appendHistory dedupes by slug+runId against what is already on disk', async () => {
-  const a = old({ slug: 'dup', runId: 'r1' });
-  const r1 = await queueHistory.appendHistory([a]);
-  expect(r1.appended).toBe(1);
-  const r2 = await queueHistory.appendHistory([a]); // replay of the same batch (crash-recovery scenario)
-  expect(r2.appended).toBe(0);
-  const read = await queueHistory.readHistory({ limit: 10 });
-  expect(read.length).toBe(1);
-});
-
-test('appendHistory: a needs_review ledger line and a terminal row sharing slug+runId do NOT dedupe against each other', async () => {
-  // An entry and its resolution line (needsReviewLedger.cjs) deliberately
-  // reference the SAME runId as each other — and a slug's terminal archive
-  // row can later reuse that same runId too (same run, different `kind`).
-  // jobKey must bucket by kind or the second/third write looks like a
-  // crash-replay of the first and silently never lands.
-  const entryLine = { kind: 'needs_review_entry', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
-  const resolutionLine = { kind: 'needs_review_resolution', slug: 'ledger-dup', runId: 'shared-run', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 1000 };
-  const terminalLine = old({ slug: 'ledger-dup', runId: 'shared-run' });
-  const r1 = await queueHistory.appendHistory([entryLine]);
-  const r2 = await queueHistory.appendHistory([resolutionLine]);
-  const r3 = await queueHistory.appendHistory([terminalLine]);
-  expect(r1.appended).toBe(1);
-  expect(r2.appended).toBe(1);
-  expect(r3.appended).toBe(1);
-  const read = await queueHistory.readHistory({ limit: 10 });
-  expect(read.filter((j) => j.slug === 'ledger-dup')).toHaveLength(3);
-});
-
-test('readHistory respects limit and returns [] when file is absent', async () => {
-  const empty = await queueHistory.readHistory({ limit: 5 });
-  expect(empty).toEqual([]);
-
-  // Realistic append order: oldest finishedAt first (append-only file grows
-  // forward in time), so s7 is both last-appended and newest.
-  const entries = Array.from({ length: 8 }, (_, i) => old({ slug: `s${i}`, runId: `r${i}`, finishedAt: new Date(NOW - (7 - i) * 60_000).toISOString() }));
-  await queueHistory.appendHistory(entries);
-  const read = await queueHistory.readHistory({ limit: 3 });
-  expect(read.length).toBe(3);
-  // Federated readHistory (2026-07-31) orders by finishedAt newest-first.
-  expect(read.map((j) => j.slug)).toEqual(['s7', 's6', 's5']);
-});
-
-test('readHistory tail-reads correctly when the file is larger than one chunk', async () => {
-  // Force many small appends so the file exceeds the initial 64KB read chunk.
-  const bigEntries = Array.from({ length: 2000 }, (_, i) => ({
-    slug: `bulk-${i}`,
-    status: 'completed',
-    runId: `bulk-run-${i}`,
-    finishedAt: new Date(NOW - i * 1000).toISOString(),
-    bodyPreview: 'x'.repeat(80),
-  }));
-  await queueHistory.appendHistory(bigEntries);
-  const read = await queueHistory.readHistory({ limit: 5 });
-  // The tail read only touches the file's end; whatever was read comes back
-  // ordered by finishedAt newest-first.
-  expect(read.length).toBe(5);
-  const t = (j) => Date.parse(j.finishedAt);
-  for (let i = 1; i < read.length; i++) expect(t(read[i - 1])).toBeGreaterThanOrEqual(t(read[i]));
-});
-
-// ---------- selectHistoryJobs merge (scheduler.cjs) ----------
-
-test('selectHistoryJobs merges hot jobs[] and history tail, newest-first, deduped', () => {
-  const { selectHistoryJobs } = require('../scheduler.cjs');
-  const hotJob = fresh({ slug: 'hot-1', runId: 'rh1' });
-  const historyEntry = old({ slug: 'hist-1', runId: 'rhist1' });
-  const merged = selectHistoryJobs([hotJob], 10, [historyEntry]);
-  expect(merged.map((j) => j.slug)).toEqual(['hot-1', 'hist-1']); // hot is newer
-});
-
-test('selectHistoryJobs: jobs[] entry wins over a duplicate history entry with the same slug+runId', () => {
-  const { selectHistoryJobs } = require('../scheduler.cjs');
-  const hotCopy = fresh({ slug: 'dup', runId: 'rd', bodyPreview: 'from-hot' });
-  const historyCopy = fresh({ slug: 'dup', runId: 'rd', bodyPreview: 'from-history' });
-  const merged = selectHistoryJobs([hotCopy], 10, [historyCopy]);
-  expect(merged.length).toBe(1);
-  expect(merged[0].bodyPreview).toBe('from-hot');
-});
-
-test('selectHistoryJobs: default historyEntries=[] preserves old call shape', () => {
-  const { selectHistoryJobs } = require('../scheduler.cjs');
-  const merged = selectHistoryJobs([fresh()], 10);
-  expect(merged.map((j) => j.slug)).toEqual(['01-fresh']);
-});
-
-test('selectHistoryJobs: needs_review ledger lines (kind !== "terminal") are excluded from the merged result', () => {
-  // The History view renders ScheduleJob-shaped rows (status, exitCode, ...)
-  // — a needs_review_entry/needs_review_resolution line (needsReviewLedger.cjs)
-  // has neither, and must not slip through as a statusless row in that table.
-  const { selectHistoryJobs } = require('../scheduler.cjs');
-  const terminalEntry = old({ slug: 'hist-1', runId: 'rhist1' });
-  const ledgerEntry = { kind: 'needs_review_entry', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize' };
-  const ledgerResolution = { kind: 'needs_review_resolution', slug: 'ledger-1', runId: 'rledger1', at: new Date(NOW).toISOString(), resolvedTo: 'completed', ladderRung: 'reverify', source: 'reverifyNeedsReview:heal', dwellMs: 500 };
-  const merged = selectHistoryJobs([], 10, [terminalEntry, ledgerEntry, ledgerResolution]);
-  expect(merged.map((j) => j.slug)).toEqual(['hist-1']);
-});
-
-// ---------- historyTerminalBySlug ----------
-//
-// Guards against scheduler.cjs's reconcile() resurrecting an already-
-// archived-to-history job as a fresh 'pending' entry (and the scheduler
-// then genuinely re-executing an already-completed PRD) just because its
-// job row already left jobs[]. reconcile() consults this map before
-// treating an unmatched on-disk PRD slug as brand-new.
-
-test('historyTerminalBySlug: returns status + finishedAt for every archived slug', async () => {
-  const a = old({ slug: 'term-completed', status: 'completed', runId: 'rc' });
-  const b = old({ slug: 'term-failed', status: 'failed', runId: 'rf' });
-  await queueHistory.appendHistory([a, b]);
-
-  const map = await queueHistory.historyTerminalBySlug();
-  expect(map.get('term-completed')).toEqual({ status: 'completed', finishedAt: a.finishedAt, landedCommit: null });
-  expect(map.get('term-failed')).toEqual({ status: 'failed', finishedAt: b.finishedAt, landedCommit: null });
-  expect(map.has('never-archived-slug')).toBe(false);
-});
-
-test('historyTerminalBySlug: returns an empty map when history.jsonl is absent', async () => {
-  const map = await queueHistory.historyTerminalBySlug();
-  expect(map.size).toBe(0);
-});
-
-test('historyTerminalBySlug: cache invalidates after a new appendHistory call (mtime changes)', async () => {
-  const a = old({ slug: 'cache-1', runId: 'rca' });
-  await queueHistory.appendHistory([a]);
-  const first = await queueHistory.historyTerminalBySlug();
-  expect(first.has('cache-1')).toBe(true);
-  expect(first.has('cache-2')).toBe(false);
-
-  const b = old({ slug: 'cache-2', runId: 'rcb' });
-  await queueHistory.appendHistory([b]);
-  const second = await queueHistory.historyTerminalBySlug();
-  expect(second.has('cache-1')).toBe(true);
-  expect(second.has('cache-2')).toBe(true);
-});
-
-test('historyTerminalBySlug: ignores needs_review ledger lines, even a LATER one for an already-terminal slug', async () => {
-  // Chronological order matters here: the terminal row lands first, and a
-  // needs_review_entry for the SAME slug (a later re-run parking again)
-  // lands after it. Without the kind guard, last-line-wins would replace
-  // the true 'completed' record with a status-less ledger row.
-  const terminal = old({ slug: 'mixed-1', status: 'completed', runId: 'rterm' });
-  await queueHistory.appendHistory([terminal]);
-  await queueHistory.appendHistory([{
-    kind: 'needs_review_entry', slug: 'mixed-1', runId: 'rlater', cwd: null,
-    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
-  }]);
-
-  const map = await queueHistory.historyTerminalBySlug();
-  expect(map.get('mixed-1')).toEqual({ status: 'completed', finishedAt: terminal.finishedAt, landedCommit: null });
-});
-
-// ---------- completedSlugsForCwd (PRD 1122) ----------
-//
-// Feeds scheduler.cjs's computeDepHistorySatisfaction: a dependsOn slug with
-// no live queue row is only satisfied when it shows up here (or in
-// prds-archived/) — scoped to ONE project's own history shard so a
-// same-named PRD in an unrelated project can never satisfy a dep.
-
-test('completedSlugsForCwd: returns slugs completed in this project\'s own shard only', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projA-'));
-  const otherCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projB-'));
-  await queueHistory.appendHistory([
-    old({ slug: '900-base', status: 'completed', runId: 'ra', cwd: projectCwd }),
-    old({ slug: '901-failed', status: 'failed', runId: 'rb', cwd: projectCwd }),
-    old({ slug: '900-base', status: 'completed', runId: 'rc', cwd: otherCwd }),
-  ]);
-
-  const slugs = await queueHistory.completedSlugsForCwd(projectCwd);
-  expect(slugs.has('900-base')).toBe(true);
-  expect(slugs.has('901-failed')).toBe(false);
-
-  // Same slug completed in a DIFFERENT project must not leak across.
-  const otherSlugs = await queueHistory.completedSlugsForCwd(otherCwd);
-  expect(otherSlugs.has('900-base')).toBe(true);
-  const unrelatedCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-projC-'));
-  expect((await queueHistory.completedSlugsForCwd(unrelatedCwd)).size).toBe(0);
-});
-
-test('completedSlugsForCwd: returns an empty Set when the project has no history shard yet', async () => {
-  const freshCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-fresh-'));
-  const slugs = await queueHistory.completedSlugsForCwd(freshCwd);
-  expect(slugs.size).toBe(0);
-});
-
-test('completedSlugsForCwd: ignores needs_review ledger lines even when they are the newest line for a completed slug', async () => {
-  const projectCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-1122-ledger-'));
-  await queueHistory.appendHistory([
-    old({ slug: '900-base', status: 'completed', runId: 'ra', cwd: projectCwd }),
-  ]);
-  // A later needs_review park for a NEW run of the same slug must not blank
-  // out the earlier 'completed' record read by completedSlugsForCwd.
-  await queueHistory.appendHistory([{
-    kind: 'needs_review_entry', slug: '900-base', runId: 'rb', cwd: projectCwd,
-    at: new Date(NOW).toISOString(), reason: 'uncommitted_changes', source: 'spawnJob:finalize',
-  }]);
-
-  const slugs = await queueHistory.completedSlugsForCwd(projectCwd);
-  expect(slugs.has('900-base')).toBe(true);
-});

package/src/main/__tests__/queueOps-interactive-ac-lint.test.cjs

@@ -1,65 +0,0 @@
-/**
- * queueOps-interactive-ac-lint.test.cjs — lint for AC checkboxes that
- * instruct an interactive/GUI-rendering step (xvfb-run, playwright test,
- * electron.launch, screenshot, ...) that a headless claude -p executor can
- * never satisfy (see the 776/779 exit143 incidents, 2026-07-30). Must key off
- * AC-checkbox context specifically — a PRD's Out-of-scope/notes prose telling
- * the executor NOT to do this (PRDs 780/787/788's pattern) must not trigger.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/queueOps-interactive-ac-lint.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { lintOneAsync } = require('../queueOps.cjs');
-
-function writeTmpPrd(body) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-lint-interactive-'));
-  const p = path.join(dir, 'test-prd.md');
-  const raw = `---\ntitle: "test"\ncwd: ~\nestimateMinutes: 10\n---\n\n${body}\n`;
-  fs.writeFileSync(p, raw, 'utf8');
-  return p;
-}
-
-test('flags a PRD with xvfb-run as an AC checkbox line', async () => {
-  const p = writeTmpPrd(
-    '# Acceptance criteria\n\n- [ ] `xvfb-run -a npx playwright test tests/e2e/foo.spec.ts` passes\n',
-  );
-  const { findings } = await lintOneAsync(p);
-  expect(findings.some((f) => f.rule === 'interactive-xvfb')).toBe(true);
-});
-
-test('flags a PRD with playwright electron.launch as an AC checkbox line', async () => {
-  const p = writeTmpPrd(
-    '# Acceptance criteria\n\n- [ ] Playwright `electron.launch` boots the app and captures a screenshot of the Scheduler tab\n',
-  );
-  const { findings } = await lintOneAsync(p);
-  expect(findings.some((f) => f.rule === 'interactive-electron-launch')).toBe(true);
-});
-
-test('does NOT flag Out-of-scope/notes prose that mentions xvfb without being a checkbox line', async () => {
-  const p = writeTmpPrd(
-    '# Acceptance criteria\n\n- [ ] `timeout 300 npm run typecheck` passes\n' +
-    '- [ ] `timeout 300 npx vitest run src/foo.test.ts` passes\n\n' +
-    'NOTE: do NOT add a `playwright test ... under xvfb` acceptance criterion here. Two prior\n' +
-    'links in this chain stalled and were SIGTERM\'d (exit 143) on exactly that step — a headless\n' +
-    '`claude -p` executor spawning `xvfb-run`/Playwright hits a tool-use rejection and hangs.\n\n' +
-    '# Out of scope\n\n' +
-    '- Making xvfb-run/Playwright actually work inside a headless claude -p job — out of scope\n',
-  );
-  const { findings } = await lintOneAsync(p);
-  expect(findings.filter((f) => f.rule.startsWith('interactive-')).length).toBe(0);
-});
-
-test('a clean PRD with only typecheck/vitest AC is not flagged', async () => {
-  const p = writeTmpPrd(
-    '# Acceptance criteria\n\n- [ ] `timeout 300 npm run typecheck` passes\n' +
-    '- [ ] `timeout 300 npx vitest run src/foo.test.ts` passes\n',
-  );
-  const { findings } = await lintOneAsync(p);
-  expect(findings.filter((f) => f.rule.startsWith('interactive-')).length).toBe(0);
-});

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

@@ -1,65 +0,0 @@
-/**
- * queueOpsArchiveDestination.test.cjs — an archived PRD lands beside its OWN
- * source, not in the machine-level scheduled-plans tree.
- *
- * PRD sources are per-project and per-Epic (CLAUDE.md's TAB → EPIC → PRD
- * model): `<cwd>/session-manager-operations/scheduler/epics/<epic-id>/prds/`.
- * `~/.claude/session-manager/scheduled-plans/` holds only run logs and
- * PRD_AUTHORING.md. archiveOne resolved its SOURCE per-project (findPrdDir)
- * but hardcoded its DESTINATION to the global PRDS_ARCHIVE_DIR, so a manual
- * archive yanked a PRD out of its Epic and stranded it in the retired global
- * tree — splitting one Epic's history across two locations.
- *
- * Observed 2026-08-13: archiving 1035-epic-worktree-ui-surfacing put it under
- * scheduled-plans/prds-archived/ while its three chain siblings (1032/1033/
- * 1034, archived by scheduler.cjs's own on-completion mover) sat correctly in
- * the Epic's prds-archived/. Two movers, two destinations, same operation.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/queueOpsArchiveDestination.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const path = require('node:path');
-const { archiveDirForSource, PRDS_DIR, PRDS_ARCHIVE_DIR } = require('../queueOps.cjs');
-
-const EPIC_PRDS = '/home/u/Projects/proj/session-manager-operations/scheduler/epics/my-epic-abc123/prds';
-const TS = '2026-08-14T05-03-41-156Z';
-
-test('an Epic PRD archives into that Epic\'s own prds-archived/, beside its prds/', () => {
-  const dir = archiveDirForSource(EPIC_PRDS, TS);
-  expect(dir).toBe(path.join(path.dirname(EPIC_PRDS), 'prds-archived', TS));
-  // Concretely: same Epic dir, sibling of prds/.
-  expect(dir).toBe(
-    `/home/u/Projects/proj/session-manager-operations/scheduler/epics/my-epic-abc123/prds-archived/${TS}`,
-  );
-});
-
-test('an Epic PRD never lands under the machine-level scheduled-plans tree', () => {
-  const dir = archiveDirForSource(EPIC_PRDS, TS);
-  expect(dir.startsWith(PRDS_ARCHIVE_DIR)).toBe(false);
-  expect(dir).not.toContain('.claude/session-manager/scheduled-plans');
-});
-
-test('the archived PRD stays inside its own project — the ops root never changes', () => {
-  const dir = archiveDirForSource(EPIC_PRDS, TS);
-  expect(dir.startsWith('/home/u/Projects/proj/session-manager-operations/')).toBe(true);
-});
-
-test('two Epics in the same project archive to their own separate dirs', () => {
-  const other = '/home/u/Projects/proj/session-manager-operations/scheduler/epics/other-epic-def456/prds';
-  expect(archiveDirForSource(EPIC_PRDS, TS)).not.toBe(archiveDirForSource(other, TS));
-});
-
-test('a legacy flat PRD still archives to the global prds-archived/ — old behavior unchanged', () => {
-  const dir = archiveDirForSource(PRDS_DIR, TS);
-  expect(dir).toBe(path.join(PRDS_ARCHIVE_DIR, TS));
-});
-
-test('the batch timestamp is shared, so one archive call reads as one event', () => {
-  const a = archiveDirForSource(EPIC_PRDS, TS);
-  const b = archiveDirForSource('/home/u/Projects/other/session-manager-operations/scheduler/epics/e/prds', TS);
-  expect(path.basename(a)).toBe(TS);
-  expect(path.basename(b)).toBe(TS);
-});

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

@@ -1,154 +0,0 @@
-/**
- * queueOpsAutoArchive.test.cjs — unit tests for queueOps.cjs's
- * selectAutoArchivable predicate + autoArchiveCompleted orchestration
- * (auto-archiving completed PRDs' .md files out of the live prds/ dir).
- *
- * selectAutoArchivable is pure (no fs) so it's fully covered here without
- * touching disk. autoArchiveCompleted's disk-mutating path (archiveMany) is
- * exercised only via its kill-switch / no-op branches, since archiveMany
- * targets the real ~/.claude/session-manager/scheduled-plans/prds-archived
- * directory (not test-injectable) — mutating that from a test run would be
- * an unwanted side effect on the developer's real filesystem.
- *
- * Run: timeout 300 npx vitest run src/main/__tests__/queueOpsAutoArchive.test.cjs
- */
-
-'use strict';
-
-import { test, expect, afterEach } from 'vitest';
-
-const RETENTION_MS = 7 * 24 * 60 * 60_000;
-const NOW = Date.parse('2026-07-24T12:00:00.000Z');
-
-const { selectAutoArchivable, autoArchiveCompleted } = require('../queueOps.cjs');
-
-function fresh(overrides = {}) {
-  return {
-    slug: '01-fresh',
-    status: 'completed',
-    finishedAt: new Date(NOW - 1 * 60 * 60_000).toISOString(), // 1h ago
-    ...overrides,
-  };
-}
-
-function old(overrides = {}) {
-  return {
-    slug: '02-old',
-    status: 'completed',
-    finishedAt: new Date(NOW - 10 * 24 * 60 * 60_000).toISOString(), // 10d ago
-    ...overrides,
-  };
-}
-
-afterEach(() => {
-  delete process.env.SM_PRD_AUTOARCHIVE_DISABLE;
-});
-
-// ---------- selectAutoArchivable ----------
-
-test('selectAutoArchivable: fresh completed job stays (not old enough)', () => {
-  const slugs = selectAutoArchivable([fresh()], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: old completed job archives', () => {
-  const slugs = selectAutoArchivable([old()], { nowMs: NOW });
-  expect(slugs).toEqual(['02-old']);
-});
-
-test('selectAutoArchivable: needs_review jobs never archive, regardless of age', () => {
-  const j = old({ slug: '03-review', status: 'needs_review' });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: failed jobs never archive, regardless of age', () => {
-  const j = old({ slug: '04-failed', status: 'failed' });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: pending jobs never archive', () => {
-  const j = old({ slug: '05-pending', status: 'pending', finishedAt: null });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: running jobs never archive', () => {
-  const j = old({ slug: '06-running', status: 'running', finishedAt: null });
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a PENDING NN-fix-<slug> sibling is protected', () => {
-  const original = old({ slug: '07-thing', status: 'completed' });
-  const fixPlan = { slug: '07-fix-thing', status: 'pending', finishedAt: null };
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a RUNNING NN-fix-<slug> sibling is protected', () => {
-  const original = old({ slug: '08-thing', status: 'completed' });
-  const fixPlan = { slug: '08-fix-thing', status: 'running', finishedAt: null };
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: a completed job with a COMPLETED fix-plan sibling is free to archive (no longer protected)', () => {
-  const original = old({ slug: '09-thing', status: 'completed' });
-  const fixPlan = old({ slug: '09-fix-thing', status: 'completed' });
-  const slugs = selectAutoArchivable([original, fixPlan], { nowMs: NOW }).sort();
-  expect(slugs).toEqual(['09-fix-thing', '09-thing']);
-});
-
-test('selectAutoArchivable: job with no/invalid finishedAt never archives even if status completed', () => {
-  const j = { slug: '10-nofinish', status: 'completed', finishedAt: null };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual([]);
-});
-
-test('selectAutoArchivable: respects retentionMs override', () => {
-  const j = { slug: '11-recent', status: 'completed', finishedAt: new Date(NOW - 2 * 60 * 60_000).toISOString() };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW, retentionMs: 60 * 60_000 }); // 1h retention
-  expect(slugs).toEqual(['11-recent']);
-});
-
-test('selectAutoArchivable: defaults retentionMs to the shared HISTORY_RETENTION_MS constant', () => {
-  const j = { slug: '12-boundary', status: 'completed', finishedAt: new Date(NOW - RETENTION_MS - 1).toISOString() };
-  const slugs = selectAutoArchivable([j], { nowMs: NOW });
-  expect(slugs).toEqual(['12-boundary']);
-});
-
-// ---------- autoArchiveCompleted ----------
-
-test('autoArchiveCompleted: kill switch SM_PRD_AUTOARCHIVE_DISABLE=1 skips entirely', async () => {
-  process.env.SM_PRD_AUTOARCHIVE_DISABLE = '1';
-  const result = await autoArchiveCompleted({ jobs: [old()] }, { nowMs: NOW });
-  expect(result.archived).toBe(0);
-  expect(result.skipped).toBe('disabled');
-});
-
-test('autoArchiveCompleted: no eligible slugs returns a no-op without touching disk', async () => {
-  const result = await autoArchiveCompleted({ jobs: [fresh()] }, { nowMs: NOW });
-  expect(result.ok).toBe(true);
-  expect(result.archived).toBe(0);
-  expect(result.archivedTo).toBe(null);
-  expect(result.results).toEqual([]);
-});
-
-test('autoArchiveCompleted: tolerates a missing/malformed state.jobs', async () => {
-  const result = await autoArchiveCompleted({}, { nowMs: NOW });
-  expect(result.archived).toBe(0);
-});
-
-// ---------- archiving never strands a runnable queue job (scheduler PRD:
-// archived-prd-skip — job 822-epics-nav-rename fired ENOENT after its PRD
-// was archived out from under a still-queued job) ----------
-
-test('selectAutoArchivable never selects a slug whose job is still pending or running, so auto-archive can never leave a runnable job pointing at an archived PRD', () => {
-  const pending = old({ slug: '13-pending', status: 'pending', finishedAt: null });
-  const running = old({ slug: '14-running', status: 'running', finishedAt: null });
-  const completed = old({ slug: '15-done', status: 'completed' });
-  const slugs = selectAutoArchivable([pending, running, completed], { nowMs: NOW });
-  expect(slugs).toEqual(['15-done']);
-});