smol-symphony 0.2.0 → 0.3.0

package/dist/src/core/schedule/tick.js

@@ -0,0 +1,553 @@
+// FCIS rewrite — the orchestrator scheduler reducer (the functional core's
+// top-level tick).
+//
+// REF (read-only, do not modify): src/orchestrator.ts — `tick()`,
+// `dispatchSorted()`, `onWorkerExit()` / `updateCircuitBreaker()`, `onRetryTimer()`
+// / `handleRetryIneligible()`, and `maybeArmSleepCycle()` / `recordSleepCycleProgress()`.
+//
+// The reference orchestrator folds three distinct runtime events over one
+// in-memory snapshot (running / claimed / retry maps + circuit-breaker streaks +
+// the sleep-cycle counter):
+//
+//   1. a POLL tick   — fetch candidates, sort, dispatch up to the slot ceiling,
+//                       then maybe arm the sleep cycle and reschedule the poll.
+//   2. a WORKER EXIT  — fold the exit into the circuit breaker; trip-to-holding
+//                       or schedule a retry/continuation.
+//   3. a RETRY TIMER  — re-poll, re-check eligibility, redispatch or release.
+//
+// This module re-expresses that fold as ONE pure, synchronous reducer:
+// `tick(event, snapshot) -> TickResult`. Every nondeterministic input (the
+// tracker candidate list, the memory probe reading, the prior clamp flag, the
+// running/claimed/retry projections, "now") is passed in as plain data on the
+// snapshot/event; every side effect the original performed (dispatch, arm a
+// retry timer, reap a VM, move-to-holding, log, reschedule the poll) is RETURNED
+// as data — a `DispatchPlan[]` + an `Effect[]` the shell executes.
+//
+// It COMPOSES the sibling deciders rather than re-deriving them:
+//   - admission.ts        → computeMemoryAdmission / decideAvailableGlobalSlots
+//   - slots.ts            → sortForDispatch / hasGlobalSlot / hasPerStateSlot
+//   - eligibility.ts      → computeEligibilityReason
+//   - retry.ts            → decideExitRetry / decideRetryAfterIneligible / scheduleRetryEffect
+//   - circuit-breaker.ts  → decideCircuitBreaker / tripToHoldingEffect
+//   - sleep-cycle.ts      → decideSpawn / recordSleepCycleProgress
+//
+// 100% SYNCHRONOUS. No async/await/Promise, no IO, no node: imports, no wall
+// clock / randomness. `now` (epoch ms, the ISO `lastPollAt` stamp) and the
+// memory-probe reading are injected. Imports only from src/types and sibling core
+// modules under src/core/schedule. (NodeNext ESM: .js on every relative import.)
+import { computeMemoryAdmission, decideAvailableGlobalSlots } from './admission.js';
+import { sortForDispatch, hasPerStateSlot } from './slots.js';
+import { computeEligibilityReason } from './eligibility.js';
+import { decideExitRetry, decideRetryAfterIneligible, scheduleRetryEffect } from './retry.js';
+import { decideCircuitBreaker, tripToHoldingEffect } from './circuit-breaker.js';
+import { decideSpawn, recordSleepCycleProgress } from './sleep-cycle.js';
+import { decideImageReadiness } from '../reconcile/image-decide.js';
+import { decideReconcileForState } from './reconcile-issue.js';
+// ─── timing constants (REF: src/orchestrator.ts) ─────────────────────────────
+/** Slot-holding follow-up delay after a clean exit (REF: `CONTINUATION_DELAY_MS`). */
+export const CONTINUATION_DELAY_MS = 1_000;
+/** Base delay for the first failure backoff (REF: `FAILURE_BASE_MS`). */
+export const FAILURE_BASE_MS = 10_000;
+/** Stable timer id the poll-tick reschedule arms (REF: the orchestrator's poll timer). */
+export const POLL_TIMER_ID = 'orchestrator_poll';
+/** Actor stamped on the orchestrator-driven sleep-cycle spawn (the create effect + its log). */
+export const SPAWN_CYCLE_ACTOR = 'symphony/sleep-cycle';
+// ─── shared slot/eligibility helpers ─────────────────────────────────────────
+/** Count pending retries that hold a slot (continuations only). */
+function pendingContinuationCount(retries) {
+    let n = 0;
+    for (const r of retries)
+        if (r.kind === 'continuation')
+            n++;
+    return n;
+}
+/**
+ * Count DISTINCT issues currently live in `stateName` across the post-dispatch
+ * running set + the on-disk candidate scan (case-insensitive). A running issue is
+ * still on disk in its state dir, so the candidate scan already covers running /
+ * claimed / a prior-poll mint; the running set is unioned for belt-and-braces.
+ * Drives the sleep-cycle `max_in_flight` guard.
+ */
+function countLiveInState(running, candidates, stateName) {
+    const key = stateName.toLowerCase();
+    const ids = new Set();
+    for (const c of candidates)
+        if (c.state.toLowerCase() === key)
+            ids.add(c.id);
+    for (const r of running)
+        if (r.state.toLowerCase() === key)
+            ids.add(r.issue_id);
+    return ids.size;
+}
+/** Build the slot-accounting snapshot for a given effective cap + claimed/running set. */
+function buildSlotSnapshot(snapshot, effectiveCap, running, retries) {
+    return {
+        effectiveCap,
+        runningCount: running.length,
+        runningStates: running.map((r) => r.state),
+        pendingRetries: retries.map((r) => ({ kind: r.kind, target_state: r.target_state })),
+    };
+}
+/**
+ * Fold the memory probe + running count + config into the admission summary and
+ * the clamp-transition log decision (REF: `computeAdmission()` +
+ * `availableGlobalSlots()`'s inline clamp logging).
+ */
+function resolveAdmission(snapshot) {
+    const admission = computeMemoryAdmission({
+        enabled: snapshot.cfg.memoryAdmissionEnabled,
+        staticCap: snapshot.cfg.staticCap,
+        running: snapshot.running.length,
+        probe: snapshot.memoryProbe,
+        reserveMib: snapshot.cfg.hostMemoryReserveMib,
+        perVmMib: snapshot.cfg.perVmMib,
+    });
+    const slots = decideAvailableGlobalSlots({
+        admission,
+        running: snapshot.running.length,
+        pendingContinuations: pendingContinuationCount(snapshot.retries),
+        previousClampActive: snapshot.previousClampActive,
+    });
+    return {
+        admission,
+        availableSlots: slots.availableSlots,
+        nextClampActive: slots.nextClampActive,
+        logs: slots.logs,
+    };
+}
+/** Arm the poll timer after `ms` (REF: `scheduleTick(ms)`). The poll tick reschedules
+ *  at `cfg.pollIntervalMs`; an operator nudge re-arms at `0` to poll now. */
+function pollTimerEffect(ms) {
+    return { family: 'timer', kind: 'set_timer', id: POLL_TIMER_ID, ms };
+}
+/** The reschedule-the-poll timer effect (REF: `scheduleTick(interval_ms)`). */
+function rescheduleEffect(cfg) {
+    return pollTimerEffect(cfg.pollIntervalMs);
+}
+// ─── the reducer ───────────────────────────────────────────────────────────────
+/**
+ * Fold one runtime event over the orchestrator snapshot. Pure and synchronous:
+ * returns the next-state deltas + the Effect[] the shell executes. Dispatches to
+ * the per-event reducer below.
+ */
+export function tick(event, snapshot) {
+    switch (event.kind) {
+        case 'poll':
+            return reducePoll(event, snapshot);
+        case 'worker_exit':
+            return reduceWorkerExit(event, snapshot);
+        case 'retry_timer':
+            return reduceRetryTimer(event, snapshot);
+        case 'operator_nudge':
+            return reduceOperatorNudge();
+        case 'operator_move':
+            return reduceOperatorMove(event, snapshot);
+    }
+}
+/**
+ * Operator nudge (REF: the operator `triggerRefresh` side-door, now an event):
+ * coalesce an immediate poll. Folds to a single `set_timer(POLL_TIMER_ID, 0)`
+ * effect — the same poll-reschedule the poll tick arms, but at `ms: 0` so the
+ * next poll runs now. No claim / dispatch / breaker deltas (an otherwise-empty
+ * TickResult); the shell's existing `set_timer`-with-`pollTimerId` branch re-arms
+ * the poll exactly as the old `triggerRefresh` did.
+ */
+function reduceOperatorNudge() {
+    return { dispatch: [], effects: [pollTimerEffect(0)], claim: [], release: [] };
+}
+/**
+ * Operator move (REF: the old `cancelLiveAttemptOnMove` shell side-door, now an
+ * event). The tracker move already landed; fold the cancel/cleanup/release
+ * decision against the live running/retry projections:
+ *   - a running attempt backs the issue → EMIT a `worker.cancel` effect (the loop
+ *     performs it; core holds no live handles). `cleanupWorkspace = toTerminal`:
+ *     a terminal target reaps the workspace, an active target keeps it so the
+ *     post-exit continuation redispatches fresh on the agent/<id> branch.
+ *   - else a pending retry backs it → RELEASE the claim (TickResult.release, which
+ *     the loop routes to releaseClaim: clears the armed backoff timer + claim +
+ *     breaker streak), freeing it now instead of waiting the backoff out.
+ *   (running/retry are mutually exclusive — a dispatch clears any pending retry,
+ *   a retry is only armed once the worker has exited — so running wins.)
+ *   - `toActive` → also re-arm the poll at 0ms (the same nudge `operator_nudge`
+ *     emits) so an active target is picked up immediately. A settled-row move with
+ *     no live attempt is just this nudge (or nothing for a holding/terminal target).
+ * Pure; no mutation.
+ */
+function reduceOperatorMove(event, snapshot) {
+    const effects = [];
+    const release = [];
+    if (snapshot.running.some((r) => r.issue_id === event.issueId)) {
+        // Source the cancel/cleanup decision from the SAME pure decider the poll-loop's
+        // move-reconcile net runs (`decideReconcileForState`), so a dashboard move and a
+        // disk/external move can't drift on the workspace-cleanup flag (issue 211). An
+        // operator move ALWAYS cancels a live attempt — even onto another active state,
+        // where the decider returns `refresh` — because the operator explicitly relocated
+        // it; only the cleanup flag is the decider's (terminal target ⇒ reap, active /
+        // holding ⇒ keep the workspace for the post-exit redispatch).
+        const action = decideReconcileForState(event.toState, snapshot.cfg.states);
+        effects.push({
+            family: 'worker',
+            kind: 'cancel',
+            issueId: event.issueId,
+            cleanupWorkspace: action.kind === 'terminate' && action.cleanup,
+        });
+    }
+    else if (snapshot.retries.some((r) => r.issue_id === event.issueId)) {
+        release.push(event.issueId);
+    }
+    if (event.toActive)
+        effects.push(pollTimerEffect(0));
+    return { dispatch: [], effects, claim: [], release };
+}
+/**
+ * Poll tick (REF: `tick()` → `dispatchSorted()` → `maybeArmSleepCycle()` →
+ * `scheduleTick()`). Sort the candidates, dispatch eligible ones until the slot
+ * ceiling is exhausted (decrementing the running set as each is claimed so the
+ * per-state + global gates see the in-tick allocations), then maybe arm the
+ * sleep cycle and reschedule the poll.
+ */
+function reducePoll(event, snapshot) {
+    const { cfg } = snapshot;
+    const { admission, availableSlots, nextClampActive, logs } = resolveAdmission(snapshot);
+    const effects = [...logs];
+    const dispatch = [];
+    const claim = [];
+    // Image-readiness gate (issue 206): when `gondolin.oci_image` is configured but
+    // its asset isn't converted yet, HOLD VM dispatch this tick and emit an
+    // `ensure_image` to kick the one-time build (the loop runs it as a tracked async
+    // and clears the hold once cached). This runs BEFORE the dispatch loop so a
+    // VM-needing candidate is never admitted against a missing image. The
+    // `gondolin.image` escape hatch wins the runtime selector when set
+    // (`resolveImagePath`), so it short-circuits the gate — never holding dispatch on
+    // `oci_image` readiness — tested the same way `resolveImagePath` tests it.
+    const escapeHatchConfigured = !!(cfg.image && cfg.image.length > 0);
+    const imageDecision = decideImageReadiness(snapshot.image, escapeHatchConfigured);
+    effects.push(...imageDecision.effects);
+    // Mutable in-tick projections: as we claim an issue we add it to `running` and
+    // `claimed` so the slot/eligibility gates see the just-made allocation (REF's
+    // loop re-reads `availableGlobalSlots()` / `running` after each dispatch).
+    const running = [...snapshot.running];
+    const claimedSet = new Set(snapshot.claimed);
+    let remaining = imageDecision.holdDispatch ? 0 : availableSlots;
+    const sorted = sortForDispatch(event.candidates);
+    for (const issue of sorted) {
+        if (remaining <= 0)
+            break;
+        const slotSnapshot = buildSlotSnapshot(snapshot, admission.effectiveCap, running, snapshot.retries);
+        const reason = computeEligibilityReason(issue, /*ignoreOwnClaim*/ false, {
+            active: cfg.activeStates,
+            terminal: cfg.terminalStates,
+            running: new Set(running.map((r) => r.issue_id)),
+            claimed: claimedSet,
+            perStateSlot: (state) => hasPerStateSlot(state, slotSnapshot, cfg.states),
+        });
+        if (reason !== null)
+            continue;
+        dispatch.push({ issue, attempt: null, trackerRoot: event.trackerRoot });
+        claim.push(issue.id);
+        claimedSet.add(issue.id);
+        running.push({ issue_id: issue.id, state: issue.state });
+        remaining--;
+    }
+    // Sleep-cycle recurring spawn. The orchestrator-idle signal is: no active
+    // candidates this poll AND nothing running/claimed/pending. Use the
+    // POST-dispatch running/claimed projections so a poll that just dispatched is
+    // correctly non-idle. A trigger MINTS a fresh ephemeral reflection issue (a
+    // create effect the shell executes) instead of re-arming one immortal ticket.
+    // Requires a resolved tracker root to write into — skip the spawn when null.
+    const noActiveCandidates = event.candidates.length === 0;
+    let doneSinceReflect;
+    if (cfg.spawn.spawnState && event.trackerRoot !== null) {
+        const idle = noActiveCandidates &&
+            running.length === 0 &&
+            claimedSet.size === 0 &&
+            snapshot.retries.length === 0;
+        // In-flight count for the `max_in_flight` guard: how many issues are already
+        // live in the spawn state right now. Counted across the on-disk candidate scan
+        // (every running/claimed/just-minted-prior-poll reflection is still on disk in
+        // the spawn dir until it transitions) UNION the post-dispatch running set, so a
+        // busy-stretch `after_terminal` trigger can't mint a second while one is live.
+        // PLUS the shell's pending mints: a `write_issue` the shell already started but
+        // hasn't yet written is invisible to both projections above, so a worker exit +
+        // poll racing between emit and landing would otherwise slip past the cap.
+        const inFlight = countLiveInState(running, event.candidates, cfg.spawn.spawnState) +
+            (snapshot.pendingSpawnMints ?? 0);
+        const decision = decideSpawn({
+            enabled: true,
+            onIdle: cfg.spawn.onIdle,
+            afterTerminal: cfg.spawn.afterTerminal,
+            doneSinceReflect: snapshot.doneSinceReflect,
+            idle,
+            inFlight,
+            maxInFlight: cfg.spawn.maxInFlight,
+            nowIso: snapshot.nowIso,
+            titleTemplate: cfg.spawn.title,
+            bodyLeadIn: cfg.spawn.body,
+        });
+        if (decision) {
+            // Mint a fresh reflection issue. The shell executes the create through a
+            // guarded path (keyed on the actor) that resets the counter only on a
+            // successful mint and restores the prior count if the mint fails. Core
+            // optimistically returns a 0 counter here so a poll that fires the create
+            // can't re-fire it before the write lands.
+            effects.push({
+                family: 'tracker',
+                kind: 'write_issue',
+                trackerRoot: event.trackerRoot,
+                state: cfg.spawn.spawnState,
+                title: decision.title,
+                description: decision.body,
+                actor: SPAWN_CYCLE_ACTOR,
+            });
+            doneSinceReflect = 0;
+            effects.push({
+                family: 'log',
+                kind: 'emit',
+                level: 'info',
+                message: 'sleep cycle spawned reflection',
+                fields: {
+                    trigger: decision.trigger,
+                    done_since_reflect: snapshot.doneSinceReflect,
+                    spawn_state: cfg.spawn.spawnState,
+                    actor: SPAWN_CYCLE_ACTOR,
+                },
+            });
+        }
+    }
+    effects.push(rescheduleEffect(cfg));
+    const result = {
+        dispatch,
+        effects,
+        claim,
+        release: [],
+        clampActive: nextClampActive,
+        lastPollAt: snapshot.nowIso,
+        admission,
+    };
+    if (doneSinceReflect !== undefined)
+        result.doneSinceReflect = doneSinceReflect;
+    return result;
+}
+/**
+ * Worker exit (REF: `onWorkerExit()` → `updateCircuitBreaker()` →
+ * `decideExitRetry()` → `scheduleRetry()`). The exited issue is already removed
+ * from `running` by the shell; this reducer folds the exit into the breaker, the
+ * sleep-cycle counter, and the retry schedule.
+ */
+function reduceWorkerExit(event, snapshot) {
+    const { cfg } = snapshot;
+    const effects = [];
+    // Sleep-cycle progress (`recordSleepCycleProgress`) — fold the exit into the
+    // terminal-transition counter. Excludes a finished reflection's own terminal
+    // move structurally (a terminal transition out of the spawn state).
+    const nextDone = recordSleepCycleProgress(snapshot.doneSinceReflect, event.progress, cfg.spawn.spawnState);
+    const doneSinceReflect = nextDone !== snapshot.doneSinceReflect ? nextDone : undefined;
+    // Circuit breaker (REF: `updateCircuitBreaker`). Fold the exit into the streak.
+    const decision = decideCircuitBreaker({
+        normal: event.normal,
+        reason: event.reason,
+        prior: snapshot.circuitBreakers.get(event.issueId) ?? null,
+        threshold: cfg.circuitBreakerThreshold,
+    });
+    if (decision.kind === 'continue') {
+        // Under threshold — persist the streak and schedule the failure retry.
+        return buildRetryExit(event, cfg, {
+            op: 'set',
+            issueId: event.issueId,
+            state: { normalizedReason: decision.normalizedReason, count: decision.count },
+        }, doneSinceReflect);
+    }
+    if (decision.kind === 'trip') {
+        // Threshold reached. Clear the streak; route to holding (when one is declared)
+        // and do NOT schedule a retry (REF: `tripCircuitBreaker` returns true).
+        effects.push({
+            family: 'runlog',
+            kind: 'system',
+            issueId: event.issueId,
+            event: 'circuit_breaker_tripped',
+            fields: { reason: event.reason, consecutive_failures: decision.count },
+        });
+        effects.push({
+            family: 'log',
+            kind: 'emit',
+            level: 'error',
+            message: 'circuit breaker tripped; halting retries',
+            fields: { reason: event.reason, consecutive_failures: decision.count },
+            issueId: event.issueId,
+        });
+        if (cfg.holdingState) {
+            effects.push(tripToHoldingEffect({
+                issueId: event.issueId,
+                holdingState: cfg.holdingState,
+                fromState: event.targetState,
+                fromRoot: event.trackerRootAtDispatch,
+                actor: event.resolvedActor,
+                reason: event.reason,
+                count: decision.count,
+            }));
+        }
+        else {
+            // No holding state declared — REF retains the claim to halt the loop and
+            // logs loudly. We do NOT release the claim; the breaker is cleared but the
+            // issue stays claimed so the eligibility gate keeps blocking it this session.
+            effects.push({
+                family: 'log',
+                kind: 'emit',
+                level: 'error',
+                message: 'no holding state declared; retaining claim to halt the retry loop',
+                fields: { reason: event.reason },
+                issueId: event.issueId,
+            });
+        }
+        const result = {
+            dispatch: [],
+            effects,
+            claim: [],
+            // Release the claim only when the move succeeds; the shell decides that on
+            // the move's EffectResult. Core proposes the clear and lets the shell hold
+            // the claim if the move is declined (matches REF's success-gated release).
+            release: cfg.holdingState ? [event.issueId] : [],
+            breaker: { op: 'clear', issueId: event.issueId },
+        };
+        if (doneSinceReflect !== undefined)
+            result.doneSinceReflect = doneSinceReflect;
+        return result;
+    }
+    // kind === 'reset': clean exit. Clear any streak and schedule the continuation.
+    return buildRetryExit(event, cfg, { op: 'clear', issueId: event.issueId }, doneSinceReflect);
+}
+/**
+ * Build the schedule-a-retry-and-exit result shared by the breaker's `continue`
+ * (set the streak) and `reset` (clear the streak) branches: compute the
+ * retry/continuation plan via `decideExitRetry`, emit the schedule + exit-log
+ * effects, and assemble the TickResult — parameterized by the `breaker` delta
+ * the branch needs. (Both branches enter with an empty effect list, so the
+ * result carries exactly the two effects emitted here.)
+ */
+function buildRetryExit(event, cfg, breaker, doneSinceReflect) {
+    const plan = decideExitRetry({
+        normal: event.normal,
+        reason: event.reason,
+        priorAttempt: event.priorAttempt,
+        targetState: event.targetState,
+        continuationDelayMs: CONTINUATION_DELAY_MS,
+        failureBaseMs: FAILURE_BASE_MS,
+        maxBackoffMs: cfg.maxRetryBackoffMs,
+    });
+    const effects = [
+        scheduleRetryEffect(event.issueId, event.identifier, plan),
+        exitLog(event, plan.attempt, plan.delayMs),
+    ];
+    const result = { dispatch: [], effects, claim: [], release: [], breaker };
+    if (doneSinceReflect !== undefined)
+        result.doneSinceReflect = doneSinceReflect;
+    return result;
+}
+/** The worker-exit log line (REF: `onWorkerExit`'s normal/abnormal log). */
+function exitLog(event, nextAttempt, delayMs) {
+    if (event.normal) {
+        return {
+            family: 'log',
+            kind: 'emit',
+            level: 'info',
+            message: 'worker exited (normal)',
+            fields: { reason: event.reason },
+            issueId: event.issueId,
+        };
+    }
+    return {
+        family: 'log',
+        kind: 'emit',
+        level: 'warn',
+        message: 'worker exited (abnormal)',
+        fields: { reason: event.reason, next_attempt: nextAttempt, delay_ms: delayMs },
+        issueId: event.issueId,
+    };
+}
+/**
+ * Retry timer (REF: `onRetryTimer()` → eligibility re-check →
+ * `handleRetryIneligible()` / redispatch). The shell already deleted the retry
+ * entry and re-polled candidates. Find the issue in the fresh candidate set,
+ * re-check eligibility ignoring its OWN claim, and decide:
+ *   - not in candidates    → release the claim.
+ *   - eligible             → redispatch (carrying the retry's attempt number).
+ *   - ineligible (no slot) → reschedule a failure backoff.
+ *   - ineligible (other)   → release the claim.
+ */
+function reduceRetryTimer(event, snapshot) {
+    const { cfg } = snapshot;
+    const issue = event.candidates.find((i) => i.id === event.issueId);
+    if (!issue) {
+        return {
+            dispatch: [],
+            effects: [
+                {
+                    family: 'log',
+                    kind: 'emit',
+                    level: 'info',
+                    message: 'retry releasing claim (not in candidates)',
+                    fields: { issue_id: event.issueId, issue_identifier: event.identifier },
+                    issueId: event.issueId,
+                },
+            ],
+            claim: [],
+            release: [event.issueId],
+            breaker: { op: 'clear', issueId: event.issueId },
+        };
+    }
+    const { admission, availableSlots } = resolveAdmission(snapshot);
+    const slotSnapshot = buildSlotSnapshot(snapshot, admission.effectiveCap, snapshot.running, snapshot.retries);
+    // `availableSlots` already factors running + pending continuations; the slot
+    // snapshot's per-state gate reuses the same effective cap so the global and
+    // per-state checks agree (REF: `eligibilityReason(issue, /*ignoreOwnClaim*/ true)`).
+    void availableSlots;
+    const reason = computeEligibilityReason(issue, /*ignoreOwnClaim*/ true, {
+        active: cfg.activeStates,
+        terminal: cfg.terminalStates,
+        running: new Set(snapshot.running.map((r) => r.issue_id)),
+        claimed: snapshot.claimed,
+        perStateSlot: (state) => hasPerStateSlot(state, slotSnapshot, cfg.states),
+    });
+    if (reason === null) {
+        // Eligible — redispatch carrying the retry's attempt number.
+        return {
+            dispatch: [{ issue, attempt: event.attempt, trackerRoot: event.trackerRoot }],
+            effects: [],
+            claim: [issue.id],
+            release: [],
+        };
+    }
+    const action = decideRetryAfterIneligible({
+        reason,
+        priorAttempt: event.attempt,
+        targetState: issue.state,
+        failureBaseMs: FAILURE_BASE_MS,
+        maxBackoffMs: cfg.maxRetryBackoffMs,
+    });
+    if (action.kind === 'reschedule') {
+        return {
+            dispatch: [],
+            effects: [scheduleRetryEffect(issue.id, issue.identifier, action.plan)],
+            claim: [],
+            release: [],
+        };
+    }
+    // release
+    return {
+        dispatch: [],
+        effects: [
+            {
+                family: 'log',
+                kind: 'emit',
+                level: 'info',
+                message: 'retry releasing claim (ineligible)',
+                fields: { issue_id: issue.id, issue_identifier: issue.identifier, reason },
+                issueId: issue.id,
+            },
+        ],
+        claim: [],
+        release: [issue.id],
+        breaker: { op: 'clear', issueId: issue.id },
+    };
+}
+//# sourceMappingURL=tick.js.map

package/dist/src/core/schedule/tick.js.map

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