claude-code-session-manager 0.95.0 → 0.96.0

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

@@ -2,7 +2,11 @@
 
 import { test } from 'vitest';
 const assert = require('node:assert/strict');
-const { parseClusters } = require('../memoryAggregate.cjs');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { parseClusters, aggregate, clustersCachePath } = require('../memoryAggregate.cjs');
+const { opsPath } = require('../lib/opsOwnership.cjs');
 
 test('parseClusters maps well-formed JSON to the result shape and routes unlisted slugs to orphans', () => {
   const slugs = ['scheduler_concurrency_memory', 'no_schedule_self_e2e', 'unrelated_note'];
@@ -68,3 +72,38 @@ test('parseClusters drops link endpoints and members that reference nonexistent
   assert.deepEqual(result.clusters[0].links, []);
   assert.deepEqual(result.orphans, []);
 });
+
+test('clustersCachePath resolves under <cwd>/session-manager-operations/memory-clusters/clusters.json, one file per project', () => {
+  const cwd = '/home/u/Projects/demo';
+  assert.equal(clustersCachePath(cwd), opsPath(cwd, 'memory-clusters', 'clusters.json'));
+  assert.match(clustersCachePath(cwd), /\/session-manager-operations\/memory-clusters\/clusters\.json$/);
+});
+
+test('aggregate persists and reads back the per-project cache file at the new ops-owned location', async () => {
+  const cwd = fs.mkdtempSync(path.join(os.homedir(), '.sm-test-memory-clusters-'));
+  try {
+    const workspace = `test-ws-${Date.now()}`;
+
+    const written = await aggregate({ workspace, refresh: true, cwd });
+    assert.equal(written.cached, false);
+    assert.deepEqual(written.clusters, []);
+    assert.deepEqual(written.orphans, []);
+
+    const expectedPath = opsPath(cwd, 'memory-clusters', 'clusters.json');
+    assert.ok(fs.existsSync(expectedPath), `expected cache file at ${expectedPath}`);
+    assert.deepEqual(JSON.parse(fs.readFileSync(expectedPath, 'utf8')).workspace, workspace);
+
+    const read = await aggregate({ workspace, refresh: false, cwd });
+    assert.equal(read.cached, true);
+    assert.equal(read.workspace, workspace);
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('aggregate without a cwd skips the cache instead of throwing', async () => {
+  const workspace = `test-ws-nocwd-${Date.now()}`;
+  const result = await aggregate({ workspace, refresh: false });
+  assert.equal(result.cached, false);
+  assert.deepEqual(result.clusters, []);
+});

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

@@ -137,7 +137,7 @@ test('a realistic error with an absolute path and a prompt-like string never rea
   process.env.HOME = home;
   // Explicit opt-in: overrides the test-environment no-op guard so this
   // test's real telemetryClient call actually persists into an isolated dir.
-  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.config', 'session-manager');
+  process.env.SM_TELEMETRY_SPOOL = path.join(home, '.claude', 'session-manager');
 
   for (const p of ['../lib/telemetryClient.cjs', '../config.cjs', '../lib/telemetrySettings.cjs', '../lib/machineProfile.cjs']) {
     const resolved = require.resolve(p);

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

@@ -0,0 +1,71 @@
+/**
+ * planValidator.test.cjs — unit tests for hasDownstreamValidator (PRD 1408).
+ *
+ * Run: timeout 300 npx vitest run src/main/__tests__/planValidator.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { hasDownstreamValidator } = require('../lib/planValidator.cjs');
+
+test('true when a pending validator row depends on the job', () => {
+  const job = { slug: '111-alpha' };
+  const jobs = [
+    job,
+    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['111-alpha'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(true);
+});
+
+test('true when the depending validator row is running', () => {
+  const job = { slug: '111-alpha' };
+  const jobs = [
+    job,
+    { slug: '999-validate', agentType: 'validator', status: 'running', dependsOn: ['111-alpha'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(true);
+});
+
+test('false when the job itself is a validator', () => {
+  const job = { slug: '999-validate', agentType: 'validator' };
+  const jobs = [
+    job,
+    { slug: '998-other-validate', agentType: 'validator', status: 'pending', dependsOn: ['999-validate'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(false);
+});
+
+test('false for null/undefined job or jobs', () => {
+  expect(hasDownstreamValidator(null, [{ slug: 'x' }])).toBe(false);
+  expect(hasDownstreamValidator(undefined, [{ slug: 'x' }])).toBe(false);
+  expect(hasDownstreamValidator({ slug: '111-alpha' }, null)).toBe(false);
+  expect(hasDownstreamValidator({ slug: '111-alpha' }, undefined)).toBe(false);
+});
+
+test('false when the validator row does not depend on this job', () => {
+  const job = { slug: '111-alpha' };
+  const jobs = [
+    job,
+    { slug: '999-validate', agentType: 'validator', status: 'pending', dependsOn: ['222-beta'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(false);
+});
+
+test('false when the depending row is a completed validator', () => {
+  const job = { slug: '111-alpha' };
+  const jobs = [
+    job,
+    { slug: '999-validate', agentType: 'validator', status: 'completed', dependsOn: ['111-alpha'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(false);
+});
+
+test('false when the depending row is not agentType validator', () => {
+  const job = { slug: '111-alpha' };
+  const jobs = [
+    job,
+    { slug: '999-other', agentType: 'dev-lead', status: 'pending', dependsOn: ['111-alpha'] },
+  ];
+  expect(hasDownstreamValidator(job, jobs)).toBe(false);
+});

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

@@ -74,7 +74,7 @@ test('buildPrdBody emits required frontmatter keys and body sections in order',
   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/);
+  expect(body).toMatch(/Your system prompt carries the ordered run contract/);
   // 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();
@@ -417,6 +417,8 @@ test('createPrd with a valid payload allocates a group, writes through remote.wr
   expect(result.ok).toBe(true);
   expect(typeof result.nn).toBe('number');
   expect(result.filename).toMatch(/^\d+-add-widget-frobnication\.md$/);
+  // PRD 1403: sizing warnings ride along in the success response, advisory only.
+  expect(Array.isArray(result.warnings)).toBe(true);
 
   const written = await fsp.readFile(path.join(prdsDir, result.filename), 'utf8');
   expect(written).toMatch(/^---\n/);

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

@@ -0,0 +1,106 @@
+/**
+ * prdSizing.test.cjs — unit tests for sizingWarnings (PRD 1403).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/prdSizing.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const { SIZING_LIMITS, sizingWarnings } = require('../lib/prdSizing.cjs');
+
+function compliantInput(overrides = {}) {
+  return {
+    estimateMinutes: 10,
+    acceptanceCriteria: ['widget frobnicates on click', 'unit test covers the frobnication path'],
+    goal: 'Add frobnication to the widget subsystem.',
+    implementationNotes: 'See src/widget.cjs:10.',
+    ...overrides,
+  };
+}
+
+test('compliant PRD yields no warnings', () => {
+  expect(sizingWarnings(compliantInput())).toEqual([]);
+});
+
+test('warns when estimateMinutes exceeds the limit', () => {
+  const warnings = sizingWarnings(compliantInput({ estimateMinutes: SIZING_LIMITS.estimateMinutes + 1 }));
+  expect(warnings.some((w) => /estimateMinutes/.test(w))).toBe(true);
+});
+
+test('does not warn when estimateMinutes is exactly the limit', () => {
+  const warnings = sizingWarnings(compliantInput({ estimateMinutes: SIZING_LIMITS.estimateMinutes }));
+  expect(warnings.some((w) => /estimateMinutes/.test(w))).toBe(false);
+});
+
+test('warns when acceptanceCriteria has more than the limit of lines', () => {
+  const acceptanceCriteria = Array.from({ length: SIZING_LIMITS.acLines + 1 }, (_, i) => `criterion ${i}`);
+  const warnings = sizingWarnings(compliantInput({ acceptanceCriteria }));
+  expect(warnings.some((w) => /acceptanceCriteria has/.test(w))).toBe(true);
+});
+
+test('does not warn when acceptanceCriteria has exactly the limit of lines', () => {
+  const acceptanceCriteria = Array.from({ length: SIZING_LIMITS.acLines }, (_, i) => `criterion ${i}`);
+  const warnings = sizingWarnings(compliantInput({ acceptanceCriteria }));
+  expect(warnings.some((w) => /acceptanceCriteria has/.test(w))).toBe(false);
+});
+
+test('warns when an AC line exceeds the per-line character limit', () => {
+  const longLine = 'x'.repeat(SIZING_LIMITS.acLineChars + 1);
+  const warnings = sizingWarnings(compliantInput({ acceptanceCriteria: [longLine] }));
+  expect(warnings.some((w) => /exceed \d+ characters/.test(w))).toBe(true);
+});
+
+test('does not warn when an AC line is exactly at the per-line character limit', () => {
+  const line = 'x'.repeat(SIZING_LIMITS.acLineChars);
+  const warnings = sizingWarnings(compliantInput({ acceptanceCriteria: [line] }));
+  expect(warnings.some((w) => /exceed \d+ characters/.test(w))).toBe(false);
+});
+
+test('warns on an open-ended search-and-fix AC line', () => {
+  const warnings = sizingWarnings(compliantInput({
+    acceptanceCriteria: ['grep e2e specs and update expectations to match the new sort order'],
+  }));
+  expect(warnings.some((w) => /open-ended search-and-fix/.test(w))).toBe(true);
+});
+
+test('does not warn on an AC line that merely mentions grep or update in isolation', () => {
+  const warnings = sizingWarnings(compliantInput({
+    acceptanceCriteria: ['grep confirms no leftover references to the old flag'],
+  }));
+  expect(warnings.some((w) => /open-ended search-and-fix/.test(w))).toBe(false);
+});
+
+test('warns on an open-ended search-and-fix AC line whose "then"/"update" half is a second sentence', () => {
+  const warnings = sizingWarnings(compliantInput({
+    acceptanceCriteria: ['Grep the repo for every usage of the old flag. Then update each call site.'],
+  }));
+  expect(warnings.some((w) => /open-ended search-and-fix/.test(w))).toBe(true);
+});
+
+test('warns on an AC line with two or more timeout commands', () => {
+  const warnings = sizingWarnings(compliantInput({
+    acceptanceCriteria: ['timeout 120 npm run typecheck && timeout 300 npm run test:unit both pass'],
+  }));
+  expect(warnings.some((w) => /two or more `timeout/.test(w))).toBe(true);
+});
+
+test('does not warn on an AC line with a single timeout command', () => {
+  const warnings = sizingWarnings(compliantInput({
+    acceptanceCriteria: ['timeout 120 npm run typecheck passes'],
+  }));
+  expect(warnings.some((w) => /two or more `timeout/.test(w))).toBe(false);
+});
+
+test('warns when goal + implementationNotes + joined AC exceeds the body character limit', () => {
+  const warnings = sizingWarnings(compliantInput({
+    goal: 'g'.repeat(SIZING_LIMITS.bodyChars + 1),
+  }));
+  expect(warnings.some((w) => /exceeding the \d+-character sizing limit/.test(w))).toBe(true);
+});
+
+test('does not warn when the combined body is exactly at the character limit', () => {
+  const goal = 'g'.repeat(SIZING_LIMITS.bodyChars);
+  const warnings = sizingWarnings({ estimateMinutes: 10, acceptanceCriteria: [], goal, implementationNotes: '' });
+  expect(warnings.some((w) => /exceeding the \d+-character sizing limit/.test(w))).toBe(false);
+});

package/src/main/__tests__/queue-starvation-dispatch-driver.test.cjs

@@ -216,6 +216,52 @@ test('rows held by a launch breaker / lease read blocked, not starved (per proje
   expect(byProject.map((v) => v.kind)).toEqual(['blocked']);
 });
 
+test('a starved queue forces its tick with bypassLoadGate:true — the CPU load gate must not freeze the last-resort dispatch', async () => {
+  // Regression for the 2026-09-23 freeze: 3 dispatchable jobs, 0 running,
+  // lastTickReason 'load-deferred' unbroken 07:00→13:06. The watchdog is the
+  // safety net for exactly that state, but it used to force its tick with
+  // bypassLoadGate:false, so a box loaded by ANOTHER process held the net's
+  // own tick behind the load gate and nothing ever ran. Spy the exported
+  // tickQueue seam (the call is routed via module.exports precisely so this
+  // is assertable without manufacturing real machine load, which
+  // SM_LOAD_GATE_PER_CORE clamps at 0.25 and can't force deterministically).
+  const cwd = '/tmp/sm-starve-bypass-project';
+  const jobs = [{ slug: 'bypass-a', cwd, status: 'pending', dependsOn: [] }];
+  const state = { jobs, paused: null, lastRunAt: new Date(NOW - 40 * 60_000).toISOString() };
+  const opts = { now: NOW, bootedAtMs: NOW - 3 * 60 * 60_000 };
+  const tickSpy = vi.spyOn(scheduler, 'tickQueue').mockResolvedValue({ fired: false, reason: 'drained' });
+  try {
+    const verdict = await scheduler.runQueueStarvationWatchdog(state, opts);
+    expect(verdict.kind).toBe('starved');
+    expect(tickSpy).toHaveBeenCalledTimes(1);
+    expect(tickSpy).toHaveBeenCalledWith({ bypassLoadGate: true });
+  } finally {
+    tickSpy.mockRestore();
+  }
+});
+
+test('the bypass is not unconditional — a queue with something already running never force-ticks at all', async () => {
+  // Guard against the bypass becoming an escape hatch: the watchdog only
+  // reaches its forced tick on a genuine 'starved' verdict (0 running). When
+  // a job is already running, classifyQueueStarvation returns null and no
+  // forced tick fires — so bypassLoadGate never even comes into play.
+  const cwd = '/tmp/sm-running-nobypass-project';
+  const jobs = [
+    { slug: 'run-a', cwd, status: 'running', dependsOn: [] },
+    { slug: 'pend-b', cwd, status: 'pending', dependsOn: [] },
+  ];
+  const state = { jobs, paused: null, lastRunAt: new Date(NOW - 40 * 60_000).toISOString() };
+  const opts = { now: NOW, bootedAtMs: NOW - 3 * 60 * 60_000 };
+  const tickSpy = vi.spyOn(scheduler, 'tickQueue').mockResolvedValue({ fired: false, reason: 'drained' });
+  try {
+    const verdict = await scheduler.runQueueStarvationWatchdog(state, opts);
+    expect(verdict).toBeNull();
+    expect(tickSpy).not.toHaveBeenCalled();
+  } finally {
+    tickSpy.mockRestore();
+  }
+});
+
 test('the watchdog latches: one forced tick / audit per starve episode, re-armed by threshold or running-count change', async () => {
   const cwd = '/tmp/sm-starve-latch-project';
   const jobs = [{ slug: 'latch-a', cwd, status: 'pending', dependsOn: [] }];

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

@@ -33,6 +33,7 @@ const path = require('node:path');
 let tmpHome;
 let originalHome;
 let scheduler;
+let bustCwdCache;
 
 beforeAll(() => {
   originalHome = process.env.HOME;
@@ -40,6 +41,7 @@ beforeAll(() => {
   process.env.HOME = tmpHome;
 
   scheduler = require('../scheduler.cjs');
+  ({ bustCwdCache } = require('../lib/queueStore.cjs'));
 
   if (!scheduler.PRDS_DIR.startsWith(tmpHome)) {
     throw new Error(`refusing to run: PRDS_DIR (${scheduler.PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
@@ -56,6 +58,14 @@ function registerActiveProject(cwd) {
   const slugDir = path.join(projectsDir, `fake-project-slug-${path.basename(cwd)}`);
   fs.mkdirSync(slugDir, { recursive: true });
   fs.writeFileSync(path.join(slugDir, 'transcript.jsonl'), JSON.stringify({ cwd }) + '\n');
+  // Each test registers a NEW project mid-file; without busting queueStore's
+  // stateCwds cache (CACHE_MS 120s), a reconcile() call from an EARLIER test
+  // in this file can leave a stale cwd list cached that this test's freshly
+  // registered project is invisible to — reconcile() then never discovers
+  // its PRD at all (confirmed: this is what made
+  // 'reconcile() still onboards a PRD written to the canonical Epic-scoped
+  // dir' intermittently fail under full-suite load, PRD 1414).
+  bustCwdCache();
 }
 
 function makeFixtureProject(prefix) {

package/src/main/__tests__/scheduler-looks-done.test.cjs

@@ -32,6 +32,23 @@ const { execFileSync } = require('node:child_process');
 
 const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'looks-done-test-'));
 process.env.HOME = tmpHome;
+// reverifyNeedsReview's own auto-fix pass (PRD 1414 root cause): a
+// needs_review row with autoFixAttempted:true is still RETRY-eligible
+// (selectAutoFixTargets) whenever autoFixOutcome is unset/'no-plan'/'error'
+// and autoFixRetries < 1 — exactly this file's PRD-1136 fixture. reverify
+// then calls spawnInvestigation(job, ...) FIRE-AND-FORGET (no `await`, only
+// `.catch()`), so it keeps running real disk/git I/O in the background after
+// reverifyNeedsReview() (and the test awaiting it) returns. Under
+// `npm run test:unit`'s full-suite load that background work sometimes had
+// enough real time to run before this file's own assertions/next test read
+// queue.json, and was observed re-discovering '30-example' as an unstamped
+// PRD and quarantining it out from under this test (confirmed via a captured
+// failure: 'quarantining unstamped PRD 30-example ... no createdVia
+// provenance'). This file's own tests only assert reverifyNeedsReview's
+// direct return value / queue mutations, never spawnInvestigation's, so
+// disable auto-fix the same way sibling scheduler test files already do
+// (e.g. scheduler-shard-quarantine.test.cjs).
+process.env.SM_AUTOFIX_DISABLE = '1';
 
 const { reverifyNeedsReview, computeLooksDone, applyNeedsReviewAutoResolve, findSatisfyingCommitOnMain } = require('../scheduler.cjs');
 const { resolveEpicPrdWriteDir } = require('../lib/prdLocations.cjs');
@@ -122,6 +139,29 @@ async function wait(ms) {
   await new Promise((r) => setTimeout(r, ms));
 }
 
+// Every test in this file shares ONE tmpHome (see the module-level mkdtempSync
+// above) and most call reverifyNeedsReview(), which scans EVERY project
+// registered under tmpHome/.claude/projects — not just the one this test just
+// wrote (queueStore.cjs's stateCwds unions allProjectCwds()+activeProjectCwds()
+// across the whole HOME). Without this cleanup, each later test's
+// reverifyNeedsReview() call re-processes every earlier test's already-settled
+// fixture row too (confirmed via full-suite stdout: the PRD-1136 test's own
+// reverifyNeedsReview() call was observed re-running auto-fix bookkeeping for
+// 171-example, a prior test's row), and each re-processed candidate costs 1+
+// real `git` subprocess calls (fetchAllRefs, committedInWindow, ...). That
+// backlog only grows as more tests run, so a later test's single
+// reverifyNeedsReview() call does correspondingly more child-process I/O — on
+// a loaded `npm run test:unit` worker pool this cumulative latency is what
+// occasionally pushes a later test toward vitest's 15s per-test budget
+// (vitest.config.ts documents the same class of load-timeout elsewhere),
+// while the file passes in ~10s alone with nothing to accumulate. Wiping the
+// registry after each test bounds every reverifyNeedsReview() call to just
+// that test's own row(s), removing the cross-test amplification.
+afterEach(() => {
+  fs.rmSync(path.join(tmpHome, '.claude', 'projects'), { recursive: true, force: true });
+  bustCwdCache();
+});
+
 test('failed + no result event (unverified-shaped) + later commit touching declared path → looksDone, transitions to needs_review', async () => {
   const projectCwd = path.join(tmpHome, 'proj-171');
   initRepo(projectCwd);

package/src/main/__tests__/scheduler-notify-originating-tab.test.cjs

@@ -260,3 +260,84 @@ test('PRD 985: a PRD missing entirely still routes via the job row\'s own epicId
   );
   expect(appendTranscriptTurn).toHaveBeenCalledWith(cwd, 'psess-985-from-queue-row', expect.anything());
 });
+
+// ─── PRD 1407: validator jobs stamp verdicts onto the authoring Epic ────────
+// A completed validator job's result text carries one `VALIDATION: <slug>
+// VERIFIED|REFUTED` line per PRD it checked. Each parsed verdict becomes its
+// own response event BEFORE the validator's own (still-unvalidated)
+// check-in, and the validator's check-in never enqueues a validation prompt
+// for itself.
+test('PRD 1407: a validator job with two sentinel lines appends two verdict events plus its own check-in, and never enqueues validation', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const appendTranscriptTurn = vi.fn(async () => {});
+  const enqueueValidation = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-validator-1' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+  const readResultFromLog = vi.fn(() => [
+    'VALIDATION: 111-alpha VERIFIED',
+    'VALIDATION: 222-beta REFUTED — missing coverage',
+  ].join('\n'));
+
+  await notifyOriginatingTab(
+    { slug: '1407-validator-run', status: 'completed', cwd: '/some/cwd', agentType: 'validator' },
+    {
+      parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent,
+      appendTranscriptTurn, readResultFromLog, enqueueValidation,
+    },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledTimes(3);
+  expect(appendResponseEvent).toHaveBeenNthCalledWith(
+    1, '/some/cwd', 'psess-validator-1', expect.stringContaining('111-alpha'),
+    { prdSlug: '111-alpha', outcome: 'completed', validation: 'verified' },
+  );
+  expect(appendResponseEvent).toHaveBeenNthCalledWith(
+    2, '/some/cwd', 'psess-validator-1', expect.stringContaining('222-beta'),
+    { prdSlug: '222-beta', outcome: 'completed', validation: 'refuted' },
+  );
+  expect(appendResponseEvent).toHaveBeenNthCalledWith(
+    3, '/some/cwd', 'psess-validator-1', expect.stringContaining('1407-validator-run'),
+    { prdSlug: '1407-validator-run', outcome: 'completed', validation: 'unvalidated' },
+  );
+  expect(enqueueValidation).not.toHaveBeenCalled();
+});
+
+// ─── PRD 1408: a downstream validator suppresses the per-PRD validation ask ─
+test('skips enqueueValidation when loadJobs reports a pending validator row depending on this job', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+  const loadJobs = vi.fn(async () => ([
+    { slug: '1408-work-item' },
+    { slug: '1408-validate', agentType: 'validator', status: 'pending', dependsOn: ['1408-work-item'] },
+  ]));
+
+  await notifyOriginatingTab(
+    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
+  expect(loadJobs).toHaveBeenCalledTimes(1);
+  expect(enqueueValidation).not.toHaveBeenCalled();
+});
+
+test('still enqueues validation when loadJobs reports no downstream validator', async () => {
+  const sendPrompt = vi.fn();
+  const appendResponseEvent = vi.fn(async () => true);
+  const enqueueValidation = vi.fn();
+  const parsePrdRaw = vi.fn(async () => ({ sourcePromptId: 'psess-1' }));
+  const loadSessions = vi.fn(async () => ({ tabs: [] }));
+  const loadJobs = vi.fn(async () => ([{ slug: '1408-work-item' }]));
+
+  await notifyOriginatingTab(
+    { slug: '1408-work-item', status: 'completed', cwd: '/some/cwd' },
+    { parsePrdRaw, loadSessions, sendPrompt, appendResponseEvent, enqueueValidation, loadJobs },
+  );
+
+  expect(appendResponseEvent).toHaveBeenCalledTimes(1);
+  expect(enqueueValidation).toHaveBeenCalledTimes(1);
+});

package/src/main/__tests__/scheduler-shard-quarantine.test.cjs

@@ -90,11 +90,16 @@ test('tickQueue dispatches the healthy project while the torn project is skipped
   const snaps = fs.readdirSync(path.dirname(torn.queueFile)).filter((f) => f.startsWith('queue.json.corrupt-'));
   expect(snaps).toHaveLength(1);
 
+  // 60s, not 20s: under npm run test:unit's full-suite parallel-worker load
+  // this occasionally needed more than 20s for the real child-process
+  // dispatch to land (PRD 1414 — confirmed flaky only inside the full suite,
+  // never in isolation or under synthetic single-file CPU load). The
+  // surrounding vitest test timeout below (120s) already budgets for this.
   await new Promise((resolve, reject) => {
     const t0 = Date.now();
     const poll = () => {
       if (fs.existsSync(path.join(good.cwd, 'ran-here.marker'))) return resolve();
-      if (Date.now() - t0 > 20_000) return reject(new Error('healthy project never dispatched'));
+      if (Date.now() - t0 > 60_000) return reject(new Error('healthy project never dispatched'));
       setTimeout(poll, 100);
     };
     poll();

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

@@ -0,0 +1,110 @@
+/**
+ * schedulerStateSidecarRestore.test.cjs — covers PRD 1392: scheduler-state.json
+ * previously left lastPollOk, lastFailureKind, backoffNextAt, cachedUtilization and
+ * cachedBindingWindowName memory-only, so a fresh boot showed misleading footer/KPI
+ * placeholders (a healthy poller reading "failed", a still-rate-limited state
+ * un-showable, utilization stuck at "—") until the next post-boot billing poll
+ * overwrote them. Proves loadSchedulerState() restores all five from disk instead of
+ * leaving the hardcoded defaults (false / null / null / null / null) in place.
+ *
+ * scheduler.cjs is a plain CJS require (like rateLimitPollerStreak.test.cjs's), so its
+ * module-level `let`s are a singleton for this test file's process — the first test
+ * below captures the pre-load snapshot itself (the hardcoded defaults) rather than
+ * assuming a fresh module per test, so the proof doesn't depend on test ordering.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/schedulerStateSidecarRestore.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeEach } from 'vitest';
+import fs from 'node:fs';
+import path from 'node:path';
+
+const { loadSchedulerState, persistSchedulerState, getSchedulerStateSnapshot } = require('../scheduler.cjs');
+const schedulerPaths = require('../lib/schedulerPaths.cjs');
+
+function writeSidecar(data) {
+  fs.mkdirSync(path.dirname(schedulerPaths.schedulerStatePath()), { recursive: true });
+  fs.writeFileSync(schedulerPaths.schedulerStatePath(), JSON.stringify(data));
+}
+
+beforeEach(() => {
+  try { fs.unlinkSync(schedulerPaths.schedulerStatePath()); } catch { /* no sidecar yet */ }
+});
+
+test('loadSchedulerState restores lastPollOk/lastFailureKind/backoffNextAt/cachedUtilization/cachedBindingWindowName from the sidecar, not the hardcoded defaults', () => {
+  // Before a restore, the module starts (or was left, by whatever ran before this test
+  // in-process) at whatever it was — capture it so the assertion below is a genuine
+  // "changed to match the file" proof, not an assumption about fresh-module defaults.
+  const before = getSchedulerStateSnapshot();
+
+  const written = {
+    version: 1,
+    lastPollOk: true,
+    lastFailureKind: 'meter_rate_limited',
+    backoffNextAt: 1_726_000_000_000,
+    cachedUtilization: 42,
+    cachedBindingWindowName: 'five_hour',
+  };
+  writeSidecar(written);
+
+  // Simulate a restart: a fresh process starts from the hardcoded module defaults
+  // (false / null / null / null / null) until loadSchedulerState() runs.
+  loadSchedulerState();
+
+  const after = getSchedulerStateSnapshot();
+  expect(after).toEqual({
+    lastPollOk: true,
+    lastFailureKind: 'meter_rate_limited',
+    backoffNextAt: 1_726_000_000_000,
+    cachedUtilization: 42,
+    cachedBindingWindowName: 'five_hour',
+  });
+  // The restore must have actually changed something relative to the pre-load
+  // snapshot — proves this run exercised the restore path, not a no-op.
+  expect(after).not.toEqual(before);
+});
+
+test('persistSchedulerState writes the same five fields back out, round-tripping through the sidecar', () => {
+  writeSidecar({
+    version: 1,
+    lastPollOk: false,
+    lastFailureKind: 'auth',
+    backoffNextAt: 1_726_100_000_000,
+    cachedUtilization: 87.5,
+    cachedBindingWindowName: 'weekly_all',
+  });
+  loadSchedulerState();
+
+  persistSchedulerState();
+
+  const onDisk = JSON.parse(fs.readFileSync(schedulerPaths.schedulerStatePath(), 'utf8'));
+  expect(onDisk.lastPollOk).toBe(false);
+  expect(onDisk.lastFailureKind).toBe('auth');
+  expect(onDisk.backoffNextAt).toBe(1_726_100_000_000);
+  expect(onDisk.cachedUtilization).toBe(87.5);
+  expect(onDisk.cachedBindingWindowName).toBe('weekly_all');
+});
+
+test('loadSchedulerState against a sidecar missing the five fields leaves the in-memory values unchanged (pre-PRD-1392 file)', () => {
+  // Establish a known non-default in-memory state first.
+  writeSidecar({
+    version: 1,
+    lastPollOk: true,
+    lastFailureKind: 'transient',
+    backoffNextAt: 5000,
+    cachedUtilization: 10,
+    cachedBindingWindowName: 'seven_day',
+  });
+  loadSchedulerState();
+  const established = getSchedulerStateSnapshot();
+
+  // A sidecar written before PRD 1392 (or first-boot with only the older fields) has
+  // none of the five new keys — loadSchedulerState's per-field `typeof` guards must
+  // leave whatever was already in memory alone, not stomp it back to a hardcoded default.
+  writeSidecar({ version: 1, lastPollAt: 123 });
+  loadSchedulerState();
+
+  expect(getSchedulerStateSnapshot()).toEqual(established);
+});

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

@@ -54,7 +54,7 @@ function silentLogger() {
   return { log: () => {}, warn: () => {} };
 }
 
-const ALL_PERSONAS = ['architect', 'dev-lead', 'project-home-builder'];
+const ALL_PERSONAS = ['architect', 'dev-lead', 'project-home-builder', 'validator'];
 
 test('fresh seed writes every persona file', async () => {
   await seedAgentPersonas({ logger: silentLogger() });
@@ -156,6 +156,24 @@ test('the bundled project-home-builder persona contains no session-manager-repo
   }
 });
 
+test('seeded dev-lead persona pins an executor-tier model', () => {
+  const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
+  const raw = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', 'dev-lead.md'), 'utf8');
+  const { fm } = splitFrontmatter(raw);
+  expect(fm.model).toBe('sonnet');
+});
+
+test('seeded dev-lead body fits AGENT_BODY_CHAR_CAP and carries the run contract', () => {
+  const { splitFrontmatter } = require('../lib/prdFrontmatter.cjs');
+  const { AGENT_BODY_CHAR_CAP } = require('../lib/agentModelResolve.cjs');
+  const raw = fs.readFileSync(path.join(__dirname, '..', '..', 'seed', 'agents', 'dev-lead.md'), 'utf8');
+  const { body } = splitFrontmatter(raw);
+  const trimmed = body.trim();
+  expect(trimmed.length).toBeLessThan(AGENT_BODY_CHAR_CAP);
+  expect(trimmed).toContain('## Run contract');
+  expect(trimmed).toContain('SCHEDULER_VERDICT: PASS');
+});
+
 test('SM_SEED_AGENT_PERSONAS_DISABLE=1 short-circuits', async () => {
   process.env.SM_SEED_AGENT_PERSONAS_DISABLE = '1';