claude-code-session-manager 0.75.3 → 0.77.0

package/src/main/lib/childWithLog.cjs

@@ -40,6 +40,10 @@
  *   killedByWatchdog — string | null
  *   error         — Error | undefined (child 'error' event or sync spawn throw)
  *   spawnFailed   — boolean, true when the error came from a synchronous spawn throw
+ *   leakedDescendants — { pid, pcpu, etimes, comm }[], the process-group survivors
+ *                       sweepChildProcessGroup found still alive right before it
+ *                       swept them. [] in the normal case (nothing leaked, or
+ *                       non-Linux, or enumeration failed). See sweepChildProcessGroup.
  *   safeLog       — same safeLog (usable inside onExit for final log lines)
  *
  * Returns { child, cancel } where cancel() clears all timers + SIGKILLs.
@@ -47,7 +51,11 @@
  */
 
 const fs = require('node:fs');
-const { spawn } = require('node:child_process');
+const { spawn, execFileSync } = require('node:child_process');
+
+// Grace period between the post-exit SIGTERM sweep and the follow-up SIGKILL
+// sweep of a detached child's process group. See sweepChildProcessGroup below.
+const POST_EXIT_GROUP_SWEEP_GRACE_MS = 5000;
 
 // ---------- Phase 1 ----------
 
@@ -119,6 +127,63 @@ function openLog(logPath) {
  * }} opts
  * @returns {{ child: import('child_process').ChildProcess | null, cancel: () => void }}
  */
+// Post-exit process-group sweep.
+//
+// Incident (2026-08-31, ~/Projects/starry-night-ships): scheduler jobs spawn
+// detached: true, and every watchdog path (result-tail, deadman, idle-tail)
+// kills the whole process group via ctx.killTree — but only on an *overrun*
+// exit. When the executor child exits normally, nothing swept the group, so
+// anything the agent had backgrounded to work around the foreground call cap
+// (the `bash -c '<gate> > /tmp/x.log; echo $? > /tmp/x.done'` shape) reparented
+// to init and kept running for nobody: three orphaned test batteries at PPID 1
+// were found, one burning ~5 cores for 56 minutes. The invariant this restores:
+// a job's descendants must not outlive the job. Killing the job's own process
+// group at the job's own exit is ownership-based and needs no /proc heuristics
+// to distinguish an abandoned descendant from a live one.
+// Enumerate the still-alive members of process group `pgid` (Linux only).
+// Read-only — never throws, never blocks the caller's exit path. Used to
+// report what sweepChildProcessGroup is about to kill, since the kill itself
+// is silent (ESRCH on the normal empty-group case).
+function enumerateProcessGroupSurvivors(pgid) {
+  if (process.platform !== 'linux') return [];
+  if (!pgid || pgid <= 1) return [];
+  try {
+    const out = execFileSync('ps', ['-eo', 'pid,pgrp,pcpu,etimes,comm'], { encoding: 'utf8', timeout: 2000 });
+    const survivors = [];
+    for (const line of out.split('\n').slice(1)) {
+      const m = line.trim().match(/^(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(.+)$/);
+      if (!m) continue;
+      const [, pidStr, pgrpStr, pcpuStr, etimesStr, comm] = m;
+      if (Number(pgrpStr) !== pgid) continue;
+      survivors.push({ pid: Number(pidStr), pcpu: Number(pcpuStr), etimes: Number(etimesStr), comm });
+    }
+    return survivors;
+  } catch {
+    return [];
+  }
+}
+
+// Returns the leaked descendants found (see enumerateProcessGroupSurvivors),
+// having enumerated them BEFORE issuing SIGTERM so the report reflects what
+// was actually swept, not what happened to still be running afterward.
+function sweepChildProcessGroup(child, detached) {
+  if (!detached) return [];
+  if (!child || !child.pid || child.pid <= 1) return [];
+  // Defensive: never target the Session Manager process's own group.
+  if (child.pid === process.pid) return [];
+
+  const leaked = enumerateProcessGroupSurvivors(child.pid).filter((p) => p.pid !== child.pid);
+
+  try { process.kill(-child.pid, 'SIGTERM'); } catch { /* ESRCH: empty group, the normal case */ }
+
+  const t = setTimeout(() => {
+    try { process.kill(-child.pid, 'SIGKILL'); } catch { /* ESRCH: empty group, the normal case */ }
+  }, POST_EXIT_GROUP_SWEEP_GRACE_MS);
+  if (t.unref) t.unref();
+
+  return leaked;
+}
+
 function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watchdogs = [], onExit }) {
   const startedAt = Date.now();
 
@@ -173,6 +238,7 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   // calls onExit (caller may still safeLog inside), then closes the fd.
   const handleDone = (exitCode, signal, error, spawnFailed) => {
     clearAllTimers();
+    const leakedDescendants = sweepChildProcessGroup(ctx.child, !!spawnSpec.options?.detached);
     if (onExit) {
       onExit({
         exitCode,
@@ -180,6 +246,7 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
         killedByWatchdog: ctx.killedByWatchdog,
         error,
         spawnFailed: spawnFailed ?? false,
+        leakedDescendants,
         safeLog,
       });
     }
@@ -215,4 +282,4 @@ function withChildAndLog({ fd, logPath, safeLog, closeFd, spawn: spawnSpec, watc
   return { child, cancel };
 }
 
-module.exports = { openLog, withChildAndLog };
+module.exports = { openLog, withChildAndLog, POST_EXIT_GROUP_SWEEP_GRACE_MS };

package/src/main/lib/claudeBin.cjs

@@ -39,4 +39,57 @@ function resolveClaudeBin() {
   return cached;
 }
 
-module.exports = { resolveClaudeBin };
+// ---------- version probe ----------
+//
+// `claude --version`, cached. The scheduler's launch circuit breaker
+// (lib/launchFailure.cjs) records the CLI version a launch block was armed
+// under and drops the block the moment the version changes — the incident
+// behind it (issue #11: an outdated CLI sending a thinking parameter the
+// model rejects) is fixed by `claude update`, and the queue must notice
+// that without a human pressing anything. Async, bounded, never throws:
+// a probe failure yields null and the breaker simply loses the
+// version-change shortcut (backoff still recovers).
+const VERSION_TTL_MS = 5 * 60_000;
+const VERSION_PROBE_TIMEOUT_MS = 8_000;
+let versionCache = { at: 0, value: null, inflight: null };
+
+function probeClaudeVersion({ now = Date.now(), execFileImpl } = {}) {
+  // Operator/test pin: skips executing the binary entirely.
+  if (process.env.SM_CLAUDE_VERSION) return Promise.resolve(process.env.SM_CLAUDE_VERSION);
+  if (versionCache.inflight) return versionCache.inflight;
+  if (versionCache.value !== null && now - versionCache.at < VERSION_TTL_MS) {
+    return Promise.resolve(versionCache.value);
+  }
+  const execFile = execFileImpl || require('node:child_process').execFile;
+  const bin = resolveClaudeBin();
+  versionCache.inflight = new Promise((resolve) => {
+    let settled = false;
+    const done = (value) => {
+      if (settled) return;
+      settled = true;
+      versionCache = { at: Date.now(), value, inflight: null };
+      resolve(value);
+    };
+    try {
+      // cwd is a neutral temp dir on purpose: the version does not depend on
+      // it, and the binary must never be handed the caller's working tree —
+      // a stub `claude` (tests point SM_CLAUDE_BIN at one) that writes
+      // markers or commits into process.cwd() once did so in the real repo.
+      execFile(bin, ['--version'], { timeout: VERSION_PROBE_TIMEOUT_MS, windowsHide: true, cwd: os.tmpdir() }, (err, stdout) => {
+        if (err) return done(null);
+        const m = /(\d+\.\d+\.\d+[^\s]*)/.exec(String(stdout || ''));
+        done(m ? m[1] : (String(stdout || '').trim() || null));
+      });
+    } catch {
+      done(null);
+    }
+  });
+  return versionCache.inflight;
+}
+
+/** Test hook — forget the cached version so the next probe re-executes. */
+function resetClaudeVersionCache() {
+  versionCache = { at: 0, value: null, inflight: null };
+}
+
+module.exports = { resolveClaudeBin, probeClaudeVersion, resetClaudeVersionCache };

package/src/main/lib/crossProjectFeedback.cjs

@@ -66,6 +66,7 @@ const {
 } = require('./epicMint.cjs');
 const { appendAuditEvent } = require('./auditLog.cjs');
 const { OPS_ROOT_DIR } = require('./opsOwnership.cjs');
+const { resolveProjectContext } = require('./projectRootResolve.cjs');
 
 /** Only these three Epic tags make sense for an inbound report — they are
  *  exactly the tags that route through /develop (tagLibrary.ts). 'build',
@@ -251,8 +252,14 @@ function validateFeedbackInput(input = {}) {
   } catch (e) {
     return bad(400, `toCwd rejected: ${e.message}`);
   }
+  // Normalize fromCwd (worktree -> main tree, ops-internal path -> project
+  // root) BEFORE validatePath/the same-project check below — an agent
+  // sending feedback from inside its own Epic's worktree pwd must be
+  // compared/chained against its REAL project, not the ephemeral checkout.
+  // See projectRootResolve.cjs's header.
+  const normalizedFromCwd = resolveProjectContext({ cwd: input.fromCwd }).cwd || input.fromCwd;
   try {
-    fromCwd = config.validatePath(path.resolve(input.fromCwd));
+    fromCwd = config.validatePath(path.resolve(normalizedFromCwd));
   } catch (e) {
     return bad(400, `fromCwd rejected: ${e.message}`);
   }

package/src/main/lib/definitionOfDone.cjs

@@ -328,7 +328,7 @@ const RISK_HEURISTICS = [
  * @param {string} headingText  Case-insensitive heading to find.
  * @returns {string}
  */
-function _extractSection(body, headingText) {
+function extractSection(body, headingText) {
   const escapedHeading = headingText.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
   const headingRe = new RegExp(`^#+\\s+${escapedHeading}`, 'i');
   const lines = body.split('\n');
@@ -398,7 +398,7 @@ function flagRiskySurfaces(jobs, { prdsDir, gitTimeoutMs = 10_000 } = {}) {
       try {
         const raw = fs.readFileSync(path.join(resolvedPrdsDir, `${job.slug}.md`), 'utf8');
         const body = splitFrontmatter(raw).body;
-        candidateText = _extractSection(body, 'Implementation notes');
+        candidateText = extractSection(body, 'Implementation notes');
       } catch { /* no candidate text — skip */ }
     }
 
@@ -573,6 +573,7 @@ module.exports = {
   reportPathFor,
   reportExists,
   extractAcCommand,
+  extractSection,
   reverifyAc,
   reverifyBatch,
   flagRiskySurfaces,