@ai-dossier/sched 0.57.4 → 0.57.6

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

@@ -1397,6 +1397,24 @@ function journalMilestoneProgressIfDue(ctx, state, slotId, milestone, unit, now,
 function effectiveClosedSignal(slot, truth) {
     return (0, state_1.isReportSlot)(slot) ? false : truth.closed;
 }
+/**
+ * The `QueueEntry` fields backing each entry-rail dedup event (#638): one
+ * descriptor per event instead of accessor lambdas, so `journalConditionIfDue`
+ * and `clearCondition` are single bodies. `condition` names the streak
+ * discriminator field (#637), or `null` for a presence-only streak.
+ */
+const ENTRY_DEDUP_MARKERS = {
+    'ground-truth-unreachable': {
+        since: 'ground_truth_unreachable_since',
+        ticks: 'ground_truth_unreachable_ticks',
+        condition: 'ground_truth_unreachable_condition',
+    },
+    'pr-watch-waiting': {
+        since: 'pr_watch_waiting_since',
+        ticks: 'pr_watch_waiting_ticks',
+        condition: null,
+    },
+};
 /**
  * Journal `event` for `unit` on the first tick of a new streak, then again
  * only every `JOURNAL_DEDUP_REANNOUNCE_TICKS` ticks while it persists (#632).
@@ -1426,23 +1444,27 @@ function effectiveClosedSignal(slot, truth) {
  * Returns the patched state — callers must thread it, or the marker is lost
  * and the event re-fires next tick as if nothing had been recorded.
  */
-function journalConditionIfDue(ctx, state, unit, event, sinceOf, ticksOf, withMarker, extra) {
+function journalConditionIfDue(ctx, state, unit, event, condition, extra) {
     const issue = (0, journal_1.issueOfUnit)(unit);
     const entry = issue === null ? undefined : (0, state_1.findEntry)(state, issue);
     if (issue === null || entry === undefined) {
         journal(ctx, event, unit, extra);
         return state;
     }
-    const isNewStreak = sinceOf(entry) === null;
-    const ticks = isNewStreak ? 1 : ticksOf(entry) + 1;
+    const marker = ENTRY_DEDUP_MARKERS[event];
     const now = ctx.deps.now();
-    const since = isNewStreak ? now.toISOString() : sinceOf(entry);
-    if (isNewStreak || ticks % types_1.JOURNAL_DEDUP_REANNOUNCE_TICKS === 0) {
+    // #637: identity is the condition key + presence — a different key on the
+    // same unit starts a new streak. Events without a discriminator
+    // (`pr-watch-waiting`) are presence-only.
+    const changed = marker.condition !== null && entry[marker.condition] !== condition;
+    const { since, ticks, announce } = (0, state_1.advanceStreak)({ since: entry[marker.since], ticks: entry[marker.ticks] }, changed, now);
+    if (announce) {
         // `at` is the decision clock (AC3); `since` is the streak's onset. Both
         // are needed: `ticks_persisted` is a TICK count, and the two rails tick at
         // different, operator-tunable rates, so it maps to no fixed wall-clock.
         journal(ctx, event, unit, {
             ...extra,
+            ...(condition !== null ? { condition } : {}),
             at: now.toISOString(),
             since,
             ticks_persisted: ticks,
@@ -1453,39 +1475,29 @@ function journalConditionIfDue(ctx, state, unit, event, sinceOf, ticksOf, withMa
     // elsewhere (`isStaleFailedPark`'s window, `status.ts`'s "since" display,
     // `readiness.ts`'s dispatch tiebreak) as a clock that must not reset on a
     // silent tick.
-    return (0, state_1.patchEntry)(state, issue, withMarker(since, ticks), now, false);
-}
-function journalGroundTruthUnreachableIfDue(ctx, state, unit, extra) {
-    return journalConditionIfDue(ctx, state, unit, 'ground-truth-unreachable', (e) => e.ground_truth_unreachable_since, (e) => e.ground_truth_unreachable_ticks, (since, ticks) => ({
-        ground_truth_unreachable_since: since,
-        ground_truth_unreachable_ticks: ticks,
-    }), extra);
-}
-function journalPrWatchWaitingIfDue(ctx, state, unit, extra) {
-    return journalConditionIfDue(ctx, state, unit, 'pr-watch-waiting', (e) => e.pr_watch_waiting_since, (e) => e.pr_watch_waiting_ticks, (since, ticks) => ({ pr_watch_waiting_since: since, pr_watch_waiting_ticks: ticks }), extra);
+    return (0, state_1.patchEntry)(state, issue, {
+        [marker.since]: since,
+        [marker.ticks]: ticks,
+        ...(marker.condition !== null ? { [marker.condition]: condition } : {}),
+    }, now, false);
 }
 /**
- * Clear a `QueueEntry`'s `ground-truth-unreachable` marker once truth
- * answers again (#632) — a no-op when nothing was set, so callers can call
- * this unconditionally on every tick truth is healthy without churning
+ * Clear a `QueueEntry`'s `event` dedup marker once the condition resolves
+ * (#632) — a no-op when nothing was set, so callers can call this
+ * unconditionally on every tick the condition is healthy without churning
  * `updated_at` for entries that were never in a streak.
  */
-function clearGroundTruthUnreachable(state, unit, now) {
-    const issue = (0, journal_1.issueOfUnit)(unit);
-    const entry = issue === null ? undefined : (0, state_1.findEntry)(state, issue);
-    if (issue === null || entry === undefined || entry.ground_truth_unreachable_since === null) {
-        return state;
-    }
-    return (0, state_1.patchEntry)(state, issue, { ground_truth_unreachable_since: null, ground_truth_unreachable_ticks: 0 }, now, false);
-}
-/** Same as `clearGroundTruthUnreachable`, for the `pr-watch-waiting` marker. */
-function clearPrWatchWaiting(state, unit, now) {
+function clearCondition(state, unit, event, now) {
     const issue = (0, journal_1.issueOfUnit)(unit);
     const entry = issue === null ? undefined : (0, state_1.findEntry)(state, issue);
-    if (issue === null || entry === undefined || entry.pr_watch_waiting_since === null) {
+    const marker = ENTRY_DEDUP_MARKERS[event];
+    if (issue === null || entry === undefined || entry[marker.since] === null)
         return state;
-    }
-    return (0, state_1.patchEntry)(state, issue, { pr_watch_waiting_since: null, pr_watch_waiting_ticks: 0 }, now, false);
+    return (0, state_1.patchEntry)(state, issue, {
+        [marker.since]: null,
+        [marker.ticks]: 0,
+        ...(marker.condition !== null ? { [marker.condition]: null } : {}),
+    }, now, false);
 }
 /**
  * #575: journal the ignored stale milestone — shared by `reconcileRunning`'s
@@ -1727,7 +1739,7 @@ function reconcileRunning(ctx, state, slot, truth, unit) {
     // this unit until truth returns. The dead-pid rail above still ran — local
     // truth needs no network.
     if (!truth.reachable) {
-        return journalGroundTruthUnreachableIfDue(ctx, state, unit, {
+        return journalConditionIfDue(ctx, state, unit, 'ground-truth-unreachable', 'poll-unreachable', {
             slot: slot.id,
             detail: 'stall/advance decisions paused until truth returns',
         });
@@ -1736,7 +1748,7 @@ function reconcileRunning(ctx, state, slot, truth, unit) {
     // a PREVIOUS tick is over.
     // Named for what it holds — a SchedState with the streak cleared — not for
     // `truth.reachable`, the boolean five lines up.
-    const cleared = clearGroundTruthUnreachable(state, unit, now);
+    const cleared = clearCondition(state, unit, 'ground-truth-unreachable', now);
     // Ground truth says the unit is DONE while the agent still holds the slot —
     // externally-advanced state (AC3): reclaim the slot, kill the leftover agent.
     // A parked milestone is deliberately NOT an advance: a detached run parks
@@ -1875,7 +1887,7 @@ dispatchSignals = NO_DISPATCH_SIGNALS) {
     // hold the exit in `verifying` until truth returns, then decide. The agent
     // is already gone; no slot work is lost by waiting.
     if (!truth.reachable) {
-        return journalGroundTruthUnreachableIfDue(ctx, next, unit, {
+        return journalConditionIfDue(ctx, next, unit, 'ground-truth-unreachable', 'poll-unreachable', {
             slot: slot.id,
             detail: 'exit verification paused until truth returns',
         });
@@ -1900,10 +1912,10 @@ dispatchSignals = NO_DISPATCH_SIGNALS) {
             // against an empty trail. Return the recorded state (the pre-#596 form
             // did — `parkUnit`'s internal guard returned the state it was handed),
             // not the un-recorded `next`. #632: dedup like the sibling check above
-            // — same marker, since only one of the two can be live for this unit
-            // on a given tick (this branch is reached only after `truth.reachable`
-            // already held).
-            return journalGroundTruthUnreachableIfDue(ctx, parked, unit, {
+            // — same marker, but a distinct condition key (#637): this branch is
+            // reached only after `truth.reachable` held, so an unreachable-poll
+            // streak from the previous tick must not swallow this line.
+            return journalConditionIfDue(ctx, parked, unit, 'ground-truth-unreachable', 'parked-milestone-no-pr', {
                 slot: slot.id,
                 detail: `parked milestone (run=${truth.milestone?.run ?? 'unknown'}) carries no parseable pr= key — holding in verifying`,
             });
@@ -1911,12 +1923,12 @@ dispatchSignals = NO_DISPATCH_SIGNALS) {
         // #632: a pr= key was found — both flavors of this unit's
         // ground-truth-unreachable streak (unreachable poll, unparseable pr=)
         // are resolved.
-        return parkUnit(ctx, clearGroundTruthUnreachable(parked, unit, now), unit, pr);
+        return parkUnit(ctx, clearCondition(parked, unit, 'ground-truth-unreachable', now), unit, pr);
     }
     // #632: truth answered this tick and this unit isn't stuck on the
     // missing-pr= edge above — any streak recorded against a PREVIOUS tick
     // (either flavor) is over.
-    next = clearGroundTruthUnreachable(next, unit, now);
+    next = clearCondition(next, unit, 'ground-truth-unreachable', now);
     // #575: fence to THIS dispatch's `spawned_at` — an agent that exited having
     // posted nothing new must not read as complete against the issue's
     // PREVIOUS run's report milestone; it falls through to the recovery ladder
@@ -2160,18 +2172,18 @@ function reconcileParked(ctx, state, prPoll) {
             if (!prPoll.truths.has(issue)) {
                 continue; // parked AFTER the poll ran (this tick) — next cadence picks it up
             }
-            next = journalGroundTruthUnreachableIfDue(ctx, next, unit, {
+            next = journalConditionIfDue(ctx, next, unit, 'ground-truth-unreachable', 'pr-watch-paused', {
                 detail: 'pr watch paused until truth returns',
             });
             continue;
         }
         // #632: truth answered this tick — any unreachable streak recorded
         // against a PREVIOUS tick is over.
-        next = clearGroundTruthUnreachable(next, unit, ctx.deps.now());
+        next = clearCondition(next, unit, 'ground-truth-unreachable', ctx.deps.now());
         const failWatch = (reason) => {
             journal(ctx, 'pr-watch-failed', unit, { reason, pr: entry.pr });
             // #632: the watch is ending (terminal failure) — no more "waiting".
-            return clearPrWatchWaiting(failUnit(ctx, next, unit, reason), unit, ctx.deps.now());
+            return clearCondition(failUnit(ctx, next, unit, reason), unit, 'pr-watch-waiting', ctx.deps.now());
         };
         // #501: MERGED is checked FIRST, before any failure rail. A PR that is
         // genuinely merged is merged regardless of a leftover `auto-merge-blocked`
@@ -2185,7 +2197,7 @@ function reconcileParked(ctx, state, prPoll) {
             // AC1: the issue must ALSO be closed (a merged PR auto-closes it) —
             // until GitHub propagates, the unit stays parked and keeps watching.
             if (prPoll.closed.get(issue) !== true) {
-                next = journalPrWatchWaitingIfDue(ctx, next, unit, {
+                next = journalConditionIfDue(ctx, next, unit, 'pr-watch-waiting', null, {
                     pr: entry.pr,
                     mergedAt: truth.mergedAt,
                     detail: 'merge seen but issue not closed — keep watching',
@@ -2193,7 +2205,7 @@ function reconcileParked(ctx, state, prPoll) {
                 continue;
             }
             next = (0, state_1.transitionIssue)(next, issue, 'shipped', { reason: null }, ctx.deps.now());
-            next = clearPrWatchWaiting(next, unit, ctx.deps.now());
+            next = clearCondition(next, unit, 'pr-watch-waiting', ctx.deps.now());
             journal(ctx, 'merge-accepted', unit, { pr: entry.pr, mergedAt: truth.mergedAt });
             ctx.result.mergeAccepted.push(unit);
             continue;
@@ -2213,7 +2225,7 @@ function reconcileParked(ctx, state, prPoll) {
             // OPEN (or mergeable UNKNOWN) — keep watching. #632: this tick's truth
             // is NOT "merge seen but not closed", so a waiting streak from an
             // earlier tick's merge-then-reverted flicker is over.
-            next = clearPrWatchWaiting(next, unit, ctx.deps.now());
+            next = clearCondition(next, unit, 'pr-watch-waiting', ctx.deps.now());
         }
     }
     return next;
@@ -2250,23 +2262,23 @@ function reconcileStaleFailedParks(ctx, state, prPoll) {
             if (!prPoll.truths.has(issue)) {
                 continue; // failed AFTER the poll ran this tick — next cadence picks it up
             }
-            next = journalGroundTruthUnreachableIfDue(ctx, next, unit, {
+            next = journalConditionIfDue(ctx, next, unit, 'ground-truth-unreachable', 'stale-failure-paused', {
                 detail: 'stale-failure reconcile paused until truth returns',
             });
             continue;
         }
         // #632: truth answered this tick — any unreachable streak recorded
         // against a PREVIOUS tick is over.
-        next = clearGroundTruthUnreachable(next, unit, ctx.deps.now());
+        next = clearCondition(next, unit, 'ground-truth-unreachable', ctx.deps.now());
         if (!isPrMerged(truth)) {
             // Still blocked/open/conflicting — stays failed. #632: not "merge seen
             // but not closed" either, so a waiting streak from an earlier tick's
             // merge-then-reverted flicker is over.
-            next = clearPrWatchWaiting(next, unit, ctx.deps.now());
+            next = clearCondition(next, unit, 'pr-watch-waiting', ctx.deps.now());
             continue;
         }
         if (prPoll.closed.get(issue) !== true) {
-            next = journalPrWatchWaitingIfDue(ctx, next, unit, {
+            next = journalConditionIfDue(ctx, next, unit, 'pr-watch-waiting', null, {
                 pr: entry.pr,
                 mergedAt: truth.mergedAt,
                 reason: entry.reason,
@@ -2276,7 +2288,7 @@ function reconcileStaleFailedParks(ctx, state, prPoll) {
         }
         const failedAt = entry.updated_at;
         next = (0, state_1.transitionIssue)(next, issue, 'shipped', { reason: null }, ctx.deps.now());
-        next = clearPrWatchWaiting(next, unit, ctx.deps.now());
+        next = clearCondition(next, unit, 'pr-watch-waiting', ctx.deps.now());
         journal(ctx, 'stale-failure-reconciled', unit, {
             pr: entry.pr,
             mergedAt: truth.mergedAt,
@@ -2371,29 +2383,15 @@ function dispatchReportAgents(ctx, state, config) {
 }
 /**
  * Run the teardown script for one merged unit OUTSIDE the state lock (#468
- * AC2). Returns null when teardown must be retried next tick (setup info
- * unreachable — a transient outage, never a failure).
+ * AC2). Returns `'unreachable'` when teardown must be retried next tick
+ * (setup info unreachable — a transient outage, never a failure); the caller
+ * journals it through the dedup idiom in its second lock pass (#636), since
+ * this function has no `SchedState` to patch.
  */
 function runTeardownFor(deps, issue) {
     const info = deps.groundTruth.setupInfo(issue);
-    const unit = `issue:${issue}`;
-    if (info === undefined) {
-        // #633: AUDITED, NOT DEDUPED. This is a tenth site with #632's shape —
-        // `teardownPendingIssues` reaches it every tick and a `null` return leaves
-        // `cleanup` unset, so an unreachable `setupInfo` re-emits this line once
-        // per reconcile interval for as long as the outage lasts.
-        //
-        // Left as-is deliberately: #632 enumerated nine sites and its plan makes
-        // the boundary load-bearing ("a site outside the table is a NEW issue, not
-        // a reason to widen this one") — widening is what dissolved b-07. The fix
-        // is tracked in #636, and is not a one-liner here: `runTeardownFor` runs
-        // OUTSIDE the store lock and has no `SchedState` to patch, so the marker
-        // has to be threaded through the caller's second lock pass.
-        deps.journal.append((0, journal_1.unitEvent)('ground-truth-unreachable', unit, {
-            detail: 'teardown paused until truth returns',
-        }), deps.now());
-        return null;
-    }
+    if (info === undefined)
+        return 'unreachable';
     if (info === null) {
         return {
             cleanup: 'failed-missing-setup-info',
@@ -2528,15 +2526,26 @@ function tick(deps, config) {
         // lock; results land in a second short lock pass together with the report
         // dispatch (AC2: teardown, THEN the cheap-tier report agent).
         const results = new Map();
+        const unreachable = [];
         for (const issue of pass1.teardownPending) {
             const teardownResult = runTeardownFor(deps, issue);
-            if (teardownResult !== null)
+            if (teardownResult === 'unreachable')
+                unreachable.push(issue);
+            else
                 results.set(issue, teardownResult);
         }
-        if (results.size > 0) {
+        if (results.size > 0 || unreachable.length > 0) {
             result = deps.store.withLock((state) => {
                 const ctx = { deps, config, dispatch, result };
-                const next = recordTeardowns(ctx, state, results);
+                let next = state;
+                // #636: `setupInfo` answered for these — any unreachable streak is over.
+                for (const issue of results.keys()) {
+                    next = clearCondition(next, `issue:${issue}`, 'ground-truth-unreachable', deps.now());
+                }
+                for (const issue of unreachable) {
+                    next = journalConditionIfDue(ctx, next, `issue:${issue}`, 'ground-truth-unreachable', 'teardown-paused', { detail: 'teardown paused until truth returns' });
+                }
+                next = recordTeardowns(ctx, next, results);
                 const withReport = dispatchReportAgents(ctx, next, config);
                 return { state: withReport, result: ctx.result };
             });