@telora/daemon 0.21.26 → 0.21.81

package/dist/escalations.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"escalations.d.ts","sourceRoot":"","sources":["../src/escalations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAGL,KAAK,oBAAoB,EACzB,KAAK,qBAAqB,EAC3B,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAEL,KAAK,yBAAyB,EAC/B,MAAM,kBAAkB,CAAC;AAE1B,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,uDAAuD;IACvD,cAAc,EAAE,MAAM,CAAC;IACvB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8CAA8C;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;OAMG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,UAAU,CAAC,EAAE,oBAAoB,CAAC;IAClC;;;OAGG;IACH,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC;;;;OAIG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAOlC;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,yEAAyE;IACzE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4EAA4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,mEAAmE;IACnE,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,mBAAmB,EAC1B,SAAS,CAAC,EAAE,yBAAyB,GACpC,OAAO,CAAC,IAAI,CAAC,CAoEf"}

package/dist/escalations.js

@@ -1,91 +0,0 @@
-/**
- * Narrow escalation seam for the PRD divergence/realign core (Delivery E).
- *
- * The PRD controller files a human escalation when a chosen pathway diverges and
- * NO surviving alternative remains (loss of phase-lock with no re-capture). Per
- * the PLL framing, the human owns intent: when the machine cannot re-acquire a
- * viable path it must hand control up, never silently lower the goal.
- *
- * This module exposes `fileEscalation({ focusId?, productId?, reason, kind?,
- * details? })` -- the controller-facing shape -- and adapts it onto the existing
- * `createEscalation` transport (queries/issues.js -> `agent_escalate`). The
- * adapter is deliberately thin: it carries `organizationId` (resolved from
- * config at the wiring site) and folds focus/product/details into the
- * escalation metadata. No business logic lives here.
- */
-import { createEscalation, markEscalationResolved } from './queries/issues.js';
-import { ESCALATION_REASONS, ESCALATION_DISPOSITIONS, } from '@telora/daemon-core';
-import { maybeRouteToNexus, } from './nexus/index.js';
-/**
- * File a human escalation from the PRD realign core. Best-effort wrapper over
- * `createEscalation`. The transport requires a session id; PRD-controller ticks
- * run outside any agent session, so we pass the empty string (server tolerates
- * a null/empty session for system-filed escalations).
- *
- * `reasonType` maps to the backend's fixed `reason_type` enum (defaulting to
- * `decision_needed`); the caller's machine `reason`/`kind` strings are carried
- * in metadata so they survive without tripping the enum/CHECK validation that
- * `reason_type` and `escalation_kind` enforce server-side.
- */
-export async function fileEscalation(input, nexusDeps) {
-    // ---- Escalation -> Nexus bridge (cross-product blockers) ----
-    // BEFORE filing the human escalation: if this is a cross-product blocker that
-    // names a target + source product, try to route it into a Nexus request. The
-    // disposition router lives in nexus-escalation-bridge.routeEscalation; here we
-    // just attempt the route and record whether it landed. Non-cross-product
-    // escalations skip this entirely and behave exactly as before.
-    const reasonType = input.reasonType ?? ESCALATION_REASONS.DECISION_NEEDED;
-    const nexusResult = await maybeRouteToNexus({
-        reasonType,
-        targetProductId: input.targetProductId,
-        sourceProductId: input.sourceProductId,
-        sourceFocusId: input.sourceFocusId,
-        sourceDeliveryId: input.sourceDeliveryId,
-        title: input.title ?? input.reason,
-        description: input.reason,
-        ...(input.acceptanceContract ? { acceptanceContract: input.acceptanceContract } : {}),
-    }, nexusDeps);
-    // Metadata hygiene (Delivery B): the bag carries EVIDENCE/PAYLOAD only.
-    //   - machine_reason DROPPED  -- it duplicated `description` (= input.reason).
-    //   - focus_id/product_id DROPPED from metadata -- provenance now lives on the
-    //     first-class columns, stamped via the anchor below.
-    //   - machine `kind` is a non-CHECK-valid PRD discriminator, kept as evidence
-    //     under `machine_discriminator` (it is NOT the DB escalation_kind).
-    // When routed to Nexus we ALSO carry the target in metadata so the audit row
-    // records the lateral target even if the edge has not yet promoted the
-    // target_product_id column write end-to-end.
-    const metadata = {
-        ...(input.kind ? { machine_discriminator: input.kind } : {}),
-        ...(nexusResult.routed && input.targetProductId
-            ? { target_product_id: input.targetProductId, nexus_request_id: nexusResult.requestId }
-            : {}),
-        ...(input.details ?? {}),
-    };
-    const { escalationId } = await createEscalation({
-        organizationId: input.organizationId,
-        sessionId: '',
-        issueId: null,
-        reasonType,
-        disposition: input.disposition ?? ESCALATION_DISPOSITIONS.NEEDS_INTENT,
-        // Provenance via the anchor -- focus carries product; the resolver fills
-        // any gaps and never throws.
-        anchor: {
-            ...(input.focusId ? { focusId: input.focusId } : {}),
-        },
-        // A directly-supplied productId still wins (explicit beats derived).
-        ...(input.productId ? { productId: input.productId } : {}),
-        // First-class cross-product target (best-effort column write; the edge may
-        // ignore it today, the metadata copy above is the durable carrier).
-        ...(input.targetProductId ? { targetProductId: input.targetProductId } : {}),
-        description: input.reason,
-        ...(Object.keys(metadata).length > 0 ? { metadata } : {}),
-    });
-    // When routed to Nexus, the audit escalation must NOT linger in the human
-    // pending inbox -- the blocker is now owned by the other product's team. Mark
-    // it resolved with a note pointing at the Nexus request. Best-effort: a missing
-    // id (older edge build) just leaves the row pending, which is the safe default.
-    if (nexusResult.routed && escalationId) {
-        await markEscalationResolved(escalationId, `Routed to Nexus request ${nexusResult.requestId}`);
-    }
-}
-//# sourceMappingURL=escalations.js.map

package/dist/escalations.js.map

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

package/dist/evaluation-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluation-context.d.ts","sourceRoot":"","sources":["../src/evaluation-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAG7D,YAAY,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAM7D;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,iBAAiB,CAAC,CA4B5B"}

package/dist/evaluation-context.js

@@ -1,44 +0,0 @@
-/**
- * Context building for guard evaluation.
- *
- * Gathers the evaluation context (delivery state, issue counts, session data)
- * needed by condition evaluators.
- *
- * The EvaluationContext interface is canonically defined in @telora/daemon-core
- * and re-exported here for backward compatibility.
- *
- * Extracted from guard-engine.ts to improve maintainability.
- */
-import { getDeliveryIssues, getDeliverySessionCount, } from './supabase.js';
-// ============================================
-// Context Builders
-// ============================================
-/**
- * Build evaluation context by querying current delivery state.
- */
-export async function buildEvaluationContext(deliveryId, lastExitCode) {
-    const [issues, sessionCount] = await Promise.all([
-        getDeliveryIssues(deliveryId),
-        getDeliverySessionCount(deliveryId),
-    ]);
-    const issuesByStatus = {};
-    const issuesByPriority = {};
-    for (const issue of issues) {
-        issuesByStatus[issue.status] = (issuesByStatus[issue.status] ?? 0) + 1;
-        if (issue.issueType !== 'Context Group') {
-            const priority = 'unknown';
-            issuesByPriority[priority] = (issuesByPriority[priority] ?? 0) + 1;
-        }
-    }
-    const openIssueCount = issues.filter(i => i.status !== 'Done').length;
-    return {
-        deliveryId,
-        openIssueCount,
-        totalIssueCount: issues.length,
-        issuesByStatus,
-        issuesByPriority,
-        lastExitCode,
-        sessionCount,
-    };
-}
-//# sourceMappingURL=evaluation-context.js.map

package/dist/evaluation-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"evaluation-context.js","sourceRoot":"","sources":["../src/evaluation-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,iBAAiB,EACjB,uBAAuB,GACxB,MAAM,eAAe,CAAC;AAMvB,+CAA+C;AAC/C,mBAAmB;AACnB,+CAA+C;AAE/C;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAC1C,UAAkB,EAClB,YAAoB;IAEpB,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QAC/C,iBAAiB,CAAC,UAAU,CAAC;QAC7B,uBAAuB,CAAC,UAAU,CAAC;KACpC,CAAC,CAAC;IAEH,MAAM,cAAc,GAA2B,EAAE,CAAC;IAClD,MAAM,gBAAgB,GAA2B,EAAE,CAAC;IAEpD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACvE,IAAI,KAAK,CAAC,SAAS,KAAK,eAAe,EAAE,CAAC;YACxC,MAAM,QAAQ,GAAG,SAAS,CAAC;YAC3B,gBAAgB,CAAC,QAAQ,CAAC,GAAG,CAAC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACrE,CAAC;IACH,CAAC;IAED,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,MAAM,CAAC;IAEtE,OAAO;QACL,UAAU;QACV,cAAc;QACd,eAAe,EAAE,MAAM,CAAC,MAAM;QAC9B,cAAc;QACd,gBAAgB;QAChB,YAAY;QACZ,YAAY;KACb,CAAC;AACJ,CAAC"}

package/dist/external-hold.d.ts

@@ -1,146 +0,0 @@
-/**
- * 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 { updateDeliveryStatus } from './supabase.js';
-import type { ExternalHoldState } 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/external-hold.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"external-hold.d.ts","sourceRoot":"","sources":["../src/external-hold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAC1D,OAAO,KAAK,EAAqB,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAwBpF,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/external-hold.js

@@ -1,223 +0,0 @@
-/**
- * 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 './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/external-hold.js.map

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

package/dist/focus-branch-ahead.d.ts

@@ -1,42 +0,0 @@
-/**
- * Landed-work check for focus completion.
- *
- * A focus reads complete only when its agent work has measurably LANDED where a
- * human inspecting the tree will find it. The observed failure: an agent branch
- * carried four substantive commits, was never merged, and the board still read
- * complete because completion was inferred from delivery status, not from where
- * the work actually landed.
- *
- * This reads branch state DETERMINISTICALLY from git (a standing daemon
- * invariant -- never inferred from agent claims): true when the focus's agent
- * branch carries commits not reachable from the product's integration branch.
- * The focus-completion evaluate phase consults it and holds `complete` open while
- * the branch is ahead; the merge-back loop lands the branch (the normal outcome)
- * and files a stuck_focus_branch escalation for a genuinely-unmergeable one.
- *
- * @module focus-branch-ahead
- */
-import { getAllFocusWorktrees } from './focus-worktree-state.js';
-import { branchHasUnmergedCommits } from './worktree/index.js';
-import type { DaemonConfig } from './types.js';
-/** Injected seam so the check is unit-testable without a real worktree/git. */
-export interface FocusBranchAheadDeps {
-    getAllFocusWorktrees: typeof getAllFocusWorktrees;
-    branchHasUnmergedCommits: typeof branchHasUnmergedCommits;
-}
-/**
- * True when the focus's agent branch carries commits not reachable from the
- * product's integration branch -- i.e. its work has NOT landed.
- *
- * `productConfig` must be product-SCOPED (configForProduct) so integrationBranch
- * and repoPath resolve to the focus's own product in a multi-product daemon.
- *
- * Returns false when the focus has no tracked worktree (nothing to land). The
- * git primitive returns false on any git failure rather than throwing, so a git
- * hiccup fails OPEN (allows complete) rather than wedging completion forever --
- * the merge-back loop's stuck_focus_branch escalation is the durable backstop
- * for work that genuinely cannot land, and the evaluate phase re-checks every
- * tick so a transient false-open self-corrects.
- */
-export declare function focusBranchAhead(focusId: string, productConfig: DaemonConfig, deps?: FocusBranchAheadDeps): boolean;
-//# sourceMappingURL=focus-branch-ahead.d.ts.map

package/dist/focus-branch-ahead.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"focus-branch-ahead.d.ts","sourceRoot":"","sources":["../src/focus-branch-ahead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAC/D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,+EAA+E;AAC/E,MAAM,WAAW,oBAAoB;IACnC,oBAAoB,EAAE,OAAO,oBAAoB,CAAC;IAClD,wBAAwB,EAAE,OAAO,wBAAwB,CAAC;CAC3D;AAOD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,YAAY,EAC3B,IAAI,GAAE,oBAAkC,GACvC,OAAO,CAQT"}

package/dist/focus-branch-ahead.js

@@ -1,45 +0,0 @@
-/**
- * Landed-work check for focus completion.
- *
- * A focus reads complete only when its agent work has measurably LANDED where a
- * human inspecting the tree will find it. The observed failure: an agent branch
- * carried four substantive commits, was never merged, and the board still read
- * complete because completion was inferred from delivery status, not from where
- * the work actually landed.
- *
- * This reads branch state DETERMINISTICALLY from git (a standing daemon
- * invariant -- never inferred from agent claims): true when the focus's agent
- * branch carries commits not reachable from the product's integration branch.
- * The focus-completion evaluate phase consults it and holds `complete` open while
- * the branch is ahead; the merge-back loop lands the branch (the normal outcome)
- * and files a stuck_focus_branch escalation for a genuinely-unmergeable one.
- *
- * @module focus-branch-ahead
- */
-import { getAllFocusWorktrees } from './focus-worktree-state.js';
-import { branchHasUnmergedCommits } from './worktree/index.js';
-const defaultDeps = {
-    getAllFocusWorktrees,
-    branchHasUnmergedCommits,
-};
-/**
- * True when the focus's agent branch carries commits not reachable from the
- * product's integration branch -- i.e. its work has NOT landed.
- *
- * `productConfig` must be product-SCOPED (configForProduct) so integrationBranch
- * and repoPath resolve to the focus's own product in a multi-product daemon.
- *
- * Returns false when the focus has no tracked worktree (nothing to land). The
- * git primitive returns false on any git failure rather than throwing, so a git
- * hiccup fails OPEN (allows complete) rather than wedging completion forever --
- * the merge-back loop's stuck_focus_branch escalation is the durable backstop
- * for work that genuinely cannot land, and the evaluate phase re-checks every
- * tick so a transient false-open self-corrects.
- */
-export function focusBranchAhead(focusId, productConfig, deps = defaultDeps) {
-    const wt = deps.getAllFocusWorktrees().get(focusId);
-    if (!wt)
-        return false;
-    return deps.branchHasUnmergedCommits(wt.branchName, productConfig.integrationBranch, productConfig.repoPath);
-}
-//# sourceMappingURL=focus-branch-ahead.js.map

package/dist/focus-branch-ahead.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"focus-branch-ahead.js","sourceRoot":"","sources":["../src/focus-branch-ahead.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAC;AAS/D,MAAM,WAAW,GAAyB;IACxC,oBAAoB;IACpB,wBAAwB;CACzB,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,gBAAgB,CAC9B,OAAe,EACf,aAA2B,EAC3B,OAA6B,WAAW;IAExC,MAAM,EAAE,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IACpD,IAAI,CAAC,EAAE;QAAE,OAAO,KAAK,CAAC;IACtB,OAAO,IAAI,CAAC,wBAAwB,CAClC,EAAE,CAAC,UAAU,EACb,aAAa,CAAC,iBAAiB,EAC/B,aAAa,CAAC,QAAQ,CACvB,CAAC;AACJ,CAAC"}