@telora/daemon 0.21.12 → 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,104 +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;
-/** 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;
-}
-/** 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;
-}): 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;AAYpF,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,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;CAClB;AAED,0EAA0E;AAC1E,wBAAgB,qBAAqB,CAAC,SAAS,EAAE,OAAO,GAAG,iBAAiB,GAAG,IAAI,CASlF;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,CAAA;CAAE,GACpE,OAAO,CAAC,IAAI,CAAC,CAYf;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,CA+BvB;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAI/D"}

package/dist/external-hold.js

@@ -1,149 +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 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;
-/** 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 } = eh;
-    if (typeof condition !== 'string' || typeof clearsWhen !== 'string' || typeof declaredAt !== 'string') {
-        return null;
-    }
-    return { 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 gateState = {
-        blocking: [],
-        warnings: [],
-        evaluatedAt: params.declaredAt,
-        externalHold: {
-            condition: params.condition,
-            clearsWhen: params.clearsWhen,
-            declaredAt: params.declaredAt,
-        },
-    };
-    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 };
-    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 };
-    }
-    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 };
-}
-/** 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)
-        return `external hold: ${hold.hold.condition} (clears when: ${hold.hold.clearsWhen})`;
-    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":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAExC,MAAM,GAAG,GAAG,YAAY,CAAC,EAAE,MAAM,EAAE,eAAe,EAAE,CAAC,CAAC;AAEtD,8EAA8E;AAC9E,0EAA0E;AAC1E,6EAA6E;AAC7E,+EAA+E;AAC/E,+DAA+D;AAC/D,MAAM,aAAa,GAAG,QAAQ,CAAC;AAiB/B;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAA+B,GAAG,EAAE,CAAC,KAAK,CAAC;AAYlF,0EAA0E;AAC1E,MAAM,UAAU,qBAAqB,CAAC,SAAkB;IACtD,IAAI,SAAS,KAAK,IAAI,IAAI,OAAO,SAAS,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACrE,MAAM,EAAE,GAAI,SAAwC,CAAC,YAAY,CAAC;IAClE,IAAI,EAAE,KAAK,IAAI,IAAI,OAAO,EAAE,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACvD,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,GAAG,EAA6B,CAAC;IAC5E,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACtG,OAAO,IAAI,CAAC;IACd,CAAC;IACD,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;AAC/C,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAAsB,EACtB,UAAkB,EAClB,MAAqE;IAErE,MAAM,SAAS,GAAsB;QACnC,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,WAAW,EAAE,MAAM,CAAC,UAAU;QAC9B,YAAY,EAAE;YACZ,SAAS,EAAE,MAAM,CAAC,SAAS;YAC3B,UAAU,EAAE,MAAM,CAAC,UAAU;YAC7B,UAAU,EAAE,MAAM,CAAC,UAAU;SAC9B;KACF,CAAC;IACF,MAAM,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AACzG,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,IAAsB,EACtB,UAAkB,EAClB,SAAiB;IAEjB,MAAM,SAAS,GAAsB;QACnC,QAAQ,EAAE,EAAE;QACZ,QAAQ,EAAE,EAAE;QACZ,WAAW,EAAE,SAAS;KACvB,CAAC;IACF,MAAM,IAAI,CAAC,oBAAoB,CAAC,UAAU,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,CAAC,CAAC;AACzG,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,IAAsB,EACtB,UAAkB,EAClB,SAAkB,EAClB,iBAA6C,EAC7C,QAAsB,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;IAEpD,MAAM,IAAI,GAAG,qBAAqB,CAAC,SAAS,CAAC,CAAC;IAC9C,IAAI,IAAI,KAAK,IAAI;QAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAEtE,IAAI,YAAY,GAAG,KAAK,CAAC;IACzB,IAAI,CAAC;QACH,YAAY,GAAG,MAAM,iBAAiB,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,GAAG,CAAC,IAAI,CACN,+DAA+D,UAAU,MAAM;YAC/E,uCAAwC,GAAa,CAAC,OAAO,EAAE,CAChE,CAAC;QACF,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;IAC9C,CAAC;IAED,IAAI,YAAY,EAAE,CAAC;QACjB,IAAI,CAAC;YACH,MAAM,iBAAiB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;QACrD,CAAC;QAAC,OAAO,GAAG,EAAE,CAAC;YACb,yEAAyE;YACzE,uEAAuE;YACvE,4DAA4D;YAC5D,GAAG,CAAC,IAAI,CACN,2DAA2D,UAAU,GAAG;gBACxE,0CAA2C,GAAa,CAAC,OAAO,EAAE,CACnE,CAAC;QACJ,CAAC;QACD,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC9C,CAAC;IAED,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;AAC9C,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,oBAAoB,CAAC,IAAkB;IACrD,IAAI,IAAI,CAAC,OAAO;QAAE,OAAO,qDAAqD,CAAC;IAC/E,IAAI,IAAI,CAAC,IAAI;QAAE,OAAO,kBAAkB,IAAI,CAAC,IAAI,CAAC,SAAS,kBAAkB,IAAI,CAAC,IAAI,CAAC,UAAU,GAAG,CAAC;IACrG,OAAO,UAAU,CAAC;AACpB,CAAC"}

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"}

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

@@ -1,62 +0,0 @@
-/**
- * Focus branch identity: derivation, pinning, and worktree-dir mapping.
- *
- * A focus's branch name was historically re-derived from the LIVE agent-role
- * registry at every spawn (generateFocusBranchName below). A mid-flight role
- * rename/reassignment therefore changed which branch the daemon's git plumbing
- * addressed -- pointing spawns, review-coverage rev-parse, and worktree
- * resolution at a branch that never existed (the 2026-08-06 Tinker Tailor
- * incident).
- *
- * The identity is now PINNED: persisted (product_focuses.branch_name) the first
- * time the focus branch is created, and read back thereafter. resolveFocusBranchName
- * is the single decision point -- read the pinned value if present, otherwise
- * derive it (and signal the caller to persist it, write-once).
- *
- * Extracted into its own light module (only a type import + sanitizeGitSegment,
- * NO @telora/daemon-core / spawn graph) so every consumer -- spawn, lifecycle,
- * provisioning, worktree resolution -- and the unit tests can use it without
- * pulling in focus-executor.ts. focus-executor re-exports generateFocusBranchName
- * for back-compat with existing importers.
- */
-import type { AgentRole } from './types.js';
-/**
- * Derive the focus branch name from the role, focus name, and focus id:
- * `agent/<role>/<focus-name>-<short-id>`. This is the FIRST-CREATION deriver
- * only -- once a focus has a pinned branch_name, consumers read that instead
- * (see resolveFocusBranchName). The short-id is the immutable focus-id prefix.
- */
-export declare function generateFocusBranchName(role: AgentRole, focusName: string, focusId: string): string;
-/**
- * Map a focus branch name to its worktree directory name. The worktree path is
- * `join(worktreeDir, branchName.replace('/', '-'))` (worktree.ts), so a pinned
- * branch name pins the worktree directory too -- one stored value covers both.
- */
-export declare function focusWorktreeDirName(branchName: string): string;
-/** Result of resolving a focus's branch identity. */
-export interface ResolvedFocusBranch {
-    /** The branch name to use for all git plumbing this spawn. */
-    branchName: string;
-    /**
-     * True when `branchName` came from the persisted pin. False when it was
-     * freshly derived because no pin existed yet -- the caller should persist it
-     * (setFocusBranchName) so the identity is captured on first creation.
-     */
-    pinned: boolean;
-}
-/**
- * Resolve a focus's branch identity, preferring the pinned value.
- *
- * If `pinnedBranch` is a non-empty string, it is returned verbatim (immune to
- * role renames -- this is the whole point). Otherwise the name is derived from
- * the current role and `pinned:false` signals the caller to persist it. A
- * blank/whitespace pinned value is treated as absent (defensive against an
- * empty column write).
- */
-export declare function resolveFocusBranchName(args: {
-    pinnedBranch: string | null | undefined;
-    role: AgentRole;
-    focusName: string;
-    focusId: string;
-}): ResolvedFocusBranch;
-//# sourceMappingURL=focus-branch-identity.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"focus-branch-identity.d.ts","sourceRoot":"","sources":["../src/focus-branch-identity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAG5C;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAKnG;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAE/D;AAED,qDAAqD;AACrD,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,UAAU,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,MAAM,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC;IACxC,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB,GAAG,mBAAmB,CAMtB"}

package/dist/focus-branch-identity.js

@@ -1,59 +0,0 @@
-/**
- * Focus branch identity: derivation, pinning, and worktree-dir mapping.
- *
- * A focus's branch name was historically re-derived from the LIVE agent-role
- * registry at every spawn (generateFocusBranchName below). A mid-flight role
- * rename/reassignment therefore changed which branch the daemon's git plumbing
- * addressed -- pointing spawns, review-coverage rev-parse, and worktree
- * resolution at a branch that never existed (the 2026-08-06 Tinker Tailor
- * incident).
- *
- * The identity is now PINNED: persisted (product_focuses.branch_name) the first
- * time the focus branch is created, and read back thereafter. resolveFocusBranchName
- * is the single decision point -- read the pinned value if present, otherwise
- * derive it (and signal the caller to persist it, write-once).
- *
- * Extracted into its own light module (only a type import + sanitizeGitSegment,
- * NO @telora/daemon-core / spawn graph) so every consumer -- spawn, lifecycle,
- * provisioning, worktree resolution -- and the unit tests can use it without
- * pulling in focus-executor.ts. focus-executor re-exports generateFocusBranchName
- * for back-compat with existing importers.
- */
-import { sanitizeGitSegment } from './git/utils.js';
-/**
- * Derive the focus branch name from the role, focus name, and focus id:
- * `agent/<role>/<focus-name>-<short-id>`. This is the FIRST-CREATION deriver
- * only -- once a focus has a pinned branch_name, consumers read that instead
- * (see resolveFocusBranchName). The short-id is the immutable focus-id prefix.
- */
-export function generateFocusBranchName(role, focusName, focusId) {
-    const sanitizedRoleName = sanitizeGitSegment(role.name);
-    const shortId = focusId.slice(0, 8);
-    const sanitizedFocusName = sanitizeGitSegment(focusName);
-    return `agent/${sanitizedRoleName}/${sanitizedFocusName}-${shortId}`;
-}
-/**
- * Map a focus branch name to its worktree directory name. The worktree path is
- * `join(worktreeDir, branchName.replace('/', '-'))` (worktree.ts), so a pinned
- * branch name pins the worktree directory too -- one stored value covers both.
- */
-export function focusWorktreeDirName(branchName) {
-    return branchName.replace(/\//g, '-');
-}
-/**
- * Resolve a focus's branch identity, preferring the pinned value.
- *
- * If `pinnedBranch` is a non-empty string, it is returned verbatim (immune to
- * role renames -- this is the whole point). Otherwise the name is derived from
- * the current role and `pinned:false` signals the caller to persist it. A
- * blank/whitespace pinned value is treated as absent (defensive against an
- * empty column write).
- */
-export function resolveFocusBranchName(args) {
-    const { pinnedBranch, role, focusName, focusId } = args;
-    if (typeof pinnedBranch === 'string' && pinnedBranch.trim().length > 0) {
-        return { branchName: pinnedBranch, pinned: true };
-    }
-    return { branchName: generateFocusBranchName(role, focusName, focusId), pinned: false };
-}
-//# sourceMappingURL=focus-branch-identity.js.map