claude-code-session-manager 0.97.0 → 0.100.0

package/src/main/__tests__/scheduler-admin-routes.test.cjs

@@ -1,199 +0,0 @@
-/**
- * scheduler-admin-routes.test.cjs — unit tests for scheduler.cjs's
- * registerAdminRoutes (PRD 689 — moved out of the former standalone admin
- * HTTP server module's handleRequest, no behavior change). Exercises the
- * two job-management admin
- * HTTP routes against a fake `remote` object, wired through the real
- * localAdminHttp.cjs transport.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-admin-routes.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const http = require('node:http');
-const { createAdminHttp } = require('../lib/localAdminHttp.cjs');
-const { registerAdminRoutes } = require('../scheduler.cjs');
-
-function request(port, { method = 'GET', path: reqPath, token, body }) {
-  return new Promise((resolve, reject) => {
-    const headers = {};
-    if (token !== undefined) headers.Authorization = `Bearer ${token}`;
-    let payload;
-    if (body !== undefined) {
-      payload = JSON.stringify(body);
-      headers['Content-Type'] = 'application/json';
-      headers['Content-Length'] = Buffer.byteLength(payload);
-    }
-    const req = http.request({ hostname: '127.0.0.1', port, method, path: reqPath, headers }, (res) => {
-      const chunks = [];
-      res.on('data', (c) => chunks.push(c));
-      res.on('end', () => {
-        const text = Buffer.concat(chunks).toString('utf8');
-        let json = null;
-        try { json = JSON.parse(text); } catch { /* leave null for non-JSON bodies */ }
-        resolve({ status: res.statusCode, json, text });
-      });
-    });
-    req.on('error', reject);
-    if (payload) req.write(payload);
-    req.end();
-  });
-}
-
-function makeFakeRemote({ jobs = [] } = {}) {
-  return {
-    async listJobs() {
-      return jobs.map((j) => ({ slug: j.slug, title: j.title, status: j.status, cwd: j.cwd }));
-    },
-    // Mirrors the real scheduler.cjs remote.resetJob's force-guard so this
-    // fake exercises the SAME contract the admin route promises callers.
-    async resetJob(slug, opts = {}) {
-      const job = jobs.find((j) => j.slug === slug);
-      if (!job) return { ok: false, error: 'not found' };
-      if (job.status === 'completed' && opts.force !== true) {
-        return {
-          ok: false,
-          error: 'job already completed — resetting it would re-execute shipped work; archive the PRD instead, or pass force:true',
-        };
-      }
-      job.status = 'pending';
-      job.runId = null;
-      job.startedAt = null;
-      job.finishedAt = null;
-      job.exitCode = null;
-      job.error = null;
-      delete job.runtime;
-      delete job.verifierVerdict;
-      return { ok: true, slug, status: 'pending' };
-    },
-  };
-}
-
-async function startWithRemote(remote) {
-  // Force the e2e-suffixed token path so this suite never races the real
-  // ~/.claude/session-manager/admin-api.json against other test files (or a
-  // live production instance) that also call createAdminHttp() concurrently.
-  const prevE2e = process.env.SM_E2E;
-  process.env.SM_E2E = '1';
-  const admin = createAdminHttp();
-  registerAdminRoutes(admin, remote);
-  const { port, token } = await admin.start();
-  if (prevE2e === undefined) delete process.env.SM_E2E; else process.env.SM_E2E = prevE2e;
-  return { admin, port, token };
-}
-
-test('GET /admin/scheduler/jobs with correct token returns 200 + array', async () => {
-  const remote = makeFakeRemote({
-    jobs: [{ slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo' }],
-  });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, { path: '/admin/scheduler/jobs', token });
-    expect(res.status).toBe(200);
-    expect(Array.isArray(res.json)).toBeTruthy();
-    expect(res.json.length).toBe(1);
-    expect(res.json[0].slug).toBe('10-foo');
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('POST /admin/scheduler/reset-job with unknown slug returns ok:false', async () => {
-  const remote = makeFakeRemote({ jobs: [] });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, {
-      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: 'does-not-exist' },
-    });
-    expect(res.status).toBe(200);
-    expect(res.json.ok).toBe(false);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('POST /admin/scheduler/reset-job without slug returns 400', async () => {
-  const remote = makeFakeRemote({ jobs: [] });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, {
-      method: 'POST', path: '/admin/scheduler/reset-job', token, body: {},
-    });
-    expect(res.status).toBe(400);
-    expect(res.json.ok).toBe(false);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('POST /admin/scheduler/reset-job with known needs_review slug flips job to pending and clears run fields', async () => {
-  const job = {
-    slug: '10-foo',
-    title: 'Foo',
-    status: 'needs_review',
-    cwd: '/tmp/foo',
-    runId: 'run-1',
-    startedAt: 100,
-    finishedAt: 200,
-    exitCode: 0,
-    error: null,
-    runtime: { pid: 1234 },
-    verifierVerdict: 'PASS',
-  };
-  const remote = makeFakeRemote({ jobs: [job] });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, {
-      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo' },
-    });
-    expect(res.status).toBe(200);
-    expect(res.json).toEqual({ ok: true, slug: '10-foo', status: 'pending' });
-    expect(job.status).toBe('pending');
-    expect(job.runId).toBe(null);
-    expect(job.startedAt).toBe(null);
-    expect(job.finishedAt).toBe(null);
-    expect(job.exitCode).toBe(null);
-    expect(job.error).toBe(null);
-    expect('runtime' in job).toBe(false);
-    expect('verifierVerdict' in job).toBe(false);
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('POST /admin/scheduler/reset-job on a completed job without force refuses and does not mutate', async () => {
-  const job = { slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo', runId: 'run-1' };
-  const remote = makeFakeRemote({ jobs: [job] });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, {
-      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo' },
-    });
-    expect(res.status).toBe(200);
-    expect(res.json.ok).toBe(false);
-    expect(res.json.error).toMatch(/force:true/);
-    expect(job.status).toBe('completed');
-    expect(job.runId).toBe('run-1');
-  } finally {
-    await admin.stop();
-  }
-});
-
-test('POST /admin/scheduler/reset-job on a completed job WITH force:true resets it', async () => {
-  const job = { slug: '10-foo', title: 'Foo', status: 'completed', cwd: '/tmp/foo', runId: 'run-1' };
-  const remote = makeFakeRemote({ jobs: [job] });
-  const { admin, port, token } = await startWithRemote(remote);
-  try {
-    const res = await request(port, {
-      method: 'POST', path: '/admin/scheduler/reset-job', token, body: { slug: '10-foo', force: true },
-    });
-    expect(res.status).toBe(200);
-    expect(res.json).toEqual({ ok: true, slug: '10-foo', status: 'pending' });
-    expect(job.status).toBe('pending');
-    expect(job.runId).toBe(null);
-  } finally {
-    await admin.stop();
-  }
-});

package/src/main/__tests__/scheduler-adopted-run-supervision.test.cjs

@@ -1,143 +0,0 @@
-/**
- * scheduler-adopted-run-supervision.test.cjs — an executor the boot spared
- * (`adoptedAtBoot`) is supervised like a freshly spawned one: budget, idle-tail
- * and deadman re-armed from the durable record, quietMachine lease re-acquired,
- * and a budget kill parks needs_review/budget_exceeded via classifyBudgetKill.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-adopted-run-supervision.test.cjs
- */
-
-'use strict';
-
-import { test, expect, vi, beforeEach, afterEach } from 'vitest';
-const { superviseAdoptedRuns, evaluateAdoptedRun } = require('../lib/adoptedRunSupervisor.cjs');
-const quietMachineLease = require('../lib/quietMachineLease.cjs');
-const { classifyBudgetKill } = require('../scheduler.cjs');
-
-const MIN = 60_000;
-const T0 = Date.parse('2026-09-18T12:00:00Z');
-
-beforeEach(() => {
-  vi.useFakeTimers();
-  vi.setSystemTime(T0);
-  quietMachineLease.__resetForTests();
-});
-afterEach(() => {
-  vi.useRealTimers();
-  quietMachineLease.__resetForTests();
-});
-
-function harness({ rows, records, logMtimeMs = () => Date.now(), alive = () => true }) {
-  const kills = [];
-  const stamps = [];
-  const supervised = [];
-  const registry = new Map();
-  const ctx = {
-    registry,
-    runDir: (j) => `/runs/${j.runId}`,
-    readRecord: (_dir, slug) => records[slug] ?? null,
-    lease: quietMachineLease,
-    markSupervised: async (j) => { supervised.push(j.slug); },
-    makeDeps: (j, record) => ({
-      logPath: `/runs/${j.runId}/${j.slug}.log`,
-      statLogMtimeMs: () => logMtimeMs(j.slug),
-      pidAlive: alive,
-      identityOf: () => record.identity,
-      isDifferentProcess: () => false,
-      killGroup: (pgid, signal) => { kills.push({ slug: j.slug, pgid, signal }); },
-      stampKill: async (kind, reason) => { stamps.push({ slug: j.slug, kind, reason }); },
-      checkIntervalMs: MIN,
-      sigkillAfterMs: 30_000,
-      defaultMaxDurationMs: 4 * 60 * MIN,
-    }),
-  };
-  return { ctx, kills, stamps, supervised, registry, run: () => superviseAdoptedRuns(rows, ctx) };
-}
-
-const row = (slug, extra = {}) => ({ slug, status: 'running', runId: 'r1', adoptedAtBoot: new Date(T0).toISOString(), ...extra });
-const record = (slug, extra = {}) => ({
-  slug, pid: 4242, pgid: 4242, identity: { startTicks: 1 }, startedAt: T0, budgetMs: 45 * MIN, maxDurationMs: null, idleKillMs: 20 * MIN, ...extra,
-});
-
-test('an adopted run past its budget is killed and its budget kill classifies needs_review/budget_exceeded', async () => {
-  const h = harness({ rows: [row('over')], records: { over: record('over', { startedAt: T0 - 50 * MIN }) } });
-  expect(await h.run()).toEqual(['over']);
-  await vi.advanceTimersByTimeAsync(0);
-  expect(h.stamps).toHaveLength(1);
-  expect(h.stamps[0].kind).toBe('budget');
-  expect(h.kills).toEqual([{ slug: 'over', pgid: 4242, signal: 'SIGTERM' }]);
-  // SIGKILL follows if the group survives SIGTERM.
-  await vi.advanceTimersByTimeAsync(30_000);
-  expect(h.kills.map((k) => k.signal)).toEqual(['SIGTERM', 'SIGKILL']);
-  // Same classifier as a native budget kill.
-  const outcome = classifyBudgetKill({ killedByWatchdog: h.stamps[0].kind, budgetKillReason: h.stamps[0].reason, exitCode: null }, null);
-  expect(outcome.status).toBe('needs_review');
-  expect(outcome.reason).toMatch(/wall-clock budget exceeded/);
-});
-
-test('a run within budget is untouched until the interval crosses the budget', async () => {
-  const h = harness({ rows: [row('ok')], records: { ok: record('ok', { startedAt: T0 - 10 * MIN }) } });
-  await h.run();
-  await vi.advanceTimersByTimeAsync(5 * MIN);
-  expect(h.kills).toEqual([]);
-  expect(h.stamps).toEqual([]);
-  // 10m + 36m elapsed > 45m budget: the re-armed interval now fires.
-  await vi.advanceTimersByTimeAsync(31 * MIN);
-  expect(h.stamps.map((s) => s.kind)).toEqual(['budget']);
-  expect(h.kills[0].signal).toBe('SIGTERM');
-});
-
-test('idle-tail: a stalled log past idleKillMs is SIGTERMed; deadman SIGKILLs at maxDurationMs', async () => {
-  const idle = harness({
-    rows: [row('idle')], records: { idle: record('idle', { startedAt: T0 - 5 * MIN }) },
-    logMtimeMs: () => T0 - 25 * MIN,
-  });
-  await idle.run();
-  await vi.advanceTimersByTimeAsync(0);
-  expect(idle.stamps.map((s) => s.kind)).toEqual(['idle-tail']);
-  expect(idle.kills[0].signal).toBe('SIGTERM');
-
-  const dead = harness({
-    rows: [row('dm')], records: { dm: record('dm', { startedAt: T0 - 5 * MIN, budgetMs: null, maxDurationMs: 4 * 60 * MIN }) },
-  });
-  await dead.run();
-  await vi.advanceTimersByTimeAsync(4 * 60 * MIN);
-  expect(dead.stamps.map((s) => s.kind)).toEqual(['deadman']);
-  expect(dead.kills.map((k) => k.signal)).toEqual(['SIGKILL']);
-});
-
-test('a null record.maxDurationMs falls back to the native 4h deadman', () => {
-  const rec = record('x', { budgetMs: null, startedAt: T0 - 5 * 60 * MIN });
-  expect(evaluateAdoptedRun(rec, { now: T0, logMtimeMs: T0, defaultMaxDurationMs: 4 * 60 * MIN })?.kind).toBe('deadman');
-});
-
-test('the quietMachine lease is re-acquired, supervisedAt stamped once, and an exempt (null budget) run is not budget-killed', async () => {
-  const h = harness({
-    rows: [row('quiet', { quietMachine: true })],
-    records: { quiet: record('quiet', { budgetMs: null, startedAt: T0 - 90 * MIN }) },
-  });
-  expect(await h.run()).toEqual(['quiet']);
-  expect(quietMachineLease.holder()).toBe('quiet');
-  expect(h.supervised).toEqual(['quiet']);
-  await vi.advanceTimersByTimeAsync(10 * MIN);
-  expect(h.kills).toEqual([]);
-  // A second dispatch-loop pass does not re-arm or re-stamp.
-  expect(await h.run()).toEqual([]);
-  expect(h.supervised).toEqual(['quiet']);
-});
-
-test('a pid that is gone is never signalled; rows that stop running drop their supervisor', async () => {
-  const h = harness({
-    rows: [row('gone')], records: { gone: record('gone', { startedAt: T0 - 90 * MIN }) }, alive: () => false,
-  });
-  await h.run();
-  await vi.advanceTimersByTimeAsync(2 * MIN);
-  expect(h.kills).toEqual([]);
-  expect(h.stamps).toEqual([]);
-
-  const live = harness({ rows: [row('fin')], records: { fin: record('fin') } });
-  await live.run();
-  expect(live.registry.size).toBe(1);
-  await superviseAdoptedRuns([{ slug: 'fin', status: 'completed', runId: 'r1' }], live.ctx);
-  expect(live.registry.size).toBe(0);
-});

package/src/main/__tests__/scheduler-already-satisfied-on-main.test.cjs

@@ -1,105 +0,0 @@
-/**
- * scheduler-already-satisfied-on-main.test.cjs — PRD 1136.
- *
- * Two live rows (1133-reaper-must-verify-integration-before-completed,
- * 1134-land-stranded-sm-job-branches) were false-negatived on 2026-09-06:
- * their work had already landed on main before their runs dispatched, so
- * each run exited 0, made no commit, and left a clean tree — the exact
- * 'silent_no_op' shape commitGuardVerdict parks as needs_review ("finish
- * protocol incomplete"). Both then auto-minted a redundant `-fix-` child
- * queued to re-do already-shipped work.
- *
- * This exercises the full finalize decision chain — commitGuardVerdict
- * (unchanged) feeding resolveCommitGuardOutcome (new) — entirely at the
- * pure-function level, per standards.md's TDD guidance and the PRD's own
- * implementation note to prefer a pure isAlreadySatisfiedOnMain-style helper
- * over driving the whole spawnJob pipeline.
- *
- * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-already-satisfied-on-main.test.cjs
- */
-
-'use strict';
-
-import { test, expect } from 'vitest';
-const { commitGuardVerdict, selectAutoFixTargets } = require('../scheduler.cjs');
-const { resolveCommitGuardOutcome, isAlreadySatisfiedOnMain } = require('../lib/reaperHelpers.cjs');
-
-const noSiblingOnDisk = () => false;
-
-// AC 1: exit 0 / no commit / clean tree, with a commit on main newer than
-// queuedAt touching the PRD's declared paths → completed, naming the sha.
-test('silent_no_op + a satisfying commit on main → completed-shaped verdict naming the sha, not needs_review', () => {
-  const guardVerdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-  expect(guardVerdict.verdict).toBe('silent_no_op'); // sanity: this is the shape 1133/1134 hit
-
-  const outcome = resolveCommitGuardOutcome(guardVerdict, ['5de4134abc123']);
-  expect(outcome.verdict).toBe('already_satisfied_on_main');
-  expect(outcome.verdict).not.toBe('needs_review');
-  expect(outcome.satisfyingSha).toBe('5de4134abc123');
-  expect(outcome.reason).toMatch(/5de4134abc123/);
-});
-
-// AC 2: the inverse — same clean-tree/no-commit shape, but NO commit on main
-// satisfies it → still parks as the existing 'finish protocol incomplete'
-// verdict. The gate must not be weakened into always-passing.
-test('silent_no_op + NO satisfying commit on main → unchanged silent_no_op verdict, still parks needs_review', () => {
-  const guardVerdict = commitGuardVerdict({
-    newlyDirty: [],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    isFixPlanJob: false,
-    verifyResult: null,
-  });
-
-  const outcome = resolveCommitGuardOutcome(guardVerdict, []);
-  expect(outcome).toBe(guardVerdict); // untouched — same object, not just same shape
-  expect(outcome.verdict).toBe('silent_no_op');
-  expect(outcome.downgradeTo).toBe('needs_review');
-  expect(outcome.reason).toMatch(/finish protocol incomplete/);
-});
-
-test('resolveCommitGuardOutcome never touches the uncommitted_changes shape, satisfied or not', () => {
-  const guardVerdict = commitGuardVerdict({
-    newlyDirty: ['src/main/someFeature.cjs'],
-    siblingRunning: false,
-    jobSelfCommitted: false,
-    legitimateNoOp: false,
-    verifyResult: null,
-  });
-  expect(guardVerdict.verdict).toBe('uncommitted_changes');
-
-  const outcome = resolveCommitGuardOutcome(guardVerdict, ['5de4134abc123']);
-  expect(outcome).toBe(guardVerdict);
-  expect(outcome.verdict).toBe('uncommitted_changes');
-});
-
-test('resolveCommitGuardOutcome: null guardVerdict (no violation) passes through as null', () => {
-  expect(resolveCommitGuardOutcome(null, ['5de4134'])).toBeNull();
-});
-
-// AC 3: a job terminalised via the already-satisfied path never becomes a
-// fix-plan target — selectAutoFixTargets only ever considers needs_review
-// rows, and the already-satisfied path never produces one.
-test('a job whose status is completed (the already-satisfied outcome) is never selected for an auto-fix child', () => {
-  const jobs = [{
-    slug: '1133-reaper-must-verify-integration-before-completed',
-    status: 'completed',
-    runId: '2026-09-06T13-03-00-000Z',
-    verifierVerdict: 'already_satisfied_on_main',
-  }];
-  const targets = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
-  expect(targets).toEqual([]);
-});
-
-test('isAlreadySatisfiedOnMain picks the newest (first) satisfying commit when several land', () => {
-  const verdict = isAlreadySatisfiedOnMain(['newest111', 'older222']);
-  expect(verdict.sha).toBe('newest111');
-});

package/src/main/__tests__/scheduler-archive-completed-prd.test.cjs

@@ -1,102 +0,0 @@
-/**
- * scheduler-archive-completed-prd.test.cjs — unit tests for archiveCompletedPrd
- * (PRD 812 dormant-default-session-review-nits recurrence fix): a job's PRD
- * `.md` must move from its `prds/` dir into the SIBLING `prds-archived/` dir
- * the moment its job transitions to `completed`, so a re-fired scheduler
- * tick can never pick the same finished slug back up.
- *
- * 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-archive-completed-prd.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 { archiveCompletedPrd, prdDirForCwd } = require('../scheduler.cjs');
-
-const tmpDirs = [];
-
-function makeFixtureCwd() {
-  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-archive-prd-'));
-  tmpDirs.push(cwd);
-  return cwd;
-}
-
-afterEach(() => {
-  while (tmpDirs.length) {
-    const dir = tmpDirs.pop();
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('archiveCompletedPrd moves the .md from prds/ into sibling prds-archived/', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-archive-on-completed';
-  const prdsDir = prdDirForCwd(cwd);
-  fs.mkdirSync(prdsDir, { recursive: true });
-  const src = path.join(prdsDir, `${slug}.md`);
-  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
-
-  await archiveCompletedPrd(slug, cwd);
-
-  expect(fs.existsSync(src)).toBe(false);
-  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
-  expect(fs.existsSync(archivedPath)).toBe(true);
-  expect(fs.readFileSync(archivedPath, 'utf8')).toBe('# Goal\n\ntest\n');
-});
-
-test('a job left in needs_review never has its PRD archived (the .md stays in prds/)', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-no-archive-on-needs-review';
-  const prdsDir = prdDirForCwd(cwd);
-  fs.mkdirSync(prdsDir, { recursive: true });
-  const src = path.join(prdsDir, `${slug}.md`);
-  fs.writeFileSync(src, '# Goal\n\ntest\n', 'utf8');
-
-  // scheduler.cjs only calls archiveCompletedPrd from status==='completed'
-  // transition sites — a needs_review (or failed/running) transition never
-  // invokes it, so the source file is untouched.
-
-  expect(fs.existsSync(src)).toBe(true);
-  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
-  expect(fs.existsSync(archivedPath)).toBe(false);
-});
-
-test('archiveCompletedPrd is a silent no-op when the source .md is missing (ENOENT)', async () => {
-  const cwd = makeFixtureCwd();
-  const slug = 'test-archive-enoent-noop';
-  const prdsDir = prdDirForCwd(cwd);
-  fs.mkdirSync(prdsDir, { recursive: true });
-
-  await expect(archiveCompletedPrd(slug, cwd)).resolves.toBeUndefined();
-
-  const archivedPath = path.join(prdsDir, '..', 'prds-archived', `${slug}.md`);
-  expect(fs.existsSync(archivedPath)).toBe(false);
-});
-
-test('archiveCompletedPrd refuses a slug that would resolve outside the PRD dir', async () => {
-  const cwd = makeFixtureCwd();
-  const prdsDir = prdDirForCwd(cwd);
-  fs.mkdirSync(prdsDir, { recursive: true });
-
-  // A slug crafted to escape prdsDir via '..' segments (SLUG_RE normally
-  // blocks this at the IPC boundary; archiveCompletedPrd itself must still
-  // refuse it as defense-in-depth, matching schedule:clear-queue's check).
-  const outsideDir = path.join(prdsDir, '..');
-  const escapeSlug = '../escaped-outside';
-  const outsideTarget = path.join(outsideDir, 'escaped-outside.md');
-  fs.writeFileSync(outsideTarget, 'should never be touched', 'utf8');
-
-  await expect(archiveCompletedPrd(escapeSlug, cwd)).resolves.toBeUndefined();
-
-  // Untouched in place — containment check refused before any rename.
-  expect(fs.existsSync(outsideTarget)).toBe(true);
-  expect(fs.readFileSync(outsideTarget, 'utf8')).toBe('should never be touched');
-  const archivedPath = path.join(prdsDir, '..', 'prds-archived', 'escaped-outside.md');
-  expect(fs.existsSync(archivedPath)).toBe(false);
-});