@ai-dossier/sched 0.58.0 → 0.58.1

package/dist/engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}

package/dist/engine.js

@@ -111,6 +111,7 @@ const core_1 = require("@ai-dossier/core");
 const batch_dispatch_1 = require("./batch-dispatch");
 const dispatch_1 = require("./dispatch");
 const dispatch_health_1 = require("./dispatch-health");
+const dossier_root_1 = require("./dossier-root");
 const fence_1 = require("./fence");
 const groundtruth_1 = require("./groundtruth");
 const journal_1 = require("./journal");
@@ -237,6 +238,28 @@ function pollUnits(deps, state) {
             });
             continue;
         }
+        if (slot.status === 'assigned') {
+            // #778: a crash-left `assigned` slot is spawned fresh by
+            // `reconcileAssigned` — the same "resume after days" shape as
+            // `recovering`. A live pid is re-attached, never re-spawned, so it needs
+            // no read; report slots close their issue at merge, by design.
+            const issue = (0, journal_1.issueOfUnit)(slot.unit);
+            if (issue === null || out.has(slot.unit) || (0, state_1.isReportSlot)(slot))
+                continue;
+            if (slot.pid !== null && deps.spawnDeps.isAlive(slot.pid, slot.pid_start ?? undefined)) {
+                continue;
+            }
+            if (((0, state_1.findEntry)(state, issue)?.stale_closed_at ?? null) !== null)
+                continue;
+            out.set(slot.unit, {
+                reachable: true,
+                milestone: null,
+                closed: deps.groundTruth.issueClosed(issue),
+                head: null,
+                branch: slot.branch,
+            });
+            continue;
+        }
         if (slot.status !== 'running' && slot.status !== 'verifying' && slot.status !== 'exited') {
             continue;
         }
@@ -396,6 +419,36 @@ function pollLabels(deps, state, config, dispatch) {
         labels.set(issue, deps.groundTruth.issueLabels(issue));
     return { ran: true, labels };
 }
+/**
+ * #778: one `issueClosed` read per issue unit the dispatch pass could place
+ * this tick (the first `max_slots` runnable, unheld, unflagged issue units —
+ * the same ceiling as `pollLabels`) plus orphaned `dispatched` entries that
+ * `requeueOrphanedDispatches` is about to put back in that queue. A paused
+ * fleet dispatches nothing, so it reads nothing. `issueClosed` is false when
+ * gh is unreachable: an unreadable issue is never treated as closed.
+ */
+function pollClosed(deps, state, config) {
+    const out = new Map();
+    if (state.paused)
+        return out;
+    const held = new Set(state.slots.map((slot) => slot.unit).filter((u) => u !== null));
+    const unflagged = (issue) => (0, state_1.findEntry)(state, issue)?.stale_closed_at === null;
+    const candidates = state.entries
+        .filter((e) => e.status === 'dispatched' && !held.has(`issue:${e.issue}`))
+        .map((e) => e.issue);
+    for (const unit of (0, readiness_1.runnableUnits)(state)) {
+        if (unit.kind === 'issue' && !held.has(`issue:${unit.issue}`))
+            candidates.push(unit.issue);
+    }
+    for (const issue of candidates) {
+        if (out.size >= config.max_slots)
+            break;
+        if (out.has(issue) || !unflagged(issue))
+            continue;
+        out.set(issue, deps.groundTruth.issueClosed(issue));
+    }
+    return out;
+}
 /**
  * Issues this tick's read CONFIRMED carry no hard-block label (#544) — the
  * only issues `dispatchAssignments` may place. A failed read is absent here,
@@ -655,7 +708,9 @@ function seedResumeTrail(ctx, state, issue) {
         branch,
         baseBranch,
         batch: evidence.batch,
-        worktree: path.join(ctx.deps.repoDir, 'worktrees', branch.replaceAll('/', '-')),
+        // #890: the same project-root resolution batch worktrees use, so a nested
+        // layout (`.dossier/` above the checkout) lands slot + batch trees in one root.
+        worktree: path.join((0, dossier_root_1.worktreesDirFor)(ctx.deps.repoDir), branch.replaceAll('/', '-')),
         revertedCommits: evidence.reverted_commits,
     });
     if (!outcome.ok) {
@@ -2019,8 +2074,36 @@ dispatchSignals = NO_DISPATCH_SIGNALS) {
         ...(resolved.lastTool !== null ? { last_tool: resolved.lastTool } : {}),
     }, { escalate: progressed });
 }
+/**
+ * The stale-closed guard shared by every slot rail that would spawn a fresh
+ * agent (#776 `recovering`, #778 `assigned`). Returns the state to keep (the
+ * unit must NOT be spawned this tick) or `null` when the spawn may proceed.
+ *
+ * The flag is sticky and the slot stays held: releasing it is an operator
+ * decision (`sched stop --issue N`), which `sched status` names. `truth.closed`
+ * is false when gh is unreachable, so an unreachable poll never flags a unit
+ * (no work is killed on a network blip) — and an already-flagged unit stays
+ * held without any read, so a blip cannot un-hold it either.
+ */
+function holdIfIssueClosed(ctx, state, slot, unit, truth) {
+    const issue = (0, journal_1.issueOfUnit)(unit);
+    const entry = issue === null ? undefined : (0, state_1.findEntry)(state, issue);
+    if (!entry || issue === null || (0, state_1.isReportSlot)(slot))
+        return null;
+    if (entry.stale_closed_at !== null)
+        return state;
+    if (!truth.closed)
+        return null;
+    const now = ctx.deps.now();
+    journal(ctx, 'stale-closed', unit, {
+        slot: slot.id,
+        detail: `issue #${issue} is closed — recovery will not re-dispatch it; release the slot with \`sched stop --issue ${issue}\``,
+    });
+    // Not an activity bump: `updated_at` keeps meaning "last state change".
+    return (0, state_1.patchEntry)(state, issue, { stale_closed_at: now.toISOString() }, now, false);
+}
 /** Re-attach or spawn a slot left `assigned` by a crash between assign and spawn. */
-function reconcileAssigned(ctx, state, slot, unit) {
+function reconcileAssigned(ctx, state, slot, unit, truth) {
     if (slot.pid !== null && ctx.deps.spawnDeps.isAlive(slot.pid)) {
         // Crash after spawn, before the running transition: re-attach by pid.
         journal(ctx, 'orphan-pid', unit, {
@@ -2030,6 +2113,11 @@ function reconcileAssigned(ctx, state, slot, unit) {
         });
         return (0, state_1.transitionSlot)(state, slot.id, 'running', {}, ctx.deps.now());
     }
+    // #778: never spawn fresh for an issue that is closed on GitHub. Same model
+    // as `reconcileRecovering` (#776): flag, journal, hold the slot.
+    const held = holdIfIssueClosed(ctx, state, slot, unit, truth);
+    if (held !== null)
+        return held;
     if (state.paused)
         return state;
     journal(ctx, 'assigned', unit, { slot: slot.id, detail: 'crash-recovery spawn' });
@@ -2040,24 +2128,10 @@ function reconcileRecovering(ctx, state, slot, truth, unit) {
     // #776: never re-dispatch a unit whose issue is closed. Checked BEFORE the
     // pause guard so a paused scheduler still flags it (the incident shape:
     // paused for days with a recovering slot on an issue shipped elsewhere —
-    // `sched resume` would have re-run finished work). The flag is sticky and
-    // the slot stays held: releasing it is an operator decision
-    // (`sched stop --issue N`), which `sched status` names.
-    const issue = (0, journal_1.issueOfUnit)(unit);
-    const entry = issue === null ? undefined : (0, state_1.findEntry)(state, issue);
-    if (entry && issue !== null && !(0, state_1.isReportSlot)(slot)) {
-        if (entry.stale_closed_at !== null)
-            return state;
-        if (truth.closed) {
-            const now = ctx.deps.now();
-            journal(ctx, 'stale-closed', unit, {
-                slot: slot.id,
-                detail: `issue #${issue} is closed — recovery will not re-dispatch it; release the slot with \`sched stop --issue ${issue}\``,
-            });
-            // Not an activity bump: `updated_at` keeps meaning "last state change".
-            return (0, state_1.patchEntry)(state, issue, { stale_closed_at: now.toISOString() }, now, false);
-        }
-    }
+    // `sched resume` would have re-run finished work).
+    const held = holdIfIssueClosed(ctx, state, slot, unit, truth);
+    if (held !== null)
+        return held;
     // #629: while paused, do not resume a `recovering` slot's respawn — this is
     // the crash-recovery rail (a sched restart caught a slot between
     // `enterRecovery`'s transition and its own `spawnUnit` call, OR `enterRecovery`
@@ -2096,7 +2170,7 @@ function reconcileSlots(ctx, state, polled) {
         };
         switch (slot.status) {
             case 'assigned':
-                next = reconcileAssigned(ctx, next, slot, unit);
+                next = reconcileAssigned(ctx, next, slot, unit, truth);
                 break;
             case 'running':
                 next = reconcileRunning(ctx, next, slot, truth, unit);
@@ -2137,7 +2211,14 @@ function requeueOrphanedDispatches(ctx, state) {
         // that condition's first occurrence on this one. Without it, a crash
         // during an outage leaves `ground_truth_unreachable_ticks` mid-streak and
         // the redispatched unit stays silent until the next re-announcement.
-        next = (0, state_1.transitionIssue)(next, entry.issue, 'queued', { reason: null, ...state_1.CLEARED_ENTRY_DEDUP_MARKERS }, now);
+        next = (0, state_1.transitionIssue)(next, entry.issue, 'queued', {
+            reason: null,
+            ...state_1.CLEARED_ENTRY_DEDUP_MARKERS,
+            // #778: a stale-closed flag survives the requeue — clearing it would
+            // let one unreachable-gh tick re-dispatch a shipped issue. Unflagged
+            // orphans are read by `pollClosed` and flagged in the dispatch pass.
+            stale_closed_at: entry.stale_closed_at,
+        }, now);
         journal(ctx, 'requeued', `issue:${entry.issue}`, {
             detail: 'orphaned dispatch requeued after restart',
         });
@@ -2401,7 +2482,7 @@ function runTeardownFor(deps, issue) {
     return (0, teardown_1.runTeardown)(deps.teardownExec, deps.repoDir, info);
 }
 /** Phase 3: refill — every freed slot is filled in THIS tick (AC5). */
-function dispatchAssignments(ctx, state, config, labelVerifiedIssues) {
+function dispatchAssignments(ctx, state, config, labelVerifiedIssues, closedPoll) {
     const now = ctx.deps.now();
     // #544: `pollLabels` reads only the first `max_slots` runnable units — the
     // ceiling on what this pass can place — which keeps the per-tick `gh` cost
@@ -2420,6 +2501,12 @@ function dispatchAssignments(ctx, state, config, labelVerifiedIssues) {
             .filter((entry) => !labelVerifiedIssues.has(entry.issue))
             .map((entry) => `issue:${entry.issue}`))
         : new Set();
+    // #778: a stale-closed entry is never dispatched (the flag is sticky; only
+    // `sched stop` / a requeue-elsewhere resolves it).
+    for (const entry of state.entries) {
+        if (entry.stale_closed_at !== null)
+            exclude.add(`issue:${entry.issue}`);
+    }
     // #565: decide who wins each free slot over BOTH kinds — a ready batch
     // outranking a same-readiness issue (priority desc → readiness age → issue
     // number, `runnableUnits`) must not lose its capacity to an issue dispatch
@@ -2451,6 +2538,19 @@ function dispatchAssignments(ctx, state, config, labelVerifiedIssues) {
         const entry = (0, state_1.findEntry)(next, assignment.issue);
         if (!entry)
             continue;
+        // #778: queued/classified entries (and requeued orphans) whose issue was
+        // closed while they waited are flagged, not dispatched.
+        // Unread (unblocked mid-tick by the label pass, or slid into the window)
+        // falls back to one bounded read here: assignments never exceed free
+        // capacity, and a same-tick refill (#525 AC5) must not be deferred.
+        const closed = closedPoll.get(assignment.issue) ?? ctx.deps.groundTruth.issueClosed(assignment.issue);
+        if (closed) {
+            journal(ctx, 'stale-closed', unit, {
+                detail: `issue #${assignment.issue} is closed — will not dispatch it; drop it with \`sched stop --issue ${assignment.issue}\``,
+            });
+            next = (0, state_1.patchEntry)(next, assignment.issue, { stale_closed_at: now.toISOString() }, now, false);
+            continue;
+        }
         const { state: withSlot, slotId } = (0, scheduler_1.assignToIdleSlot)(next, unit, null, now);
         next = withSlot;
         journal(ctx, 'assigned', unit, { slot: slotId, priority: entry.priority });
@@ -2504,6 +2604,7 @@ function tick(deps, config) {
     const prPoll = pollParkedPrs(deps, state0, dispatch);
     const labelPoll = pollLabels(deps, state0, config, dispatch);
     const labelVerifiedIssues = labelVerified(labelPoll);
+    const closedPoll = pollClosed(deps, state0, config);
     const pass1 = deps.store.withLock((state) => {
         const ctx = { deps, config, dispatch, result: emptyResult() };
         let next = reconcileSlots(ctx, state, polled);
@@ -2514,7 +2615,7 @@ function tick(deps, config) {
         // #544: immediately before the dispatch pass, so a cleared label can be
         // dispatched this same tick and a fresh one can never be dispatched over.
         next = reconcileLabelBlocks(ctx, next, labelPoll);
-        next = dispatchAssignments(ctx, next, config, labelVerifiedIssues);
+        next = dispatchAssignments(ctx, next, config, labelVerifiedIssues, closedPoll);
         return {
             state: next,
             result: { tick: ctx.result, teardownPending: teardownPendingIssues(next) },