@telora/daemon 0.21.26 → 0.21.81

package/dist/delivery/delivery-reconciler.js

@@ -0,0 +1,249 @@
+/**
+ * Single-writer delivery reconciler (PURE).
+ *
+ * Delivery 3 of the Delivery Execution Pathway Consolidation focus
+ * (reality-tree injection #10: "Delivery execution_status has exactly one
+ * writer -- the daemon reconciler; every transition flows through it").
+ *
+ * This module is the consolidation's center of gravity: ONE pure function that
+ * computes the single next execution_status the daemon should write, plus ONE
+ * shared "issues are done" predicate that replaces the divergent copies spread
+ * across the live writers (advanceDeliveryStage / advanceDeliveryStatuses /
+ * runReviewExitHandler / checkDeliveryAutoAdvance / checkVerifyDeliveriesForOpenIssues).
+ *
+ * That claim is now TRUE of every named writer AND mechanically enforced: each
+ * of the five routes its status decision through `resolveReconciledWrite`
+ * (delivery-reconciler-apply.ts) over the delivery's REAL issue list, and uses
+ * the shared OPEN_ISSUE_STATUSES / areDeliveryIssuesDone predicate -- no writer
+ * synthesizes issues from a count, carries a `!TERMINAL_ISSUE_STATUSES.has`
+ * open-work predicate, or keeps a superseded status write. The gate that keeps
+ * this header honest is `npm run lint:reconciler-single-writer`
+ * (scripts/lint-reconciler-single-writer.mjs, wired into lint:all): it fails if
+ * any named writer reintroduces its own derivation, or if this header names a
+ * writer that no longer exists. Keep the "live writers ( ... )" list above
+ * accurate -- the gate parses it.
+ *
+ * It is deliberately PURE -- no I/O, no supabase, no git. Callers gather the
+ * signal (issues, worktree-committed flag, guard verdict, review state) and
+ * pass it in; the reconciler only computes. This is what makes it
+ * shadow-testable: run it alongside the live path, compare its target to the
+ * live status, log divergence, write nothing (see delivery-reconciler-shadow.ts).
+ *
+ * The behavior here MIRRORS the CURRENT live writers as pinned by the
+ * Delivery 2 characterization suite
+ * (__tests__/delivery-state-machine-characterization.test.ts). It characterizes
+ * what the system does today, not an idealized target -- the shadow phase exists
+ * precisely to prove parity before any cutover.
+ *
+ * The coding -> queued re-queue edge (open work at team exit -> re-queue) is
+ * present in EXECUTION_STATUS_TRANSITIONS as of the D5 cleanup. `result.canonical`
+ * flags transitions NOT in the canonical map; the coding -> queued edge now
+ * resolves to `canonical=true`.
+ */
+import { OPEN_ISSUE_STATUSES, filterWorkIssues } from '../shell/constants.js';
+import { DELIVERY_STATUS, isValidTransition } from '@telora/daemon-core';
+// ── Shared predicate (the single definition) ─────────────────────────
+/**
+ * THE shared "issues are done" predicate. A delivery's work is done when none
+ * of its work issues (Tasks/Bugs, excluding Context Groups) are in an OPEN
+ * status. OPEN = {To Do, In Progress, Blocked}; 'In Review' and 'Verified' are
+ * terminal here -- this is the daemon predicate, deliberately chosen as the
+ * single source of truth over the Postgres auto_close predicate (which requires
+ * every issue to be literally 'Done'). A delivery with zero work issues is
+ * vacuously done.
+ *
+ * This is the ONE open-work predicate every delivery writer consumes. It is
+ * built on the shared OPEN_ISSUE_STATUSES set (constants.ts). advanceDeliveryStatuses
+ * previously computed its open count from `!TERMINAL_ISSUE_STATUSES.has` (now
+ * collapsed onto OPEN_ISSUE_STATUSES), and an `ACTIVE_WORK_STATUSES` copy that
+ * duplicated the same set has been deleted -- there is no longer a second
+ * membership definition to drift against.
+ */
+export function areDeliveryIssuesDone(issues) {
+    const work = filterWorkIssues([...issues]);
+    if (work.length === 0)
+        return true;
+    return work.every(i => !OPEN_ISSUE_STATUSES.has(i.status));
+}
+/** Whether the delivery has at least one work issue (Task/Bug). */
+export function hasWorkIssues(issues) {
+    return filterWorkIssues([...issues]).length > 0;
+}
+/**
+ * Whether any work issue is in an OPEN (active) status. This is the routing
+ * signal for verify -> verify_failed (open work on a verify delivery) and the
+ * coding/verify_failed re-queue (open work re-queues). Mirror image of
+ * areDeliveryIssuesDone for deliveries that have work.
+ */
+export function hasOpenWork(issues) {
+    return filterWorkIssues([...issues]).some(i => OPEN_ISSUE_STATUSES.has(i.status));
+}
+/** Whether any work issue is actively In Progress -- the queued -> coding driver. */
+export function hasActiveWork(issues) {
+    return filterWorkIssues([...issues]).some(i => i.status === 'In Progress');
+}
+/**
+ * Whether any work issue is BLOCKING open work: open (To Do / In Progress /
+ * Blocked) AND not a deferrable review note. This is the verify -> verify_failed
+ * routing signal: a verify delivery whose only open work is deferrable
+ * low-severity review notes converges (approve) instead of re-coding. With no
+ * issue marked `deferrable` this is identical to hasOpenWork, so every
+ * non-classifying caller keeps its current behavior.
+ */
+export function hasBlockingOpenWork(issues) {
+    return filterWorkIssues([...issues])
+        .some(i => OPEN_ISSUE_STATUSES.has(i.status) && !i.deferrable);
+}
+// ── Discovery-only determination (two signals) ───────────────────────
+// The audit-shape predicates live in the dependency-free `audit-shape.ts` module
+// (no `@telora/daemon-core`) so listener-auto-advance / completion can import
+// them without pulling the reconciler's daemon-core chain. Re-exported here for
+// back-compat with importers that reach for them via delivery-reconciler.
+export { isAuditPhaseFocus, isDiscoveryOnlyDelivery, } from '../audit/audit-shape.js';
+// ── The reconciler ───────────────────────────────────────────────────
+function result(currentStatus, target, reason) {
+    const changed = target !== currentStatus;
+    return {
+        target,
+        changed,
+        reason,
+        canonical: !changed || isValidTransition(currentStatus, target),
+    };
+}
+/**
+ * Compute the single next execution_status for a delivery from its full signal.
+ *
+ * Faithful to the current live writers (Delivery 2 characterization):
+ *   - queued  : has work + all done -> coding (step toward verify);
+ *               has work + active   -> coding (work started);
+ *               otherwise            -> stay (scoping gate / not started).
+ *   - coding  : open work           -> queued (re-queue);
+ *               no work issues (non-discovery) -> queued (empty-delivery scoping
+ *                                    gate: never advance an issue-less delivery to
+ *                                    verify on the vacuous all-done truth);
+ *               all done + uncommitted worktree -> stay coding (git-safety gate);
+ *               all done + committed + guard blocked -> paused;
+ *               all done + committed -> verify.
+ *   - verify  : blocking open work   -> verify_failed (deferrable low-severity
+ *                                       review notes do NOT block -> converge);
+ *               guard blocked        -> paused;
+ *               verdict gaps_found   -> verify_failed (never converge on an
+ *                                       unresolved verdict);
+ *               report exists        -> done;
+ *               clean review session -> done (auto-approve);
+ *               otherwise            -> stay verify (awaiting review outcome).
+ *   - verify_failed : open work      -> queued (re-queue);
+ *                     all done       -> coding (re-iterate).
+ *   - draft/planning/paused/done/cancelled : stay (out of reconciler scope;
+ *               paused is cleared by a human re-queue, terminal states are final).
+ */
+export function reconcileDeliveryStatus(input) {
+    const { currentStatus, issues, gitState, guardVerdict, reviewState, discoveryOnly } = input;
+    const allDone = areDeliveryIssuesDone(issues);
+    const openWork = hasOpenWork(issues);
+    const hasWork = hasWorkIssues(issues);
+    switch (currentStatus) {
+        case DELIVERY_STATUS.QUEUED: {
+            if (!hasWork) {
+                // Discovery-only deliveries are exempt from the scoping gate: with no
+                // work issues they step toward a terminal state instead of wedging.
+                if (discoveryOnly) {
+                    return result(currentStatus, DELIVERY_STATUS.CODING, 'discovery-only delivery, no scoping required -> advance toward terminal');
+                }
+                return result(currentStatus, DELIVERY_STATUS.QUEUED, 'no work issues yet (scoping gate holds queued)');
+            }
+            if (allDone) {
+                return result(currentStatus, DELIVERY_STATUS.CODING, 'queued with all work terminal -> step to coding before advancing');
+            }
+            if (hasActiveWork(issues)) {
+                return result(currentStatus, DELIVERY_STATUS.CODING, 'work in progress -> coding');
+            }
+            return result(currentStatus, DELIVERY_STATUS.QUEUED, 'work not started -> stay queued');
+        }
+        case DELIVERY_STATUS.CODING: {
+            if (openWork) {
+                return result(currentStatus, DELIVERY_STATUS.QUEUED, 'open work remains -> re-queue');
+            }
+            // Empty-delivery scoping gate: a delivery with NO work issues must never
+            // advance coding -> verify on the vacuous "all issues done" truth
+            // (areDeliveryIssuesDone is true over an empty set). An unscoped delivery
+            // that reached coding rests back at queued so a team scopes it, instead of
+            // rocketing to verify and generating verify_evidence_unavailable about work
+            // that never began (2026-07-27 incident). Discovery-only deliveries (audit
+            // findings; their contract is Context Groups, not Task/Bug) are EXEMPT and
+            // still walk to their terminal -- the only caller that walks an empty
+            // delivery forward, checkDeliveryAutoAdvance, passes discoveryOnly=true and
+            // gates it on resolved Context Group findings.
+            if (!hasWork && !discoveryOnly) {
+                return result(currentStatus, DELIVERY_STATUS.QUEUED, 'no work issues (scoping gate) -> re-queue to queued (never advance an empty delivery to verify)');
+            }
+            if (!gitState.worktreeCommitted) {
+                return result(currentStatus, DELIVERY_STATUS.CODING, 'all work done but worktree has uncommitted changes -> git-safety gate holds in coding');
+            }
+            if (guardVerdict?.blocked) {
+                return result(currentStatus, DELIVERY_STATUS.PAUSED, 'guard blocked coding->verify -> paused');
+            }
+            return result(currentStatus, DELIVERY_STATUS.VERIFY, 'all work done + worktree committed -> verify');
+        }
+        case DELIVERY_STATUS.VERIFY: {
+            // Only BLOCKING open work falls a verify delivery. A delivery whose only
+            // open work is deferrable low-severity review notes converges (approve)
+            // rather than re-coding -- the notes stay tracked but do not churn the
+            // verify gate. Non-classified issues are blocking by default, so this is
+            // identical to the raw open-work check for every other caller.
+            if (hasBlockingOpenWork(issues)) {
+                return result(currentStatus, DELIVERY_STATUS.VERIFY_FAILED, 'blocking open work on a verify delivery -> verify_failed');
+            }
+            if (guardVerdict?.blocked) {
+                return result(currentStatus, DELIVERY_STATUS.PAUSED, 'verify->done gate blocked -> paused');
+            }
+            // A discovery-only delivery has no review to await -- its findings ARE the
+            // output. With no blocking work it converges to done (completing the
+            // canonical walk queued->coding->verify->done).
+            if (discoveryOnly) {
+                return result(currentStatus, DELIVERY_STATUS.DONE, 'discovery-only delivery, discovery complete -> done');
+            }
+            // The verdict is authoritative: a gaps_found review can NEVER converge to
+            // done. If gaps_found came with blocking issues the hasBlockingOpenWork
+            // branch above already routed; reaching here means gaps_found with no
+            // blocking work -- a routing inconsistency (gaps reported, no actionable
+            // issue filed). Route to verify_failed anyway; the handler files the
+            // inconsistency escalation. This sits BEFORE the reportExists/auto-approve
+            // done branches precisely because a gaps_found report has reportExists=true.
+            if (reviewState?.outcome === 'gaps_found') {
+                return result(currentStatus, DELIVERY_STATUS.VERIFY_FAILED, 'review verdict gaps_found -> verify_failed (never converge to done on an unresolved verdict)');
+            }
+            if (reviewState?.reportExists) {
+                return result(currentStatus, DELIVERY_STATUS.DONE, 'explicit review report present -> done');
+            }
+            if (reviewState?.sessionType === 'review' && reviewState.succeeded) {
+                // Silence approves ONLY with positive evidence of inspection. A clean
+                // review session that did no review work (inspected === false -- zero
+                // tool activity) is a BLIND gate, not a passing review: "the absence of
+                // filed defects decides nothing". Route it to the bounded verify_failed
+                // re-work (same bounded path the verify-side evidence-unavailable case
+                // uses) rather than converging an uninspected pass to the irreversible
+                // done. inspected undefined preserves the legacy auto-approve for
+                // callers predating the signal; production always passes an explicit
+                // boolean.
+                if (reviewState.inspected === false) {
+                    return result(currentStatus, DELIVERY_STATUS.VERIFY_FAILED, 'clean review session with no inspection evidence -> verify_failed (blind gate, bounded re-work)');
+                }
+                return result(currentStatus, DELIVERY_STATUS.DONE, 'clean review session, no report -> done (auto-approve)');
+            }
+            return result(currentStatus, DELIVERY_STATUS.VERIFY, 'no open work, awaiting review outcome -> stay verify');
+        }
+        case DELIVERY_STATUS.VERIFY_FAILED: {
+            if (openWork) {
+                return result(currentStatus, DELIVERY_STATUS.QUEUED, 'verify_failed with open work -> re-queue');
+            }
+            return result(currentStatus, DELIVERY_STATUS.CODING, 'verify_failed, work done -> coding (re-iterate)');
+        }
+        // draft / planning / paused / done / cancelled: not driven by the
+        // issue-rollup reconciler. paused is cleared by a human re-queue;
+        // terminal states are final.
+        default:
+            return result(currentStatus, currentStatus, `status '${currentStatus}' is not reconciler-driven -> stay`);
+    }
+}
+//# sourceMappingURL=delivery-reconciler.js.map

package/dist/delivery/delivery-reconciler.js.map

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

package/dist/delivery/external-hold.d.ts

@@ -0,0 +1,145 @@
+/**
+ * External-hold gate: an irreducibly-external dependency is durable STATE on
+ * the delivery, not an inbox event.
+ *
+ * Some work is outside every capability Telora could ever build -- rotating
+ * credentials at a provider a third party owns is the live example: no code and
+ * no execution surface reaches those accounts. Filed as an agent_escalations
+ * row it becomes an event on a queue it can never leave under its own power --
+ * an unanswered question forever, and (because it persists) it forces dedup
+ * machinery, which is itself the tell that the shape is wrong.
+ *
+ * This module represents that class as a declared hold on external reality,
+ * carried in the delivery's `gate_state` JSONB (the same durable field that
+ * already holds `operatorHold` / `shortfallProposalIds`), distinct from an
+ * escalation row. Two properties it must preserve:
+ *   1. It still HOLDS the delivery out of `done` -- the operator-hold gate's
+ *      delivery-holding property is correct and survives here (see the
+ *      external-hold check wired alongside resolveOperatorHold on every
+ *      verify->done path).
+ *   2. It clears by RE-READING REALITY -- an injectable condition evaluator --
+ *      not by a human clicking "resolve" on an inbox item. When the condition
+ *      is re-evaluated true, the hold clears itself with no one touching a
+ *      queue; the machine closes the loop.
+ *
+ * Boundary: this is ONLY for the irreducibly external. Anything a capable
+ * resolver could close routes through the resolver-dispatch seam
+ * (resolver-dispatch.ts), never here -- this is not a second parking lot.
+ *
+ * @module external-hold
+ */
+import type { ExternalHoldState, updateDeliveryStatus } from '../queries/deliveries.js';
+/** The slice of deps this gate needs (structural, so no import cycle). */
+export interface ExternalHoldDeps {
+    updateDeliveryStatus: typeof updateDeliveryStatus;
+}
+/**
+ * Re-evaluate whether an external hold's clearing condition is now met.
+ * Injectable so a real probe (or an operator re-reading reality) plugs in
+ * without this module knowing how any specific external condition is checked.
+ * Returns true when reality has changed such that the hold should clear.
+ */
+export type ExternalConditionEvaluator = (hold: ExternalHoldState) => boolean | Promise<boolean>;
+/**
+ * The default production evaluator: an irreducibly-external dependency does not
+ * auto-clear from its free-text condition -- there is no generic probe for
+ * "provider X rotated the keys". So the default KEEPS the hold (returns false)
+ * until reality is re-read as changed via {@link clearExternalHold}. This is
+ * the correct conservative behavior: an unmet external dependency must keep
+ * holding the delivery out of done, and it never becomes an inbox question. A
+ * subsystem that CAN probe a specific condition supplies its own evaluator.
+ */
+export declare const holdUntilExternallyCleared: ExternalConditionEvaluator;
+/**
+ * Read the current status of the cross-product requests named by an external
+ * hold's clearing reference. Injected so external-hold.ts stays free of request
+ * I/O (and of the bare `@telora/*` value imports that request queries pull in,
+ * which mis-resolve under the node:test module-mock loader). Production
+ * implementation lives at the wiring sites over queries/requests.ts. Returns one
+ * row per KNOWN request; a referenced id absent from the result is treated as
+ * unreadable (fail-closed) by the evaluator below.
+ */
+export type RequestStatusReader = (requestIds: string[]) => Promise<Array<{
+    id: string;
+    status?: string;
+}>>;
+/**
+ * Build the production external-condition evaluator: re-read the requests named
+ * by a hold's `clearsWhenRequestsClosed` and clear the hold ONLY when EVERY one
+ * has reached contract-gated closure ('closed').
+ *
+ *   - No machine-readable reference on the hold (legacy 3-field hold, or one
+ *     declared without a reference) -> KEEP HOLDING with no I/O, identical to
+ *     holdUntilExternallyCleared. This keeps the wiring INERT for every hold
+ *     that predates the producer; such a hold is surfaced as reference-less by
+ *     resolveExternalHold, never silently self-cleared.
+ *   - A referenced request that is 'delivered' but not 'closed' -> keep holding
+ *     (deliver-with-findings is not closure).
+ *   - A referenced request that is 'declined' -> keep holding (a decline is a
+ *     human-decides state surfaced elsewhere; the delivery does not advance).
+ *   - A referenced request that cannot be read this pass (missing row) -> THROW,
+ *     which resolveExternalHold turns into held (fail-closed). A transport error
+ *     from the reader propagates the same way.
+ */
+export declare function makeRequestClosureEvaluator(readStatuses: RequestStatusReader): ExternalConditionEvaluator;
+/** The resolved external-hold state for one delivery. */
+export interface ExternalHold {
+    /** True when an unmet external hold is present on the delivery. */
+    held: boolean;
+    /** The hold state when present; null when there is none. */
+    hold: ExternalHoldState | null;
+    /** The condition re-evaluated true this pass and the hold was cleared. */
+    cleared: boolean;
+    /**
+     * True when the delivery is held but the hold carries NO machine-readable
+     * clearing reference (`clearsWhenRequestsClosed`) -- so the daemon has nothing
+     * to re-read and the hold will not self-clear. Surfaced (not silently a
+     * normal, self-clearing hold) so an operator/agent inspecting the delivery
+     * learns it needs a reference or a reality change to move. Absent/false when
+     * not held, when cleared, or when the hold carries a reference.
+     */
+    referenceLess?: boolean;
+}
+/** Narrow a delivery's `gate_state` JSONB to its externalHold, if any. */
+export declare function readExternalHoldState(gateState: unknown): ExternalHoldState | null;
+/**
+ * Declare an irreducibly-external hold on a delivery: write the blocking
+ * condition and what would clear it into the delivery's gate_state. This
+ * creates NO agent_escalations row -- that is the whole point: an external
+ * dependency is state, not an inbox event.
+ *
+ * gate_state is written through daemon_update_delivery_status (which requires
+ * an executionStatus), so this re-asserts `verify` and writes the gate, exactly
+ * like writeOperatorHoldGateState. Best-effort logging on failure; the caller
+ * decides how to surface a write failure.
+ */
+export declare function declareExternalHold(deps: ExternalHoldDeps, deliveryId: string, params: {
+    condition: string;
+    clearsWhen: string;
+    declaredAt: string;
+    clearsWhenRequestsClosed?: string[];
+}): Promise<void>;
+/**
+ * Clear an external hold: rewrite gate_state WITHOUT the externalHold field,
+ * re-asserting `verify` so the delivery is free to advance on the next pass.
+ * This is the "reality changed -- re-read confirms the dependency is met" path,
+ * and it is condition-driven, NOT a human resolving an escalation.
+ */
+export declare function clearExternalHold(deps: ExternalHoldDeps, deliveryId: string, clearedAt: string): Promise<void>;
+/**
+ * Resolve whether a delivery is externally held, re-evaluating the clearing
+ * condition as a first-class part of the read.
+ *
+ * FAILS CLOSED like the operator-hold gate: if the condition evaluator throws,
+ * the hold is kept (held: true). A missed hold lets an externally-blocked
+ * delivery reach done -- the failure this focus exists to stop -- so the safe
+ * direction is to hold.
+ *
+ * When the condition re-evaluates true, the hold is cleared (gate_state
+ * rewritten without it) and this returns held: false, cleared: true. That is
+ * the loop closing itself by re-reading reality -- no human resolve, no inbox.
+ */
+export declare function resolveExternalHold(deps: ExternalHoldDeps, deliveryId: string, gateState: unknown, evaluateCondition: ExternalConditionEvaluator, clock?: () => string): Promise<ExternalHold>;
+/** Human-readable hold reason for an exit/advance log line. */
+export declare function describeExternalHold(hold: ExternalHold): string;
+//# sourceMappingURL=external-hold.d.ts.map

package/dist/delivery/external-hold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-hold.d.ts","sourceRoot":"","sources":["../../src/delivery/external-hold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAqB,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAwB3G,0EAA0E;AAC1E,MAAM,WAAW,gBAAgB;IAC/B,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;CACnD;AAED;;;;;GAKG;AACH,MAAM,MAAM,0BAA0B,GAAG,CACvC,IAAI,EAAE,iBAAiB,KACpB,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAEhC;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,0BAAwC,CAAC;AAElF;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAChC,UAAU,EAAE,MAAM,EAAE,KACjB,OAAO,CAAC,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAAC;AAErD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,2BAA2B,CACzC,YAAY,EAAE,mBAAmB,GAChC,0BAA0B,CAe5B;AAED,yDAAyD;AACzD,MAAM,WAAW,YAAY;IAC3B,mEAAmE;IACnE,IAAI,EAAE,OAAO,CAAC;IACd,4DAA4D;IAC5D,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAAC;IAC/B,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;IACjB;;;;;;;OAOG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,iBAAiB,GAAG,IAAI,CAmBlF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GACzG,OAAO,CAAC,IAAI,CAAC,CAmBf;AAED;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,IAAI,CAAC,CAOf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,gBAAgB,EACtB,UAAU,EAAE,MAAM,EAClB,SAAS,EAAE,OAAO,EAClB,iBAAiB,EAAE,0BAA0B,EAC7C,KAAK,GAAE,MAAM,MAAuC,GACnD,OAAO,CAAC,YAAY,CAAC,CAoCvB;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAY/D"}

package/dist/delivery/external-hold.js

@@ -0,0 +1,223 @@
+/**
+ * External-hold gate: an irreducibly-external dependency is durable STATE on
+ * the delivery, not an inbox event.
+ *
+ * Some work is outside every capability Telora could ever build -- rotating
+ * credentials at a provider a third party owns is the live example: no code and
+ * no execution surface reaches those accounts. Filed as an agent_escalations
+ * row it becomes an event on a queue it can never leave under its own power --
+ * an unanswered question forever, and (because it persists) it forces dedup
+ * machinery, which is itself the tell that the shape is wrong.
+ *
+ * This module represents that class as a declared hold on external reality,
+ * carried in the delivery's `gate_state` JSONB (the same durable field that
+ * already holds `operatorHold` / `shortfallProposalIds`), distinct from an
+ * escalation row. Two properties it must preserve:
+ *   1. It still HOLDS the delivery out of `done` -- the operator-hold gate's
+ *      delivery-holding property is correct and survives here (see the
+ *      external-hold check wired alongside resolveOperatorHold on every
+ *      verify->done path).
+ *   2. It clears by RE-READING REALITY -- an injectable condition evaluator --
+ *      not by a human clicking "resolve" on an inbox item. When the condition
+ *      is re-evaluated true, the hold clears itself with no one touching a
+ *      queue; the machine closes the loop.
+ *
+ * Boundary: this is ONLY for the irreducibly external. Anything a capable
+ * resolver could close routes through the resolver-dispatch seam
+ * (resolver-dispatch.ts), never here -- this is not a second parking lot.
+ *
+ * @module external-hold
+ */
+import { createLogger } from '../shell/log.js';
+const log = createLogger({ module: 'external-hold' });
+// The `verify` status re-asserted by a gate_state write. Daemon-local literal
+// for the same reason as operator-hold.ts's VERIFY_STATUS: this module is
+// pulled into listener tests under the node:test module-mock loader, where a
+// bare `@telora/*` VALUE import mis-resolves. The DB CHECK on execution_status
+// is the real constraint; this mirrors DELIVERY_STATUS.VERIFY.
+const VERIFY_STATUS = 'verify';
+// The request status that means a cross-product request reached contract-gated
+// closure -- the ONLY status that clears a request-referenced external hold.
+// Daemon-local literal for the same reason as VERIFY_STATUS above (this module
+// is pulled into listener tests under the node:test module-mock loader, where a
+// bare `@telora/*` value import mis-resolves), and to avoid an import cycle:
+// nexus/return.ts imports declareExternalHold from HERE (the producer), so this
+// module must not import back from nexus/return.ts. Keep in sync with the
+// request lifecycle vocabulary there (NON_TERMINAL_REQUEST_STATUSES): 'delivered'
+// is non-terminal-for-the-source and 'declined' is a terminal exit that is NOT
+// closure -- neither clears the hold, only 'closed' does.
+const REQUEST_STATUS_CLOSED = 'closed';
+/**
+ * The default production evaluator: an irreducibly-external dependency does not
+ * auto-clear from its free-text condition -- there is no generic probe for
+ * "provider X rotated the keys". So the default KEEPS the hold (returns false)
+ * until reality is re-read as changed via {@link clearExternalHold}. This is
+ * the correct conservative behavior: an unmet external dependency must keep
+ * holding the delivery out of done, and it never becomes an inbox question. A
+ * subsystem that CAN probe a specific condition supplies its own evaluator.
+ */
+export const holdUntilExternallyCleared = () => false;
+/**
+ * Build the production external-condition evaluator: re-read the requests named
+ * by a hold's `clearsWhenRequestsClosed` and clear the hold ONLY when EVERY one
+ * has reached contract-gated closure ('closed').
+ *
+ *   - No machine-readable reference on the hold (legacy 3-field hold, or one
+ *     declared without a reference) -> KEEP HOLDING with no I/O, identical to
+ *     holdUntilExternallyCleared. This keeps the wiring INERT for every hold
+ *     that predates the producer; such a hold is surfaced as reference-less by
+ *     resolveExternalHold, never silently self-cleared.
+ *   - A referenced request that is 'delivered' but not 'closed' -> keep holding
+ *     (deliver-with-findings is not closure).
+ *   - A referenced request that is 'declined' -> keep holding (a decline is a
+ *     human-decides state surfaced elsewhere; the delivery does not advance).
+ *   - A referenced request that cannot be read this pass (missing row) -> THROW,
+ *     which resolveExternalHold turns into held (fail-closed). A transport error
+ *     from the reader propagates the same way.
+ */
+export function makeRequestClosureEvaluator(readStatuses) {
+    return async (hold) => {
+        const ids = hold.clearsWhenRequestsClosed;
+        if (!ids || ids.length === 0)
+            return false; // reference-less -> keep holding
+        const rows = await readStatuses(ids); // transport error -> throw -> fail-closed
+        for (const id of ids) {
+            const row = rows.find((r) => r.id === id);
+            if (!row) {
+                // A referenced request we cannot read is unreadable state: fail-closed.
+                throw new Error(`external-hold: referenced request ${id} not found in status read`);
+            }
+            if (row.status !== REQUEST_STATUS_CLOSED)
+                return false; // not yet closed -> hold
+        }
+        return true; // every referenced request closed -> dependency met
+    };
+}
+/** Narrow a delivery's `gate_state` JSONB to its externalHold, if any. */
+export function readExternalHoldState(gateState) {
+    if (gateState === null || typeof gateState !== 'object')
+        return null;
+    const eh = gateState.externalHold;
+    if (eh === null || typeof eh !== 'object')
+        return null;
+    const { condition, clearsWhen, declaredAt, clearsWhenRequestsClosed } = eh;
+    if (typeof condition !== 'string' || typeof clearsWhen !== 'string' || typeof declaredAt !== 'string') {
+        return null;
+    }
+    // The clearing reference is OPTIONAL and additive: a legacy hold with only the
+    // three string fields must STILL narrow to a valid hold. Include the reference
+    // only when it is a well-formed array of strings; a malformed value is dropped
+    // (the hold reads as reference-less rather than becoming unreadable/null).
+    const requestIds = Array.isArray(clearsWhenRequestsClosed) && clearsWhenRequestsClosed.every((x) => typeof x === 'string')
+        ? clearsWhenRequestsClosed
+        : undefined;
+    return requestIds
+        ? { condition, clearsWhen, declaredAt, clearsWhenRequestsClosed: requestIds }
+        : { condition, clearsWhen, declaredAt };
+}
+/**
+ * Declare an irreducibly-external hold on a delivery: write the blocking
+ * condition and what would clear it into the delivery's gate_state. This
+ * creates NO agent_escalations row -- that is the whole point: an external
+ * dependency is state, not an inbox event.
+ *
+ * gate_state is written through daemon_update_delivery_status (which requires
+ * an executionStatus), so this re-asserts `verify` and writes the gate, exactly
+ * like writeOperatorHoldGateState. Best-effort logging on failure; the caller
+ * decides how to surface a write failure.
+ */
+export async function declareExternalHold(deps, deliveryId, params) {
+    const externalHold = {
+        condition: params.condition,
+        clearsWhen: params.clearsWhen,
+        declaredAt: params.declaredAt,
+        // Persist the machine-readable clearing reference only when non-empty, so a
+        // hold declared without one reads back as reference-less rather than
+        // carrying an empty array the evaluator would treat as reference-less anyway.
+        ...(params.clearsWhenRequestsClosed && params.clearsWhenRequestsClosed.length > 0
+            ? { clearsWhenRequestsClosed: params.clearsWhenRequestsClosed }
+            : {}),
+    };
+    const gateState = {
+        blocking: [],
+        warnings: [],
+        evaluatedAt: params.declaredAt,
+        externalHold,
+    };
+    await deps.updateDeliveryStatus(deliveryId, VERIFY_STATUS, undefined, gateState, undefined, undefined);
+}
+/**
+ * Clear an external hold: rewrite gate_state WITHOUT the externalHold field,
+ * re-asserting `verify` so the delivery is free to advance on the next pass.
+ * This is the "reality changed -- re-read confirms the dependency is met" path,
+ * and it is condition-driven, NOT a human resolving an escalation.
+ */
+export async function clearExternalHold(deps, deliveryId, clearedAt) {
+    const gateState = {
+        blocking: [],
+        warnings: [],
+        evaluatedAt: clearedAt,
+    };
+    await deps.updateDeliveryStatus(deliveryId, VERIFY_STATUS, undefined, gateState, undefined, undefined);
+}
+/**
+ * Resolve whether a delivery is externally held, re-evaluating the clearing
+ * condition as a first-class part of the read.
+ *
+ * FAILS CLOSED like the operator-hold gate: if the condition evaluator throws,
+ * the hold is kept (held: true). A missed hold lets an externally-blocked
+ * delivery reach done -- the failure this focus exists to stop -- so the safe
+ * direction is to hold.
+ *
+ * When the condition re-evaluates true, the hold is cleared (gate_state
+ * rewritten without it) and this returns held: false, cleared: true. That is
+ * the loop closing itself by re-reading reality -- no human resolve, no inbox.
+ */
+export async function resolveExternalHold(deps, deliveryId, gateState, evaluateCondition, clock = () => new Date().toISOString()) {
+    const hold = readExternalHoldState(gateState);
+    if (hold === null)
+        return { held: false, hold: null, cleared: false };
+    // A hold with no (or empty) machine-readable clearing reference has nothing
+    // for the daemon to re-read, so it cannot self-clear -- surface it rather than
+    // let it read as a normal, self-clearing hold.
+    const referenceLess = !hold.clearsWhenRequestsClosed || hold.clearsWhenRequestsClosed.length === 0;
+    let conditionMet = false;
+    try {
+        conditionMet = await evaluateCondition(hold);
+    }
+    catch (err) {
+        log.warn(`[external-hold] condition re-evaluation failed for delivery ${deliveryId} -- ` +
+            `holding verify->done (fail-closed): ${err.message}`);
+        return { held: true, hold, cleared: false, referenceLess };
+    }
+    if (conditionMet) {
+        try {
+            await clearExternalHold(deps, deliveryId, clock());
+        }
+        catch (err) {
+            // The hold is decided cleared; a failed rewrite must not resurrect it as
+            // held (that would strand the delivery). Log and report cleared -- the
+            // next pass sees the same met condition and rewrites again.
+            log.warn(`[external-hold] failed to clear gate_state for delivery ${deliveryId} ` +
+                `(condition met, will retry next pass): ${err.message}`);
+        }
+        return { held: false, hold, cleared: true };
+    }
+    return { held: true, hold, cleared: false, referenceLess };
+}
+/** Human-readable hold reason for an exit/advance log line. */
+export function describeExternalHold(hold) {
+    if (hold.cleared)
+        return 'external hold cleared (condition re-evaluated true)';
+    if (hold.hold) {
+        const base = `external hold: ${hold.hold.condition} (clears when: ${hold.hold.clearsWhen})`;
+        // Name the reference-less case so it is not mistaken for a self-clearing
+        // hold: nothing references what would clear it, so the daemon cannot re-read
+        // it to done -- it needs a reality change or a re-declaration with a reference.
+        return hold.referenceLess
+            ? `${base} [no machine-readable clearing reference -- will not self-clear]`
+            : base;
+    }
+    return 'not held';
+}
+//# sourceMappingURL=external-hold.js.map

package/dist/delivery/external-hold.js.map

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