claude-code-session-manager 0.88.0 → 0.89.0

package/src/main/scheduler.cjs

@@ -1865,7 +1865,12 @@ function computeStallSummary(state) {
     byProject[key].invalid = (byProject[key].invalid || 0) + 1;
   }
   const total = jobs.length + invalidJobs.length;
-  const stalled = total > 0 && running === 0 && pending === 0 && !state?.paused;
+  // A drained queue (every row completed/skipped) is idle, not stalled — a
+  // stall needs at least one parked problem row (failed/needs_review/
+  // quarantined/invalid) that is waiting on someone.
+  const isProblemStatus = (st) => st !== 'completed' && st !== 'skipped';
+  const stalled = total > 0 && running === 0 && pending === 0 && !state?.paused
+    && (invalidJobs.length > 0 || jobs.some((j) => isProblemStatus(j.status)));
   for (const key of Object.keys(byProject)) {
     const counts = byProject[key];
     const projRunning = counts.running || 0;
@@ -1873,7 +1878,9 @@ function computeStallSummary(state) {
     const projTotal = Object.keys(counts)
       .filter((k) => k !== 'stalled')
       .reduce((sum, k) => sum + counts[k], 0);
-    counts.stalled = projTotal > 0 && projRunning === 0 && projPending === 0 && !state?.paused;
+    const projProblem = Object.keys(counts)
+      .some((k) => k !== 'stalled' && k !== 'completed' && k !== 'skipped' && counts[k] > 0);
+    counts.stalled = projTotal > 0 && projRunning === 0 && projPending === 0 && !state?.paused && projProblem;
   }
   return { stalled, total, running, pending, byProject };
 }
@@ -4790,6 +4797,25 @@ As the LAST LINE of your final result text, emit exactly one of:
 Print PASS only once the commit above has actually landed.`;
 }
 
+/**
+ * Stamps integrateBranch's failure subtype (`failureKind`) and conflicted
+ * paths onto a job row at finalize; clears both when there is no failure so
+ * a re-run never carries a stale subtype. Plain JSON values only.
+ */
+function stampIntegrationFailure(row, integration) {
+  if (integration && integration.failureKind) {
+    row.integrationFailureKind = integration.failureKind;
+    if (Array.isArray(integration.conflictedPaths)) row.integrationConflictPaths = integration.conflictedPaths;
+    else delete row.integrationConflictPaths;
+    if (integration.baseHeadSha) row.integrationBaseHeadSha = integration.baseHeadSha;
+    else delete row.integrationBaseHeadSha;
+  } else {
+    delete row.integrationFailureKind;
+    delete row.integrationConflictPaths;
+    delete row.integrationBaseHeadSha;
+  }
+}
+
 /**
  * Mechanical recovery (PRD 1130). isFixPlanBeyondDepthCap (below) is the
  * ONLY gate on re-investigating a fix-plan job at investigationDepth >= 2 —
@@ -4802,14 +4828,21 @@ Print PASS only once the commit above has actually landed.`;
  * auto-fix it authors no plan and spawns no model; it is pure git.
  *
  * The closed set of mechanically-resolvable verdicts starts at exactly
- * 'worktree_integration_failed': PRD 1125 already taught integrateBranch to
- * parse git's "would be overwritten by merge" stderr, verify the blocking
- * paths are byte-identical to the branch, discard the proven duplicates, and
- * retry the merge once. A job parked with this verdict has its `sm-job/
- * <slug>` branch preserved (integrateJobBranch never deletes the branch on
- * failure — see cleanupJobWorktree's `keepBranch: !integration.ok`), so a
- * plain re-call of integrateBranch against that same branch inherits PRD
- * 1125's auto-resolution for free — no re-implementation needed here.
+ * 'worktree_integration_failed', which covers two subtypes (job.
+ * integrationFailureKind): `blocking_paths` — PRD 1125 taught integrateBranch
+ * to parse git's "would be overwritten by merge" stderr, verify the blocking
+ * paths are byte-identical to the branch, discard the proven duplicates and
+ * retry once, so a re-call can genuinely succeed once the dirty files are
+ * gone — and `content_conflict`, which PRD 1125 explicitly does NOT handle
+ * (parseBlockingMergePaths returns null for it). Only pure-addition text
+ * conflicts are auto-resolved (mc-02, gitWorktree.cjs, kill switch
+ * SM_PURE_ADDITION_MERGE_DISABLE=1) — and that already ran inside the
+ * original failed integration. Re-calling integrateBranch for a content
+ * conflict that survived it, against an unmoved base HEAD, fails
+ * deterministically, so the selector skips it (WITHOUT spending the one
+ * attempt) until HEAD moves — a sibling merge may make the retry succeed.
+ * A job parked with this verdict has its `sm-job/<slug>` branch preserved
+ * (cleanupJobWorktree's `keepBranch: !integration.ok`).
  *
  * Bounded to exactly one attempt via job.mechanicalRecoveryAttempted,
  * stamped in the SAME mutate as the outcome (performMechanicalRecovery,
@@ -4821,11 +4854,41 @@ Print PASS only once the commit above has actually landed.`;
  */
 const MECHANICALLY_RESOLVABLE_VERDICTS = new Set(['worktree_integration_failed']);
 
-function selectMechanicalRecoveryTarget(job) {
+/**
+ * True when a retry is provably futile: a content_conflict whose base HEAD is
+ * the same as at failure time. Unknown state (no stamp, null current HEAD)
+ * is NOT futile — falls back to attempting the retry.
+ */
+function isMechanicalRecoveryFutile(job, currentHeadSha) {
+  return job.integrationFailureKind === 'content_conflict'
+    && !!job.integrationBaseHeadSha
+    && !!currentHeadSha
+    && job.integrationBaseHeadSha === currentHeadSha;
+}
+
+/**
+ * Resolves the current HEAD once per distinct cwd for a pass. Returns a
+ * `(job) => sha|null` lookup over `jobs`; the memo lives only as long as the
+ * returned closure. O(distinct cwds) git calls, not O(jobs).
+ */
+async function resolveHeadShasForPass(jobs) {
+  const byCwd = new Map();
+  for (const j of jobs || []) {
+    if (!j || j.status !== 'needs_review' || j.integrationFailureKind !== 'content_conflict') continue;
+    const cwd = j.cwd || DEFAULT_PROJECT_CWD;
+    if (!byCwd.has(cwd)) byCwd.set(cwd, gitHead(cwd));
+  }
+  const resolved = new Map();
+  for (const [cwd, p] of byCwd) resolved.set(cwd, await p);
+  return (j) => (j && resolved.get(j.cwd || DEFAULT_PROJECT_CWD)) || null;
+}
+
+function selectMechanicalRecoveryTarget(job, currentHeadSha = null) {
   if (process.env.SM_MECHANICAL_RECOVERY_DISABLE === '1') return null;
   if (!job || job.status !== 'needs_review') return null;
   if (!MECHANICALLY_RESOLVABLE_VERDICTS.has(job.verifierVerdict)) return null;
   if (job.mechanicalRecoveryAttempted === true) return null;
+  if (isMechanicalRecoveryFutile(job, currentHeadSha)) return null;
   const cwd = job.cwd || DEFAULT_PROJECT_CWD;
   return { slug: job.slug, cwd, branch: jobWorktree.branchNameFor(job.slug), carriedPaths: job.carriedPaths || [] };
 }
@@ -6037,7 +6100,7 @@ async function spawnInvestigation(failedJob, runDir, { deadChild = null } = {})
   // Mechanical recovery (PRD 1130): same first-refusal treatment — a job
   // eligible for a pure-git retry must never also get a cold-read fix-plan
   // PRD authored in the same pass.
-  if (selectMechanicalRecoveryTarget(failedJob)) {
+  if (selectMechanicalRecoveryTarget(failedJob, failedJob.integrationFailureKind === 'content_conflict' ? await gitHead(failedJob.cwd || DEFAULT_PROJECT_CWD) : null)) {
     console.log(`[scheduler] skip investigation: ${failedJob.slug} is mechanical-recovery eligible`);
     return { deferred: false };
   }
@@ -6852,6 +6915,7 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
     let res;
     let worktreeLeftoverDirty = [];
     let worktreeIntegrationFailure = null;
+    let worktreeIntegrationDetail = null;
     // Set only when integrateJobBranch's stderr-parsing auto-resolve fired
     // (PRD 1125) — surfaced on the job row so the Queue UI can say the merge
     // self-healed rather than silently looking like an ordinary merge.
@@ -6912,6 +6976,7 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
         }
         if (!integration.ok) {
           worktreeIntegrationFailure = integration.reason;
+          worktreeIntegrationDetail = integration;
           console.error(`[scheduler] ${job.slug}: worktree branch integration FAILED (${integration.reason}) — branch ${worktree.branch} preserved in ${guardCwd} for manual recovery`);
         } else if (integration.integrated) {
           console.log(`[scheduler] ${job.slug}: worktree branch ${worktree.branch} integrated into ${guardCwd}${integration.mergeCommit ? ' (merge commit)' : ' (fast-forward)'}`);
@@ -7198,7 +7263,9 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
     if (worktreeIntegrationFailure) {
       verifyResult = {
         verdict: 'worktree_integration_failed',
-        reason: `worktree branch integration failed: ${worktreeIntegrationFailure} — branch preserved for manual merge`,
+        reason: worktreeIntegrationDetail && worktreeIntegrationDetail.failureKind === 'content_conflict'
+          ? `Integration blocked by a content conflict in ${(worktreeIntegrationDetail.conflictedPaths || []).join(', ') || 'unknown paths'} — branch ${jobWorktree.branchNameFor(job.slug)} preserved; needs a manual merge.`
+          : `worktree branch integration failed: ${worktreeIntegrationFailure} — branch preserved for manual merge`,
         downgradeTo: 'needs_review',
       };
     }
@@ -7313,6 +7380,9 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
     let mechanicalRecoveryTarget = null;
     let terminalNotifySnapshot = null;
     const newlyCompletedPrds = [];
+    // Base HEAD for the mechanical-recovery futility check — read here, never inside mutate() (no I/O).
+    const finalizeHeadSha = worktreeIntegrationDetail && worktreeIntegrationDetail.failureKind === 'content_conflict'
+      ? await gitHead(guardCwd) : null;
     await mutate((s) => {
       const i2 = s.jobs.findIndex((x) => x.slug === job.slug);
       // A job already moved off 'running' by someone else (namely
@@ -7504,6 +7574,7 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
           } else if (!['blocked_by_foreign_wip_streak', 'budget_exceeded'].includes(s.jobs[i2].verifierVerdict)) {
             delete s.jobs[i2].verifierVerdict;
           }
+          stampIntegrationFailure(s.jobs[i2], worktreeIntegrationFailure ? worktreeIntegrationDetail : null);
           transitionJob(s.jobs[i2], effectiveStatus, { reason: finalizeReason, source: 'spawnJob:finalize' });
           s.jobs[i2].finishedAt = new Date().toISOString();
           s.jobs[i2].exitCode = res.exitCode;
@@ -7613,7 +7684,7 @@ async function spawnJob(job, runId, runDir, defaultCwd, resumeTarget = null) {
             // depth-cap check, so it must never fall through to either.
             // Snapshot only (no I/O inside mutate()); the actual git retry
             // happens outside mutate(), below.
-            const mTarget = selectMechanicalRecoveryTarget(s.jobs[i2]);
+            const mTarget = selectMechanicalRecoveryTarget(s.jobs[i2], finalizeHeadSha);
             if (mTarget) {
               mechanicalRecoveryJob = { ...s.jobs[i2] };
               mechanicalRecoveryTarget = mTarget;
@@ -10821,9 +10892,17 @@ async function reverifyNeedsReview() {
   // check in spawnJob missed because the app restarted in between). Depth
   // never disqualifies it, so it runs regardless of investigationDepth.
   {
+    const headFor = await resolveHeadShasForPass(queueForResumeAndAutofix.jobs);
     for (const job of queueForResumeAndAutofix.jobs) {
-      const target = selectMechanicalRecoveryTarget(job);
-      if (!target) continue;
+      const head = headFor(job);
+      const target = selectMechanicalRecoveryTarget(job, head);
+      if (!target) {
+        if (job.status === 'needs_review' && job.mechanicalRecoveryAttempted !== true
+          && MECHANICALLY_RESOLVABLE_VERDICTS.has(job.verifierVerdict) && isMechanicalRecoveryFutile(job, head)) {
+          console.log(`[scheduler] mechanical-recovery: skip ${job.slug} — content conflict, base HEAD unchanged since failure`);
+        }
+        continue;
+      }
       console.log(`[scheduler] mechanical-recovery: needs_review ${job.slug} → re-integrating ${target.branch}`);
       performMechanicalRecovery(job, target).catch((e) => {
         console.error('[scheduler] performMechanicalRecovery error', job.slug, e);
@@ -12591,6 +12670,9 @@ module.exports = {
   buildClaudeSpawnArgs,
   spawnResumeRecovery,
   selectMechanicalRecoveryTarget,
+  isMechanicalRecoveryFutile,
+  resolveHeadShasForPass,
+  stampIntegrationFailure,
   performMechanicalRecovery,
   MECHANICALLY_RESOLVABLE_VERDICTS,
   selectLeftoverQuarantineTarget,