smol-symphony 0.2.0 → 0.3.0

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

@@ -0,0 +1,83 @@
+// FCIS rewrite — pure dispatch-eligibility decisions.
+//
+// Ported faithfully from `src/orchestrator-decisions.ts`
+// (computeEligibilityReason / hasNonTerminalBlocker / resolveActorString) of the
+// reference orchestrator. These are deterministic, side-effect-free decision
+// functions: every nondeterministic input (the active/terminal/running/claimed
+// state sets and the per-state slot availability) is passed in as plain data,
+// so the functions stay (data) -> data.
+//
+// The orchestrator shell holds the live tracker view and concurrency
+// bookkeeping; it materialises an EligibilitySnapshot each poll and calls
+// computeEligibilityReason to learn whether an issue may be dispatched. A null
+// return means "dispatch it"; a non-null string is a short, human-facing reason
+// the issue is currently ineligible (surfaced in the run log / dashboard).
+//
+// 100% SYNCHRONOUS. No IO, no clock, no randomness. Imports only from
+// src/types. (NodeNext ESM: .js extension on the relative type import.)
+import { resolveStateKey } from '../state-resolve.js';
+/**
+ * Returns null when the issue is eligible to dispatch, otherwise a short reason
+ * string. `ignoreOwnClaim` is set by the retry path so an issue's own claim does
+ * not block its redispatch.
+ *
+ * Order of checks mirrors the reference exactly (callers and tests depend on
+ * the precedence): required-fields → state-active → already-running →
+ * already-claimed → per-state-slot → todo-blocker. The first failing check
+ * wins; later checks are not evaluated.
+ */
+export function computeEligibilityReason(issue, ignoreOwnClaim, snap) {
+    if (!issue.id || !issue.identifier || !issue.title || !issue.state) {
+        return 'missing required issue fields';
+    }
+    const state = issue.state.toLowerCase();
+    if (!snap.active.has(state) || snap.terminal.has(state))
+        return 'state not active';
+    if (snap.running.has(issue.id))
+        return 'already running';
+    if (!ignoreOwnClaim && snap.claimed.has(issue.id))
+        return 'already claimed';
+    if (!snap.perStateSlot(issue.state))
+        return 'no per-state slot';
+    if (state === 'todo' && hasNonTerminalBlocker(issue, snap.terminal)) {
+        return 'has non-terminal blocker';
+    }
+    return null;
+}
+/**
+ * True when the issue has at least one blocker that is NOT in a terminal state.
+ * An unresolvable blocker (null `state`) counts as non-terminal — we cannot
+ * prove it is done, so we keep the issue blocked. Blocker state membership is
+ * tested against the LOWERCASED terminal set.
+ */
+export function hasNonTerminalBlocker(issue, terminal) {
+    for (const b of issue.blocked_by) {
+        if (!b.state)
+            return true;
+        if (!terminal.has(b.state.toLowerCase()))
+            return true;
+    }
+    return false;
+}
+/**
+ * Resolved actor string (`"<adapter>/<model or 'default'>"`) for the
+ * dispatch-time RunningEntry. When the state is not declared in the workflow,
+ * falls back to the workflow-level adapter/model (the reference returned null
+ * from the canonical-key lookup and substituted the defaults inline; we keep
+ * the same observable result — the function always returns a string).
+ *
+ * Per-state `adapter` overrides the workflow adapter when set. For the model,
+ * `undefined` inherits the workflow model while an explicit `null` clears it to
+ * `'default'` — matching the StateConfig.model "undefined inherits / null
+ * clears" contract.
+ */
+export function resolveActorString(states, workflowAdapter, workflowModel, state) {
+    const key = resolveStateKey(states, state);
+    if (key === null)
+        return `${workflowAdapter}/${workflowModel ?? 'default'}`;
+    const s = states[key];
+    const adapter = s.adapter ?? workflowAdapter;
+    const model = s.model === undefined ? workflowModel : s.model;
+    return `${adapter}/${model ?? 'default'}`;
+}
+//# sourceMappingURL=eligibility.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"eligibility.js","sourceRoot":"","sources":["../../../../src/core/schedule/eligibility.ts"],"names":[],"mappings":"AAAA,sDAAsD;AACtD,EAAE;AACF,yDAAyD;AACzD,iFAAiF;AACjF,6EAA6E;AAC7E,+EAA+E;AAC/E,8EAA8E;AAC9E,wCAAwC;AACxC,EAAE;AACF,qEAAqE;AACrE,0EAA0E;AAC1E,+EAA+E;AAC/E,gFAAgF;AAChF,2EAA2E;AAC3E,EAAE;AACF,sEAAsE;AACtE,wEAAwE;AAIxE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAOtD;;;;;;;;;GASG;AACH,MAAM,UAAU,wBAAwB,CACtC,KAAY,EACZ,cAAuB,EACvB,IAAyB;IAEzB,IAAI,CAAC,KAAK,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,IAAI,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC;QACnE,OAAO,+BAA+B,CAAC;IACzC,CAAC;IACD,MAAM,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IACxC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC;QAAE,OAAO,kBAAkB,CAAC;IACnF,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAAE,OAAO,iBAAiB,CAAC;IACzD,IAAI,CAAC,cAAc,IAAI,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC;QAAE,OAAO,iBAAiB,CAAC;IAC5E,IAAI,CAAC,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,KAAK,CAAC;QAAE,OAAO,mBAAmB,CAAC;IAChE,IAAI,KAAK,KAAK,MAAM,IAAI,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpE,OAAO,0BAA0B,CAAC;IACpC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,KAAY,EAAE,QAA6B;IAC/E,KAAK,MAAM,CAAC,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC;QACjC,IAAI,CAAC,CAAC,CAAC,KAAK;YAAE,OAAO,IAAI,CAAC;QAC1B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IACxD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAmC,EACnC,eAAuB,EACvB,aAAwC,EACxC,KAAa;IAEb,MAAM,GAAG,GAAG,eAAe,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;IAC3C,IAAI,GAAG,KAAK,IAAI;QAAE,OAAO,GAAG,eAAe,IAAI,aAAa,IAAI,SAAS,EAAE,CAAC;IAC5E,MAAM,CAAC,GAAG,MAAM,CAAC,GAAG,CAAE,CAAC;IACvB,MAAM,OAAO,GAAG,CAAC,CAAC,OAAO,IAAI,eAAe,CAAC;IAC7C,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC9D,OAAO,GAAG,OAAO,IAAI,KAAK,IAAI,SAAS,EAAE,CAAC;AAC5C,CAAC"}

package/dist/src/core/schedule/reconcile-issue.js

@@ -0,0 +1,82 @@
+// FCIS rewrite — pure per-running-issue reconcile decision.
+//
+// Ported faithfully from `src/orchestrator-decisions.ts`
+// (decideReconcileForIssue / ReconcileAction) of the reference orchestrator.
+// Deterministic and side-effect free: the only inputs are the freshly-fetched
+// tracker view of one running issue and the workflow `states:` map. The shell
+// owns the running-issue bookkeeping and the actual terminate/refresh/cleanup
+// IO; this function only DECIDES which of those to perform.
+//
+// 100% SYNCHRONOUS. No IO, no clock, no randomness, no node: imports. Imports
+// only from src/types. (NodeNext ESM: .js extension on the relative type
+// imports.)
+//
+// The role filters `activeStateNames` / `terminalStateNames` are the canonical
+// pure folds in core/issue/parse.ts (the WIRED home for the state-role helpers);
+// imported from there so the three former copies can't drift.
+import { activeStateNames, terminalStateNames } from '../issue/parse.js';
+/**
+ * Per-running-issue reconcile decision based on the freshly-fetched tracker
+ * view. Branch precedence is ported exactly from the reference (callers/tests
+ * depend on it):
+ *
+ *   1. Missing row (`fresh === undefined`)  → terminate, NO cleanup
+ *      (`reason: 'tracker_state_missing'`). The issue vanished from the tracker;
+ *      we can't know whether its workspace is safe to reap, so leave it.
+ *   2. Terminal-role state  → terminate, cleanup driven BY ROLE
+ *      (`reason: 'tracker_state_terminal'`). Routing the cleanup flag through
+ *      the canonical state's `role` (rather than hard-coding `true`) lets a
+ *      future per-state `cleanup_workspace` flag flip without touching the
+ *      orchestrator. A terminal-role state cleans up; anything else does not.
+ *   3. Active-role state  → refresh the in-memory issue snapshot.
+ *   4. Anything else (holding, or a state not declared in the workflow) →
+ *      terminate, NO cleanup (`reason: 'tracker_state_non_active'`).
+ *
+ * State membership is compared case-insensitively (the tracker may store a
+ * differently-cased directory name than the workflow declares), matching the
+ * rest of symphony's eligibility/reconcile paths.
+ *
+ * Thin wrapper over {@link decideReconcileForState}: the only field consulted is
+ * `fresh.state`, so the state-keyed decider holds the logic and the operator-move
+ * reducer (which has the moved-to state, not a full Issue) shares it verbatim —
+ * the poll-loop reconcile and the dashboard move path can't drift (issue 211).
+ */
+export function decideReconcileForIssue(fresh, states) {
+    return decideReconcileForState(fresh?.state, states);
+}
+/**
+ * The state-keyed core of {@link decideReconcileForIssue}: decide the reconcile
+ * action from a freshly-resolved tracker STATE NAME (or `undefined` for a row that
+ * is no longer present). Same branch precedence + case-insensitive matching as the
+ * Issue-keyed wrapper; shared by the operator-move reducer, which holds the move
+ * target state rather than a full Issue.
+ */
+export function decideReconcileForState(state, states) {
+    if (state === undefined) {
+        return { kind: 'terminate', cleanup: false, reason: 'tracker_state_missing' };
+    }
+    const s = state.toLowerCase();
+    const terminal = new Set(terminalStateNames(states).map((n) => n.toLowerCase()));
+    if (terminal.has(s)) {
+        // Cleanup is driven by the canonical state's role: a terminal-role state
+        // reaps its workspace, anything matched here that somehow isn't terminal
+        // (it can't be, given `terminalStateNames`, but keep the reference's
+        // defensive null-handling) does not.
+        //
+        // Canonicalize via a declaration-order case-insensitive scan over the
+        // ALREADY-LOWERCASED `s` — matching the reference exactly
+        // (`Object.keys(states).find((n) => n.toLowerCase() === s)`). No
+        // exact-own-property short-circuit: the first declared name whose lowercased
+        // form equals `s` wins, so a (pathological) name declared twice resolves to
+        // the first declaration's role.
+        const canonical = Object.keys(states).find((n) => n.toLowerCase() === s);
+        const cleanup = canonical !== undefined ? states[canonical].role === 'terminal' : false;
+        return { kind: 'terminate', cleanup, reason: 'tracker_state_terminal' };
+    }
+    const active = new Set(activeStateNames(states).map((n) => n.toLowerCase()));
+    if (active.has(s)) {
+        return { kind: 'refresh' };
+    }
+    return { kind: 'terminate', cleanup: false, reason: 'tracker_state_non_active' };
+}
+//# sourceMappingURL=reconcile-issue.js.map

package/dist/src/core/schedule/reconcile-issue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-issue.js","sourceRoot":"","sources":["../../../../src/core/schedule/reconcile-issue.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAC5D,EAAE;AACF,yDAAyD;AACzD,6EAA6E;AAC7E,8EAA8E;AAC9E,8EAA8E;AAC9E,8EAA8E;AAC9E,4DAA4D;AAC5D,EAAE;AACF,8EAA8E;AAC9E,yEAAyE;AACzE,YAAY;AACZ,EAAE;AACF,+EAA+E;AAC/E,iFAAiF;AACjF,8DAA8D;AAK9D,OAAO,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAwB,EACxB,MAAmC;IAEnC,OAAO,uBAAuB,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC;AACvD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CACrC,KAAyB,EACzB,MAAmC;IAEnC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,EAAE,CAAC;IAChF,CAAC;IAED,MAAM,CAAC,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;IAE9B,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IACjF,IAAI,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QACpB,yEAAyE;QACzE,yEAAyE;QACzE,qEAAqE;QACrE,qCAAqC;QACrC,EAAE;QACF,sEAAsE;QACtE,0DAA0D;QAC1D,iEAAiE;QACjE,6EAA6E;QAC7E,4EAA4E;QAC5E,gCAAgC;QAChC,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC,CAAC;QACzE,MAAM,OAAO,GAAG,SAAS,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAE,CAAC,IAAI,KAAK,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC;QACzF,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,wBAAwB,EAAE,CAAC;IAC1E,CAAC;IAED,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,gBAAgB,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;IAC7E,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;QAClB,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAC7B,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,0BAA0B,EAAE,CAAC;AACnF,CAAC"}

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

@@ -0,0 +1,96 @@
+// FCIS rewrite — pure retry/continuation scheduling core.
+//
+// Ported faithfully from the original `src/orchestrator-decisions.ts`
+// (`decideExitRetry`, `decideRetryAfterIneligible`, `RetrySchedulePlan`). These
+// are the deciders the orchestrator folds over a freshly-exited worker (clean vs
+// abnormal exit) and over a re-polled-but-ineligible retry candidate.
+//
+// Every function here is pure and SYNCHRONOUS: (data) -> data. The only side
+// effect the original orchestrator performed at these sites — arming a timer to
+// redispatch — becomes a returned `timer.schedule_retry` Effect (see
+// `scheduleRetryEffect`), which the shell EXECUTES. No clock, no randomness, no
+// IO. Imports are restricted to src/types.
+/**
+ * Exponential-backoff delay for a failure retry, capped at `maxBackoffMs`.
+ *
+ * `attempt` is the 1-based attempt number being scheduled, so the first failure
+ * (`attempt === 1`) waits `baseMs * 2^0 === baseMs`, the second `baseMs * 2`,
+ * and so on. Mirrors the inline `Math.min(base * 2^(attempt-1), max)` the
+ * original carried at both retry sites.
+ */
+export function backoffDelayMs(attempt, baseMs, maxBackoffMs) {
+    return Math.min(baseMs * Math.pow(2, attempt - 1), maxBackoffMs);
+}
+/**
+ * Retry schedule for a worker that just exited. A normal exit becomes a
+ * `continuation` (short, slot-holding, no error) so the same issue resumes its
+ * post-transition state; an abnormal exit becomes a `failure` with exponential
+ * backoff capped at `maxBackoffMs` (does NOT hold a slot). `target_state` is
+ * whatever state the running entry was carrying at exit time.
+ *
+ * A `continuation` always reports `attempt: 1` — it is a fresh handoff, not a
+ * retry of a prior attempt. A `failure` increments the prior attempt (or starts
+ * at 1 when there was none).
+ */
+export function decideExitRetry(input) {
+    if (input.normal) {
+        return {
+            attempt: 1,
+            delayMs: input.continuationDelayMs,
+            error: null,
+            kind: 'continuation',
+            target_state: input.targetState,
+        };
+    }
+    const nextAttempt = input.priorAttempt !== null && input.priorAttempt !== undefined ? input.priorAttempt + 1 : 1;
+    return {
+        attempt: nextAttempt,
+        delayMs: backoffDelayMs(nextAttempt, input.failureBaseMs, input.maxBackoffMs),
+        error: input.reason,
+        kind: 'failure',
+        target_state: input.targetState,
+    };
+}
+/** The no-slot reason that the ineligible path treats as a transient reschedule. */
+export const NO_SLOT_REASON = 'no per-state slot';
+/**
+ * Retry-timer response when a re-polled issue is found ineligible. A
+ * `no per-state slot` reason yields a failure-backoff reschedule (the loop can
+ * dispatch other work during the wait); any other ineligibility releases the
+ * claim. Mirrors the inline switch the original orchestrator carried.
+ *
+ * The reschedule delay backs off on `priorAttempt` (NOT `priorAttempt + 1`):
+ * the original computed `base * 2^priorAttempt` for the new `attempt:
+ * priorAttempt + 1`, matching `backoffDelayMs(priorAttempt + 1, …)`.
+ */
+export function decideRetryAfterIneligible(input) {
+    if (input.reason !== NO_SLOT_REASON)
+        return { kind: 'release' };
+    const nextAttempt = input.priorAttempt + 1;
+    return {
+        kind: 'reschedule',
+        plan: {
+            attempt: nextAttempt,
+            delayMs: backoffDelayMs(nextAttempt, input.failureBaseMs, input.maxBackoffMs),
+            error: 'no available orchestrator slots',
+            kind: 'failure',
+            target_state: input.targetState,
+        },
+    };
+}
+/**
+ * Fold a {@link RetrySchedulePlan} into the `timer.schedule_retry` Effect the
+ * shell executes to arm the (continuation or backoff) redispatch. This is the
+ * single seam where a retry decision becomes a side effect: core returns the
+ * Effect, the shell registers the actual timer.
+ */
+export function scheduleRetryEffect(issueId, identifier, plan) {
+    return {
+        family: 'timer',
+        kind: 'schedule_retry',
+        issueId,
+        identifier,
+        plan,
+    };
+}
+//# sourceMappingURL=retry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retry.js","sourceRoot":"","sources":["../../../../src/core/schedule/retry.ts"],"names":[],"mappings":"AAAA,0DAA0D;AAC1D,EAAE;AACF,sEAAsE;AACtE,gFAAgF;AAChF,iFAAiF;AACjF,sEAAsE;AACtE,EAAE;AACF,6EAA6E;AAC7E,gFAAgF;AAChF,qEAAqE;AACrE,gFAAgF;AAChF,2CAA2C;AAM3C;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,OAAe,EAAE,MAAc,EAAE,YAAoB;IAClF,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,CAAC,EAAE,YAAY,CAAC,CAAC;AACnE,CAAC;AAmBD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,KAA2B;IACzD,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;QACjB,OAAO;YACL,OAAO,EAAE,CAAC;YACV,OAAO,EAAE,KAAK,CAAC,mBAAmB;YAClC,KAAK,EAAE,IAAI;YACX,IAAI,EAAE,cAAkC;YACxC,YAAY,EAAE,KAAK,CAAC,WAAW;SAChC,CAAC;IACJ,CAAC;IACD,MAAM,WAAW,GACf,KAAK,CAAC,YAAY,KAAK,IAAI,IAAI,KAAK,CAAC,YAAY,KAAK,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/F,OAAO;QACL,OAAO,EAAE,WAAW;QACpB,OAAO,EAAE,cAAc,CAAC,WAAW,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC;QAC7E,KAAK,EAAE,KAAK,CAAC,MAAM;QACnB,IAAI,EAAE,SAA6B;QACnC,YAAY,EAAE,KAAK,CAAC,WAAW;KAChC,CAAC;AACJ,CAAC;AAED,oFAAoF;AACpF,MAAM,CAAC,MAAM,cAAc,GAAG,mBAAmB,CAAC;AAmBlD;;;;;;;;;GASG;AACH,MAAM,UAAU,0BAA0B,CACxC,KAAsC;IAEtC,IAAI,KAAK,CAAC,MAAM,KAAK,cAAc;QAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;IAChE,MAAM,WAAW,GAAG,KAAK,CAAC,YAAY,GAAG,CAAC,CAAC;IAC3C,OAAO;QACL,IAAI,EAAE,YAAY;QAClB,IAAI,EAAE;YACJ,OAAO,EAAE,WAAW;YACpB,OAAO,EAAE,cAAc,CAAC,WAAW,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,YAAY,CAAC;YAC7E,KAAK,EAAE,iCAAiC;YACxC,IAAI,EAAE,SAA6B;YACnC,YAAY,EAAE,KAAK,CAAC,WAAW;SAChC;KACF,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,OAAe,EACf,UAAkB,EAClB,IAAuB;IAEvB,OAAO;QACL,MAAM,EAAE,OAAO;QACf,IAAI,EAAE,gBAAgB;QACtB,OAAO;QACP,UAAU;QACV,IAAI;KACL,CAAC;AACJ,CAAC"}

package/dist/src/core/schedule/sleep-cycle.js

@@ -0,0 +1,133 @@
+// FCIS rewrite — pure sleep-cycle (recurring reflection spawn) decisions.
+//
+// The sleep cycle is modelled as a recurring STATE that spawns ephemeral
+// reflection issues, NOT as one immortal ticket parked in a holding state. When
+// the orchestrator has accumulated enough finished work (a `done_threshold`
+// trigger) or goes idle with at least one issue finished since the last cycle (an
+// `idle` trigger), `decideSpawn` mints a FRESH issue into the spawn state. Each
+// reflection is born there, runs once, and terminates in a dedicated terminal —
+// like every other ticket. The shell folds each freshly-exited worker into a
+// terminal-transition counter via `recordSleepCycleProgress`, then each poll asks
+// `decideSpawn` whether a trigger fires; on a fire it returns the new issue's
+// title + body (provenance the static prompt can't know), which the shell turns
+// into a create-issue effect, resetting the counter only on a successful mint.
+//
+// 100% SYNCHRONOUS. No IO, no clock, no randomness, no node: imports. Every
+// decision is (data) -> data; the only side effect the shell performs at these
+// sites (the async create + counter reset) stays in the shell — core just returns
+// the spawn intent / note text / next counter value. The "now" stamp is injected
+// as `nowIso` data (the same "inject the clock as data" precedent as
+// `summarizeRunLog`'s required `generatedAt`). Imports only from src/types.
+// (NodeNext ESM: .js extension on the relative type import.)
+/**
+ * Decide whether to mint a fresh reflection issue this tick, and on which
+ * trigger. Returns the spawn intent (trigger + derived title/body) or null when
+ * no trigger fires.
+ *
+ * The done-threshold trigger takes precedence over idle when both hold (it's
+ * the stronger, count-based signal — handy for the operator-visible log line).
+ *
+ * The idle trigger is deliberately gated on `doneSinceReflect > 0`: an idle
+ * orchestrator with nothing finished since the last cycle has nothing new to
+ * reflect on, and spawning anyway would spin (spawn -> reflect -> terminal ->
+ * idle -> spawn ...) forever. Requiring fresh terminal work breaks that loop
+ * while still honoring the "sleep when not busy" framing.
+ *
+ * `max_in_flight` is load-bearing: minting removed the immortal ticket's built-in
+ * "one location = one reflection" mutex, so without this guard a busy stretch's
+ * `after_terminal` trigger could mint a second cycle while one is still live.
+ * When `inFlight >= maxInFlight` no issue is minted, regardless of trigger.
+ *
+ * Returns null when spawning is disabled, the in-flight cap is reached, or no
+ * trigger fires.
+ */
+export function decideSpawn(input) {
+    if (!input.enabled)
+        return null;
+    // Never mint a second while one (or `maxInFlight`) is already live in the spawn
+    // state — the recurring-state replacement for the immortal ticket's mutex.
+    if (input.inFlight >= input.maxInFlight)
+        return null;
+    const trigger = decideTrigger(input);
+    if (trigger === null)
+        return null;
+    return {
+        trigger,
+        title: renderTitle(input.titleTemplate, input.nowIso),
+        body: spawnBody(trigger, input.doneSinceReflect, input.afterTerminal, input.nowIso, input.bodyLeadIn),
+    };
+}
+/** Which trigger (if any) fires this tick — the pure trigger half of {@link decideSpawn}. */
+function decideTrigger(input) {
+    if (input.afterTerminal > 0 && input.doneSinceReflect >= input.afterTerminal) {
+        return 'done_threshold';
+    }
+    if (input.onIdle && input.idle && input.doneSinceReflect > 0)
+        return 'idle';
+    return null;
+}
+/**
+ * Render the minted issue's title from the configured template, substituting a
+ * human-readable `{{ stamp }}` (e.g. `2026-06-03 13:56`) derived purely from the
+ * injected `nowIso`. A template with no placeholder is used verbatim.
+ */
+function renderTitle(template, nowIso) {
+    return template.replace(/\{\{\s*stamp\s*\}\}/g, readableStamp(nowIso));
+}
+/** `2026-06-03T13:56:12.000Z` → `2026-06-03 13:56` (date + HH:MM, no seconds/Z). Pure. */
+function readableStamp(nowIso) {
+    return nowIso.slice(0, 16).replace('T', ' ');
+}
+/**
+ * The provenance body for the minted reflection issue. Plain text, generated once
+ * at mint — the point-in-time provenance the static `prompts/Reflect.md` can't
+ * know (the trigger, the counter, the timestamp). It exists for the human reading
+ * the archived issue later; the reflector itself works from the prompt + the
+ * eval_mode mounts, not from this body. NO instructions / guardrails (those live
+ * in the prompt) and NO templating (the issue body is inert data the prompt
+ * interpolates, not a Liquid template).
+ */
+function spawnBody(trigger, doneSinceReflect, afterTerminal, nowIso, leadIn) {
+    const why = trigger === 'done_threshold'
+        ? `${doneSinceReflect} issues reached a terminal state since the last reflection cycle (threshold: ${afterTerminal}).`
+        : `the orchestrator went idle with ${doneSinceReflect} issue(s) finished since the last reflection cycle.`;
+    return [
+        leadIn && leadIn.length > 0 ? leadIn : 'Auto-spawned reflection cycle.',
+        '',
+        `Trigger: ${trigger} — ${why}`,
+        `Spawned at: ${nowIso}.`,
+    ].join('\n');
+}
+/**
+ * Fold a freshly-exited worker into the terminal-transition counter the sleep
+ * cycle triggers read, returning the NEXT counter value (the original mutated
+ * `this.doneSinceReflect`; here it is pure).
+ *
+ * Only the work the reflector mines counts — a transition into a `role: terminal`
+ * state (Done / Cancelled / the spawn's terminal), as recorded by
+ * `last_transition.terminal`. A reflection's OWN terminal move is excluded
+ * STRUCTURALLY — by its from-state, not a fixed issue id: with ephemeral
+ * reflections there is no immortal ticket to match, so any terminal transition
+ * ORIGINATING from the spawn state is a finished reflection's own move and must
+ * not count toward spawning the next cycle (else the cycle never settles). A
+ * non-terminal exit (a continuation, a reroute) never advances the counter.
+ *
+ * `spawnState` is the configured spawn state (`SpawnRouting.spawnState`); a null
+ * value means spawning is unconfigured, in which case the counter is left
+ * untouched (matching the original's disabled-block no-op).
+ */
+export function recordSleepCycleProgress(doneSinceReflect, entry, spawnState) {
+    // Spawning unconfigured: never advance the counter.
+    if (!spawnState)
+        return doneSinceReflect;
+    const t = entry.last_transition;
+    // Only a terminal transition (into a role: terminal state) is mineable work.
+    if (!t?.terminal)
+        return doneSinceReflect;
+    // A reflection's own terminal move (out of the spawn state) never counts toward
+    // spawning the next cycle — exclude it structurally by its from-state.
+    if (t.from_state.toLowerCase() === spawnState.toLowerCase())
+        return doneSinceReflect;
+    return doneSinceReflect + 1;
+}
+//# sourceMappingURL=sleep-cycle.js.map

package/dist/src/core/schedule/sleep-cycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sleep-cycle.js","sourceRoot":"","sources":["../../../../src/core/schedule/sleep-cycle.ts"],"names":[],"mappings":"AAAA,0EAA0E;AAC1E,EAAE;AACF,yEAAyE;AACzE,gFAAgF;AAChF,4EAA4E;AAC5E,kFAAkF;AAClF,gFAAgF;AAChF,gFAAgF;AAChF,6EAA6E;AAC7E,kFAAkF;AAClF,8EAA8E;AAC9E,gFAAgF;AAChF,+EAA+E;AAC/E,EAAE;AACF,4EAA4E;AAC5E,+EAA+E;AAC/E,kFAAkF;AAClF,iFAAiF;AACjF,qEAAqE;AACrE,4EAA4E;AAC5E,6DAA6D;AAW7D;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,WAAW,CAAC,KAAiB;IAC3C,IAAI,CAAC,KAAK,CAAC,OAAO;QAAE,OAAO,IAAI,CAAC;IAChC,gFAAgF;IAChF,2EAA2E;IAC3E,IAAI,KAAK,CAAC,QAAQ,IAAI,KAAK,CAAC,WAAW;QAAE,OAAO,IAAI,CAAC;IACrD,MAAM,OAAO,GAAG,aAAa,CAAC,KAAK,CAAC,CAAC;IACrC,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAClC,OAAO;QACL,OAAO;QACP,KAAK,EAAE,WAAW,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,MAAM,CAAC;QACrD,IAAI,EAAE,SAAS,CAAC,OAAO,EAAE,KAAK,CAAC,gBAAgB,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,UAAU,CAAC;KACtG,CAAC;AACJ,CAAC;AAED,6FAA6F;AAC7F,SAAS,aAAa,CAAC,KAAiB;IACtC,IAAI,KAAK,CAAC,aAAa,GAAG,CAAC,IAAI,KAAK,CAAC,gBAAgB,IAAI,KAAK,CAAC,aAAa,EAAE,CAAC;QAC7E,OAAO,gBAAgB,CAAC;IAC1B,CAAC;IACD,IAAI,KAAK,CAAC,MAAM,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,gBAAgB,GAAG,CAAC;QAAE,OAAO,MAAM,CAAC;IAC5E,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,WAAW,CAAC,QAAgB,EAAE,MAAc;IACnD,OAAO,QAAQ,CAAC,OAAO,CAAC,sBAAsB,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC;AACzE,CAAC;AAED,0FAA0F;AAC1F,SAAS,aAAa,CAAC,MAAc;IACnC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;AAC/C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,SAAS,CAChB,OAA0B,EAC1B,gBAAwB,EACxB,aAAqB,EACrB,MAAc,EACd,MAAqB;IAErB,MAAM,GAAG,GACP,OAAO,KAAK,gBAAgB;QAC1B,CAAC,CAAC,GAAG,gBAAgB,gFAAgF,aAAa,IAAI;QACtH,CAAC,CAAC,mCAAmC,gBAAgB,qDAAqD,CAAC;IAC/G,OAAO;QACL,MAAM,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,gCAAgC;QACvE,EAAE;QACF,YAAY,OAAO,MAAM,GAAG,EAAE;QAC9B,eAAe,MAAM,GAAG;KACzB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,wBAAwB,CACtC,gBAAwB,EACxB,KAA8B,EAC9B,UAAyB;IAEzB,oDAAoD;IACpD,IAAI,CAAC,UAAU;QAAE,OAAO,gBAAgB,CAAC;IACzC,MAAM,CAAC,GAAG,KAAK,CAAC,eAAe,CAAC;IAChC,6EAA6E;IAC7E,IAAI,CAAC,CAAC,EAAE,QAAQ;QAAE,OAAO,gBAAgB,CAAC;IAC1C,gFAAgF;IAChF,uEAAuE;IACvE,IAAI,CAAC,CAAC,UAAU,CAAC,WAAW,EAAE,KAAK,UAAU,CAAC,WAAW,EAAE;QAAE,OAAO,gBAAgB,CAAC;IACrF,OAAO,gBAAgB,GAAG,CAAC,CAAC;AAC9B,CAAC"}

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

@@ -0,0 +1,124 @@
+// FCIS rewrite — pure slot accounting (functional core).
+//
+// Ports the orchestrator's concurrency gate (REF: src/orchestrator.ts
+// `availableGlobalSlots`, `hasPerStateSlot`, `perStateConcurrencyCap`,
+// `sortForDispatch`) into pure, synchronous functions over plain-data
+// snapshots.
+//
+// The keystone behaviour this module owns:
+//   - GLOBAL slots:    max(0, effectiveCap - running - pendingContinuations)
+//   - PER-STATE slots:  inState < cap && globalSlots > 0   (cap from config)
+//   - CONTINUATIONS HOLD A SLOT, FAILURES DO NOT. A continuation is the
+//     post-transition resume of an issue that just normal-exited; reserving its
+//     slot during the (short) continuation delay stops a tick that fires inside
+//     that window from dispatching a brand-new issue and stealing the slot the
+//     resuming worker is about to reclaim. Failure-backoff retries do NOT hold a
+//     slot, so the orchestrator is free to run other work during the backoff.
+//   - sortForDispatch: priority ASC (null last), created_at ASC (unparseable
+//     last), identifier localeCompare as the final tiebreak.
+//
+// This module is given the ALREADY-RESOLVED effective cap (the memory-admission
+// clamp is a separate core concern that folds a /proc/meminfo probe + config
+// into `effectiveCap`); slot accounting just reads it from the snapshot so the
+// snapshot endpoint and the dispatch loop can never desync. Nothing here reads
+// the clock, randomness, or any IO — `created_at` is parsed deterministically
+// from the issue's ISO string via the injected `parseTimestamp` (default uses
+// Date.parse, which is pure — it does not read the wall clock).
+/** Count pending retries that hold a slot (continuations only). */
+function pendingContinuationCount(pendingRetries) {
+    let n = 0;
+    for (const r of pendingRetries) {
+        if (r.kind === 'continuation')
+            n++;
+    }
+    return n;
+}
+/**
+ * Global available-slot count.
+ *
+ * REF: `availableGlobalSlots()` — `max(0, effective_cap - running - pendingContinuations)`.
+ * Pending continuations are reserved against the cap; failure-backoff retries
+ * are not (they are absent from the holding set by construction — only `kind ===
+ * 'continuation'` entries count).
+ */
+export function availableGlobalSlots(snapshot) {
+    const held = pendingContinuationCount(snapshot.pendingRetries);
+    return Math.max(0, snapshot.effectiveCap - snapshot.runningCount - held);
+}
+/** True iff the global gate has at least one free slot. */
+export function hasGlobalSlot(snapshot) {
+    return availableGlobalSlots(snapshot) > 0;
+}
+/**
+ * Resolve a state's per-state concurrency cap (`states.<name>.max_concurrent`)
+ * with a case-insensitive name lookup, mirroring how issue states arrive from
+ * the tracker in arbitrary case.
+ *
+ * REF: `perStateConcurrencyCap()`. Returns `undefined` when the state is
+ * unknown, declares no cap, or declares a zero cap — in REF, `if (!cap)` treats
+ * both `undefined` and `0` as "no per-state cap, only the global ceiling
+ * applies," so we collapse them to `undefined` here.
+ */
+export function resolvePerStateCap(stateName, caps) {
+    const lower = stateName.toLowerCase();
+    for (const name of Object.keys(caps)) {
+        if (name.toLowerCase() === lower) {
+            const cap = caps[name]?.max_concurrent;
+            return cap ? cap : undefined;
+        }
+    }
+    return undefined;
+}
+/**
+ * Per-state slot accounting.
+ *
+ * REF: `hasPerStateSlot()`. With no per-state cap declared the global gate is
+ * the only constraint. With a cap, count the running attempts in that state
+ * PLUS any pending continuation whose target state matches (so the resuming
+ * worker is guaranteed its slot when the timer fires), and require both
+ * `inState < cap` and a free global slot.
+ *
+ * `caps` is the `states` config keyed by state name (case-insensitive lookup).
+ */
+export function hasPerStateSlot(stateName, snapshot, caps) {
+    const cap = resolvePerStateCap(stateName, caps);
+    if (cap === undefined)
+        return hasGlobalSlot(snapshot);
+    const lower = stateName.toLowerCase();
+    let inState = 0;
+    for (const s of snapshot.runningStates) {
+        if (s.toLowerCase() === lower)
+            inState++;
+    }
+    for (const r of snapshot.pendingRetries) {
+        if (r.kind === 'continuation' && r.target_state.toLowerCase() === lower) {
+            inState++;
+        }
+    }
+    return inState < cap && hasGlobalSlot(snapshot);
+}
+const defaultParseTimestamp = (iso) => iso ? Date.parse(iso) : Number.NaN;
+/**
+ * Dispatch ordering.
+ *
+ * REF: `sortForDispatch()` — priority ASC with null priority ordered last,
+ * then created_at ASC with unparseable/null created_at ordered last, then
+ * identifier `localeCompare` as the final stable tiebreak. Returns a NEW array
+ * (does not mutate the input).
+ */
+export function sortForDispatch(issues, parseTimestamp = defaultParseTimestamp) {
+    return [...issues].sort((a, b) => {
+        const pa = a.priority ?? Number.POSITIVE_INFINITY;
+        const pb = b.priority ?? Number.POSITIVE_INFINITY;
+        if (pa !== pb)
+            return pa - pb;
+        const rawA = parseTimestamp(a.created_at);
+        const rawB = parseTimestamp(b.created_at);
+        const ca = Number.isFinite(rawA) ? rawA : Number.POSITIVE_INFINITY;
+        const cb = Number.isFinite(rawB) ? rawB : Number.POSITIVE_INFINITY;
+        if (Number.isFinite(ca) && Number.isFinite(cb) && ca !== cb)
+            return ca - cb;
+        return a.identifier.localeCompare(b.identifier);
+    });
+}
+//# sourceMappingURL=slots.js.map

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

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