claude-code-session-manager 0.74.0 → 0.75.1

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

@@ -11,7 +11,7 @@ const assert = require('node:assert/strict');
 const {
   selectAutoFixTargets, isUnresolvableNeedsReview, isRescanCandidate,
   healTargetForFix, isFixPlanBeyondDepthCap, MAX_INVESTIGATION_DEPTH,
-  isEligibleForImmediateAutoFix,
+  isEligibleForImmediateAutoFix, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor,
 } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
@@ -34,8 +34,8 @@ test('selects a fresh needs_review job', () => {
   assert.strictEqual(result[0].slug, '05-my-feature');
 });
 
-test('excludes job with autoFixAttempted: true', () => {
-  const jobs = [makeJob({ autoFixAttempted: true })];
+test('excludes job with autoFixAttempted: true whose retry is already spent', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixRetries: 1 })];
   const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
   assert.strictEqual(result.length, 0);
 });
@@ -105,12 +105,112 @@ test('autoFixOutcome no-plan with retries=1 is exhausted (not selected)', () =>
   assert.strictEqual(result.length, 0);
 });
 
-test('autoFixAttempted true with no outcome recorded stays excluded (existing 1-attempt cap)', () => {
-  const jobs = [makeJob({ autoFixAttempted: true })];
+// ---- PRD: unstamped/error outcomes must retry once, not dead-end forever ----
+
+test('autoFixAttempted true with NO outcome recorded (unstamped — spawn threw before onExit wired) is retry-eligible once', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixRetries: 0 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 1);
+});
+
+test('autoFixAttempted true with no outcome AND retries=1 is exhausted (not selected)', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixRetries: 1 })];
   const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
   assert.strictEqual(result.length, 0);
 });
 
+test('autoFixOutcome error with retries=0 is retry-eligible', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 0 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 1);
+});
+
+test('autoFixOutcome error with retries=1 is exhausted (not selected)', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 1 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
+test('autoFixOutcome plan is NEVER retried, regardless of autoFixRetries', () => {
+  const jobs = [makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 })];
+  const result = selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk });
+  assert.strictEqual(result.length, 0);
+});
+
+// ---- isExhaustedAutoFix / isPlanUnqueued (reverifyNeedsReview annotation) ----
+
+test('isExhaustedAutoFix: no-plan outcome with retries spent → true', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan', autoFixRetries: 1 });
+  assert.strictEqual(isExhaustedAutoFix(job), true);
+});
+
+test('isExhaustedAutoFix: error outcome with retries spent → true', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'error', autoFixRetries: 1 });
+  assert.strictEqual(isExhaustedAutoFix(job), true);
+});
+
+test('isExhaustedAutoFix: unstamped outcome with retries spent → true', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1 });
+  assert.strictEqual(isExhaustedAutoFix(job), true);
+});
+
+test('isExhaustedAutoFix: retries not yet spent → false (still eligible for its one retry)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan', autoFixRetries: 0 });
+  assert.strictEqual(isExhaustedAutoFix(job), false);
+});
+
+test('isExhaustedAutoFix: plan outcome is never "exhausted" here — isPlanUnqueued\'s job instead', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 1 });
+  assert.strictEqual(isExhaustedAutoFix(job), false);
+});
+
+test('isPlanUnqueued: plan outcome, fix slug absent from queue → true', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan' });
+  assert.strictEqual(isPlanUnqueued(job, new Set()), true);
+});
+
+test('isPlanUnqueued: plan outcome, fix slug present in queue → false', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan' });
+  assert.strictEqual(isPlanUnqueued(job, new Set([fixSlugFor(job)])), false);
+});
+
+test('isPlanUnqueued: no-plan outcome is never "plan unqueued"', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'no-plan' });
+  assert.strictEqual(isPlanUnqueued(job, new Set()), false);
+});
+
+// ---- invariant: every needs_review job is either an auto-fix target, or
+// classified by one of the annotation predicates (i.e. would receive a
+// non-null verifierVerdict) — no job may fall through both. ----
+
+test('invariant: attempted+no-outcome, retries spent → not a target, but IS annotatable', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1 });
+  const isTarget = selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).length === 1;
+  const isAnnotatable = isExhaustedAutoFix(job) || isPlanUnqueued(job, new Set())
+    || isUnresolvableNeedsReview(job, { hasRunDir: true });
+  assert.strictEqual(isTarget, false);
+  assert.strictEqual(isAnnotatable, true);
+});
+
+test('invariant: plan outcome, no queue row → not a target, but IS annotatable (autofix_plan_unqueued)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan' });
+  const isTarget = selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).length === 1;
+  const isAnnotatable = isExhaustedAutoFix(job) || isPlanUnqueued(job, new Set())
+    || isUnresolvableNeedsReview(job, { hasRunDir: true });
+  assert.strictEqual(isTarget, false);
+  assert.strictEqual(isAnnotatable, true);
+});
+
+test('invariant: plan outcome WITH a queue row → not a target and NOT annotated (waiting on the fix-plan job itself)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan' });
+  const queuedSlugs = new Set([fixSlugFor(job)]);
+  const isTarget = selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).length === 1;
+  const isAnnotatable = isExhaustedAutoFix(job) || isPlanUnqueued(job, queuedSlugs)
+    || isUnresolvableNeedsReview(job, { hasRunDir: true });
+  assert.strictEqual(isTarget, false);
+  assert.strictEqual(isAnnotatable, false);
+});
+
 test('excludes when fix sibling exists on disk', () => {
   const jobs = [makeJob()];
   // fixSlug = '05-fix-my-feature'
@@ -224,12 +324,18 @@ test('isEligibleForImmediateAutoFix: fresh needs_review job (fresh from spawnJob
   assert.strictEqual(result, true);
 });
 
-test('isEligibleForImmediateAutoFix: job already autoFixAttempted is excluded (prevents double-spawn with the periodic pass)', () => {
-  const job = makeJob({ autoFixAttempted: true });
+test('isEligibleForImmediateAutoFix: attempted job with retry already spent is excluded (prevents double-spawn with the periodic pass)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1 });
   const result = isEligibleForImmediateAutoFix(job, [job], noSiblingOnDisk);
   assert.strictEqual(result, false);
 });
 
+test('isEligibleForImmediateAutoFix: attempted job with an unstamped outcome and its retry still unspent IS eligible (bounded once)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 0 });
+  const result = isEligibleForImmediateAutoFix(job, [job], noSiblingOnDisk);
+  assert.strictEqual(result, true);
+});
+
 test('isEligibleForImmediateAutoFix: fix sibling already on disk excludes the job', () => {
   const job = makeJob();
   // fixSlug = '05-fix-my-feature'

package/src/main/__tests__/scheduler-fix-plan-path.test.cjs

@@ -0,0 +1,119 @@
+/**
+ * scheduler-fix-plan-path.test.cjs — regression test for the self-heal
+ * dead-letter bug: spawnInvestigation used to write every auto-fix plan into
+ * the RETIRED flat `<cwd>/session-manager-operations/scheduler/prds/` dir
+ * (prdDirForCwd), which reconcile()'s consolidateAllFlatPrds sweeps BEFORE
+ * scanning for queue rows — so a freshly-authored fix plan (no queue row yet
+ * by definition) was archived into `prds-archived/` on the very next pass
+ * and never enqueued. Confirmed live in starry-night-ships: job
+ * 105-arena-perf-fences produced a valid fix plan that landed in
+ * prds-archived/ having never appeared in queue.json or history.jsonl.
+ *
+ * The fix: resolveFixPlanPath resolves the write dir from the ORIGINAL job's
+ * live PRD location (findPrdDir, via resolveVerifyPrdPath) — normally the
+ * originating Epic's own `epics/<epicId>/prds/`, which consolidateFlatPrds
+ * never touches — falling back to the flat dir only when the original can't
+ * be found live anywhere on disk.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-fix-plan-path.test.cjs
+ */
+
+'use strict';
+
+import { test, expect, beforeAll, afterAll } from 'vitest';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+let tmpHome;
+let originalHome;
+let resolveFixPlanPath;
+let PRDS_DIR;
+let consolidateFlatPrds;
+
+beforeAll(() => {
+  originalHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'sm-fix-plan-path-'));
+  process.env.HOME = tmpHome;
+
+  // Load AFTER HOME is stubbed — scheduler.cjs snapshots os.homedir() into
+  // PRDS_DIR at module load, not lazily (see scheduler-find-prd-dir.test.cjs).
+  ({ resolveFixPlanPath, PRDS_DIR } = require('../scheduler.cjs'));
+  ({ consolidateFlatPrds } = require('../lib/prdMigration.cjs'));
+
+  if (!PRDS_DIR.startsWith(tmpHome)) {
+    throw new Error(`refusing to run: PRDS_DIR (${PRDS_DIR}) is not under the temp HOME (${tmpHome})`);
+  }
+
+  // allProjectCwds()/activeProjectCwds() (consumed by findPrdDir's candidate
+  // search) discover project cwds by scanning ~/.claude/projects/*/*.jsonl
+  // for a `cwd` field — fake one project transcript pointing at the real
+  // on-disk cwd used below (mirrors scheduler-verify-prd-path.test.cjs).
+  const projectsDir = path.join(tmpHome, '.claude', 'projects');
+  const projDir = path.join(projectsDir, 'fake-fix-plan-project-slug');
+  fs.mkdirSync(projDir, { recursive: true });
+  fs.writeFileSync(
+    path.join(projDir, 'session.jsonl'),
+    `${JSON.stringify({ cwd: projectCwd() })}\n`,
+    'utf8',
+  );
+});
+
+afterAll(() => {
+  process.env.HOME = originalHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+});
+
+function projectCwd() {
+  return path.join(tmpHome, 'fix-plan-project-cwd');
+}
+
+test('resolveFixPlanPath resolves the fix plan into the SAME Epic-scoped dir as the original PRD, and it survives consolidateFlatPrds', async () => {
+  const cwd = projectCwd();
+  const epicId = 'test-epic-arena-perf';
+  const slug = `105-arena-perf-fences-${process.pid}`;
+  const prdsDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'epics', epicId, 'prds');
+  fs.mkdirSync(prdsDir, { recursive: true });
+  fs.writeFileSync(path.join(prdsDir, `${slug}.md`), '---\ntitle: arena perf fences\n---\n\n# Goal\n\ntest\n', 'utf8');
+
+  const failedJob = { slug, cwd, parallelGroup: 5 };
+  const resolved = await resolveFixPlanPath(failedJob);
+
+  const expectedFixSlug = '05-fix-arena-perf-fences-' + process.pid;
+  expect(resolved.fixSlug).toBe(expectedFixSlug);
+  expect(resolved.livePrdDir).toBe(prdsDir);
+  expect(resolved.fixPath).toBe(path.join(prdsDir, `${expectedFixSlug}.md`));
+
+  // A fix plan written at the resolved path must survive a consolidateFlatPrds
+  // pass over the SAME project cwd — the sweep only ever touches the flat dir.
+  fs.writeFileSync(resolved.fixPath, `---\ntitle: Fix: arena perf fences\ncwd: ${cwd}\nparallelGroup: 5\nestimateMinutes: 30\n---\n\nfix body\n`, 'utf8');
+  await consolidateFlatPrds(cwd);
+  expect(fs.existsSync(resolved.fixPath)).toBe(true);
+});
+
+test('resolveFixPlanPath falls back to the flat dir when the original PRD cannot be found live anywhere on disk', async () => {
+  const cwd = path.join(tmpHome, 'fix-plan-project-cwd-missing');
+  const slug = `999-nonexistent-${process.pid}`;
+  const failedJob = { slug, cwd, parallelGroup: 3 };
+
+  const resolved = await resolveFixPlanPath(failedJob);
+
+  expect(resolved.livePrdDir).toBe(null);
+  const flatDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
+  expect(resolved.fixPath).toBe(path.join(flatDir, `${resolved.fixSlug}.md`));
+});
+
+test('the OLD flat-dir path (regression guard) does NOT survive consolidateFlatPrds — proves the bug this fix addresses', async () => {
+  const cwd = path.join(tmpHome, 'fix-plan-project-cwd-old-behavior');
+  const flatDir = path.join(cwd, 'session-manager-operations', 'scheduler', 'prds');
+  fs.mkdirSync(flatDir, { recursive: true });
+  const oldFixPath = path.join(flatDir, '07-fix-old-behavior.md');
+  fs.writeFileSync(oldFixPath, `---\ntitle: Fix: old behavior\ncwd: ${cwd}\nparallelGroup: 7\nestimateMinutes: 30\n---\n\nfix body\n`, 'utf8');
+
+  // No queue.json at all — the file has no live queue row, exactly the
+  // freshly-authored-fix-plan situation the bug hit.
+  await consolidateFlatPrds(cwd);
+
+  expect(fs.existsSync(oldFixPath)).toBe(false);
+  expect(fs.existsSync(path.join(cwd, 'session-manager-operations', 'scheduler', 'prds-archived', '07-fix-old-behavior.md'))).toBe(true);
+});

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

@@ -0,0 +1,105 @@
+/**
+ * seedAgentPersonas.test.cjs — unit tests for src/main/seedAgentPersonas.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedAgentPersonas.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');
+
+let tmpHome;
+let realHome;
+let seedAgentPersonas;
+
+// config.cjs bakes os.homedir() into top-level consts at first require
+// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
+// alongside seedAgentPersonas.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = ['../seedAgentPersonas.cjs', '../config.cjs'];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-agent-personas-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
+  purgeRequireCache();
+  ({ seedAgentPersonas } = require('../seedAgentPersonas.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_SEED_AGENT_PERSONAS_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+function agentsDir() {
+  return path.join(tmpHome, '.claude', 'agents');
+}
+
+function markerPath() {
+  return path.join(tmpHome, '.claude', 'session-manager', '.agent-personas-seeded');
+}
+
+function silentLogger() {
+  return { log: () => {}, warn: () => {} };
+}
+
+test('fresh seed writes both persona files', async () => {
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  const architect = path.join(agentsDir(), 'architect.md');
+  const devLead = path.join(agentsDir(), 'dev-lead.md');
+  expect(fs.existsSync(architect)).toBe(true);
+  expect(fs.existsSync(devLead)).toBe(true);
+
+  const bundledArchitect = fs.readFileSync(
+    path.join(__dirname, '..', '..', 'seed', 'agents', 'architect.md'),
+    'utf8'
+  );
+  expect(fs.readFileSync(architect, 'utf8')).toBe(bundledArchitect);
+
+  const marker = JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
+  expect(marker.done).toBe(true);
+});
+
+test('a pre-existing persona file is left byte-identical', async () => {
+  fs.mkdirSync(agentsDir(), { recursive: true });
+  const architect = path.join(agentsDir(), 'architect.md');
+  const customContent = '# My custom architect\nnever overwrite me\n';
+  fs.writeFileSync(architect, customContent);
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  expect(fs.readFileSync(architect, 'utf8')).toBe(customContent);
+  // dev-lead had no pre-existing file, so it should still be seeded.
+  expect(fs.existsSync(path.join(agentsDir(), 'dev-lead.md'))).toBe(true);
+});
+
+test('done:true marker short-circuits without touching agents dir', async () => {
+  const mPath = markerPath();
+  fs.mkdirSync(path.dirname(mPath), { recursive: true });
+  fs.writeFileSync(mPath, JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  expect(fs.existsSync(agentsDir())).toBe(false);
+});
+
+test('SM_SEED_AGENT_PERSONAS_DISABLE=1 short-circuits', async () => {
+  process.env.SM_SEED_AGENT_PERSONAS_DISABLE = '1';
+
+  await seedAgentPersonas({ logger: silentLogger() });
+
+  expect(fs.existsSync(agentsDir())).toBe(false);
+  expect(fs.existsSync(markerPath())).toBe(false);
+});

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

@@ -0,0 +1,145 @@
+/**
+ * seedSchedulerMcp.test.cjs — unit tests for src/main/seedSchedulerMcp.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedSchedulerMcp.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');
+
+let tmpHome;
+let realHome;
+let seedSchedulerMcp;
+
+// config.cjs bakes os.homedir() into top-level consts at first require
+// (allowedRoots/WRITE_PREFIXES, used by writeJsonSync) — must be purged
+// alongside seedSchedulerMcp.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = ['../seedSchedulerMcp.cjs', '../config.cjs'];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-scheduler-mcp-test-'));
+  process.env.HOME = tmpHome;
+  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
+  purgeRequireCache();
+  ({ seedSchedulerMcp } = require('../seedSchedulerMcp.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  delete process.env.SM_SEED_SCHEDULER_MCP_DISABLE;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+function markerPath() {
+  return path.join(tmpHome, '.claude', 'session-manager', '.scheduler-mcp-seeded');
+}
+
+function claudeJsonPath() {
+  return path.join(tmpHome, '.claude.json');
+}
+
+function silentLogger() {
+  return { log: () => {}, warn: () => {} };
+}
+
+function readMarker() {
+  return JSON.parse(fs.readFileSync(markerPath(), 'utf8'));
+}
+
+test('fresh registration calls addFn with the absolute server path and writes done marker', async () => {
+  const calls = [];
+  const addFn = async (serverPath) => {
+    calls.push(serverPath);
+    return { ok: true, exitCode: 0 };
+  };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(calls).toHaveLength(1);
+  expect(path.isAbsolute(calls[0])).toBe(true);
+  expect(calls[0].endsWith(path.join('scripts', 'scheduler-mcp-server.cjs'))).toBe(true);
+
+  const marker = readMarker();
+  expect(marker.done).toBe(true);
+  expect(marker.attempts).toBe(0);
+});
+
+test('already-registered at user scope short-circuits without calling addFn', async () => {
+  fs.writeFileSync(
+    claudeJsonPath(),
+    JSON.stringify({
+      mcpServers: {
+        'session-manager-scheduler': { type: 'stdio', command: 'node', args: ['/some/path/scheduler-mcp-server.cjs'] },
+        fetch: { type: 'stdio', command: 'uvx', args: ['mcp-server-fetch'] },
+      },
+    })
+  );
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+  const marker = readMarker();
+  expect(marker.done).toBe(true);
+
+  // Untouched — the pre-existing registration (and sibling entries) stay as-is.
+  const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath(), 'utf8'));
+  expect(claudeJson.mcpServers['session-manager-scheduler'].args).toEqual(['/some/path/scheduler-mcp-server.cjs']);
+  expect(claudeJson.mcpServers.fetch).toBeDefined();
+});
+
+test('done:true marker short-circuits without calling addFn', async () => {
+  fs.mkdirSync(path.dirname(markerPath()), { recursive: true });
+  fs.writeFileSync(markerPath(), JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+});
+
+test('SM_SEED_SCHEDULER_MCP_DISABLE=1 short-circuits', async () => {
+  process.env.SM_SEED_SCHEDULER_MCP_DISABLE = '1';
+  let called = false;
+  const addFn = async () => { called = true; return { ok: true }; };
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+
+  expect(called).toBe(false);
+  expect(fs.existsSync(markerPath())).toBe(false);
+});
+
+test('a failed attempt bumps the counter and stops after MAX_ATTEMPTS', async () => {
+  const addFn = async () => ({ ok: false, error: 'boom' });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 1 });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 2 });
+
+  await seedSchedulerMcp({ logger: silentLogger(), addFn });
+  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
+
+  // MAX_ATTEMPTS reached — a 4th run must not call addFn again or bump further.
+  let called = false;
+  const trackedAddFn = async () => { called = true; return { ok: false, error: 'boom' }; };
+  await seedSchedulerMcp({ logger: silentLogger(), addFn: trackedAddFn });
+
+  expect(called).toBe(false);
+  expect(readMarker()).toMatchObject({ done: false, attempts: 3 });
+});

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

@@ -0,0 +1,100 @@
+/**
+ * seedStatus.test.cjs — unit tests for src/main/seedStatus.cjs.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/seedStatus.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');
+
+let tmpHome;
+let realHome;
+let getSeedStatus;
+
+// config.cjs (via seedSchedulerMcp/seedAgentPersonas) and each seed*.cjs
+// module bake os.homedir() into top-level consts at first require — purge
+// all of them alongside seedStatus.cjs so each test's tmpHome takes effect.
+const MODULES_TO_RELOAD = [
+  '../seedStatus.cjs',
+  '../seedDevPlugin.cjs',
+  '../seedSchedulerMcp.cjs',
+  '../seedAgentPersonas.cjs',
+  '../config.cjs',
+];
+
+function purgeRequireCache() {
+  for (const m of MODULES_TO_RELOAD) {
+    try { delete require.cache[require.resolve(m)]; } catch { /* not loaded yet */ }
+  }
+}
+
+beforeEach(() => {
+  realHome = process.env.HOME;
+  tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'seed-status-test-'));
+  process.env.HOME = tmpHome;
+  purgeRequireCache();
+  ({ getSeedStatus } = require('../seedStatus.cjs'));
+});
+
+afterEach(() => {
+  process.env.HOME = realHome;
+  fs.rmSync(tmpHome, { recursive: true, force: true });
+  purgeRequireCache();
+});
+
+const MARKER_NAMES = {
+  'dev-plugin': '.dev-plugin-seeded',
+  'scheduler-mcp': '.scheduler-mcp-seeded',
+  'agent-personas': '.agent-personas-seeded',
+};
+
+function markerPath(id) {
+  return path.join(tmpHome, '.claude', 'session-manager', MARKER_NAMES[id]);
+}
+
+function writeMarker(id, contents) {
+  const p = markerPath(id);
+  fs.mkdirSync(path.dirname(p), { recursive: true });
+  fs.writeFileSync(p, contents);
+}
+
+test('no marker files at all → every seeder reports pending with a fix string', () => {
+  const status = getSeedStatus();
+  for (const id of Object.keys(MARKER_NAMES)) {
+    expect(status[id].status).toBe('pending');
+    expect(typeof status[id].fix).toBe('string');
+    expect(status[id].fix.length).toBeGreaterThan(0);
+  }
+});
+
+for (const id of Object.keys(MARKER_NAMES)) {
+  test(`${id}: done:true marker → done`, () => {
+    writeMarker(id, JSON.stringify({ done: true, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('done');
+  });
+
+  test(`${id}: done:false, attempts below max → pending`, () => {
+    writeMarker(id, JSON.stringify({ done: false, attempts: 1, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+
+  test(`${id}: done:false, attempts >= max → exhausted`, () => {
+    writeMarker(id, JSON.stringify({ done: false, attempts: 3, ts: '2026-01-01T00:00:00.000Z' }));
+    expect(getSeedStatus()[id].status).toBe('exhausted');
+  });
+
+  test(`${id}: unparseable marker → pending, never throws`, () => {
+    writeMarker(id, 'not json at all {{{');
+    expect(() => getSeedStatus()).not.toThrow();
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+
+  test(`${id}: missing marker file → pending`, () => {
+    // No file written for this id — directory may not even exist.
+    expect(getSeedStatus()[id].status).toBe('pending');
+  });
+}