claude-code-session-manager 0.42.0 → 0.44.0

package/src/main/scheduler.cjs

@@ -86,7 +86,7 @@ const queueOps = require('./queueOps.cjs');
 // match ROOT/QUEUE_PATH below since both resolve the same ~/.claude/session-manager
 // home-dir layout.
 const { resolvePrdsDirs, resolvePrdWriteDir, listEpicPrdDirs, listArchivedPrdDirs } = require('./lib/prdLocations.cjs');
-const { ensureEpic, appendPrdCreatedEvent, removeEpic, readActiveIndex } = require('./lib/epicMint.cjs');
+const { ensureEpic, appendPrdCreatedEvent, readActiveIndex } = require('./lib/epicMint.cjs');
 
 // ---------- origin session resolution (PRD 832) ----------
 // An Epic IS a tagged claude session — job rows carry the originating
@@ -3710,6 +3710,15 @@ function registerScheduleHandlers() {
   // configuration tab.
   ipcMain.handle('schedule:session-slots', () => sessionSlots.snapshot());
 
+  // Home-tab control for the same pool: user-set cap in [0, 10], default 5.
+  // 0 pauses new claude -p launches machine-wide without killing anything
+  // already running. SM_SESSION_SLOTS (if set) still overrides this at read
+  // time — sessionSlots.snapshot().envOverride tells the UI to disable itself.
+  ipcMain.handle('schedule:set-session-slots', validated(schemas.setSessionSlotsSchema, async (data) => {
+    sessionSlots.setCap(data.cap);
+    return sessionSlots.snapshot();
+  }));
+
   ipcMain.handle('schedule:health', async () => {
     const state = await readQueue();
     const runningJobs = [];
@@ -4178,13 +4187,6 @@ async function init() {
 
 // remote — callable from webRemote.cjs without going through IPC.
 const remote = {
-  async getState() {
-    const state = await readQueue();
-    await reconcile(state);
-    await writeQueue(state);
-    return buildScheduleStatePayload(state, { withPaths: true });
-  },
-
   // `cwd` is optional: prdCreate.cjs's create flow passes the target
   // project's cwd explicitly (the file may not exist yet, so there's
   // nothing for findPrdDir to search for); the renderer's slug-only IPC
@@ -4220,33 +4222,12 @@ const remote = {
     }
   },
 
-  async readLog(slug, runId) {
-    const logPath = path.resolve(path.join(RUNS_DIR, runId, `${slug}.log`));
-    if (!logPath.startsWith(RUNS_DIR + path.sep)) {
-      return { ok: false, error: 'invalid slug or runId' };
-    }
-    try {
-      // realpath resolves symlinks; re-check boundary to block a rogue agent job
-      // that places a symlink inside RUNS_DIR pointing outside the safe root.
-      const real = await fsp.realpath(logPath);
-      if (!real.startsWith(RUNS_DIR + path.sep)) {
-        return { ok: false, error: 'invalid slug or runId' };
-      }
-      const text = await fsp.readFile(real, 'utf8');
-      return { ok: true, text };
-    } catch (e) {
-      return { ok: false, error: e?.message };
-    }
-  },
-
   // `cwd` optional — see readPrd's comment above; prdCreate.cjs's create
   // flow supplies it (the destination project dir for a brand-new file that
   // doesn't exist yet, so findPrdDir would return nothing to write into).
   async writePrd(slug, body, cwd) {
     let dir;
     let epicTrace = null;
-    let epicCreated = false;
-    let epicId = null;
     if (cwd) {
       // Edit-in-place if this slug already lives anywhere under this project
       // (legacy flat dir or any Epic's prds/); otherwise this is a CREATE,
@@ -4258,29 +4239,37 @@ const remote = {
         if (candidate && fs.existsSync(candidate)) { dir = d; break; }
       }
       if (!dir) {
+        // Every PRD must join an EXISTING, already-human-approved Epic —
+        // mintIfMissing:false means this never conjures a new one. Only
+        // Epics born from explicit human intent (New Epic UI, or
+        // /propose-epic + Approve & start) may write PRDs; this write path
+        // is not itself a human-intent gate, so it must not become one by
+        // accident.
+        const { fm } = splitFrontmatter(body);
         try {
-          const { fm } = splitFrontmatter(body);
           const epic = await ensureEpic(cwd, {
-            goalText: fm.title || slug,
-            tag: fm.tag,
-            // An Epic-conversation dispatch already has its Epic — join it.
             // fm.sourcePromptId must be an existing Epic's promptSessionId
             // (== its active-index.json sessions key), NOT a
             // PromptTicket.id — epicMint.cjs's ensureEpic looks it up via
             // `index.sessions[explicitEpicId]` (see epicMint.cjs ~line 73),
             // a literal-equality join. Any other id (e.g. a PromptTicket.id)
-            // simply won't match and mints a sibling Epic instead of joining.
+            // simply won't match and this call throws below.
             epicId: fm.sourcePromptId,
+            mintIfMissing: false,
+            // Join-only call (mintIfMissing:false, explicit epicId): the
+            // explicitEpicId branch in ensureEpic returns before `source` is
+            // ever read, so this is a no-op today — kept for symmetry/audit
+            // trail if that join path ever grows a source-touch (PRD 902/905).
+            source: { producer: 'scheduler-dispatch', prdSlug: slug },
           });
           dir = epic.prdDir;
           epicTrace = epic.epicId;
-          epicCreated = epic.created === true;
-          epicId = epic.epicId;
         } catch (e) {
-          // Epic mint must never block a PRD write — fall back to the
-          // legacy flat dir and log loudly.
-          console.error(`[scheduler] ensureEpic failed for ${slug}: ${e?.message}`);
-          dir = prdDirForCwd(cwd);
+          return {
+            ok: false,
+            error: `no existing Epic to join (sourcePromptId=${fm.sourcePromptId ?? 'none'}): ${e?.message ?? 'unknown error'}. `
+              + 'Create the Epic first via the New Epic UI or /propose-epic + Approve & start, then pass its id as sourcePromptId.',
+          };
         }
       }
       await fsp.mkdir(dir, { recursive: true });
@@ -4289,30 +4278,11 @@ const remote = {
       if (dir === PRDS_DIR) ensureDirs();
     }
 
-    // PRD 825: if this call minted a brand-new Epic (ensureEpic's `created`)
-    // and the write below never lands, don't strand an empty Epic dir —
-    // best-effort remove `<epic>/prds` then `<epic>` itself, only when empty.
-    // PRD 851: also drop the Epic's active-index.json entry (sessions/events)
-    // so an orphaned seed-prompt-only Epic doesn't linger in the Epics nav.
-    // Gated on epicCreated (never fires when ensureEpic joined an existing
-    // Epic) so a pre-existing Epic's history is never touched.
-    const cleanupEmptyMintedEpic = async () => {
-      if (!epicCreated || !epicId) return;
-      try {
-        const entries = await fsp.readdir(dir);
-        if (entries.length === 0) {
-          await fsp.rmdir(dir);
-          const epicRootDir = path.dirname(dir);
-          const epicRootEntries = await fsp.readdir(epicRootDir);
-          if (epicRootEntries.length === 0) await fsp.rmdir(epicRootDir);
-        }
-      } catch { /* best-effort only */ }
-      try { removeEpic(cwd, epicId); } catch { /* best-effort only */ }
-    };
-
+    // writePrd only ever JOINS an existing Epic now (mintIfMissing:false
+    // above) — it can never mint one, so there is no orphaned-mint case left
+    // to roll back here (contrast the old PRD 825/851 cleanup, removed).
     const resolved = safeSlugPathIn(dir, slug);
     if (!resolved) {
-      await cleanupEmptyMintedEpic();
       return { ok: false, error: 'invalid slug' };
     }
     try {
@@ -4324,23 +4294,20 @@ const remote = {
       // symlink.
       const realParent = await fsp.realpath(path.dirname(resolved));
       if (realParent !== dir && !realParent.startsWith(dir + path.sep)) {
-        await cleanupEmptyMintedEpic();
         return { ok: false, error: 'invalid slug' };
       }
       const existing = await fsp.lstat(resolved).catch(() => null);
       if (existing && existing.isSymbolicLink()) {
-        await cleanupEmptyMintedEpic();
         return { ok: false, error: 'invalid slug' };
       }
       await config.writeTextAtomic(resolved, body, { writer: 'scheduler' });
       const stat = await fsp.stat(resolved);
       if (epicTrace) {
-        // Best-effort: record the dispatch on the minted Epic's event chain.
+        // Best-effort: record the dispatch on the Epic's event chain.
         try { await appendPrdCreatedEvent(cwd, epicTrace, slug); } catch { /* trace only */ }
       }
       return { ok: true, bytesWritten: stat.size };
     } catch (e) {
-      await cleanupEmptyMintedEpic();
       return { ok: false, error: e?.message ?? 'write failed' };
     }
   },
@@ -4378,28 +4345,6 @@ const remote = {
   // reuses the same allocator the file-based /develop authoring path relies
   // on implicitly, rather than re-deriving NN here.
   allocateParallelGroup,
-
-  async runNow() {
-    await clearPause('run-now');
-    runDueJobs().catch((e) => logs.writeLine({
-      level: 'error', scope: 'scheduler',
-      message: 'runDueJobs error (remote:run-now)', meta: { error: e?.message },
-    }));
-    return { ok: true };
-  },
-
-  async setConfig(partial) {
-    const cfg = await mutate((state) => {
-      const { supervisor: supPartial, ...rest } = partial;
-      state.config = { ...state.config, ...rest };
-      if (supPartial !== undefined) {
-        state.config.supervisor = { ...(state.config.supervisor ?? {}), ...supPartial };
-      }
-      return state.config;
-    });
-    await rescheduleTimer();
-    return { ok: true, config: cfg };
-  },
 };
 
 // Registers the two job-management admin HTTP routes (PRD 689 — moved

package/src/main/templates/PRD_AUTHORING.md

@@ -392,7 +392,11 @@ the user may or may not have open.
 
 ### Fallback: writing the PRD file directly
 
-When the app is not running, first mint (or join) an Epic — `node <session-manager-repo>/scripts/mint-epic.cjs <cwd> "<goal>" [feature|bug|discussion]`; its last stdout line is the prds dir — then write `<NN>-<slug>.md` by hand into that
+When the app is not running, first join the EXISTING, already-human-approved Epic you're already
+working inside — `node <session-manager-repo>/scripts/mint-epic.cjs <cwd> <epic-id>`; its last
+stdout line is the prds dir. This only joins; it never creates an Epic, and errors out if
+`<epic-id>` doesn't already exist — get a human to create/approve the Epic first (New Epic UI, or
+`/propose-epic` + Approve & start) if it doesn't. Then write `<NN>-<slug>.md` by hand into that
 `<cwd>/session-manager-operations/scheduler/epics/<epic-id>/prds/` dir (the flat `scheduler/prds/` is RETIRED and auto-archived unexecuted at boot), add `sourcePromptId: <epic-id>` to the frontmatter so the job keeps its Epic linkage, following the frontmatter rules in §6 and the
 body conventions the rest of this guide describes (`# Goal`, `# Acceptance criteria`,
 `# Implementation notes`, `## Engineering standards` inlined verbatim — see `/develop`'s output

package/src/main/webRemote.cjs

@@ -1054,7 +1054,6 @@ function getDispatchMap() {
 
   const { manager: ptyManager } = require('./pty.cjs');
   const sessionsStore = require('./sessionsStore.cjs');
-  const scheduler = require('./scheduler.cjs');
   const { remote: histRemote } = require('./historyAggregator.cjs');
   const chatRunner = require('./chatRunner.cjs');
 
@@ -1095,37 +1094,6 @@ function getDispatchMap() {
       return { ok: true };
     },
 
-    'cmd:schedule:state': async () =>
-      scheduler.remote.getState(),
-
-    'cmd:schedule:read-prd': async (payload) => {
-      const parsed = schemas.scheduleSlug.parse(payload);
-      return scheduler.remote.readPrd(parsed.slug);
-    },
-
-    'cmd:schedule:read-log': async (payload) => {
-      const parsed = schemas.scheduleReadLog.parse(payload);
-      return scheduler.remote.readLog(parsed.slug, parsed.runId);
-    },
-
-    'cmd:schedule:write-prd': async (payload) => {
-      const parsed = schemas.scheduleWritePrd.parse(payload);
-      return scheduler.remote.writePrd(parsed.slug, parsed.body);
-    },
-
-    'cmd:schedule:reset-job': async (payload) => {
-      const parsed = schemas.scheduleSlug.parse(payload);
-      return scheduler.remote.resetJob(parsed.slug);
-    },
-
-    'cmd:schedule:run-now': async () =>
-      scheduler.remote.runNow(),
-
-    'cmd:schedule:set-config': async (payload) => {
-      const parsed = schemas.setConfigSchema.default({}).parse(payload ?? {});
-      return scheduler.remote.setConfig(parsed);
-    },
-
     'cmd:history:aggregate': async (payload) => {
       const parsed = schemas.historyAggregate.parse(payload);
       return histRemote.aggregate(parsed);

package/src/preload/api.d.ts

@@ -1390,8 +1390,16 @@ export interface SessionManagerAPI {
   };
   schedule: {
     state: () => Promise<ScheduleStateSnapshot>;
-    /** Machine-wide claude -p slot pool (sessionSlots.cjs): total/inUse/holders. */
-    sessionSlots: () => Promise<{ total: number; inUse: number; holders: { owner: string; at: string }[] }>;
+    /** Machine-wide claude -p slot pool (sessionSlots.cjs): total/inUse/holders + [min,max]/default/envOverride. */
+    sessionSlots: () => Promise<{
+      total: number; inUse: number; holders: { owner: string; at: string }[];
+      min: number; max: number; default: number; envOverride: boolean;
+    }>;
+    /** Set the slot pool's user cap (Home tab), [0, 10]; 0 pauses new launches. Ignored if SM_SESSION_SLOTS is set. */
+    setSessionSlots: (cap: number) => Promise<{
+      total: number; inUse: number; holders: { owner: string; at: string }[];
+      min: number; max: number; default: number; envOverride: boolean;
+    }>;
     setConfig: (partial: Partial<ScheduleConfig & { supervisor?: Partial<SupervisorConfig> }>) => Promise<{ ok: boolean; config: ScheduleConfig }>;
     resetJob: (slug: string) => Promise<{ ok: boolean; error?: string }>;
     runNow: () => Promise<{ ok: boolean }>;

package/src/preload/index.cjs

@@ -254,6 +254,7 @@ contextBridge.exposeInMainWorld('api', {
   schedule: {
     state: () => ipcRenderer.invoke('schedule:state'),
     sessionSlots: () => ipcRenderer.invoke('schedule:session-slots'),
+    setSessionSlots: (cap) => ipcRenderer.invoke('schedule:set-session-slots', { cap }),
     setConfig: (partial) => ipcRenderer.invoke('schedule:set-config', partial),
     resetJob: (slug) => ipcRenderer.invoke('schedule:reset-job', { slug }),
     runNow: () => ipcRenderer.invoke('schedule:run-now'),