claude-code-session-manager 0.37.1 → 0.38.0

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

@@ -1,40 +1,48 @@
 /**
  * prdCreate.test.cjs — unit tests for the create-PRD body builder (PRD 549,
- * gh-issue-6). Pure-function tests only; the HTTP route + auth/cwd-boundary
- * behavior is covered by adminServer.test.cjs.
+ * gh-issue-6) and, since PRD 689, its registerAdminRoute create-prd HTTP
+ * route (moved verbatim out of the former standalone admin HTTP server
+ * module's handleRequest).
  *
- * Run: timeout 120 node --test src/main/__tests__/prdCreate.test.cjs
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdCreate.test.cjs
  */
 
 'use strict';
 
-const { test } = require('node:test');
-const assert = require('node:assert/strict');
+import { test, expect } from 'vitest';
 const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const http = require('node:http');
 const {
   deriveSlugFromTitle,
   buildPrdBody,
   readStandards,
+  STANDARDS_PATH,
   PRD_CREATE_SLUG_RE,
+  registerAdminRoute,
 } = require('../lib/prdCreate.cjs');
+const { createAdminHttp } = require('../lib/localAdminHttp.cjs');
+const config = require('../config.cjs');
+const prdParser = require('../scheduler/prdParser.cjs');
 
 test('deriveSlugFromTitle lowercases, kebab-cases, and strips non-alnum runs', () => {
-  assert.strictEqual(deriveSlugFromTitle('Add Foo Bar!! Baz'), 'add-foo-bar-baz');
-  assert.strictEqual(deriveSlugFromTitle('  leading/trailing  '), 'leading-trailing');
+  expect(deriveSlugFromTitle('Add Foo Bar!! Baz')).toBe('add-foo-bar-baz');
+  expect(deriveSlugFromTitle('  leading/trailing  ')).toBe('leading-trailing');
 });
 
 test('deriveSlugFromTitle output always satisfies PRD_CREATE_SLUG_RE', () => {
   const slug = deriveSlugFromTitle('Some Title 123');
-  assert.ok(PRD_CREATE_SLUG_RE.test(slug));
+  expect(PRD_CREATE_SLUG_RE.test(slug)).toBeTruthy();
 });
 
 test('readStandards reads the real standards.md and returns non-empty text', async () => {
   const text = await readStandards();
-  assert.ok(text.includes('Execution discipline'));
+  expect(text.includes('Execution discipline')).toBeTruthy();
 });
 
 test('buildPrdBody emits required frontmatter keys and body sections in order', async () => {
-  const standards = await readStandards();
   const body = buildPrdBody({
     title: 'Do the thing',
     cwd: '~/Projects/session-manager',
@@ -43,40 +51,272 @@ test('buildPrdBody emits required frontmatter keys and body sections in order',
     acceptanceCriteria: ['thing exists', 'tests pass'],
     implementationNotes: 'See file.cjs:10.',
     outOfScope: ['not this'],
-  }, standards);
+  });
 
-  assert.ok(body.startsWith('---\n'));
-  assert.match(body, /title: Do the thing/);
-  assert.match(body, /cwd: ~\/Projects\/session-manager/);
-  assert.match(body, /estimateMinutes: 15/);
+  expect(body.startsWith('---\n')).toBeTruthy();
+  expect(body).toMatch(/title: Do the thing/);
+  expect(body).toMatch(/cwd: ~\/Projects\/session-manager/);
+  expect(body).toMatch(/estimateMinutes: 15/);
 
   const goalIdx = body.indexOf('# Goal');
   const acIdx = body.indexOf('# Acceptance criteria');
   const implIdx = body.indexOf('# Implementation notes');
   const oosIdx = body.indexOf('# Out of scope');
   const standardsIdx = body.indexOf('## Engineering standards');
-  assert.ok(goalIdx > 0 && goalIdx < acIdx && acIdx < implIdx && implIdx < oosIdx && oosIdx < standardsIdx,
-    'sections must appear in Goal -> AC -> Implementation notes -> Out of scope -> Engineering standards order');
+  // sections must appear in Goal -> AC -> Implementation notes -> Out of scope -> Engineering standards order
+  expect(goalIdx > 0 && goalIdx < acIdx && acIdx < implIdx && implIdx < oosIdx && oosIdx < standardsIdx).toBeTruthy();
 
-  assert.match(body, /- \[ \] thing exists/);
-  assert.match(body, /- \[ \] tests pass/);
-  assert.match(body, /- not this/);
-  assert.ok(body.includes('Execution discipline'), 'must inline the standards.md content verbatim');
+  expect(body).toMatch(/- \[ \] thing exists/);
+  expect(body).toMatch(/- \[ \] tests pass/);
+  expect(body).toMatch(/- not this/);
+  // must point at STANDARDS_PATH rather than inline the standards.md content
+  expect(body.includes(STANDARDS_PATH)).toBeTruthy();
+  expect(body).toMatch(/Before writing any code, read/);
+  // the pointer block mentions "Execution discipline" by name, but must not
+  // inline the full standards.md prose (e.g. its Performance-section rules)
+  expect(body.includes('Lay out hot data contiguously')).toBeFalsy();
 });
 
 test('buildPrdBody omits parallelGroup frontmatter key when not supplied', () => {
   const body = buildPrdBody({
     title: 't', cwd: '~/x', estimateMinutes: 5, goal: 'g',
     acceptanceCriteria: ['a'], implementationNotes: 'n',
-  }, 'standards text');
-  assert.ok(!/parallelGroup:/.test(body));
+  });
+  expect(!/parallelGroup:/.test(body)).toBeTruthy();
 });
 
 test('readStandards result is byte-identical to the on-disk file (single source of truth)', async () => {
-  const path = require('node:path');
   const onDisk = fs.readFileSync(
     path.join(__dirname, '..', '..', '..', 'plugins', 'session-manager-dev', 'skills', 'develop', 'standards.md'),
     'utf8',
   );
-  assert.strictEqual(await readStandards(), onDisk);
+  expect(await readStandards()).toBe(onDisk);
+});
+
+// ──────────────────────────────────────────── create-prd admin route
+
+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();
+  });
+}
+
+// config.cjs's validateWrite only allows writes under a registered non-home
+// allowedRoot's `.claude/` subtree (mirrors the real ROOT layout, which is
+// $HOME/.claude/session-manager/...) — so the temp prdsDir must live under
+// `<root>/.claude/...`, not directly under the temp root itself.
+async function mkTmpPrdsDir() {
+  const root = await fsp.mkdtemp(path.join(os.tmpdir(), 'sm-admin-create-prd-'));
+  config.addAllowedRoot(root);
+  const prdsDir = path.join(root, '.claude', 'prds');
+  await fsp.mkdir(prdsDir, { recursive: true });
+  return prdsDir;
+}
+
+// Mirrors scheduler.cjs's real `remote.allocateParallelGroup` / `remote.writePrd`
+// (same underlying prdParser.allocateParallelGroup + config.writeTextAtomic
+// calls) but pointed at a throwaway temp dir instead of the user's real
+// scheduled-plans/prds — so these tests never touch $HOME/.claude.
+function makeFakeRemoteWithPrdsDir(prdsDir) {
+  return {
+    async allocateParallelGroup() {
+      return prdParser.allocateParallelGroup(prdsDir);
+    },
+    async readPrd(slug) {
+      try {
+        const text = await fsp.readFile(path.join(prdsDir, `${slug}.md`), 'utf8');
+        return { ok: true, text };
+      } catch (e) {
+        return { ok: false, error: e?.message };
+      }
+    },
+    async writePrd(slug, body) {
+      try {
+        const filePath = path.join(prdsDir, `${slug}.md`);
+        await config.writeTextAtomic(filePath, body);
+        return { ok: true };
+      } catch (e) {
+        return { ok: false, error: e?.message };
+      }
+    },
+  };
+}
+
+function validCreateBody(overrides = {}) {
+  return {
+    title: 'Add widget frobnication',
+    cwd: os.homedir(),
+    estimateMinutes: 15,
+    goal: 'Add frobnication to the widget subsystem.',
+    acceptanceCriteria: ['widget frobnicates on click', 'timeout 300 npm run typecheck passes'],
+    implementationNotes: 'See src/widget.cjs:10.',
+    outOfScope: ['not touching gadgets'],
+    ...overrides,
+  };
+}
+
+async function startWithRemote(remote) {
+  const admin = createAdminHttp();
+  registerAdminRoute(admin, remote);
+  const { port, token } = await admin.start();
+  return { admin, port, token };
+}
+
+test('POST /admin/scheduler/create-prd without token returns 401', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', body: validCreateBody(),
+    });
+    expect(res.status).toBe(401);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd with a valid payload writes a file with frontmatter + standards appended, returns {nn, filename, status}', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token, body: validCreateBody(),
+    });
+    expect(res.status).toBe(200);
+    expect(res.json.status).toBe('queued');
+    expect(typeof res.json.nn).toBe('number');
+    expect(res.json.filename).toMatch(/^\d+-add-widget-frobnication\.md$/);
+
+    const written = await fsp.readFile(path.join(prdsDir, res.json.filename), 'utf8');
+    expect(written).toMatch(/^---\n/);
+    expect(written).toMatch(/title: Add widget frobnication/);
+    expect(written).toMatch(/cwd: .+/);
+    expect(written).toMatch(/estimateMinutes: 15/);
+    expect(written).toMatch(/# Goal/);
+    expect(written).toMatch(/# Acceptance criteria/);
+    expect(written).toMatch(/- \[ \] widget frobnicates on click/);
+    expect(written).toMatch(/# Implementation notes/);
+    expect(written).toMatch(/# Out of scope/);
+    expect(written).toMatch(/## Engineering standards/);
+    // must point at STANDARDS_PATH rather than inline standards.md
+    expect(written.includes(STANDARDS_PATH)).toBeTruthy();
+    expect(written.includes('Lay out hot data contiguously')).toBeFalsy();
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd with malformed frontmatter (missing acceptanceCriteria) is rejected and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const body = validCreateBody();
+    delete body.acceptanceCriteria;
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token, body,
+    });
+    expect(res.status).toBe(400);
+    expect(res.json.ok).toBe(false);
+    const entries = await fsp.readdir(prdsDir);
+    expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd with cwd outside allowed roots is rejected and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ cwd: '/etc/passwd-adjacent-outside-home' }),
+    });
+    expect(res.status).toBe(400);
+    expect(res.json.ok).toBe(false);
+    const entries = await fsp.readdir(prdsDir);
+    expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd rejects a title containing a newline (frontmatter-injection guard) and writes no file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ title: 'Legit title\n---\nEvil: injected' }),
+    });
+    expect(res.status).toBe(400);
+    expect(res.json.ok).toBe(false);
+    const entries = await fsp.readdir(prdsDir);
+    expect(entries.filter((f) => f.endsWith('.md')).length).toBe(0);
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd with an explicit parallelGroup+slug that already exists on disk returns 409 and does not clobber the file', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    await fsp.writeFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'ORIGINAL CONTENT\n');
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ slug: 'my-explicit-slug', parallelGroup: 777 }),
+    });
+    expect(res.status).toBe(409);
+    expect(res.json.ok).toBe(false);
+    const stillThere = await fsp.readFile(path.join(prdsDir, '777-my-explicit-slug.md'), 'utf8');
+    // existing PRD file must not be overwritten
+    expect(stillThere).toBe('ORIGINAL CONTENT\n');
+  } finally {
+    await admin.stop();
+  }
+});
+
+test('POST /admin/scheduler/create-prd honors an explicit slug + parallelGroup instead of deriving/allocating', async () => {
+  const prdsDir = await mkTmpPrdsDir();
+  const remote = makeFakeRemoteWithPrdsDir(prdsDir);
+  const { admin, port, token } = await startWithRemote(remote);
+  try {
+    const res = await request(port, {
+      method: 'POST', path: '/admin/scheduler/create-prd', token,
+      body: validCreateBody({ slug: 'my-explicit-slug', parallelGroup: 777 }),
+    });
+    expect(res.status).toBe(200);
+    expect(res.json.nn).toBe(777);
+    expect(res.json.filename).toBe('777-my-explicit-slug.md');
+    expect(fs.existsSync(path.join(prdsDir, '777-my-explicit-slug.md'))).toBeTruthy();
+  } finally {
+    await admin.stop();
+  }
 });

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

@@ -0,0 +1,150 @@
+/**
+ * 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 }));
+    },
+    async resetJob(slug) {
+      const job = jobs.find((j) => j.slug === slug);
+      if (!job) return { ok: false, error: 'not found' };
+      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) {
+  const admin = createAdminHttp();
+  registerAdminRoutes(admin, remote);
+  const { port, token } = await admin.start();
+  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 slug flips job to pending and clears run fields', async () => {
+  const job = {
+    slug: '10-foo',
+    title: 'Foo',
+    status: 'completed',
+    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();
+  }
+});

package/src/main/__tests__/scheduler-boot-orphans.test.cjs

@@ -0,0 +1,172 @@
+/**
+ * scheduler-boot-orphans.test.cjs — boot-time reconciliation of 'running' jobs
+ * left behind by an app crash/restart (PRD 686: consolidated in from the
+ * external watchdog's reconcileQueueOffline(), which is now deleted from
+ * scripts/lib/watchdogHelpers.cjs).
+ *
+ * Covers the two behaviors most likely to drift in the move:
+ *   - a still-alive orphaned pid must be DEFERRED, never classified from its
+ *     (possibly still-being-written) log in the same pass (partitionBootOrphans)
+ *   - the ORPHAN_REQUEUE_CAP re-queue/exhaustion boundary (applyOrphanOutcome)
+ *
+ * Run: timeout 120 node --test src/main/__tests__/scheduler-boot-orphans.test.cjs
+ */
+
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const {
+  partitionBootOrphans,
+  applyOrphanOutcome,
+  feedbackSweepDue,
+  FEEDBACK_SWEEP_TICK_INTERVAL,
+  sweepFeedback,
+} = require('../scheduler.cjs');
+const { ORPHAN_REQUEUE_CAP } = require('../lib/reaperHelpers.cjs');
+
+test('partitionBootOrphans defers a running job whose pid is still alive', () => {
+  const jobs = [
+    { slug: 'alive-orphan', status: 'running', runtime: { pid: 111 } },
+    { slug: 'dead-orphan', status: 'running', runtime: { pid: 222 } },
+    { slug: 'no-pid-orphan', status: 'running', runtime: {} },
+    { slug: 'not-running', status: 'pending' },
+  ];
+  const isAlive = (pid) => pid === 111;
+
+  const { immediate, deferred } = partitionBootOrphans(jobs, isAlive);
+
+  assert.deepEqual(deferred, ['alive-orphan']);
+  assert.deepEqual(immediate.sort(), ['dead-orphan', 'no-pid-orphan']);
+});
+
+test('partitionBootOrphans ignores non-running jobs entirely', () => {
+  const jobs = [
+    { slug: 'a', status: 'completed', runtime: { pid: 1 } },
+    { slug: 'b', status: 'failed', runtime: { pid: 2 } },
+  ];
+  const { immediate, deferred } = partitionBootOrphans(jobs, () => true);
+  assert.deepEqual(immediate, []);
+  assert.deepEqual(deferred, []);
+});
+
+test('applyOrphanOutcome: success finalizes to completed, clears runtime', () => {
+  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, exitCode: null };
+  applyOrphanOutcome(job, 'success');
+  assert.equal(job.status, 'completed');
+  assert.equal(job.exitCode, 0);
+  assert.equal(job.error, null);
+  assert.ok(job.finishedAt);
+  assert.equal(job.runtime, undefined);
+});
+
+test('applyOrphanOutcome: failed finalizes to failed with orphan note', () => {
+  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, exitCode: null };
+  applyOrphanOutcome(job, 'failed', ' (orphan pid=1: killed)');
+  assert.equal(job.status, 'failed');
+  assert.equal(job.exitCode, 1);
+  assert.match(job.error, /orphaned: app restarted while running \(orphan pid=1: killed\)/);
+  assert.equal(job.runtime, undefined);
+});
+
+test('applyOrphanOutcome: no_result re-queues to pending under the cap and increments orphanRetries', () => {
+  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, orphanRetries: 0 };
+  applyOrphanOutcome(job, 'no_result');
+  assert.equal(job.status, 'pending');
+  assert.equal(job.orphanRetries, 1);
+  assert.match(job.error, /re-queued \(attempt 1/);
+  assert.equal(job.runtime, undefined);
+});
+
+test('applyOrphanOutcome: no_result at the cap fails terminally instead of re-queuing again', () => {
+  const job = { slug: 's', status: 'running', runtime: { pid: 1 }, orphanRetries: ORPHAN_REQUEUE_CAP };
+  applyOrphanOutcome(job, 'unknown');
+  assert.equal(job.status, 'failed');
+  assert.match(job.error, new RegExp(`exhausted ${ORPHAN_REQUEUE_CAP} re-queue attempts`));
+  assert.equal(job.runtime, undefined);
+});
+
+// ── feedback sweep moved into the 60s poll tick (PRD 686) ───────────────────
+
+test('feedbackSweepDue gates on the tick interval, not every tick', () => {
+  for (let i = 1; i < FEEDBACK_SWEEP_TICK_INTERVAL; i++) {
+    assert.equal(feedbackSweepDue(i), false, `tick ${i} should not be due yet`);
+  }
+  assert.equal(feedbackSweepDue(FEEDBACK_SWEEP_TICK_INTERVAL), true);
+  assert.equal(feedbackSweepDue(FEEDBACK_SWEEP_TICK_INTERVAL + 1), true);
+});
+
+test('scheduler.cjs reuses watchdogHelpers.sweep verbatim (no forked copy)', () => {
+  const { sweep } = require('../../../scripts/lib/watchdogHelpers.cjs');
+  assert.equal(sweepFeedback, sweep, 'scheduler.cjs must import the same sweep function, not reimplement it');
+});
+
+function makeTmpDir() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'sched-boot-sweep-'));
+}
+
+function makeQueue(base) {
+  const queuePath = path.join(base, 'queue.json');
+  fs.writeFileSync(queuePath, JSON.stringify({ version: 1, jobs: [], paused: null }, null, 2));
+  return queuePath;
+}
+
+const FAKE_SKILL = '---\nname: process-feedback\ndescription: x\n---\n\n# process-feedback\n\nbody\n';
+const FAKE_STANDARDS = '# Engineering standards\n\nbody\n';
+
+test('the poll-tick sweep call emits a PRD for an active project with open feedback, and skips one outside the 90-min window', () => {
+  const base = makeTmpDir();
+  try {
+    // Active project (10 min ago) with open feedback → should emit.
+    const activeProj = path.join(base, 'active-proj');
+    fs.mkdirSync(path.join(activeProj, 'session-manager-operations', 'feedback'), { recursive: true });
+    fs.writeFileSync(path.join(activeProj, 'session-manager-operations', 'feedback', '2026-01-01-item.md'), '# Item\n');
+
+    // Stale project (120 min ago, outside the 90-min window) with open feedback → should NOT be scanned at all.
+    const staleProj = path.join(base, 'stale-proj');
+    fs.mkdirSync(path.join(staleProj, 'session-manager-operations', 'feedback'), { recursive: true });
+    fs.writeFileSync(path.join(staleProj, 'session-manager-operations', 'feedback', '2026-01-01-item.md'), '# Item\n');
+
+    // Active project with no open feedback → scanned but not emitted.
+    const noFeedbackProj = path.join(base, 'no-feedback-proj');
+    fs.mkdirSync(noFeedbackProj, { recursive: true });
+
+    const projectsDir = path.join(base, 'projects');
+    const recent = new Date(Date.now() - 10 * 60 * 1000);
+    const stale = new Date(Date.now() - 120 * 60 * 1000);
+    for (const [slug, cwd, mtime] of [
+      ['slug-active', activeProj, recent],
+      ['slug-stale', staleProj, stale],
+      ['slug-no-feedback', noFeedbackProj, recent],
+    ]) {
+      const projDir = path.join(projectsDir, slug);
+      fs.mkdirSync(projDir, { recursive: true });
+      const fp = path.join(projDir, 'a.jsonl');
+      fs.writeFileSync(fp, JSON.stringify({ cwd }) + '\n');
+      fs.utimesSync(fp, mtime, mtime);
+    }
+
+    const prdsDir = path.join(base, 'prds');
+    fs.mkdirSync(prdsDir);
+    const queuePath = makeQueue(base);
+    const skillPath = path.join(base, 'SKILL.md');
+    const standardsPath = path.join(base, 'standards.md');
+    fs.writeFileSync(skillPath, FAKE_SKILL);
+    fs.writeFileSync(standardsPath, FAKE_STANDARDS);
+
+    const result = sweepFeedback({ projectsDir, prdsDir, queuePath, skillPath, standardsPath });
+
+    assert.equal(result.scanned, 2, 'only the two in-window projects should be scanned');
+    assert.equal(result.emitted, 1, 'only the active project with open feedback should get a PRD');
+
+    const emittedFiles = fs.readdirSync(prdsDir).filter((f) => f.endsWith('.md'));
+    assert.equal(emittedFiles.length, 1);
+    assert.match(emittedFiles[0], /feedback-active-proj\.md$/);
+  } finally {
+    fs.rmSync(base, { recursive: true, force: true });
+  }
+});