@telora/daemon 0.21.83 → 0.21.134

package/dist/delivery/paused-revival.js

@@ -0,0 +1,229 @@
+/**
+ * Paused-delivery revival -- the daemon-traversable EXIT from `paused` (TEL-1:
+ * "Every path into `paused` has a daemon-traversable exit or a named human-act
+ * hold").
+ *
+ * A `paused` delivery is a guard BLOCK on a transition (coding->verify or
+ * verify->done), written with an open `transition_blocks` row carrying the
+ * blocked transition and its human decision_paths (retry / override). Before
+ * this consumer, that block row was written but "nothing read it back": a paused
+ * delivery was skipped by every actionable-status pass, never re-evaluated, and
+ * -- because paused BLOCKS lower-ranked deliveries -- it wedged the whole ranked
+ * queue until a human re-queued it. On an ARMED focus that human never comes
+ * (2026-07-28 ruling: an armed focus reaches its terminal without a human;
+ * decide-and-record, reversibility as tiebreaker).
+ *
+ * This module reads the block row back. Each sweep, for every paused delivery it
+ * re-evaluates the SAME blocked transition's guards and routes the fresh verdict
+ * through the single-writer reconciler (delivery-reconciler `paused` case):
+ *   - guard CLEARED  -> revive `paused` -> `queued` (the canonical revival edge);
+ *                       the normal walk re-drives and re-hits the gate. This is
+ *                       the daemon-traversable exit.
+ *   - guard STILL blocks -> hold. The pause stays a NAMED human-act hold (its
+ *                       gate_state blocking conditions + the block's `override`
+ *                       decision path name the act only a human can perform), and
+ *                       the wedge watchdog surfaces it. The daemon never OVERRIDES
+ *                       an unclear gate -- that irreversible act is the human's.
+ *
+ * A paused delivery with NO open block row is NOT abandoned: the blocked FORWARD
+ * transition (coding->verify / verify->done) is recovered from the delivery's
+ * preserved source stage and re-evaluated the same way -- so a hard-guard pause
+ * that wrote no block_transition row still gets a daemon-traversable exit. Only a
+ * pause whose stage yields no recoverable forward transition (unknown/ambiguous)
+ * stays `no-block` for the watchdog.
+ *
+ * DI-first: `reconcilePausedDelivery` + `checkPausedDeliveriesForRevival` take a
+ * deps object so they unit-test with plain stubs (no `mock.module`, which would
+ * poison the daemon-core bare-import loader). `buildDefaultPausedRevivalDeps`
+ * wires the real query/guard functions for the listener.
+ */
+import { DELIVERY_STATUS } from '@telora/daemon-core';
+import { resolveReconciledWrite } from './delivery-reconciler-apply.js';
+import { getActiveTransitionBlock, resolveTransitionBlock } from '../queries/guards.js';
+import { evaluateGuardsAtTransition } from '../guard/guard-evaluator.js';
+import { fetchEffectiveWorkflow } from '../queries/workflows.js';
+import { updateDeliveryStatus, getActiveFocuses } from '../queries/deliveries.js';
+import { getFocusDeliveries } from '../queries/focuses.js';
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'paused-revival' });
+/**
+ * The canonical FORWARD delivery-stage a pause blocks. A `paused` delivery was
+ * blocked advancing coding->verify or verify->done (the only two guard-block
+ * pause producers, delivery-reconciler.ts:314/329); the blocked transition is the
+ * one FROM the source stage TO this forward stage. Used to recover the transition
+ * for re-evaluation when there is no transition_blocks row to read it from.
+ */
+const FORWARD_DELIVERY_STAGE = {
+    [DELIVERY_STATUS.CODING]: DELIVERY_STATUS.VERIFY,
+    [DELIVERY_STATUS.VERIFY]: DELIVERY_STATUS.DONE,
+};
+/**
+ * The `decision_path` stamped on a block the daemon closes on auto-revival. The
+ * block leaves `decided_by` NULL (a machine action has no auth.users id), which
+ * is what keeps it OUT of the human-routing resolved-block query (that path
+ * requires decided_by IS NOT NULL). This value is the audit marker for "the
+ * daemon revived past this block because its guard cleared", never a human's
+ * retry/override choice.
+ */
+const AUTO_REVIVAL_DECISION_PATH = 'daemon_auto_revival';
+/**
+ * Re-evaluate one paused delivery's blocking guard and, if it has cleared,
+ * traverse it out of paused via the single-writer reconciler. Returns the
+ * outcome for sweep accounting. Never throws for an expected I/O failure -- a
+ * guard-reeval failure holds the delivery (safe: stays paused) rather than
+ * risking a wrong revival.
+ */
+export async function reconcilePausedDelivery(delivery, organizationId, deps) {
+    // Recover the blocked transition: prefer the open block row (the block_transition
+    // producer), else derive the forward transition from the preserved source stage
+    // (a hard-guard pause with no block row). Either yields the transition whose
+    // guards we re-evaluate; neither => nothing recoverable, leave for the watchdog.
+    const block = await deps.getActiveTransitionBlock(delivery.id);
+    const transitionId = block?.transitionId ??
+        (await deps.resolveForwardTransitionId(delivery.id, delivery.currentWorkflowStageId));
+    if (!transitionId)
+        return 'no-block';
+    let stillBlocked;
+    try {
+        stillBlocked = await deps.reEvaluateGuardBlocked(delivery.id, organizationId, transitionId);
+    }
+    catch (err) {
+        log.warn(`[paused-revival] guard re-eval failed for "${delivery.name}" (${delivery.id.slice(0, 8)}): ` +
+            `${err.message} -- holding paused this tick`);
+        return 'held';
+    }
+    // Route the fresh verdict through the single reconciler computation. The
+    // paused case revives to `queued` only when the guard has cleared; otherwise
+    // it stays paused.
+    const decision = resolveReconciledWrite({
+        input: {
+            currentStatus: DELIVERY_STATUS.PAUSED,
+            issues: [],
+            gitState: { worktreeCommitted: true },
+            guardVerdict: { blocked: stillBlocked },
+            reviewState: null,
+        },
+    });
+    if (decision.target === DELIVERY_STATUS.PAUSED)
+        return 'held';
+    // Close out the block this revival acted on BEFORE the status write, so even a
+    // crash between the two leaves the block resolved (the next sweep then derives
+    // the forward transition from the preserved stage rather than re-reading a
+    // stale row). A derived-forward revival (block === null) has nothing to close.
+    // Best-effort: a close failure never blocks the already-decided revival.
+    if (block) {
+        try {
+            await deps.resolveTransitionBlock(block.id, AUTO_REVIVAL_DECISION_PATH);
+        }
+        catch (err) {
+            log.warn(`[paused-revival] failed to close block ${block.id.slice(0, 8)} for ` +
+                `"${delivery.name}" (${delivery.id.slice(0, 8)}): ${err.message} -- ` +
+                `revival proceeds; a stale-open block may be re-read on a later pause episode`);
+        }
+    }
+    const stageId = await deps.resolveStageId(delivery.id, decision.target);
+    // Clear gate_state + completion_artifacts explicitly (null, not undefined): the
+    // block that held this delivery no longer applies once it leaves paused, so the
+    // row must carry no gate state describing the block it has left. queries/
+    // deliveries.ts only clears the column on null; undefined would leave it stale.
+    await deps.updateDeliveryStatus(delivery.id, decision.target, stageId, null, null, { organizationId, fromStatus: DELIVERY_STATUS.PAUSED });
+    log.info(`[paused-revival] revived "${delivery.name}" (${delivery.id.slice(0, 8)}) ` +
+        `paused -> ${decision.target}: blocking guard cleared on re-eval`);
+    return 'revived';
+}
+/**
+ * Sweep every active focus's paused deliveries and revive the ones whose
+ * blocking guard has cleared. Runs on TEAMLESS focuses too (a paused delivery
+ * wedges the queue so no team spawns) -- hence it iterates active focuses, not
+ * activeTeams. Best-effort per focus/delivery: one failure never aborts the
+ * sweep.
+ */
+export async function checkPausedDeliveriesForRevival(config, deps) {
+    let revived = 0;
+    let held = 0;
+    let noBlock = 0;
+    let focuses;
+    try {
+        focuses = await deps.getActiveFocuses(config.organizationId, config.productId);
+    }
+    catch (err) {
+        log.warn(`[paused-revival] failed to fetch active focuses: ${err.message}`);
+        return { revived, held, noBlock };
+    }
+    for (const focus of focuses) {
+        let deliveries;
+        try {
+            deliveries = await deps.getFocusDeliveries(focus.focus_id);
+        }
+        catch (err) {
+            log.warn(`[paused-revival] failed to fetch deliveries for focus ${focus.focus_id.slice(0, 8)}: ${err.message}`);
+            continue;
+        }
+        for (const delivery of deliveries) {
+            if ((delivery.executionStatus ?? '') !== DELIVERY_STATUS.PAUSED)
+                continue;
+            try {
+                const outcome = await reconcilePausedDelivery(delivery, config.organizationId, deps);
+                if (outcome === 'revived')
+                    revived++;
+                else if (outcome === 'held')
+                    held++;
+                else
+                    noBlock++;
+            }
+            catch (err) {
+                log.warn(`[paused-revival] revival check failed for "${delivery.name}" (${delivery.id.slice(0, 8)}): ${err.message}`);
+            }
+        }
+    }
+    return { revived, held, noBlock };
+}
+/**
+ * Wire the real query + guard functions into a sweep-deps object for the
+ * listener. Kept as thin adapters (not direct assignments) so the wide,
+ * strictly-typed writer/query signatures reduce to this consumer's narrow seam.
+ * `reEvaluateGuardBlocked` is PURE measurement: evaluateGuardsAtTransition
+ * fetches guards + builds context and returns a verdict; it does NOT write the
+ * delivery's execution_status (that stays the reconciler's job here).
+ */
+export function buildDefaultPausedRevivalDeps() {
+    return {
+        getActiveTransitionBlock: async (deliveryId) => {
+            const block = await getActiveTransitionBlock(deliveryId);
+            return block ? { id: block.id, transitionId: block.transition_id } : null;
+        },
+        resolveForwardTransitionId: async (deliveryId, currentStageId) => {
+            if (!currentStageId)
+                return null;
+            const workflow = await fetchEffectiveWorkflow(deliveryId);
+            const sourceStage = workflow.stages.find((s) => s.id === currentStageId);
+            if (!sourceStage)
+                return null;
+            const forwardName = FORWARD_DELIVERY_STAGE[sourceStage.name];
+            if (!forwardName)
+                return null;
+            const forwardStage = workflow.stages.find((s) => s.name === forwardName);
+            if (!forwardStage)
+                return null;
+            const transition = (workflow.transitions ?? []).find((t) => t.from_stage_id === currentStageId && t.to_stage_id === forwardStage.id);
+            return transition?.id ?? null;
+        },
+        reEvaluateGuardBlocked: async (deliveryId, organizationId, transitionId) => {
+            const result = await evaluateGuardsAtTransition(deliveryId, organizationId, transitionId, 0);
+            return !result.should_proceed;
+        },
+        resolveStageId: async (deliveryId, statusName) => {
+            const workflow = await fetchEffectiveWorkflow(deliveryId);
+            return workflow.stages.find((s) => s.name === statusName)?.id;
+        },
+        updateDeliveryStatus: (deliveryId, status, stageId, gateState, completionArtifacts, transition) => 
+        // Pass the caller's gate_state + completion_artifacts THROUGH (reconcile-
+        // PausedDelivery clears them with null on the way out of paused) instead of
+        // hardcoding, so the clear is driven by -- and testable at -- the caller.
+        updateDeliveryStatus(deliveryId, status, stageId, gateState, completionArtifacts, transition),
+        resolveTransitionBlock: (blockId, decisionPath) => resolveTransitionBlock(blockId, decisionPath),
+        getActiveFocuses: (organizationId, productId) => getActiveFocuses(organizationId, productId),
+        getFocusDeliveries: (focusId) => getFocusDeliveries(focusId),
+    };
+}
+//# sourceMappingURL=paused-revival.js.map

package/dist/delivery/paused-revival.js.map

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

package/dist/delivery/wait-reachability.d.ts

@@ -0,0 +1,149 @@
+/**
+ * Wait reachability: can the condition a wait is blocked on still fire?
+ *
+ * The daemon waits in several places (an external hold, a stall-cycle counter, a
+ * mid-focus handoff, a CI merge gate). Every one of them holds against some
+ * awaited condition, but none of them ask the one question that tells patience
+ * from a stall: CAN THE THING BEING WAITED FOR STILL ARRIVE? A wait blocked on
+ * another actor (that actor can still act) and a wait blocked on itself -- or on
+ * a recorded fact that never re-evaluates -- look identical from the outside.
+ *
+ * This module is the shared answer. It classifies an awaited condition by WHAT
+ * it is blocked on, and derives reachability from that:
+ *   - other_actor -> REACHABLE   (another actor can still satisfy it)
+ *   - self        -> UNREACHABLE (only the waiter can produce it -> deadlock)
+ *   - static_fact -> UNREACHABLE (a recorded fact that never re-evaluates
+ *                                 without new input, e.g. a CI result on an
+ *                                 unchanged sha)
+ *
+ * It is PURE and dependency-free so the decision is unit-testable without a live
+ * daemon, and so the hold sites (next task) and the shared wait descriptor
+ * (delivery 2) can both reuse the same classification.
+ *
+ * Reference incident (2026-08-17, f1): the lead held on three triggers, none of
+ * which could fire -- integration advancing (blocked by the very guard failure it
+ * was waiting out -> `self`), a CI-red result "auto-resolving" (a recorded fact
+ * on a sha that never re-evaluates -> `static_fact`), and a re-verify only that
+ * lead could initiate (-> `self`). The named constructors below encode exactly
+ * those classes so a caller states its wait's KIND, not a raw blocker enum.
+ *
+ * This GENERALIZES the reachability notion external-hold.ts already carries: a
+ * hold with no machine-readable clearing reference ("will not self-clear") is a
+ * hold whose condition cannot fire. Cross-product request holds are the live
+ * `other_actor` case -- an OPEN request the peer product can still close.
+ *
+ * @module wait-reachability
+ */
+/**
+ * What a wait is blocked on -- the single axis that decides reachability.
+ *   - other_actor: another actor (a peer product, a CI runner, integration
+ *     merge-back) can still act, so the wait can still be satisfied.
+ *   - self: only the waiter itself could produce what it waits for -- waiting is
+ *     a deadlock (e.g. a re-verify only the holding lead could initiate).
+ *   - static_fact: a recorded fact that never re-evaluates without new input
+ *     (e.g. a CI result on an unchanged sha; it cannot change without a NEW
+ *     commit, so waiting for it to change cannot succeed).
+ */
+export type WaitBlocker = 'other_actor' | 'self' | 'static_fact';
+/** A described awaited condition: what is being waited for, and what blocks it. */
+export interface AwaitedCondition {
+    /** Human-readable statement of what is being waited for (for logs/records). */
+    condition: string;
+    /** What the wait is blocked on -- decides whether it can still fire. */
+    blockedOn: WaitBlocker;
+}
+/**
+ * The shared form EVERY place the daemon waits describes itself in: the awaited
+ * condition plus what it is blocked on. A `WaitDescriptor` IS an
+ * {@link AwaitedCondition} -- the alias names its role as the one shared wait
+ * vocabulary the independent waiting sites (external hold, CI merge gate, the
+ * no-progress counters, the handoff loop, the verify_failed cap) all speak, so a
+ * wait blocked on another actor is tellable from a wait blocked on itself
+ * WITHOUT reconstructing daemon state. Render it with {@link renderWait}.
+ */
+export type WaitDescriptor = AwaitedCondition;
+/** The reachability verdict for an awaited condition. */
+export interface WaitReachability {
+    /** True when the condition can still fire (blocked on another actor). */
+    reachable: boolean;
+    /** The blocker the verdict was derived from (echoed for logs/records). */
+    blockedOn: WaitBlocker;
+    /** Human-readable reason, suitable for a daemon log line or a hold record. */
+    reason: string;
+}
+/**
+ * Classify whether an awaited condition can still fire. Pure and total: the
+ * verdict depends ONLY on `blockedOn`, so the same condition always classifies
+ * the same way regardless of who asks.
+ */
+export declare function classifyWaitReachability(c: AwaitedCondition): WaitReachability;
+/** Convenience predicate: can this awaited condition still fire? */
+export declare function canStillFire(c: AwaitedCondition): boolean;
+/**
+ * A stable, machine-checkable marker naming what a wait is blocked on, so a
+ * daemon log line lets a reader tell a wait blocked on ANOTHER ACTOR (can still
+ * arrive) from one blocked on ITSELF or on a RECORDED FACT (cannot arrive)
+ * WITHOUT reconstructing daemon state from git + DB. The three markers are
+ * disjoint substrings by construction. This is the shared vocabulary the hold
+ * log sites emit; delivery 2 folds it into the single wait-descriptor render.
+ */
+export declare function describeWaitReachability(r: WaitReachability): string;
+/**
+ * The ONE canonical render of a wait for the daemon log: states WHAT is awaited
+ * and WHETHER it can still arrive, on one line, so a stall is legible from the
+ * log alone. Every waiting site routes its wait through this single function, so
+ * a future change to how a wait reads -- or a new fact to surface about every
+ * wait -- is made here, once, rather than in each component that waits.
+ */
+export declare function renderWait(wait: WaitDescriptor): string;
+/**
+ * A cross-product request the peer product can still close. REACHABLE: the peer
+ * is another actor and an OPEN request can still reach closure. Mirrors
+ * external-hold.ts `clearsWhenRequestsClosed`.
+ */
+export declare function crossProductRequestWait(requestIds: readonly string[]): AwaitedCondition;
+/**
+ * A recorded CI-status result on an UNCHANGED sha. A `red` (or otherwise
+ * non-green) result at refs/ci-status/<sha> never re-evaluates for the same
+ * commit -- it can only change with a NEW commit -- so waiting for it to turn
+ * green is waiting on a static fact. UNREACHABLE.
+ *
+ * A `pending` run is NOT this: the CI runner is still an active other actor, so
+ * that is a `ciRunPendingWait` (reachable). Only a settled, non-green result on
+ * a sha that will not change is the static-fact trap.
+ */
+export declare function recordedCiResultWait(sha: string, ciStatus: string): AwaitedCondition;
+/**
+ * A CI run still in progress for a sha. REACHABLE: the CI runner (another actor)
+ * has not finished, so a result can still arrive. Distinct from
+ * `recordedCiResultWait`, which is a SETTLED result on a sha that will not change.
+ */
+export declare function ciRunPendingWait(sha: string): AwaitedCondition;
+/**
+ * A re-verify (or any re-run) that only the holding lead itself could initiate.
+ * UNREACHABLE: the awaited event can only be produced by the waiter, so waiting
+ * for it is a deadlock.
+ */
+export declare function selfInitiatedReverifyWait(detail: string): AwaitedCondition;
+/**
+ * The daemon awaiting a team's own progress on its non-terminal deliveries.
+ * From the daemon's vantage the TEAM is another actor that can still act, so
+ * this is REACHABLE -- the daemon legitimately waits on it. The bound on how
+ * long it waits is the no-progress / scope-coverage guard (the stall counters),
+ * NOT unreachability: a stall here is "the actor has not acted for N cycles",
+ * surfaced by the guard tripping, not "the wait can never be satisfied".
+ */
+export declare function teamProgressWait(nonTerminalCount: number): AwaitedCondition;
+/**
+ * An integration branch advancing (merge-back). REACHABLE by default -- merge-back
+ * is driven by another actor (the daemon merge loop). But when the advance is
+ * blocked by the very condition this wait is itself waiting out (a circular
+ * wait, as in the 2026-08-17 incident where merge-back skipped the lead's branch
+ * as active_team because the lead was still executing), it is UNREACHABLE:
+ * nothing external can clear it while the wait persists.
+ */
+export declare function integrationAdvanceWait(opts: {
+    circular: boolean;
+    detail: string;
+}): AwaitedCondition;
+//# sourceMappingURL=wait-reachability.d.ts.map

package/dist/delivery/wait-reachability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-reachability.d.ts","sourceRoot":"","sources":["../../src/delivery/wait-reachability.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH;;;;;;;;;GASG;AACH,MAAM,MAAM,WAAW,GAAG,aAAa,GAAG,MAAM,GAAG,aAAa,CAAC;AAEjE,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,+EAA+E;IAC/E,SAAS,EAAE,MAAM,CAAC;IAClB,wEAAwE;IACxE,SAAS,EAAE,WAAW,CAAC;CACxB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GAAG,gBAAgB,CAAC;AAE9C,yDAAyD;AACzD,MAAM,WAAW,gBAAgB;IAC/B,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;IACnB,0EAA0E;IAC1E,SAAS,EAAE,WAAW,CAAC;IACvB,8EAA8E;IAC9E,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,gBAAgB,GAAG,gBAAgB,CAqB9E;AAED,oEAAoE;AACpE,wBAAgB,YAAY,CAAC,CAAC,EAAE,gBAAgB,GAAG,OAAO,CAEzD;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,gBAAgB,GAAG,MAAM,CASpE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAEvD;AAOD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,gBAAgB,CAgBvF;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,gBAAgB,CAKpF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAK9D;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAK1E;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAAC,gBAAgB,EAAE,MAAM,GAAG,gBAAgB,CAK3E;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,gBAAgB,CAUpG"}

package/dist/delivery/wait-reachability.js

@@ -0,0 +1,193 @@
+/**
+ * Wait reachability: can the condition a wait is blocked on still fire?
+ *
+ * The daemon waits in several places (an external hold, a stall-cycle counter, a
+ * mid-focus handoff, a CI merge gate). Every one of them holds against some
+ * awaited condition, but none of them ask the one question that tells patience
+ * from a stall: CAN THE THING BEING WAITED FOR STILL ARRIVE? A wait blocked on
+ * another actor (that actor can still act) and a wait blocked on itself -- or on
+ * a recorded fact that never re-evaluates -- look identical from the outside.
+ *
+ * This module is the shared answer. It classifies an awaited condition by WHAT
+ * it is blocked on, and derives reachability from that:
+ *   - other_actor -> REACHABLE   (another actor can still satisfy it)
+ *   - self        -> UNREACHABLE (only the waiter can produce it -> deadlock)
+ *   - static_fact -> UNREACHABLE (a recorded fact that never re-evaluates
+ *                                 without new input, e.g. a CI result on an
+ *                                 unchanged sha)
+ *
+ * It is PURE and dependency-free so the decision is unit-testable without a live
+ * daemon, and so the hold sites (next task) and the shared wait descriptor
+ * (delivery 2) can both reuse the same classification.
+ *
+ * Reference incident (2026-08-17, f1): the lead held on three triggers, none of
+ * which could fire -- integration advancing (blocked by the very guard failure it
+ * was waiting out -> `self`), a CI-red result "auto-resolving" (a recorded fact
+ * on a sha that never re-evaluates -> `static_fact`), and a re-verify only that
+ * lead could initiate (-> `self`). The named constructors below encode exactly
+ * those classes so a caller states its wait's KIND, not a raw blocker enum.
+ *
+ * This GENERALIZES the reachability notion external-hold.ts already carries: a
+ * hold with no machine-readable clearing reference ("will not self-clear") is a
+ * hold whose condition cannot fire. Cross-product request holds are the live
+ * `other_actor` case -- an OPEN request the peer product can still close.
+ *
+ * @module wait-reachability
+ */
+/**
+ * Classify whether an awaited condition can still fire. Pure and total: the
+ * verdict depends ONLY on `blockedOn`, so the same condition always classifies
+ * the same way regardless of who asks.
+ */
+export function classifyWaitReachability(c) {
+    switch (c.blockedOn) {
+        case 'other_actor':
+            return {
+                reachable: true,
+                blockedOn: 'other_actor',
+                reason: `blocked on another actor (can still arrive): ${c.condition}`,
+            };
+        case 'self':
+            return {
+                reachable: false,
+                blockedOn: 'self',
+                reason: `blocked on itself -- only the waiter could produce this, so it cannot arrive: ${c.condition}`,
+            };
+        case 'static_fact':
+            return {
+                reachable: false,
+                blockedOn: 'static_fact',
+                reason: `blocked on a recorded fact that never re-evaluates without new input, so it cannot arrive: ${c.condition}`,
+            };
+    }
+}
+/** Convenience predicate: can this awaited condition still fire? */
+export function canStillFire(c) {
+    return classifyWaitReachability(c).reachable;
+}
+/**
+ * A stable, machine-checkable marker naming what a wait is blocked on, so a
+ * daemon log line lets a reader tell a wait blocked on ANOTHER ACTOR (can still
+ * arrive) from one blocked on ITSELF or on a RECORDED FACT (cannot arrive)
+ * WITHOUT reconstructing daemon state from git + DB. The three markers are
+ * disjoint substrings by construction. This is the shared vocabulary the hold
+ * log sites emit; delivery 2 folds it into the single wait-descriptor render.
+ */
+export function describeWaitReachability(r) {
+    switch (r.blockedOn) {
+        case 'other_actor':
+            return 'wait: blocked on ANOTHER ACTOR (can still arrive)';
+        case 'self':
+            return 'wait: blocked on ITSELF (cannot arrive -- only the waiter could produce it)';
+        case 'static_fact':
+            return 'wait: blocked on a RECORDED FACT (cannot arrive without new input)';
+    }
+}
+/**
+ * The ONE canonical render of a wait for the daemon log: states WHAT is awaited
+ * and WHETHER it can still arrive, on one line, so a stall is legible from the
+ * log alone. Every waiting site routes its wait through this single function, so
+ * a future change to how a wait reads -- or a new fact to surface about every
+ * wait -- is made here, once, rather than in each component that waits.
+ */
+export function renderWait(wait) {
+    return `${wait.condition} [${describeWaitReachability(classifyWaitReachability(wait))}]`;
+}
+// ── Named constructors for the recognized wait kinds ────────────────────────
+// Callers state their wait's KIND; the constructor sets the correct blocker so
+// the incident's three unreachable classes cannot be mis-classified at a call
+// site. These are the vocabulary delivery 2's shared descriptor builds on.
+/**
+ * A cross-product request the peer product can still close. REACHABLE: the peer
+ * is another actor and an OPEN request can still reach closure. Mirrors
+ * external-hold.ts `clearsWhenRequestsClosed`.
+ */
+export function crossProductRequestWait(requestIds) {
+    if (requestIds.length === 0) {
+        // No request reference: nothing names an actor that could ever close this, so
+        // it cannot arrive -- the REFERENCE-LESS external hold. Classifying it as a
+        // recorded fact (UNREACHABLE) rather than other_actor is what lets a caller
+        // branch on the reachability verdict (e.g. isReferenceLessHoldStale) instead
+        // of mistaking a hold with nothing to re-read for one a peer will close.
+        return {
+            condition: 'cross-product hold with NO request reference to close (nothing to re-read)',
+            blockedOn: 'static_fact',
+        };
+    }
+    return {
+        condition: `cross-product request(s) to close: ${requestIds.join(', ')}`,
+        blockedOn: 'other_actor',
+    };
+}
+/**
+ * A recorded CI-status result on an UNCHANGED sha. A `red` (or otherwise
+ * non-green) result at refs/ci-status/<sha> never re-evaluates for the same
+ * commit -- it can only change with a NEW commit -- so waiting for it to turn
+ * green is waiting on a static fact. UNREACHABLE.
+ *
+ * A `pending` run is NOT this: the CI runner is still an active other actor, so
+ * that is a `ciRunPendingWait` (reachable). Only a settled, non-green result on
+ * a sha that will not change is the static-fact trap.
+ */
+export function recordedCiResultWait(sha, ciStatus) {
+    return {
+        condition: `CI status '${ciStatus}' recorded for unchanged sha ${sha} to change (needs a new commit)`,
+        blockedOn: 'static_fact',
+    };
+}
+/**
+ * A CI run still in progress for a sha. REACHABLE: the CI runner (another actor)
+ * has not finished, so a result can still arrive. Distinct from
+ * `recordedCiResultWait`, which is a SETTLED result on a sha that will not change.
+ */
+export function ciRunPendingWait(sha) {
+    return {
+        condition: `CI run to finish for sha ${sha}`,
+        blockedOn: 'other_actor',
+    };
+}
+/**
+ * A re-verify (or any re-run) that only the holding lead itself could initiate.
+ * UNREACHABLE: the awaited event can only be produced by the waiter, so waiting
+ * for it is a deadlock.
+ */
+export function selfInitiatedReverifyWait(detail) {
+    return {
+        condition: `a re-verify only this lead could initiate: ${detail}`,
+        blockedOn: 'self',
+    };
+}
+/**
+ * The daemon awaiting a team's own progress on its non-terminal deliveries.
+ * From the daemon's vantage the TEAM is another actor that can still act, so
+ * this is REACHABLE -- the daemon legitimately waits on it. The bound on how
+ * long it waits is the no-progress / scope-coverage guard (the stall counters),
+ * NOT unreachability: a stall here is "the actor has not acted for N cycles",
+ * surfaced by the guard tripping, not "the wait can never be satisfied".
+ */
+export function teamProgressWait(nonTerminalCount) {
+    return {
+        condition: `progress from the team on ${nonTerminalCount} non-terminal delivery(ies)`,
+        blockedOn: 'other_actor',
+    };
+}
+/**
+ * An integration branch advancing (merge-back). REACHABLE by default -- merge-back
+ * is driven by another actor (the daemon merge loop). But when the advance is
+ * blocked by the very condition this wait is itself waiting out (a circular
+ * wait, as in the 2026-08-17 incident where merge-back skipped the lead's branch
+ * as active_team because the lead was still executing), it is UNREACHABLE:
+ * nothing external can clear it while the wait persists.
+ */
+export function integrationAdvanceWait(opts) {
+    return opts.circular
+        ? {
+            condition: `integration to advance, blocked by the condition this wait is itself holding out: ${opts.detail}`,
+            blockedOn: 'self',
+        }
+        : {
+            condition: `integration to advance (merge-back): ${opts.detail}`,
+            blockedOn: 'other_actor',
+        };
+}
+//# sourceMappingURL=wait-reachability.js.map

package/dist/delivery/wait-reachability.js.map

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