@ai-dossier/sched 0.52.0 → 0.54.0

package/dist/batch-dispatch.js

@@ -100,6 +100,7 @@ exports.MAX_BATCH_AGENT_RESPAWNS = exports.tailMembersRefusal = void 0;
 exports.memberBranchFor = memberBranchFor;
 exports.evictMemberAndContinue = evictMemberAndContinue;
 exports.resumeBlockedGate = resumeBlockedGate;
+exports.undispatchedSurvivingMembers = undispatchedSurvivingMembers;
 exports.reconcileStaleBlockedBatches = reconcileStaleBlockedBatches;
 exports.memberDispatchModeFor = memberDispatchModeFor;
 exports.runBatchTick = runBatchTick;
@@ -3141,7 +3142,18 @@ const MEMBER_RECONCILE_CHAIN = {
  * and the branch is exactly what the merge evidence below covers.
  */
 function everySurvivingMemberDispatched(state, batch) {
+    return undispatchedSurvivingMembers(state, batch).length === 0;
+}
+/**
+ * The surviving members `everySurvivingMemberDispatched` finds NOT yet
+ * dispatched — the members that keep a blocked batch out of
+ * `reconcileStaleBlockedBatches` (#686). Exported for `sched attach-pr`
+ * (#824), which refuses to record a PR the reconcile would then never act on,
+ * and names these members in the refusal.
+ */
+function undispatchedSurvivingMembers(state, batch) {
     const evicted = new Set(batch.evictions.map((e) => e.issue));
+    const undispatched = [];
     for (const issue of batch.members) {
         const entry = (0, state_1.findEntry)(state, issue);
         if (!entry)
@@ -3159,9 +3171,9 @@ function everySurvivingMemberDispatched(state, batch) {
         // completion — everything the entry can reach afterwards means the
         // member was dispatched and its work is on the branch.
         if (!DISPATCHED_MEMBER_STATUSES.has(entry.status))
-            return false;
+            undispatched.push(issue);
     }
-    return true;
+    return undispatched;
 }
 /** Slot-line statuses that prove a member was actually dispatched (see above). */
 const DISPATCHED_MEMBER_STATUSES = new Set([
@@ -3228,6 +3240,26 @@ function clearPrDetectAmbiguous(deps, batch, now) {
  */
 function recordPrDetectAmbiguous(deps, batch, matches, now) {
     const { since, ticks, announce } = advanceBatchDedupStreak(batch.pr_detect_ambiguous_reason, batch.pr_detect_ambiguous_since, batch.pr_detect_ambiguous_ticks, state_1.PR_DETECT_AMBIGUOUS_REASON, now);
+    // #824 review: the lookup above ran outside the lock — an operator's
+    // `sched attach-pr` (or a resume/abandon) may have landed meanwhile. Write
+    // the streak (and journal it) only while the batch is STILL blocked with no
+    // PR; never rewrite the marker an attach just cleared, nor tell the
+    // operator to run `sched attach-pr` after they already did.
+    const written = deps.store.withLock((s) => {
+        const b = (0, state_1.findBatch)(s, batch.id);
+        if (!b || b.status !== 'blocked' || b.pr !== null)
+            return { state: s, result: false };
+        return {
+            state: (0, state_1.patchBatch)(s, batch.id, {
+                pr_detect_ambiguous_reason: state_1.PR_DETECT_AMBIGUOUS_REASON,
+                pr_detect_ambiguous_since: since,
+                pr_detect_ambiguous_ticks: ticks,
+            }, now, false),
+            result: true,
+        };
+    });
+    if (!written)
+        return;
     if (announce) {
         journalEvent(deps, 'pr-detect-ambiguous', unit(batch.id), {
             reason: state_1.PR_DETECT_AMBIGUOUS_REASON,
@@ -3236,21 +3268,14 @@ function recordPrDetectAmbiguous(deps, batch, matches, now) {
             at: now.toISOString(),
             since,
             ticks_persisted: ticks,
-            // #789 review: neither "record it explicitly" (no command exists) nor
-            // "close the extras" (a MERGED PR cannot be closed, so it never leaves
-            // `gh pr list --state merged`) was ever an actionable remedy — state
-            // what actually resolves it instead. #824 tracks the missing verb.
-            detail: `${matches.length} MERGED PRs match head=${batch.branch ?? '?'} (#${matches.join(', #')}) — refusing to guess which is ours; nothing recorded. The batch still reconciles via commits-in-base/members-closed evidence if either holds; otherwise inspect and \`sched abandon --batch ${batch.id}\`, or use \`sched attach-pr\` once #824 ships it`,
+            // #789 review: "close the extras" (a MERGED PR cannot be closed, so it
+            // never leaves `gh pr list --state merged`) was never an actionable
+            // remedy — state what actually resolves it instead: the operator names
+            // the batch's own PR with `sched attach-pr` (#824), which holds it to
+            // these same candidate checks.
+            detail: `${matches.length} MERGED PRs match head=${batch.branch ?? '?'} (#${matches.join(', #')}) — refusing to guess which is ours; nothing recorded. The batch still reconciles via commits-in-base/members-closed evidence if either holds; otherwise inspect the candidates and record the batch's own with \`sched attach-pr --batch ${batch.id} <pr>\`, or \`sched abandon --batch ${batch.id}\``,
         });
     }
-    deps.store.withLock((s) => ({
-        state: (0, state_1.patchBatch)(s, batch.id, {
-            pr_detect_ambiguous_reason: state_1.PR_DETECT_AMBIGUOUS_REASON,
-            pr_detect_ambiguous_since: since,
-            pr_detect_ambiguous_ticks: ticks,
-        }, now, false),
-        result: undefined,
-    }));
 }
 /**
  * #686: reconcile a `blocked` batch whose work demonstrably shipped anyway.
@@ -3382,7 +3407,7 @@ function reconcileStaleBlockedBatches(deps, now, result, anchorCtx) {
         // #789 review: what the lock ACTUALLY applied, not what the outer
         // snapshot predicted — re-derived from `b` (read under the lock) below,
         // since `batch.pr` could in principle have changed between the snapshot
-        // above and the lock acquiring (e.g. a future `sched attach-pr`, #824).
+        // above and the lock acquiring (e.g. `sched attach-pr`, #824).
         let effectivePr = null;
         let prWasRecorded = false;
         deps.store.withLock((s) => {