claude-code-session-manager 0.75.3 → 0.76.0

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;
     }

package/src/preload/api.d.ts

@@ -199,6 +199,31 @@ export interface McpStatusResult {
   checkedAt: number;
 }
 
+/** One session-manager-scheduler MCP tool's catalog entry (src/main/lib/mcpToolCatalog.cjs) —
+ *  the same data GET /admin/mcp/catalog serves, read in-process for Project Home's
+ *  PhAgentTools block. */
+export interface McpToolCatalogEntry {
+  name: string;
+  group: 'scheduler' | 'chat' | 'feedback' | 'help';
+  purpose: string;
+  whenToUse: string;
+  whenNotToUse: string;
+  exampleArgs: Record<string, unknown>;
+  notes: string | null;
+}
+
+export interface McpRecipe {
+  id: string;
+  title: string;
+  steps: string[];
+}
+
+export interface McpCatalogResult {
+  ok: boolean;
+  tools: McpToolCatalogEntry[];
+  recipes: McpRecipe[];
+}
+
 /** Mirrors WorkType (src/main/lib/workTypeLibrary.cjs) / EpicTag (tagLibrary.ts) — the
  *  same Epic-mission taxonomy, reused here since an Agent persona's `tags` field is that
  *  same concept, not a free-form string list. */
@@ -323,11 +348,31 @@ export interface TestFireHookResult {
 }
 
 export interface DelegationReadinessCheck {
-  id: 'scheduler-mcp' | 'dev-plugin' | 'agent-personas' | 'prd-write-guard';
+  id:
+    | 'scheduler-mcp'
+    | 'scheduler-mcp-live'
+    | 'scheduler-mcp-project-duplicate'
+    | 'dev-plugin'
+    | 'agent-personas'
+    | 'prd-write-guard';
   label: string;
   ok: boolean;
   detail: string;
   fix: string | null;
+  /** Non-null when Session Manager can install this fix itself, one press. */
+  fixAction: 'install-prd-write-guard' | null;
+  /** True when ok:true is a WARNING (still passing, but worth a human's attention) — today only scheduler-mcp-project-duplicate. */
+  warn?: boolean;
+  /** True when this check didn't run because a precondition (another check) already failed — reported ok:true, not a failure. */
+  skipped?: boolean;
+}
+
+export interface InstallPrdWriteGuardResult {
+  ok: boolean;
+  action: 'installed' | 'repaired' | 'already-installed' | 'error';
+  settingsPath?: string;
+  command?: string;
+  error?: string;
 }
 
 export interface DelegationReadiness {
@@ -602,10 +647,31 @@ export interface ScheduleStateSnapshot {
   pollHealth?: SchedulePollHealth;
   /** Effective concurrency cap and whether it's env-pinned or config-driven. */
   effectiveConcurrency: ScheduleEffectiveConcurrency;
+  /**
+   * CPU-load launch gate (PRD 1085): why nothing is launching when the box
+   * is saturated. Null before the first tick that evaluated it.
+   */
+  loadGate?: ScheduleLoadGate | null;
   /** Returned only by the initial state() call, not the broadcast event. */
   paths?: SchedulePaths;
 }
 
+export interface ScheduleLoadGate {
+  /** True when this tick's launches were withheld because of load. */
+  gated: boolean;
+  /** True when load would have gated but an explicit Run now bypassed it. */
+  bypassed: boolean;
+  /** 1-minute load average divided by core count. */
+  ratio: number;
+  /** LOAD_GATE_PER_CORE (or SM_LOAD_GATE_PER_CORE); 0 means disabled. */
+  threshold: number;
+  loadavg1: number | null;
+  cores: number;
+  /** How long the current gated stretch has lasted, 0 when not gated. */
+  gatedSinceMs: number;
+  at: string;
+}
+
 export interface HistoryAggregateRequest {
   fromDate?: string;
   toDate?: string;
@@ -1298,6 +1364,7 @@ export interface SessionManagerAPI {
     /** "Can this project actually delegate?" — the 4 preconditions for
      *  scheduler_create_prd being in an agent's tool list at all. */
     delegationReadiness: (cwd: string) => Promise<DelegationReadiness>;
+    installPrdWriteGuard: (cwd: string) => Promise<InstallPrdWriteGuardResult>;
     onNewSession: (handler: () => void) => () => void;
     onRebootSession: (handler: () => void) => () => void;
     archiveProject: (encoded: string) => Promise<{ ok: boolean; error?: string }>;
@@ -1350,6 +1417,7 @@ export interface SessionManagerAPI {
   };
   mcp: {
     status: () => Promise<McpStatusResult>;
+    catalog: () => Promise<McpCatalogResult>;
   };
   agents: {
     listPersonas: () => Promise<AgentPersona[]>;

package/src/preload/index.cjs

@@ -23,6 +23,7 @@ contextBridge.exposeInMainWorld('api', {
     homeSelfCheck: () => ipcRenderer.invoke('app:home-self-check'),
     seedStatus: () => ipcRenderer.invoke('app:seed-status'),
     delegationReadiness: (cwd) => ipcRenderer.invoke('app:delegation-readiness', { cwd }),
+    installPrdWriteGuard: (cwd) => ipcRenderer.invoke('app:install-prd-write-guard', { cwd }),
     onNewSession: (handler) => {
       const listener = () => handler();
       ipcRenderer.on('app:new-session', listener);
@@ -94,6 +95,7 @@ contextBridge.exposeInMainWorld('api', {
   },
   mcp: {
     status: () => ipcRenderer.invoke('mcp:status'),
+    catalog: () => ipcRenderer.invoke('mcp:catalog'),
   },
   agents: {
     listPersonas: () => ipcRenderer.invoke('agents:list-personas'),