wicked-crew 0.7.13 → 0.7.14

package/dist/api/delivery-cache.d.ts

@@ -0,0 +1,135 @@
+/**
+ * The background delivery-derivation cache — `GET /runs` p99 (perf finding #2).
+ *
+ * The vacuity split (crew#311) put two git probes per would-be-stranded run on the run DTOs'
+ * assembly path. On the LIST route that is a fan-out: ~20 terminal worktrees × (status + log)
+ * with a 10s timeout each, contending with the active worker's own git — measured p99 18.7s /
+ * max 18.9s while p50 stayed 182ms and `GET /runs/:id` (the same actor read) stayed 10ms in the
+ * exact same windows. The TTL memo bounded the cost per window but not the worst case: the
+ * unlucky poll that lands after expiry pays every probe, serially contended.
+ *
+ * This cache inverts the ownership: derivation runs in the BACKGROUND and the request path only
+ * ever reads a map. Concretely —
+ *
+ *   - a sweep every {@link DELIVERY_SWEEP_INTERVAL_MS} (= `WORKTREE_CLEAN_TTL_MS`, so labels
+ *     stay exactly as fresh as the memo already promised) re-derives every candidate run:
+ *     COMPLETED + repo-scoped + not already delivered — the only shape whose full derivation
+ *     can differ from the stat-only one;
+ *   - a terminal-frame warm ({@link warm}) derives a run ONCE when it reaches terminal state,
+ *     so a finished run's label heals in seconds, not at the next tick;
+ *   - the request path calls {@link read}: a hit answers the derived state; a miss degrades to
+ *     the stat-only tri-state (`deliveryStateOf` — the pre-crew#311 stranded/none label) for at
+ *     most one tick and NEVER blocks on (or triggers) a derivation. The list path spawns no git,
+ *     ever.
+ *
+ * The sweep pool is capped at {@link MAX_CONCURRENT_DERIVATIONS} with an in-flight guard per
+ * run, so the background layer can never storm git the way the request fan-out did. Probes are
+ * injected (the shared TTL-memoized git probes in production), so the campaigns rollup — which
+ * still derives on-request over the SAME probe memo — rides warm entries the sweeper refreshed.
+ *
+ * FAILURE RULE (PR #435 review): a derivation whose probes could not answer
+ * (`VacuityProbeUnavailable` — git unspawnable, timeout, a worktree racing the engine's
+ * terminal reap) is NEVER recorded — absence of an answer is not a verdict. The entry stays
+ * untouched (miss ⇒ the honest stat-only degrade) and the run re-derives on a short backoff,
+ * so a raced terminal-frame warm heals in seconds even where the sweep is off.
+ */
+import type { AgentSession, SessionView } from '../core/types.js';
+import { type DeliveryState, type VacuityProbes } from './delivery-index.js';
+/** The session facts the derivation reads — the same pick `deliveryStateWithVacuity` takes. */
+type SessionFacts = Pick<AgentSession, 'id' | 'status' | 'repo_ref' | 'workdir'>;
+/** One tick = the trust window the per-probe memo already grants, so moving derivation off the
+ *  request path changes WHO pays, never how stale a label may read. */
+export declare const DELIVERY_SWEEP_INTERVAL_MS = 30000;
+/** The background pool cap: at most this many derivations (each up to two git subprocesses) run
+ *  at once, so a 50-run backlog drains as a trickle instead of a spike that contends with the
+ *  active worker's git — the exact contention the request-path fan-out exhibited. */
+export declare const MAX_CONCURRENT_DERIVATIONS = 3;
+/** First retry delay after a derivation whose probes could not answer; doubles per consecutive
+ *  failure up to the sweep cadence. The terminal-frame warm fires at the most turbulent instant
+ *  of a run's life (the engine's terminal reap runs concurrently), so a raced first derivation
+ *  is EXPECTED — the retry is what heals it in seconds even where no sweep ticks (test-built
+ *  daemons keep the interval off). */
+export declare const DERIVATION_RETRY_BASE_MS = 1000;
+export interface DeliveryDerivationCacheDeps {
+    /** The candidate set per sweep — the same ~10ms actor read the routes use. */
+    listViews: () => Promise<SessionView[]>;
+    /** The probes behind 'stranded'/'vacuous'. In the daemon these are the SAME TTL-memoized git
+     *  probes the campaigns rollup uses; only `worktreeExists` (one stat, no git) is ever invoked
+     *  on the request path — the git pair runs exclusively under this cache's pool. */
+    probes: VacuityProbes;
+    /** A run the `DeliveryIndex` already answers needs no derivation — the read path
+     *  short-circuits on the recorded URL before it ever consults this cache. */
+    isDelivered: (runId: string) => boolean;
+    /** Retry-backoff floor after a failed derivation (tests shorten it). */
+    retryBaseMs?: number;
+    log?: (msg: string) => void;
+    /** ERROR-level channel for a NON-probe derivation throw — a defect, not weather (the daemon
+     *  wires `app.log.error`, which the diagnostics ring also captures). Falls back to `log`. */
+    logError?: (msg: string) => void;
+}
+export declare class DeliveryDerivationCache {
+    private readonly deps;
+    /** runId → the last full derivation. Entries exist only for candidate runs; the sweep prunes
+     *  ids the store no longer serves and runs the index has since recorded as delivered. */
+    private readonly derived;
+    /** The per-run in-flight guard: a run being derived is never enqueued a second time — a
+     *  sweep overlapping a terminal-frame warm folds into ONE derivation, not two git pairs. */
+    private readonly inFlight;
+    /** The pool: `active` counts held permits, `waiting` holds resolvers that each RECEIVE a
+     *  permit on release (the count transfers — it never dips below the true concurrency). */
+    private active;
+    private readonly waiting;
+    private sweeping;
+    private timer;
+    /** Per-run backoff after a failed derivation (reset on the next honest verdict). */
+    private readonly retryDelayMs;
+    /** Pending retry timers — unref'd, and cleared on {@link stop} so a closed daemon (or a
+     *  test's torn-down server) never re-derives into the void. */
+    private readonly retryTimers;
+    /** Set by {@link stop}: a derivation still in flight when the daemon closes must not arm a
+     *  NEW retry timer after the stop already swept the set (Copilot on #435). */
+    private stopped;
+    constructor(deps: DeliveryDerivationCacheDeps);
+    /**
+     * The request path. Synchronous by design — a cache hit answers the background-derived state;
+     * a miss answers the stat-only tri-state (one `existsSync`, no git) and does NOT enqueue a
+     * derivation: scheduling belongs to the sweep and the terminal warm alone, so a request can
+     * never fan a poll out into subprocess spawns, however cold the cache.
+     *
+     * Non-candidate shapes skip the cache entirely: their stat answer IS the full derivation, and
+     * skipping keeps a (theoretical) stale entry from ever outliving its run's candidacy.
+     */
+    read(session: SessionFacts): DeliveryState;
+    /**
+     * The terminal-frame warm: derive this run once, now, so a just-finished run's label heals in
+     * probe-time instead of waiting for the next tick. Fired from the daemon's CoreEvent
+     * subscription AFTER `resolveRunDelivery` settles — a just-recorded PR URL then skips the
+     * derivation via `isDelivered`. Best-effort like everything on that hook: never throws.
+     */
+    warm(runId: string): Promise<void>;
+    /**
+     * One background pass: prune entries the store no longer serves (or the index has since
+     * recorded as delivered), then re-derive every candidate through the capped pool. Re-entrant
+     * calls fold — a sweep still draining when the next tick fires is not stacked, so a slow git
+     * day degrades to a slower refresh, never to a growing backlog.
+     */
+    sweep(): Promise<void>;
+    /** Arm the tick (and sweep once immediately, so a restarted daemon's labels heal in seconds,
+     *  not at +30s). Unref'd — the interval must never hold the process open. */
+    start(intervalMs?: number): void;
+    stop(): void;
+    /** Enqueue one run's full derivation (in-flight-guarded, pool-capped).
+     *
+     *  THE LOAD-BEARING RULE (PR #435 review): a derivation whose probes FAILED is never cached
+     *  as if it were an honest answer. The production probes throw `VacuityProbeUnavailable` when
+     *  git could not answer (a raced teardown, a timeout, a load spike) — recording that as
+     *  'stranded' pinned a WRONG label on vacuous runs, forever where no sweep ticks. On failure
+     *  the entry is left untouched (a miss keeps the honest stat-only degrade; a previous honest
+     *  verdict stands) and the run re-derives after a short backoff, doubling up to the sweep
+     *  cadence — the in-flight guard folds overlapping schedules, so retries can never storm. */
+    private schedule;
+    private acquire;
+    private release;
+}
+export {};
+//# sourceMappingURL=delivery-cache.d.ts.map

package/dist/api/delivery-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"delivery-cache.d.ts","sourceRoot":"","sources":["../../src/api/delivery-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,aAAa,EACnB,MAAM,qBAAqB,CAAC;AAE7B,+FAA+F;AAC/F,KAAK,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC,CAAC;AAEjF;uEACuE;AACvE,eAAO,MAAM,0BAA0B,QAAwB,CAAC;AAEhE;;qFAEqF;AACrF,eAAO,MAAM,0BAA0B,IAAI,CAAC;AAE5C;;;;sCAIsC;AACtC,eAAO,MAAM,wBAAwB,OAAQ,CAAC;AAE9C,MAAM,WAAW,2BAA2B;IAC1C,8EAA8E;IAC9E,SAAS,EAAE,MAAM,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACxC;;uFAEmF;IACnF,MAAM,EAAE,aAAa,CAAC;IACtB;iFAC6E;IAC7E,WAAW,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC;IACxC,wEAAwE;IACxE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;IAC5B;iGAC6F;IAC7F,QAAQ,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC;AASD,qBAAa,uBAAuB;IAsBtB,OAAO,CAAC,QAAQ,CAAC,IAAI;IArBjC;6FACyF;IACzF,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAoC;IAC5D;gGAC4F;IAC5F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D;8FAC0F;IAC1F,OAAO,CAAC,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAA+C;IAC5D,oFAAoF;IACpF,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;IAC1D;mEAC+D;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA4C;IACxE;kFAC8E;IAC9E,OAAO,CAAC,OAAO,CAAS;gBAEK,IAAI,EAAE,2BAA2B;IAE9D;;;;;;;;OAQG;IACH,IAAI,CAAC,OAAO,EAAE,YAAY,GAAG,aAAa;IAQ1C;;;;;OAKG;IACG,IAAI,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAgBxC;;;;;OAKG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyB5B;iFAC6E;IAC7E,KAAK,CAAC,UAAU,GAAE,MAAmC,GAAG,IAAI;IAU5D,IAAI,IAAI,IAAI;IAUZ;;;;;;;;iGAQ6F;IAC7F,OAAO,CAAC,QAAQ;YA+DF,OAAO;IAQrB,OAAO,CAAC,OAAO;CAKhB"}

package/dist/api/delivery-cache.js

@@ -0,0 +1,245 @@
+/**
+ * The background delivery-derivation cache — `GET /runs` p99 (perf finding #2).
+ *
+ * The vacuity split (crew#311) put two git probes per would-be-stranded run on the run DTOs'
+ * assembly path. On the LIST route that is a fan-out: ~20 terminal worktrees × (status + log)
+ * with a 10s timeout each, contending with the active worker's own git — measured p99 18.7s /
+ * max 18.9s while p50 stayed 182ms and `GET /runs/:id` (the same actor read) stayed 10ms in the
+ * exact same windows. The TTL memo bounded the cost per window but not the worst case: the
+ * unlucky poll that lands after expiry pays every probe, serially contended.
+ *
+ * This cache inverts the ownership: derivation runs in the BACKGROUND and the request path only
+ * ever reads a map. Concretely —
+ *
+ *   - a sweep every {@link DELIVERY_SWEEP_INTERVAL_MS} (= `WORKTREE_CLEAN_TTL_MS`, so labels
+ *     stay exactly as fresh as the memo already promised) re-derives every candidate run:
+ *     COMPLETED + repo-scoped + not already delivered — the only shape whose full derivation
+ *     can differ from the stat-only one;
+ *   - a terminal-frame warm ({@link warm}) derives a run ONCE when it reaches terminal state,
+ *     so a finished run's label heals in seconds, not at the next tick;
+ *   - the request path calls {@link read}: a hit answers the derived state; a miss degrades to
+ *     the stat-only tri-state (`deliveryStateOf` — the pre-crew#311 stranded/none label) for at
+ *     most one tick and NEVER blocks on (or triggers) a derivation. The list path spawns no git,
+ *     ever.
+ *
+ * The sweep pool is capped at {@link MAX_CONCURRENT_DERIVATIONS} with an in-flight guard per
+ * run, so the background layer can never storm git the way the request fan-out did. Probes are
+ * injected (the shared TTL-memoized git probes in production), so the campaigns rollup — which
+ * still derives on-request over the SAME probe memo — rides warm entries the sweeper refreshed.
+ *
+ * FAILURE RULE (PR #435 review): a derivation whose probes could not answer
+ * (`VacuityProbeUnavailable` — git unspawnable, timeout, a worktree racing the engine's
+ * terminal reap) is NEVER recorded — absence of an answer is not a verdict. The entry stays
+ * untouched (miss ⇒ the honest stat-only degrade) and the run re-derives on a short backoff,
+ * so a raced terminal-frame warm heals in seconds even where the sweep is off.
+ */
+import { deliveryStateOf, deliveryStateWithVacuity, VacuityProbeUnavailable, WORKTREE_CLEAN_TTL_MS, } from './delivery-index.js';
+/** One tick = the trust window the per-probe memo already grants, so moving derivation off the
+ *  request path changes WHO pays, never how stale a label may read. */
+export const DELIVERY_SWEEP_INTERVAL_MS = WORKTREE_CLEAN_TTL_MS;
+/** The background pool cap: at most this many derivations (each up to two git subprocesses) run
+ *  at once, so a 50-run backlog drains as a trickle instead of a spike that contends with the
+ *  active worker's git — the exact contention the request-path fan-out exhibited. */
+export const MAX_CONCURRENT_DERIVATIONS = 3;
+/** First retry delay after a derivation whose probes could not answer; doubles per consecutive
+ *  failure up to the sweep cadence. The terminal-frame warm fires at the most turbulent instant
+ *  of a run's life (the engine's terminal reap runs concurrently), so a raced first derivation
+ *  is EXPECTED — the retry is what heals it in seconds even where no sweep ticks (test-built
+ *  daemons keep the interval off). */
+export const DERIVATION_RETRY_BASE_MS = 1_000;
+/** Only a COMPLETED repo-scoped run's full derivation can differ from the stat-only tri-state
+ *  (`deliveryStateWithVacuity` answers `deliveryStateOf` verbatim, git-free, for every other
+ *  shape) — so only these runs are ever derived or cached. */
+function isCandidate(session) {
+    return session.status === 'completed' && session.repo_ref != null;
+}
+export class DeliveryDerivationCache {
+    deps;
+    /** runId → the last full derivation. Entries exist only for candidate runs; the sweep prunes
+     *  ids the store no longer serves and runs the index has since recorded as delivered. */
+    derived = new Map();
+    /** The per-run in-flight guard: a run being derived is never enqueued a second time — a
+     *  sweep overlapping a terminal-frame warm folds into ONE derivation, not two git pairs. */
+    inFlight = new Map();
+    /** The pool: `active` counts held permits, `waiting` holds resolvers that each RECEIVE a
+     *  permit on release (the count transfers — it never dips below the true concurrency). */
+    active = 0;
+    waiting = [];
+    sweeping = false;
+    timer = null;
+    /** Per-run backoff after a failed derivation (reset on the next honest verdict). */
+    retryDelayMs = new Map();
+    /** Pending retry timers — unref'd, and cleared on {@link stop} so a closed daemon (or a
+     *  test's torn-down server) never re-derives into the void. */
+    retryTimers = new Set();
+    /** Set by {@link stop}: a derivation still in flight when the daemon closes must not arm a
+     *  NEW retry timer after the stop already swept the set (Copilot on #435). */
+    stopped = false;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * The request path. Synchronous by design — a cache hit answers the background-derived state;
+     * a miss answers the stat-only tri-state (one `existsSync`, no git) and does NOT enqueue a
+     * derivation: scheduling belongs to the sweep and the terminal warm alone, so a request can
+     * never fan a poll out into subprocess spawns, however cold the cache.
+     *
+     * Non-candidate shapes skip the cache entirely: their stat answer IS the full derivation, and
+     * skipping keeps a (theoretical) stale entry from ever outliving its run's candidacy.
+     */
+    read(session) {
+        if (isCandidate(session)) {
+            const hit = this.derived.get(session.id);
+            if (hit !== undefined)
+                return hit;
+        }
+        return deliveryStateOf(session, undefined, this.deps.probes.worktreeExists);
+    }
+    /**
+     * The terminal-frame warm: derive this run once, now, so a just-finished run's label heals in
+     * probe-time instead of waiting for the next tick. Fired from the daemon's CoreEvent
+     * subscription AFTER `resolveRunDelivery` settles — a just-recorded PR URL then skips the
+     * derivation via `isDelivered`. Best-effort like everything on that hook: never throws.
+     */
+    async warm(runId) {
+        try {
+            if (this.deps.isDelivered(runId))
+                return;
+            const views = await this.deps.listViews();
+            const view = views.find((v) => v.session.id === runId);
+            if (view === undefined || !isCandidate(view.session))
+                return;
+            await this.schedule(view.session);
+        }
+        catch (err) {
+            this.deps.log?.(`[runs] delivery-derivation warm for ${runId} failed (label reads stat-only until the next sweep): ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * One background pass: prune entries the store no longer serves (or the index has since
+     * recorded as delivered), then re-derive every candidate through the capped pool. Re-entrant
+     * calls fold — a sweep still draining when the next tick fires is not stacked, so a slow git
+     * day degrades to a slower refresh, never to a growing backlog.
+     */
+    async sweep() {
+        if (this.sweeping)
+            return;
+        this.sweeping = true;
+        try {
+            const views = await this.deps.listViews();
+            const alive = new Set(views.map((v) => v.session.id));
+            for (const id of this.derived.keys()) {
+                if (!alive.has(id) || this.deps.isDelivered(id))
+                    this.derived.delete(id);
+            }
+            await Promise.all(views
+                .filter((v) => isCandidate(v.session) && !this.deps.isDelivered(v.session.id))
+                .map((v) => this.schedule(v.session)));
+        }
+        catch (err) {
+            this.deps.log?.(`[runs] delivery-derivation sweep failed (labels degrade to the stat-only read until the next tick): ${err instanceof Error ? err.message : String(err)}`);
+        }
+        finally {
+            this.sweeping = false;
+        }
+    }
+    /** Arm the tick (and sweep once immediately, so a restarted daemon's labels heal in seconds,
+     *  not at +30s). Unref'd — the interval must never hold the process open. */
+    start(intervalMs = DELIVERY_SWEEP_INTERVAL_MS) {
+        if (this.timer !== null)
+            return;
+        this.stopped = false;
+        void this.sweep();
+        this.timer = setInterval(() => {
+            void this.sweep();
+        }, intervalMs);
+        this.timer.unref?.();
+    }
+    stop() {
+        this.stopped = true; // in-flight derivations must not arm retries past this point
+        if (this.timer !== null) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        for (const t of this.retryTimers)
+            clearTimeout(t);
+        this.retryTimers.clear();
+    }
+    /** Enqueue one run's full derivation (in-flight-guarded, pool-capped).
+     *
+     *  THE LOAD-BEARING RULE (PR #435 review): a derivation whose probes FAILED is never cached
+     *  as if it were an honest answer. The production probes throw `VacuityProbeUnavailable` when
+     *  git could not answer (a raced teardown, a timeout, a load spike) — recording that as
+     *  'stranded' pinned a WRONG label on vacuous runs, forever where no sweep ticks. On failure
+     *  the entry is left untouched (a miss keeps the honest stat-only degrade; a previous honest
+     *  verdict stands) and the run re-derives after a short backoff, doubling up to the sweep
+     *  cadence — the in-flight guard folds overlapping schedules, so retries can never storm. */
+    schedule(session) {
+        const pending = this.inFlight.get(session.id);
+        if (pending !== undefined)
+            return pending;
+        const job = (async () => {
+            await this.acquire();
+            try {
+                const state = await deliveryStateWithVacuity(session, undefined, this.deps.probes);
+                // A 'stranded' verdict over a worktree that VANISHED mid-derivation is not an answer
+                // either: the engine's terminal reap races the terminal-frame warm, and a half-removed
+                // tree can read "dirty" (deleted paths in `git status`) the instant before its .git
+                // link disappears. One stat re-check turns that race into a retry, not a pinned label.
+                if (state.delivery === 'stranded' &&
+                    typeof session.workdir === 'string' &&
+                    session.workdir !== '' &&
+                    !this.deps.probes.worktreeExists(session.workdir)) {
+                    throw new VacuityProbeUnavailable(`worktree ${session.workdir} vanished mid-derivation`, 'raced the terminal reap');
+                }
+                this.derived.set(session.id, state);
+                this.retryDelayMs.delete(session.id);
+            }
+            catch (err) {
+                if (!(err instanceof VacuityProbeUnavailable)) {
+                    // A NON-probe throw is a DEFECT (a bug in the derivation, a miswired dependency) —
+                    // not weather. Hiding it inside the quiet backoff loop would spray retry noise over
+                    // a logic error (Copilot on #435), so: record nothing (the honest stat-only degrade
+                    // stands), say it at ERROR level, and do NOT retry — in the daemon the next sweep
+                    // hits it again and keeps it loud, never silently green.
+                    (this.deps.logError ?? this.deps.log)?.(`[runs] DEFECT: delivery derivation for ${session.id} threw a non-probe error (not retried; label reads stat-only): ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`);
+                    return;
+                }
+                const delay = this.retryDelayMs.get(session.id) ?? this.deps.retryBaseMs ?? DERIVATION_RETRY_BASE_MS;
+                this.retryDelayMs.set(session.id, Math.min(delay * 2, DELIVERY_SWEEP_INTERVAL_MS));
+                this.deps.log?.(`[runs] delivery derivation for ${session.id} could not answer (label reads stat-only; ${this.stopped ? 'cache stopped — not retried' : `retrying in ${delay}ms`}): ${err.message}`);
+                // A derivation still in flight when stop() ran must not arm a timer the sweep-away
+                // already missed — a closed daemon never re-derives into the void.
+                if (this.stopped)
+                    return;
+                const timer = setTimeout(() => {
+                    this.retryTimers.delete(timer);
+                    void this.warm(session.id);
+                }, delay);
+                timer.unref?.();
+                this.retryTimers.add(timer);
+            }
+            finally {
+                this.release();
+                this.inFlight.delete(session.id);
+            }
+        })();
+        this.inFlight.set(session.id, job);
+        return job;
+    }
+    async acquire() {
+        if (this.active < MAX_CONCURRENT_DERIVATIONS) {
+            this.active += 1;
+            return;
+        }
+        await new Promise((resolve) => this.waiting.push(resolve));
+    }
+    release() {
+        const next = this.waiting.shift();
+        if (next !== undefined)
+            next(); // hand the permit over — `active` is unchanged
+        else
+            this.active -= 1;
+    }
+}
+//# sourceMappingURL=delivery-cache.js.map

package/dist/api/delivery-cache.js.map

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

package/dist/api/delivery-index.d.ts

@@ -46,7 +46,14 @@ export interface DeliveryState {
  */
 export declare function deliveryStateOf(session: Pick<AgentSession, 'status' | 'repo_ref' | 'workdir'>, url: string | undefined, worktreeExists: (path: string) => boolean): DeliveryState;
 /** The probes behind the `'vacuous'` derivation (crew#311) — injected so route tests can pin the
- *  derivation without staging real repos; production wires the memoized git probes below. */
+ *  derivation without staging real repos; production wires the memoized git probes below.
+ *
+ *  FAILURE CONTRACT (PR #435 review): a production git probe THROWS
+ *  {@link VacuityProbeUnavailable} when git could not answer — spawn failure, timeout, a
+ *  worktree or repo racing teardown, a non-git directory. That is the ABSENCE of an answer, not
+ *  a verdict, and the caller owns the degrade: the delivery cache retries WITHOUT recording
+ *  (never caching a failed probe as an honest label), and the campaigns rollup serves that one
+ *  request the stat-only tri-state. Injected test probes return plain booleans. */
 export interface VacuityProbes {
     /** One stat — the `'stranded'` gate (crew#393; `fs.existsSync` in production). */
     worktreeExists: (path: string) => boolean;
@@ -56,6 +63,17 @@ export interface VacuityProbes {
      *  commits of its own (or no longer exists) — the reaped-worktree half of vacuity. */
     runBranchIsEmpty: (repoRef: string, runId: string) => Promise<boolean>;
 }
+/**
+ * Thrown by the production probes when git COULD NOT ANSWER — infrastructure absence, not a
+ * verdict. The old behavior folded this into `false` ("not clean" / "not empty"), which was
+ * safe while every consumer re-probed within a TTL, but the delivery cache records derivations:
+ * caching a raced probe's `false` pinned a WRONG 'stranded' on a vacuous run (forever, where no
+ * sweep ticks). Distinguishing absence from verdict at the probe layer is what lets the cache
+ * refuse to record it.
+ */
+export declare class VacuityProbeUnavailable extends Error {
+    constructor(what: string, cause: unknown);
+}
 /**
  * The delivery derivation WITH the vacuity split (crew#311) — the async refinement over
  * {@link deliveryStateOf} the run DTOs actually use.
@@ -73,26 +91,36 @@ export interface VacuityProbes {
  *     work anywhere, while "reaped tree + commits on the branch" is landed work and stays
  *     `'none'` (nothing left in a worktree to lift).
  *
- * Both shapes now read `'vacuous'`, and only on POSITIVE reads: every probe fails toward the
- * pre-existing label (`'stranded'` / `'none'`), so a non-git directory, a missing repo record,
- * a deleted repo, or a git failure reads exactly as it did before this existed. (One honest
- * edge: an operator who hand-deleted a completed run's branch has made its work unreachable —
- * it reads vacuous, which is what the run now amounts to.)
+ * Both shapes now read `'vacuous'`, and only on POSITIVE reads. A missing repo RECORD still
+ * reads `false` from the branch probe (a permanent state — the label honestly falls back to
+ * `'none'`), but a git failure now PROPAGATES as {@link VacuityProbeUnavailable} instead of
+ * silently keeping the pre-existing label: the caller owns the degrade (see the failure
+ * contract on {@link VacuityProbes}). (One honest edge: an operator who hand-deleted a
+ * completed run's branch has made its work unreachable — it reads vacuous, which is what the
+ * run now amounts to.)
  */
 export declare function deliveryStateWithVacuity(session: Pick<AgentSession, 'id' | 'status' | 'repo_ref' | 'workdir'>, url: string | undefined, probes: VacuityProbes): Promise<DeliveryState>;
 /** How long a per-worktree cleanliness read is trusted before the next request re-probes. A
  *  terminal run's worktree only changes under operator hands, and `GET /runs` is polled — an
  *  unmemoized probe would be two git subprocesses per stranded run per poll. */
 export declare const WORKTREE_CLEAN_TTL_MS = 30000;
+/** How long a FAILED probe ({@link VacuityProbeUnavailable}) is memoized before a real
+ *  re-probe. Deliberately short: a failure is usually a raced teardown or a load spike, and
+ *  the delivery cache's retry needs a genuine re-probe in ~a second — but a request-path
+ *  consumer (the campaigns rollup) polling over a persistently broken repo must not spawn two
+ *  10s-timeout gits per poll tick either. */
+export declare const PROBE_FAILURE_TTL_MS = 1000;
 /**
  * The production `worktreeIsClean` probe: the SAME two read-only instruments as the engine's
  * `worktree_is_clean` — uncommitted paths (`git status --porcelain`, untracked included) and
  * run-branch-only commits (`git log --oneline HEAD --not --exclude=wicked/* --branches`) —
  * memoized per worktree path for {@link WORKTREE_CLEAN_TTL_MS}.
  *
- * Fails toward NOT-clean (see {@link deliveryStateWithVacuity} — a failure must keep the
- * pre-existing 'stranded' label, never invent 'vacuous'), and failures obey the TTL too, so a
- * transient git error doesn't pin a run's label until restart.
+ * A verdict comes only from git ANSWERING: exit 0 with empty/non-empty output. Any failure —
+ * git unspawnable, a timeout kill, a 128 "not a git repository", ENOENT from a worktree racing
+ * the terminal reap — throws {@link VacuityProbeUnavailable} (memoized for
+ * {@link PROBE_FAILURE_TTL_MS}) so no consumer can mistake absence for "not clean" and pin a
+ * wrong 'stranded' (PR #435 review). Callers degrade per the {@link VacuityProbes} contract.
  */
 export declare function gitWorktreeIsClean(ttlMs?: number, now?: () => number): (path: string) => Promise<boolean>;
 /**
@@ -102,8 +130,11 @@ export declare function gitWorktreeIsClean(ttlMs?: number, now?: () => number):
  * `refs/heads/wicked/<runId>` no longer exists in the run's repo, or it exists and
  * `git log <branch> --not --exclude=wicked/* --branches` is empty (the branch carries no commit
  * of its own — the exact second instrument of the engine's `worktree_is_clean`, aimed at the
- * branch instead of a checkout). An unresolvable repo, a git failure, or any commit on the
- * branch reads FALSE — the label falls back to `'none'`, never inventing vacuity.
+ * branch instead of a checkout). A repo the registry no longer RESOLVES reads FALSE — a
+ * permanent state, the label honestly falls back to `'none'` — while a git failure or a
+ * registry read failure throws {@link VacuityProbeUnavailable} (absence of an answer, PR #435
+ * review), memoized for {@link PROBE_FAILURE_TTL_MS}; callers degrade per the
+ * {@link VacuityProbes} contract.
  *
  * `resolveRepoRoot` is injected (routes wire it to the adapter's repo registry) and its answer
  * rides the same TTL memo as the verdict, so a `GET /runs` poll costs at most one registry read

package/dist/api/delivery-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"delivery-index.d.ts","sourceRoot":"","sources":["../../src/api/delivery-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI5E,kGAAkG;AAClG,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,MAAM,CAAC;IACxD,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,CAC7B,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC,EAC9D,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,GACxC,aAAa,CAYf;AAED;6FAC6F;AAC7F,MAAM,WAAW,aAAa;IAC5B,kFAAkF;IAClF,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IAC1C,2FAA2F;IAC3F,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACpD;0FACsF;IACtF,gBAAgB,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CACxE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,wBAAwB,CAC5C,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,IAAI,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC,EACrE,GAAG,EAAE,MAAM,GAAG,SAAS,EACvB,MAAM,EAAE,aAAa,GACpB,OAAO,CAAC,aAAa,CAAC,CAiBxB;AAED;;gFAEgF;AAChF,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,GAAE,MAA8B,EACrC,GAAG,GAAE,MAAM,MAAiB,GAC3B,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CA4BpC;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,EACjE,KAAK,GAAE,MAA8B,EACrC,GAAG,GAAE,MAAM,MAAiB,GAC3B,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CA4CtD;AAED;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGrD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAIhE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CASpE;AAED,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IAEtD;;;;;;;;OAQG;IACG,OAAO,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAsB1E,8EAA8E;IAC9E,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI;IAIrC;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;CAG1C"}
+{"version":3,"file":"delivery-index.d.ts","sourceRoot":"","sources":["../../src/api/delivery-index.ts"],"names":[],"mappings":"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"}