claude-code-session-manager 0.75.3 → 0.77.0

package/src/main/seedAgentPersonas.cjs

@@ -1,18 +1,34 @@
 /**
- * First-boot seeder for the bundled Agent personas (Architect, Dev Lead).
+ * First-boot (and stay-current) seeder for the bundled Agent personas.
  *
  * On a fresh install `~/.claude/agents/` is empty, so the Agent Library has
  * nothing to offer — no persona to select for an Epic's Actor. This seeder
- * copies the personas bundled at `src/seed/agents/*.md` into `~/.claude/agents/`
- * on first boot, one file per persona, and NEVER overwrites a file that
- * already exists there (hand-edited or user-authored personas win).
+ * copies the personas bundled at `src/seed/agents/*.md` into `~/.claude/agents/`,
+ * one file per persona, and NEVER overwrites a file that already exists there
+ * (hand-edited or user-authored personas win).
  *
- * Idempotent the same way as seedDevPlugin.cjs:
- *   1. A marker file (`~/.claude/session-manager/.agent-personas-seeded`)
- *      records seed state. Once seeding SUCCEEDS we write `done` and never
- *      touch it again. A FAILED attempt only bumps an attempt counter and
- *      retries on the next few boots (bounded by MAX_ATTEMPTS), so a
- *      transient first-boot failure doesn't permanently skip the personas.
+ * Idempotent the same way as seedDevPlugin.cjs, but per-persona rather than
+ * whole-run: the marker (`~/.claude/session-manager/.agent-personas-seeded`)
+ * records the SET of persona names already delivered (`seeded: string[]`),
+ * not just a single `done` flag. Every boot, any name in `PERSONAS` not yet in
+ * that set gets copied (subject to the same never-overwrite guard) and added
+ * to the set. This is what lets a persona added to `PERSONAS` in a later
+ * release reach a machine that already booted successfully long ago — a
+ * plain one-shot `done:true` would silently never re-run and that persona
+ * would never arrive. A name already in `seeded` is skipped even if its
+ * on-disk file was later deleted by hand — deleting a seeded persona is
+ * read as an intentional opt-out, not a request to reseed it.
+ *
+ * A whole-run FAILURE (thrown before any per-persona copy could be attempted,
+ * e.g. the bundled source dir is missing) only bumps an attempt counter and
+ * retries on the next few boots (bounded by MAX_ATTEMPTS); once attempts are
+ * exhausted the seeder gives up permanently and the machine is left exactly
+ * where it was — whatever subset of `PERSONAS` it had already reached stays
+ * in `seeded`, nothing is retried automatically, and delivering the rest is a
+ * manual copy. This is a deliberate choice: an install that has already
+ * failed MAX_ATTEMPTS times has something wrong with it (e.g. a read-only
+ * home dir) that retrying forever would not fix, and endlessly retrying on
+ * every boot would cost a syscall per persona per boot for no benefit.
  *
  * Fire-and-forget: called post-window from index.cjs. Errors are logged,
  * never thrown. Kill-switch: SM_SEED_AGENT_PERSONAS_DISABLE=1.
@@ -23,7 +39,12 @@ const path = require('node:path');
 const os = require('node:os');
 const { writeJsonSync } = require('./config.cjs');
 
-const PERSONAS = ['architect', 'dev-lead'];
+const PERSONAS = ['architect', 'dev-lead', 'project-home-builder'];
+// What `{ done: true }` (the pre-seeded-set marker format) meant: only these two personas existed
+// in PERSONAS at the time. Fixed, not derived from the current PERSONAS array above — otherwise
+// every future persona added to PERSONAS would retroactively count as already delivered to a
+// machine that finished its run under the old format, and would silently never seed there.
+const LEGACY_DONE_PERSONAS = ['architect', 'dev-lead'];
 const MAX_ATTEMPTS = 3; // give a transient first-boot failure a few chances
 
 function bundledSourceDir() {
@@ -38,14 +59,30 @@ function markerPath() {
   return path.join(os.homedir(), '.claude', 'session-manager', '.agent-personas-seeded');
 }
 
-/** Read the marker → { done:boolean, attempts:number }. Absent = fresh. */
+/**
+ * Read the marker → { seeded:string[], attempts:number }. Absent/corrupt/
+ * legacy = treated as fresh (a corrupt marker must never block seeding — a
+ * try/catch here is load-bearing, not defensive filler).
+ *
+ * Back-compat: an old-format marker (`{ done: true }`, no `seeded` array)
+ * reads as `seeded: LEGACY_DONE_PERSONAS` (the fixed set that existed when
+ * that format was the only one) — a machine that already completed a full
+ * run under the old scheme picks up only personas added to `PERSONAS` since,
+ * not a spurious reseed of architect/dev-lead.
+ */
 function readMarker() {
   try {
     const raw = fs.readFileSync(markerPath(), 'utf8').trim();
     const m = JSON.parse(raw);
-    return { done: !!m.done, attempts: Number(m.attempts) || 0 };
+    if (Array.isArray(m.seeded)) {
+      return { seeded: m.seeded.filter((n) => typeof n === 'string'), attempts: Number(m.attempts) || 0 };
+    }
+    if (m.done) {
+      return { seeded: [...LEGACY_DONE_PERSONAS], attempts: Number(m.attempts) || 0 };
+    }
+    return { seeded: [], attempts: Number(m.attempts) || 0 };
   } catch {
-    return { done: false, attempts: 0 };
+    return { seeded: [], attempts: 0 };
   }
 }
 
@@ -60,23 +97,27 @@ function writeMarker(state) {
 async function seedAgentPersonas({ logger = console, writeLog = () => {} } = {}) {
   if (process.env.SM_SEED_AGENT_PERSONAS_DISABLE === '1') return;
   const marker = readMarker();
-  if (marker.done) return;                       // succeeded before — leave it alone.
+  const pending = PERSONAS.filter((name) => !marker.seeded.includes(name));
+  if (pending.length === 0) return;              // every known persona already delivered.
   if (marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual copy only.
 
+  const seeded = [...marker.seeded];
   try {
     const srcDir = bundledSourceDir();
     const destDir = destAgentsDir();
     fs.mkdirSync(destDir, { recursive: true });
 
-    for (const name of PERSONAS) {
+    for (const name of pending) {
       const src = path.join(srcDir, `${name}.md`);
       const dest = path.join(destDir, `${name}.md`);
-      if (fs.existsSync(dest)) continue; // never overwrite an existing persona
-      fs.copyFileSync(src, dest);
-      logger.log?.(`[seedAgentPersonas] seeded ${name}.md`);
+      if (!fs.existsSync(dest)) {
+        fs.copyFileSync(src, dest);
+        logger.log?.(`[seedAgentPersonas] seeded ${name}.md`);
+      }
+      seeded.push(name); // never overwrite an existing persona, but count it delivered either way
     }
 
-    writeMarker({ done: true, attempts: marker.attempts });
+    writeMarker({ seeded, attempts: marker.attempts });
   } catch (err) {
     logger.warn?.('[seedAgentPersonas] error:', err?.message ?? err);
     writeLog({
@@ -85,7 +126,7 @@ async function seedAgentPersonas({ logger = console, writeLog = () => {} } = {})
       message: 'seed error',
       meta: { error: err?.message ?? String(err), attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
     });
-    writeMarker({ done: false, attempts: marker.attempts + 1 });
+    writeMarker({ seeded, attempts: marker.attempts + 1 });
   }
 }
 

package/src/main/seedSchedulerMcp.cjs

@@ -81,6 +81,27 @@ function alreadyRegistered() {
   }
 }
 
+/**
+ * true only when the user-scope entry EXISTS but its script arg no longer
+ * resolves on disk (repo moved, worktree deleted). An entry that is entirely
+ * ABSENT is a deliberate `claude mcp remove` and must stay removed — that
+ * case returns false here, same as any other "not registered" read.
+ */
+function scriptPathMissing() {
+  try {
+    const raw = fs.readFileSync(path.join(os.homedir(), '.claude.json'), 'utf8');
+    const servers = JSON.parse(raw)?.mcpServers;
+    const entry = servers && servers[SERVER_NAME];
+    if (!entry) return false;
+    const args = Array.isArray(entry.args) ? entry.args : [];
+    const scriptArg = args[args.length - 1];
+    if (typeof scriptArg !== 'string' || !scriptArg) return false;
+    return !fs.existsSync(scriptArg);
+  } catch {
+    return false;
+  }
+}
+
 /** Run `claude mcp add session-manager-scheduler --scope user -- node <serverPath>`.
  *  No shell:true — argv array passed directly to spawn. */
 function runClaudeMcpAdd(serverPath) {
@@ -106,14 +127,47 @@ function runClaudeMcpAdd(serverPath) {
   });
 }
 
-async function seedSchedulerMcp({ logger = console, addFn = runClaudeMcpAdd, writeLog = () => {} } = {}) {
+/** Run `claude mcp remove session-manager-scheduler --scope user`, best-effort. */
+function runClaudeMcpRemove() {
+  return new Promise((resolve) => {
+    const claudeBin = resolveClaudeBin();
+    let proc;
+    try {
+      proc = spawn(
+        claudeBin,
+        ['mcp', 'remove', SERVER_NAME, '--scope', 'user'],
+        { cwd: os.homedir(), env: cleanChildEnv({ PATH: pathWithUserBins() }), stdio: 'ignore' }
+      );
+    } catch (err) {
+      resolve({ ok: false, error: err?.message ?? String(err) });
+      return;
+    }
+    proc.on('error', (err) => resolve({ ok: false, error: err?.message ?? String(err) }));
+    proc.on('close', (code) => resolve({ ok: code === 0, exitCode: code }));
+  });
+}
+
+async function seedSchedulerMcp({ logger = console, addFn = runClaudeMcpAdd, removeFn = runClaudeMcpRemove, writeLog = () => {} } = {}) {
   if (process.env.SM_SEED_SCHEDULER_MCP_DISABLE === '1') return;
   const marker = readMarker();
-  if (marker.done) return;                       // succeeded before — leave it alone.
-  if (marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual install only.
+
+  // `claude mcp add` refuses when a server of this name already exists, so a
+  // repair must remove the stale entry first — but ONLY when the marker says
+  // `done` AND the registered script has actually gone missing. An entry
+  // that's simply absent (marker done, no ~/.claude.json entry at all) is a
+  // deliberate `claude mcp remove` and must stay removed exactly as today.
+  let repairing = false;
+  if (marker.done) {
+    if (!scriptPathMissing()) return;
+    repairing = true;
+    logger.warn?.('[seedSchedulerMcp] user-scope registration points at a missing script — repairing…');
+    await removeFn();
+  } else if (marker.attempts >= MAX_ATTEMPTS) {
+    return; // gave up — manual install only.
+  }
 
   try {
-    if (alreadyRegistered()) {
+    if (!repairing && alreadyRegistered()) {
       writeMarker({ done: true, attempts: marker.attempts });
       return;
     }