claude-code-session-manager 0.77.0 → 0.79.0

package/src/main/lib/reaperHelpers.cjs

@@ -9,6 +9,7 @@
 
 const fs = require('node:fs');
 const { readTail } = require('./fileTail.cjs');
+const { detectRateLimitInLog } = require('./rateLimitDetect.cjs');
 
 /**
  * Return true if pid is alive AND its cmdline looks like a claude process.
@@ -38,11 +39,16 @@ function claudePidAlive(pid) {
  * of its log file and scanning for the LAST `{"type":"result"}` JSONL event.
  *
  * Returns:
- *   'success'   — last result event has subtype=success and is_error !== true
- *   'failed'    — last result event exists but indicates an error
- *   'no_result' — no result event found in the tail (process may have been killed
- *                 before emitting one, or the log is absent/empty)
- *   'unknown'   — unexpected error reading/parsing (outer catch)
+ *   'success'      — last result event has subtype=success and is_error !== true
+ *   'rate_limited' — the log tail shows the same rate-limit signal spawnJob's own
+ *                    live-process check uses (detectRateLimitInLog, the shared
+ *                    single source of truth) — a NEW, distinct outcome from
+ *                    'failed' (PRD 1117): a rate-limited death is retryable, not
+ *                    a genuine gate failure, and must never collapse into 'failed'
+ *   'failed'       — last result event exists but indicates a genuine error
+ *   'no_result'    — no result event found in the tail (process may have been killed
+ *                    before emitting one, or the log is absent/empty)
+ *   'unknown'      — unexpected error reading/parsing (outer catch)
  */
 function classifyRunOutcome(logPath) {
   try {
@@ -56,8 +62,27 @@ function classifyRunOutcome(logPath) {
         if (obj && obj.type === 'result') lastResult = obj;
       } catch { /* partial line at tail boundary or non-JSON scheduler log line */ }
     }
+    // ORDER IS LOAD-BEARING. The rate-limit check must come AFTER the success
+    // determination, never before it. The CLI emits an informational
+    // `rate_limit_event` with status:"allowed_warning" on essentially every
+    // run once utilization is non-zero, and detectRateLimitInLog matches its
+    // "rateLimitType" field — so checking first classified genuinely
+    // SUCCESSFUL runs as rate_limited. Measured on 2026-09-05 against the
+    // eight most recent runs whose own meta.json recorded exitCode:0 and
+    // rateLimited:false, four came back 'rate_limited' (e.g.
+    // 200-campaign-toolkit-weak-points-and-stuns: 55 turns, is_error:false,
+    // terminalReasonFromHarness:'completed', landed commit 7fd05f7 — matched
+    // purely on an allowed_warning five_hour event). In reapDeadRunningJobs
+    // that resets a finished job to 'pending' to re-run shipped work AND
+    // engages setPaused('rate_limit') with no rate limit in effect — strictly
+    // worse than the terminal-'failed' bug the rate_limit branch was added to
+    // fix. See the guard test in this file's __tests__ sibling.
+    if (lastResult && lastResult.subtype === 'success' && lastResult.is_error !== true) return 'success';
+    // Still checked ahead of 'no_result': a run killed mid-flight by a rate
+    // limit may never emit a result event at all, and that is a rate-limited
+    // death, not silence.
+    if (detectRateLimitInLog(logPath)) return 'rate_limited';
     if (!lastResult) return 'no_result';
-    if (lastResult.subtype === 'success' && lastResult.is_error !== true) return 'success';
     return 'failed';
   } catch {
     return 'unknown';

package/src/main/lib/runLogRetention.cjs

@@ -296,11 +296,84 @@ function resolveLiveKeysForApply(runsDir, opts, enabled) {
   }
 }
 
+/**
+ * Build the set of runIds currently claimed by a job in status 'running' —
+ * used by the orphan pass below to skip a directory whose spawn may be
+ * mid-flight right now (scheduler.cjs's pickRunDir mints the runId/dir pair
+ * before the child process is spawned; the directory itself is only
+ * mkdir'd, and files only start landing in it, once execution actually
+ * commits — see executeJob). Deliberately keyed by runId alone, not
+ * `${slug}|${runId}` like liveKeysFromJobs: a shared batch dir (tickQueue
+ * hands ONE runId to several jobs at once) is in flight if ANY job dispatched
+ * into it is still running, regardless of which slug.
+ */
+function runningRunIdsFromJobs(jobs) {
+  const ids = new Set();
+  for (const job of jobs || []) {
+    if (job && job.status === 'running' && job.runId) ids.add(job.runId);
+  }
+  return ids;
+}
+
+/**
+ * Resolve the running-runId protection set for applyRetention's orphan pass,
+ * mirroring resolveLiveKeysForApply's precedence: explicit opts win, then
+ * opts.jobs, then (only when deletion is actually about to happen) a direct
+ * read of the real scheduler queue.
+ */
+function resolveRunningRunIdsForApply(opts, enabled) {
+  if (opts && opts.runningRunIds) return opts.runningRunIds;
+  if (opts && opts.jobs) return runningRunIdsFromJobs(opts.jobs);
+  if (!enabled) return new Set();
+  try {
+    const queueStore = require('./queueStore.cjs');
+    const state = queueStore.readMergedSync();
+    return runningRunIdsFromJobs(state.jobs || []);
+  } catch {
+    return new Set();
+  }
+}
+
+/**
+ * Remove every EMPTY directory directly under runsDir, at any age, except
+ * one whose runId is in runningRunIds. These are orphans left behind by a
+ * dispatch that minted a runId/dir pair (pickRunDir) but aborted before
+ * spawnJob's executeJob ever wrote into it (slot-acquire miss, worktree-cap
+ * deferral, launch-gate block, ...) — scanRunEntries never sees them (no
+ * meta.json), so the age/count policy above can't reach them either.
+ * Returns the count of directories removed.
+ */
+function sweepOrphanDirs(runsDir, runningRunIds, errors) {
+  let dirNames;
+  try {
+    dirNames = fs.readdirSync(runsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory())
+      .map((d) => d.name);
+  } catch {
+    return 0;
+  }
+
+  let removed = 0;
+  for (const runId of dirNames) {
+    if (runningRunIds.has(runId)) continue;
+    const dir = path.join(runsDir, runId);
+    try {
+      if (fs.readdirSync(dir).length !== 0) continue;
+      fs.rmdirSync(dir);
+      removed += 1;
+    } catch (e) {
+      if (e && e.code !== 'ENOENT') errors.push({ path: dir, error: e.message });
+    }
+  }
+  return removed;
+}
+
 /**
  * Compute the report, and — ONLY when isRetentionEnabled(settings) — delete
- * the eligible files and rmdir any directory left fully empty. With no
- * opt-in (the default), this is exactly computeReport(): read-only,
- * `deleted: false`, nothing removed.
+ * the eligible files, rmdir any directory left fully empty, and sweep any
+ * orphan empty run directory (see sweepOrphanDirs). With no opt-in (the
+ * default), this is exactly computeReport(): read-only, `deleted: false`,
+ * nothing removed.
  */
 function applyRetention(runsDir, settings, opts) {
   const cfg = (settings && settings.schedulerRunLogRetention) || null;
@@ -342,7 +415,10 @@ function applyRetention(runsDir, settings, opts) {
     }
   }
 
-  return { deleted: true, removedFiles, freedBytes, errors, report };
+  const runningRunIds = resolveRunningRunIdsForApply(opts, enabled);
+  const orphanDirsRemoved = sweepOrphanDirs(runsDir, runningRunIds, errors);
+
+  return { deleted: true, removedFiles, freedBytes, orphanDirsRemoved, errors, report };
 }
 
 /**
@@ -370,6 +446,8 @@ module.exports = {
   LIVE_STATUSES,
   isLiveJob,
   liveKeysFromJobs,
+  runningRunIdsFromJobs,
+  sweepOrphanDirs,
   scanRunEntries,
   computeEligibility,
   computeReport,