@telora/daemon 0.20.57 → 0.20.78

package/dist/queries/holds.d.ts

@@ -0,0 +1,177 @@
+/**
+ * Delivery hold-lookup queries.
+ *
+ * "Is something holding this delivery out of done, and what?" -- the escalation
+ * side of that question. Two disposition-keyed families live here:
+ *
+ *   - OPERATOR holds (needs_operator / external_wait): a human or an external
+ *     party must act before the declared work counts as real. Fails CLOSED at
+ *     its call site.
+ *   - DIRECTED holds (needs_intent / needs_clarification): an unanswered
+ *     question the daemon reads back to the asking agent. Fails OPEN at its
+ *     call site.
+ *
+ * Plus SELF_REPORT_STALL_HOLD_KINDS: the kinds that are machine-filed alarms
+ * ABOUT a delivery's own cycling, excluded from the operator predicate so an
+ * alarm cannot constitute the condition it reports.
+ *
+ * Extracted from queries/issues.ts to keep that file under the daemon
+ * file-size limit -- the self-referential-alarm fix pushed it to 844. Bodies
+ * verbatim; issues.ts re-exports this surface so existing importers are
+ * unaffected.
+ *
+ * @module queries/holds
+ */
+/** Escalation statuses that count as OPEN for every hold lookup here. */
+export declare const OPEN_ESCALATION_STATUSES: ReadonlySet<string>;
+/**
+ * The escalation dispositions that mean "a human operator or an external party
+ * must act before this delivery's declared work can be considered real":
+ * needs_operator (operator/infra/security action) and external_wait (blocked on
+ * a third party). Distinct from needs_intent / needs_clarification (a steering
+ * question, not a blocked-on-reality signal) and agent_resolvable (no human at
+ * all). Keyed on the DISPOSITION axis so ANY escalation kind carrying one of
+ * these holds its delivery -- the gate must not enumerate kinds.
+ *
+ * Declared as daemon-local string literals (not imported from @telora/daemon-core's
+ * ESCALATION_DISPOSITIONS) on purpose, mirroring MERGE_CONFLICT_ESCALATION_KIND
+ * below: a bare `@telora/*` VALUE import in a query module pulled into a mocked
+ * node:test fails to resolve under the module-mock loader (the daemon-local-copy
+ * rule). The canonical enum lives in packages/daemon-core/src/disposition.ts and
+ * the DB CHECK on agent_escalations.disposition is the real constraint; these
+ * strings must stay in sync with it.
+ */
+export declare const OPERATOR_HOLD_DISPOSITIONS: readonly string[];
+/**
+ * escalation_kind discriminators that are SELF-REFERENTIAL stall alarms: a
+ * machine-filed escalation ABOUT a delivery's own cycling, which must NOT be
+ * allowed to satisfy the operator-hold predicate that holds that same delivery.
+ *
+ * The fixpoint this removes (observed 2026-07-26, delivery 50131436, escalations
+ * 96262dfa -> 43c4dade): the verify_failed cap detector files
+ * verify_gate_unclearable (disposition needs_operator, anchored to the delivery)
+ * when iteration_count exceeds the cap. findOpenOperatorHoldForDelivery matched
+ * on disposition ONLY, so that alarm satisfied the very hold predicate it was
+ * raised about; the delivery was held out of `done`; `done` is the only
+ * non-cancelled terminal that makes exceedsVerifyFailedCap stop firing; and
+ * iteration_count is monotonic -- so the alarm blocked the only exit that would
+ * silence it, and resolving one let the detector file the next on the following
+ * tick.
+ *
+ * ENUMERATION -- every machine-filed, delivery-anchored needs_operator kind, and
+ * whether it is a genuine hold or a self-referential stall alarm. The exclusion
+ * criterion is narrow and precise: exclude a kind IFF (a) it re-arms while the
+ * delivery is non-terminal AND (b) its ONLY silencing is the delivery reaching
+ * the terminal state the hold blocks. A kind that describes external reality an
+ * operator must change, or that is filed once and silenced by operator
+ * resolution, is a GENUINE hold and stays.
+ *
+ *   verify_gate_unclearable (stall-detectors.ts) -- SELF-REFERENTIAL. Trigger
+ *     (iteration_count) is monotonic and re-arms every tick while non-terminal;
+ *     silenced only by done/cancelled, which the hold blocks. EXCLUDE.
+ *   verify_evidence_unavailable (verification-feedback.ts) -- self-REPORT of an
+ *     instrument fault, but filed ONCE per delivery (idempotent, never re-armed)
+ *     and silenced by operator resolution, not by `done`. It also already holds
+ *     the delivery via its OWN gate_state.blocking guard, so it does not lean on
+ *     this predicate. Not a fixpoint -> KEEP as a hold.
+ *   schema_drift_blocked (listener-auto-advance.ts) -- operator must apply a
+ *     migration (external reality). KEEP.
+ *   advance_blocked (delivery-advance-block.ts) -- dirty worktree / lockfile
+ *     state an operator or agent must resolve. KEEP.
+ *   cd_push_failed (ci-escalation.ts) / ci_run_red (ci-sensor-loop.ts) --
+ *     external CI/CD state. KEEP.
+ *   propagation_stale (staleness-sensor.ts) -- external propagation state. KEEP.
+ *
+ * (Focus-anchored kinds -- merge_conflict, merge_refused_dirty,
+ * review_window_stalled, stuck_focus_branch -- are never matched by
+ * findOpenOperatorHoldForDelivery, which keys on deliveryId, so they need no
+ * exclusion here.)
+ *
+ * Daemon-local literal for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
+ * a bare `@telora/*` value import mis-resolves under the node:test module-mock
+ * loader, and importing stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND would also
+ * form an import cycle (stall-detectors imports from this module). Keep in sync
+ * with stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND and the DB CHECK.
+ */
+export declare const SELF_REPORT_STALL_HOLD_KINDS: readonly string[];
+/** The open operator-hold escalation a delivery is blocked on (for gate_state). */
+export interface OperatorHoldEscalation {
+    id: string;
+    escalationKind: string | null;
+    disposition: string;
+}
+/**
+ * Returns the OPEN (pending|in_review) operator-hold escalation anchored to the
+ * given delivery, or null when none is open.
+ *
+ * DISPOSITION-keyed sibling of hasOpenEscalationForDelivery (which is KIND-keyed):
+ * it matches ANY escalation_kind whose disposition is in OPERATOR_HOLD_DISPOSITIONS
+ * (needs_operator / external_wait). This is the vocabulary the verify->done gate
+ * previously lacked -- an operator blocked ON a delivery (e.g. "the host restore
+ * was NOT executed") could not hold that delivery out of done, so a clean review
+ * auto-approved it. Returning the matching row (id + kind + disposition), not a
+ * bare boolean, lets the gate write the block into the delivery's gate_state.
+ *
+ * Matches on the typed delivery_id + disposition COLUMNS in preference to the
+ * metadata bag, with a metadata fallback (metadata.deliveryId / metadata.disposition)
+ * for rows already open at deploy time. The status is re-checked client-side as
+ * defense-in-depth against a deploy-lagged edge fn returning resolved rows.
+ *
+ * escalation_list has NO server-side delivery_id filter, so the delivery match is
+ * applied client-side over the org's open rows. Pass `focusId` to narrow the page
+ * server-side (the same busy-org paging concern hasOpenWorktreeDirtyEscalation
+ * addresses); omit it and the lookup reads the newest 500 open org rows.
+ *
+ * FAIL-CLOSED is the CALLER's responsibility. This function reports what it finds
+ * and THROWS on a hard API error. The verify->done gate that consumes it exists
+ * precisely to fail closed, so it must treat a lookup error as "held" -- the
+ * opposite of the other escalation lookups (dedup/auto-close), which fail OPEN
+ * because a spurious park is worse than a missed dedup. Here a missed hold lets an
+ * operator-blocked delivery reach done, which is the failure this gate prevents.
+ */
+export declare function findOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<OperatorHoldEscalation | null>;
+/**
+ * Boolean convenience over findOpenOperatorHoldForDelivery for call sites that
+ * only need to know whether the hold exists (not which escalation it is).
+ */
+export declare function hasOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<boolean>;
+/**
+ * The escalation dispositions that mean "a human must STEER before this team's
+ * work can proceed": needs_intent (scope/direction/priority) and
+ * needs_clarification (ambiguity to resolve). These are exactly the two the
+ * escalation tool documents as answerable via the `answer` field -- a DIRECTED
+ * question the daemon reads back to the asking agent, distinct from the
+ * operator-hold dispositions (needs_operator / external_wait, a blocked-on-reality
+ * signal) and agent_resolvable (no human at all).
+ *
+ * Daemon-local literals for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
+ * a bare `@telora/*` value import in a query module pulled into a mocked
+ * node:test fails to resolve under the module-mock loader. The canonical enum is
+ * packages/daemon-core/src/disposition.ts and the DB CHECK on
+ * agent_escalations.disposition is the real constraint; these strings must stay
+ * in sync with it.
+ */
+export declare const DIRECTED_HOLD_DISPOSITIONS: readonly string[];
+/**
+ * Returns the OPEN (pending|in_review) DIRECTED-hold escalation anchored to the
+ * given delivery, or null when none is open. Disposition-keyed sibling of
+ * findOpenOperatorHoldForDelivery, keyed on DIRECTED_HOLD_DISPOSITIONS
+ * (needs_intent / needs_clarification) instead of the operator-hold set.
+ *
+ * This is the vocabulary the completion-event no-progress guard previously
+ * lacked: a team parked on its own unanswered directed question could not be
+ * told apart from a team that has stalled, so the scope-coverage guard counted
+ * the wait as no-progress, re-engaged the team (real model spend), and
+ * eventually filed a team_failure ON TOP of the question.
+ *
+ * FAIL DIRECTION IS THE OPPOSITE of findOpenOperatorHoldForDelivery. The
+ * operator-hold gate's CALLER fails CLOSED (a lookup error => held) because a
+ * missed hold lets an operator-blocked delivery reach done. HERE the consuming
+ * guard must fail OPEN: a lookup error must NOT suppress a genuine stall
+ * escalation, so the caller treats an error as "not blocked". This function
+ * still reports what it finds and THROWS on a hard API error; the fail-open
+ * decision lives at the call site (completion/event-phases.computeCompletionFacts),
+ * which catches and defaults to not-blocked.
+ */
+export declare function findOpenDirectedHoldForDelivery(deliveryId: string, focusId?: string): Promise<OperatorHoldEscalation | null>;
+//# sourceMappingURL=holds.d.ts.map

package/dist/queries/holds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"holds.d.ts","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH,yEAAyE;AACzE,eAAO,MAAM,wBAAwB,EAAE,WAAW,CAAC,MAAM,CAAqC,CAAC;AAE/F;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAGvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EAEzD,CAAC;AAEF,mFAAmF;AACnF,MAAM,WAAW,sBAAsB;IACrC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CASxC;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,OAAO,CAAC,CAElB;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAGvD,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,+BAA+B,CACnD,UAAU,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAExC"}

package/dist/queries/holds.js

@@ -0,0 +1,232 @@
+/**
+ * Delivery hold-lookup queries.
+ *
+ * "Is something holding this delivery out of done, and what?" -- the escalation
+ * side of that question. Two disposition-keyed families live here:
+ *
+ *   - OPERATOR holds (needs_operator / external_wait): a human or an external
+ *     party must act before the declared work counts as real. Fails CLOSED at
+ *     its call site.
+ *   - DIRECTED holds (needs_intent / needs_clarification): an unanswered
+ *     question the daemon reads back to the asking agent. Fails OPEN at its
+ *     call site.
+ *
+ * Plus SELF_REPORT_STALL_HOLD_KINDS: the kinds that are machine-filed alarms
+ * ABOUT a delivery's own cycling, excluded from the operator predicate so an
+ * alarm cannot constitute the condition it reports.
+ *
+ * Extracted from queries/issues.ts to keep that file under the daemon
+ * file-size limit -- the self-referential-alarm fix pushed it to 844. Bodies
+ * verbatim; issues.ts re-exports this surface so existing importers are
+ * unaffected.
+ *
+ * @module queries/holds
+ */
+import { callApi } from './shared.js';
+/** Escalation statuses that count as OPEN for every hold lookup here. */
+export const OPEN_ESCALATION_STATUSES = new Set(['pending', 'in_review']);
+/**
+ * The escalation dispositions that mean "a human operator or an external party
+ * must act before this delivery's declared work can be considered real":
+ * needs_operator (operator/infra/security action) and external_wait (blocked on
+ * a third party). Distinct from needs_intent / needs_clarification (a steering
+ * question, not a blocked-on-reality signal) and agent_resolvable (no human at
+ * all). Keyed on the DISPOSITION axis so ANY escalation kind carrying one of
+ * these holds its delivery -- the gate must not enumerate kinds.
+ *
+ * Declared as daemon-local string literals (not imported from @telora/daemon-core's
+ * ESCALATION_DISPOSITIONS) on purpose, mirroring MERGE_CONFLICT_ESCALATION_KIND
+ * below: a bare `@telora/*` VALUE import in a query module pulled into a mocked
+ * node:test fails to resolve under the module-mock loader (the daemon-local-copy
+ * rule). The canonical enum lives in packages/daemon-core/src/disposition.ts and
+ * the DB CHECK on agent_escalations.disposition is the real constraint; these
+ * strings must stay in sync with it.
+ */
+export const OPERATOR_HOLD_DISPOSITIONS = [
+    'needs_operator',
+    'external_wait',
+];
+/**
+ * escalation_kind discriminators that are SELF-REFERENTIAL stall alarms: a
+ * machine-filed escalation ABOUT a delivery's own cycling, which must NOT be
+ * allowed to satisfy the operator-hold predicate that holds that same delivery.
+ *
+ * The fixpoint this removes (observed 2026-07-26, delivery 50131436, escalations
+ * 96262dfa -> 43c4dade): the verify_failed cap detector files
+ * verify_gate_unclearable (disposition needs_operator, anchored to the delivery)
+ * when iteration_count exceeds the cap. findOpenOperatorHoldForDelivery matched
+ * on disposition ONLY, so that alarm satisfied the very hold predicate it was
+ * raised about; the delivery was held out of `done`; `done` is the only
+ * non-cancelled terminal that makes exceedsVerifyFailedCap stop firing; and
+ * iteration_count is monotonic -- so the alarm blocked the only exit that would
+ * silence it, and resolving one let the detector file the next on the following
+ * tick.
+ *
+ * ENUMERATION -- every machine-filed, delivery-anchored needs_operator kind, and
+ * whether it is a genuine hold or a self-referential stall alarm. The exclusion
+ * criterion is narrow and precise: exclude a kind IFF (a) it re-arms while the
+ * delivery is non-terminal AND (b) its ONLY silencing is the delivery reaching
+ * the terminal state the hold blocks. A kind that describes external reality an
+ * operator must change, or that is filed once and silenced by operator
+ * resolution, is a GENUINE hold and stays.
+ *
+ *   verify_gate_unclearable (stall-detectors.ts) -- SELF-REFERENTIAL. Trigger
+ *     (iteration_count) is monotonic and re-arms every tick while non-terminal;
+ *     silenced only by done/cancelled, which the hold blocks. EXCLUDE.
+ *   verify_evidence_unavailable (verification-feedback.ts) -- self-REPORT of an
+ *     instrument fault, but filed ONCE per delivery (idempotent, never re-armed)
+ *     and silenced by operator resolution, not by `done`. It also already holds
+ *     the delivery via its OWN gate_state.blocking guard, so it does not lean on
+ *     this predicate. Not a fixpoint -> KEEP as a hold.
+ *   schema_drift_blocked (listener-auto-advance.ts) -- operator must apply a
+ *     migration (external reality). KEEP.
+ *   advance_blocked (delivery-advance-block.ts) -- dirty worktree / lockfile
+ *     state an operator or agent must resolve. KEEP.
+ *   cd_push_failed (ci-escalation.ts) / ci_run_red (ci-sensor-loop.ts) --
+ *     external CI/CD state. KEEP.
+ *   propagation_stale (staleness-sensor.ts) -- external propagation state. KEEP.
+ *
+ * (Focus-anchored kinds -- merge_conflict, merge_refused_dirty,
+ * review_window_stalled, stuck_focus_branch -- are never matched by
+ * findOpenOperatorHoldForDelivery, which keys on deliveryId, so they need no
+ * exclusion here.)
+ *
+ * Daemon-local literal for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
+ * a bare `@telora/*` value import mis-resolves under the node:test module-mock
+ * loader, and importing stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND would also
+ * form an import cycle (stall-detectors imports from this module). Keep in sync
+ * with stall-detectors.VERIFY_GATE_UNCLEARABLE_KIND and the DB CHECK.
+ */
+export const SELF_REPORT_STALL_HOLD_KINDS = [
+    'verify_gate_unclearable',
+];
+/**
+ * Returns the OPEN (pending|in_review) operator-hold escalation anchored to the
+ * given delivery, or null when none is open.
+ *
+ * DISPOSITION-keyed sibling of hasOpenEscalationForDelivery (which is KIND-keyed):
+ * it matches ANY escalation_kind whose disposition is in OPERATOR_HOLD_DISPOSITIONS
+ * (needs_operator / external_wait). This is the vocabulary the verify->done gate
+ * previously lacked -- an operator blocked ON a delivery (e.g. "the host restore
+ * was NOT executed") could not hold that delivery out of done, so a clean review
+ * auto-approved it. Returning the matching row (id + kind + disposition), not a
+ * bare boolean, lets the gate write the block into the delivery's gate_state.
+ *
+ * Matches on the typed delivery_id + disposition COLUMNS in preference to the
+ * metadata bag, with a metadata fallback (metadata.deliveryId / metadata.disposition)
+ * for rows already open at deploy time. The status is re-checked client-side as
+ * defense-in-depth against a deploy-lagged edge fn returning resolved rows.
+ *
+ * escalation_list has NO server-side delivery_id filter, so the delivery match is
+ * applied client-side over the org's open rows. Pass `focusId` to narrow the page
+ * server-side (the same busy-org paging concern hasOpenWorktreeDirtyEscalation
+ * addresses); omit it and the lookup reads the newest 500 open org rows.
+ *
+ * FAIL-CLOSED is the CALLER's responsibility. This function reports what it finds
+ * and THROWS on a hard API error. The verify->done gate that consumes it exists
+ * precisely to fail closed, so it must treat a lookup error as "held" -- the
+ * opposite of the other escalation lookups (dedup/auto-close), which fail OPEN
+ * because a spurious park is worse than a missed dedup. Here a missed hold lets an
+ * operator-blocked delivery reach done, which is the failure this gate prevents.
+ */
+export async function findOpenOperatorHoldForDelivery(deliveryId, focusId) {
+    return findOpenHoldForDelivery(deliveryId, OPERATOR_HOLD_DISPOSITIONS, focusId, 
+    // A machine-filed alarm ABOUT this delivery's own cycling must not satisfy
+    // the predicate that holds it -- see SELF_REPORT_STALL_HOLD_KINDS.
+    new Set(SELF_REPORT_STALL_HOLD_KINDS));
+}
+/**
+ * Boolean convenience over findOpenOperatorHoldForDelivery for call sites that
+ * only need to know whether the hold exists (not which escalation it is).
+ */
+export async function hasOpenOperatorHoldForDelivery(deliveryId, focusId) {
+    return (await findOpenOperatorHoldForDelivery(deliveryId, focusId)) !== null;
+}
+/**
+ * The escalation dispositions that mean "a human must STEER before this team's
+ * work can proceed": needs_intent (scope/direction/priority) and
+ * needs_clarification (ambiguity to resolve). These are exactly the two the
+ * escalation tool documents as answerable via the `answer` field -- a DIRECTED
+ * question the daemon reads back to the asking agent, distinct from the
+ * operator-hold dispositions (needs_operator / external_wait, a blocked-on-reality
+ * signal) and agent_resolvable (no human at all).
+ *
+ * Daemon-local literals for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
+ * a bare `@telora/*` value import in a query module pulled into a mocked
+ * node:test fails to resolve under the module-mock loader. The canonical enum is
+ * packages/daemon-core/src/disposition.ts and the DB CHECK on
+ * agent_escalations.disposition is the real constraint; these strings must stay
+ * in sync with it.
+ */
+export const DIRECTED_HOLD_DISPOSITIONS = [
+    'needs_intent',
+    'needs_clarification',
+];
+/**
+ * Returns the OPEN (pending|in_review) DIRECTED-hold escalation anchored to the
+ * given delivery, or null when none is open. Disposition-keyed sibling of
+ * findOpenOperatorHoldForDelivery, keyed on DIRECTED_HOLD_DISPOSITIONS
+ * (needs_intent / needs_clarification) instead of the operator-hold set.
+ *
+ * This is the vocabulary the completion-event no-progress guard previously
+ * lacked: a team parked on its own unanswered directed question could not be
+ * told apart from a team that has stalled, so the scope-coverage guard counted
+ * the wait as no-progress, re-engaged the team (real model spend), and
+ * eventually filed a team_failure ON TOP of the question.
+ *
+ * FAIL DIRECTION IS THE OPPOSITE of findOpenOperatorHoldForDelivery. The
+ * operator-hold gate's CALLER fails CLOSED (a lookup error => held) because a
+ * missed hold lets an operator-blocked delivery reach done. HERE the consuming
+ * guard must fail OPEN: a lookup error must NOT suppress a genuine stall
+ * escalation, so the caller treats an error as "not blocked". This function
+ * still reports what it finds and THROWS on a hard API error; the fail-open
+ * decision lives at the call site (completion/event-phases.computeCompletionFacts),
+ * which catches and defaults to not-blocked.
+ */
+export async function findOpenDirectedHoldForDelivery(deliveryId, focusId) {
+    return findOpenHoldForDelivery(deliveryId, DIRECTED_HOLD_DISPOSITIONS, focusId);
+}
+/**
+ * Shared body for the disposition-keyed open-hold lookups
+ * (findOpenOperatorHoldForDelivery / findOpenDirectedHoldForDelivery). Reads the
+ * newest 500 open (pending|in_review) escalations -- narrowed server-side by
+ * focusId when supplied, the same busy-org paging concern the sibling lookups
+ * address -- and returns the first whose delivery matches (typed delivery_id
+ * COLUMN preferred, metadata.deliveryId fallback for rows open at deploy time)
+ * AND whose disposition (typed column preferred, metadata fallback) is in the
+ * given set. Status is re-checked client-side as defense-in-depth against a
+ * deploy-lagged edge fn returning resolved rows. THROWS on a hard API error;
+ * fail-open/closed is the CALLER's choice.
+ *
+ * `excludeKinds` (optional) drops any otherwise-matching escalation whose
+ * escalation_kind is in the set BEFORE it is returned -- used by the operator-hold
+ * lookup to skip self-referential stall alarms (SELF_REPORT_STALL_HOLD_KINDS) so an
+ * alarm about a delivery's own cycling cannot hold that delivery. The kind is read
+ * from the typed column with a metadata.kind fallback (parity with the disposition
+ * fallback), so an excluded kind is dropped regardless of column promotion.
+ */
+async function findOpenHoldForDelivery(deliveryId, dispositions, focusId, excludeKinds) {
+    const holdSet = new Set(dispositions);
+    const fields = { statuses: ['pending', 'in_review'] };
+    if (focusId)
+        fields.focusId = focusId;
+    const result = await callApi('escalation_list', { fields, limit: 500 });
+    for (const e of result.escalations ?? []) {
+        if (e.status && !OPEN_ESCALATION_STATUSES.has(e.status))
+            continue;
+        const meta = e.metadata ?? null;
+        const disposition = (typeof e.disposition === 'string' ? e.disposition : null) ??
+            (typeof meta?.disposition === 'string' ? meta.disposition : null);
+        const matchedDelivery = e.deliveryId === deliveryId || meta?.deliveryId === deliveryId;
+        if (matchedDelivery && disposition !== null && holdSet.has(disposition)) {
+            const kind = (typeof e.escalationKind === 'string' ? e.escalationKind : null) ??
+                (typeof meta?.kind === 'string' ? meta.kind : null);
+            // A self-referential stall alarm about this delivery must not hold it.
+            if (excludeKinds && kind !== null && excludeKinds.has(kind))
+                continue;
+            return { id: e.id, escalationKind: e.escalationKind ?? null, disposition };
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=holds.js.map

package/dist/queries/holds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"holds.js","sourceRoot":"","sources":["../../src/queries/holds.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,aAAa,CAAC;AAEtC,yEAAyE;AACzE,MAAM,CAAC,MAAM,wBAAwB,GAAwB,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC,CAAC;AAE/F;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAsB;IAC3D,gBAAgB;IAChB,eAAe;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAsB;IAC7D,yBAAyB;CAC1B,CAAC;AASF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,UAAkB,EAClB,OAAgB;IAEhB,OAAO,uBAAuB,CAC5B,UAAU,EACV,0BAA0B,EAC1B,OAAO;IACP,2EAA2E;IAC3E,mEAAmE;IACnE,IAAI,GAAG,CAAC,4BAA4B,CAAC,CACtC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,8BAA8B,CAClD,UAAkB,EAClB,OAAgB;IAEhB,OAAO,CAAC,MAAM,+BAA+B,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC,KAAK,IAAI,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAsB;IAC3D,cAAc;IACd,qBAAqB;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,CAAC,KAAK,UAAU,+BAA+B,CACnD,UAAkB,EAClB,OAAgB;IAEhB,OAAO,uBAAuB,CAAC,UAAU,EAAE,0BAA0B,EAAE,OAAO,CAAC,CAAC;AAClF,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,KAAK,UAAU,uBAAuB,CACpC,UAAkB,EAClB,YAA+B,EAC/B,OAAgB,EAChB,YAAkC;IAElC,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,YAAY,CAAC,CAAC;IACtC,MAAM,MAAM,GAA4B,EAAE,QAAQ,EAAE,CAAC,SAAS,EAAE,WAAW,CAAC,EAAE,CAAC;IAC/E,IAAI,OAAO;QAAE,MAAM,CAAC,OAAO,GAAG,OAAO,CAAC;IACtC,MAAM,MAAM,GAAG,MAAM,OAAO,CASzB,iBAAiB,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;IAE9C,KAAK,MAAM,CAAC,IAAI,MAAM,CAAC,WAAW,IAAI,EAAE,EAAE,CAAC;QACzC,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,wBAAwB,CAAC,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC;YAAE,SAAS;QAClE,MAAM,IAAI,GAAI,CAAC,CAAC,QAA2C,IAAI,IAAI,CAAC;QACpE,MAAM,WAAW,GACf,CAAC,OAAO,CAAC,CAAC,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC;YAC1D,CAAC,OAAO,IAAI,EAAE,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACpE,MAAM,eAAe,GACnB,CAAC,CAAC,UAAU,KAAK,UAAU,IAAI,IAAI,EAAE,UAAU,KAAK,UAAU,CAAC;QACjE,IAAI,eAAe,IAAI,WAAW,KAAK,IAAI,IAAI,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,EAAE,CAAC;YACxE,MAAM,IAAI,GACR,CAAC,OAAO,CAAC,CAAC,cAAc,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC;gBAChE,CAAC,OAAO,IAAI,EAAE,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAE,IAAI,CAAC,IAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;YAClE,uEAAuE;YACvE,IAAI,YAAY,IAAI,IAAI,KAAK,IAAI,IAAI,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC;gBAAE,SAAS;YACtE,OAAO,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,CAAC,cAAc,IAAI,IAAI,EAAE,WAAW,EAAE,CAAC;QAC7E,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/queries/issues.d.ts

@@ -147,104 +147,9 @@ export declare function hasOpenTeamFailureEscalation(focusId: string): Promise<b
  * polls files exactly one open escalation instead of one per tick.
  */
 export declare function hasOpenEscalationForDelivery(deliveryId: string, escalationKind: string): Promise<boolean>;
-/**
- * The escalation dispositions that mean "a human operator or an external party
- * must act before this delivery's declared work can be considered real":
- * needs_operator (operator/infra/security action) and external_wait (blocked on
- * a third party). Distinct from needs_intent / needs_clarification (a steering
- * question, not a blocked-on-reality signal) and agent_resolvable (no human at
- * all). Keyed on the DISPOSITION axis so ANY escalation kind carrying one of
- * these holds its delivery -- the gate must not enumerate kinds.
- *
- * Declared as daemon-local string literals (not imported from @telora/daemon-core's
- * ESCALATION_DISPOSITIONS) on purpose, mirroring MERGE_CONFLICT_ESCALATION_KIND
- * below: a bare `@telora/*` VALUE import in a query module pulled into a mocked
- * node:test fails to resolve under the module-mock loader (the daemon-local-copy
- * rule). The canonical enum lives in packages/daemon-core/src/disposition.ts and
- * the DB CHECK on agent_escalations.disposition is the real constraint; these
- * strings must stay in sync with it.
- */
-export declare const OPERATOR_HOLD_DISPOSITIONS: readonly string[];
-/** The open operator-hold escalation a delivery is blocked on (for gate_state). */
-export interface OperatorHoldEscalation {
-    id: string;
-    escalationKind: string | null;
-    disposition: string;
-}
-/**
- * Returns the OPEN (pending|in_review) operator-hold escalation anchored to the
- * given delivery, or null when none is open.
- *
- * DISPOSITION-keyed sibling of hasOpenEscalationForDelivery (which is KIND-keyed):
- * it matches ANY escalation_kind whose disposition is in OPERATOR_HOLD_DISPOSITIONS
- * (needs_operator / external_wait). This is the vocabulary the verify->done gate
- * previously lacked -- an operator blocked ON a delivery (e.g. "the host restore
- * was NOT executed") could not hold that delivery out of done, so a clean review
- * auto-approved it. Returning the matching row (id + kind + disposition), not a
- * bare boolean, lets the gate write the block into the delivery's gate_state.
- *
- * Matches on the typed delivery_id + disposition COLUMNS in preference to the
- * metadata bag, with a metadata fallback (metadata.deliveryId / metadata.disposition)
- * for rows already open at deploy time. The status is re-checked client-side as
- * defense-in-depth against a deploy-lagged edge fn returning resolved rows.
- *
- * escalation_list has NO server-side delivery_id filter, so the delivery match is
- * applied client-side over the org's open rows. Pass `focusId` to narrow the page
- * server-side (the same busy-org paging concern hasOpenWorktreeDirtyEscalation
- * addresses); omit it and the lookup reads the newest 500 open org rows.
- *
- * FAIL-CLOSED is the CALLER's responsibility. This function reports what it finds
- * and THROWS on a hard API error. The verify->done gate that consumes it exists
- * precisely to fail closed, so it must treat a lookup error as "held" -- the
- * opposite of the other escalation lookups (dedup/auto-close), which fail OPEN
- * because a spurious park is worse than a missed dedup. Here a missed hold lets an
- * operator-blocked delivery reach done, which is the failure this gate prevents.
- */
-export declare function findOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<OperatorHoldEscalation | null>;
-/**
- * Boolean convenience over findOpenOperatorHoldForDelivery for call sites that
- * only need to know whether the hold exists (not which escalation it is).
- */
-export declare function hasOpenOperatorHoldForDelivery(deliveryId: string, focusId?: string): Promise<boolean>;
-/**
- * The escalation dispositions that mean "a human must STEER before this team's
- * work can proceed": needs_intent (scope/direction/priority) and
- * needs_clarification (ambiguity to resolve). These are exactly the two the
- * escalation tool documents as answerable via the `answer` field -- a DIRECTED
- * question the daemon reads back to the asking agent, distinct from the
- * operator-hold dispositions (needs_operator / external_wait, a blocked-on-reality
- * signal) and agent_resolvable (no human at all).
- *
- * Daemon-local literals for the same reason as OPERATOR_HOLD_DISPOSITIONS above:
- * a bare `@telora/*` value import in a query module pulled into a mocked
- * node:test fails to resolve under the module-mock loader. The canonical enum is
- * packages/daemon-core/src/disposition.ts and the DB CHECK on
- * agent_escalations.disposition is the real constraint; these strings must stay
- * in sync with it.
- */
-export declare const DIRECTED_HOLD_DISPOSITIONS: readonly string[];
-/**
- * Returns the OPEN (pending|in_review) DIRECTED-hold escalation anchored to the
- * given delivery, or null when none is open. Disposition-keyed sibling of
- * findOpenOperatorHoldForDelivery, keyed on DIRECTED_HOLD_DISPOSITIONS
- * (needs_intent / needs_clarification) instead of the operator-hold set.
- *
- * This is the vocabulary the completion-event no-progress guard previously
- * lacked: a team parked on its own unanswered directed question could not be
- * told apart from a team that has stalled, so the scope-coverage guard counted
- * the wait as no-progress, re-engaged the team (real model spend), and
- * eventually filed a team_failure ON TOP of the question.
- *
- * FAIL DIRECTION IS THE OPPOSITE of findOpenOperatorHoldForDelivery. The
- * operator-hold gate's CALLER fails CLOSED (a lookup error => held) because a
- * missed hold lets an operator-blocked delivery reach done. HERE the consuming
- * guard must fail OPEN: a lookup error must NOT suppress a genuine stall
- * escalation, so the caller treats an error as "not blocked". This function
- * still reports what it finds and THROWS on a hard API error; the fail-open
- * decision lives at the call site (completion/event-phases.computeCompletionFacts),
- * which catches and defaults to not-blocked.
- */
-export declare function findOpenDirectedHoldForDelivery(deliveryId: string, focusId?: string): Promise<OperatorHoldEscalation | null>;
+import { OPERATOR_HOLD_DISPOSITIONS, SELF_REPORT_STALL_HOLD_KINDS, DIRECTED_HOLD_DISPOSITIONS, findOpenOperatorHoldForDelivery, hasOpenOperatorHoldForDelivery, findOpenDirectedHoldForDelivery, type OperatorHoldEscalation } from './holds.js';
+export { OPERATOR_HOLD_DISPOSITIONS, SELF_REPORT_STALL_HOLD_KINDS, DIRECTED_HOLD_DISPOSITIONS, findOpenOperatorHoldForDelivery, hasOpenOperatorHoldForDelivery, findOpenDirectedHoldForDelivery, };
+export type { OperatorHoldEscalation };
 /**
  * escalation_kind discriminators for the two focus-merge worktree-dirty
  * classes. Declared as daemon-local string constants (not imported from
@@ -348,6 +253,44 @@ export declare function hasOpenFocusEscalation(focusId: string, escalationKind:
  * worktree), and a successful merge clears merge_conflict.
  */
 export declare function resolveOpenWorktreeDirtyEscalations(focusId: string, kinds: readonly string[], resolutionNotes?: string): Promise<number>;
+/** An open agent_resolvable filing the daemon hands to a focus's next spawn. */
+export interface AgentResolvableItem {
+    id: string;
+    escalationKind: string | null;
+    description: string;
+    createdAt: string;
+}
+/** Minimal escalation row shape the agent_resolvable filter reads. */
+export interface AgentResolvableEscalationRow {
+    id: string;
+    status?: string | null;
+    disposition?: string | null;
+    escalationKind?: string | null;
+    description?: string | null;
+    createdAt?: string | null;
+}
+/**
+ * Pure: keep only the OPEN, agent_resolvable rows and shape them into
+ * AgentResolvableItems. The status re-check is defense-in-depth so a
+ * resolved/dismissed row can never ride into a spawn even if the fetch returned
+ * one. Exported for direct unit testing (no callApi mocking needed).
+ */
+export declare function toAgentResolvableItems(rows: readonly AgentResolvableEscalationRow[]): AgentResolvableItem[];
+/**
+ * List the OPEN (pending/in_review) agent_resolvable escalations anchored to a
+ * focus -- the filings a machine (the next spawned team) can resolve without a
+ * human. This is how the daemon CONSUMES agent_resolvable filings: it hands them
+ * to the focus's next execution spawn (ride-into-next-spawn) so the agent
+ * addresses them as part of its work, and on a clean exit they auto-resolve.
+ * agent_resolvable rows are hidden from the operator inbox (the disposition
+ * routes to the machine, not the human); this is the machine-side counterpart read.
+ *
+ * escalation_list does not filter by disposition server-side, so we narrow
+ * server-side by focusId + open statuses (scoping the 500-row page to this focus)
+ * and filter disposition === agent_resolvable client-side. The status re-check is
+ * defense-in-depth so a resolved/dismissed row can never ride into a spawn.
+ */
+export declare function listOpenAgentResolvableForFocus(focusId: string): Promise<AgentResolvableItem[]>;
 /**
  * Returns true when an OPEN (status pending or in_review) PRD machine escalation
  * of the given `discriminator` already exists for the given PRD.
@@ -382,5 +325,4 @@ export declare function markEscalationResolved(escalationId: string, resolutionN
  * Create an issue on a delivery (for create_issue trigger action).
  */
 export declare function createIssue(deliveryId: string, title: string, description: string | null, issueType: string, priority: string | null): Promise<string>;
-export {};
 //# sourceMappingURL=issues.d.ts.map

package/dist/queries/issues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../src/queries/issues.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"issues.d.ts","sourceRoot":"","sources":["../../src/queries/issues.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAIL,mBAAmB,EACpB,MAAM,cAAc,CAAC;AACtB,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAkBvF,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAMxB,KAAK,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpD;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,EAAE,CAAC,CAO/E;AAED;;GAEG;AACH,wBAAsB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAOjF;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAYtF;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,uHAAuH;IACvH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC;;;;;OAKG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;;;;;OAQG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,gBAAgB,CAAC;CAC3B;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC;IAAE,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAuB1C;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,EAAE,EAAE,MAAM,CAAC;IACX,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,sBAAsB,IAAI,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAqB3E;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAuBpF;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,4BAA4B,CAChD,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC,CAsBlB;AAED,OAAO,EAEL,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,EAC/B,KAAK,sBAAsB,EAC5B,MAAM,YAAY,CAAC;AAIpB,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,EAC5B,0BAA0B,EAC1B,+BAA+B,EAC/B,8BAA8B,EAC9B,+BAA+B,GAChC,CAAC;AACF,YAAY,EAAE,sBAAsB,EAAE,CAAC;AAGvC;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,8BAA8B,mBAAmB,CAAC;AAC/D,eAAO,MAAM,mCAAmC,wBAAwB,CAAC;AAEzE;;;;;;;GAOG;AACH,eAAO,MAAM,+BAA+B,EAAE,SAAS,MAAM,EAI5D,CAAC;AA+CF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,MAAM,EACf,KAAK,GAAE,SAAS,MAAM,EAAoC,GACzD,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,gEAAgE;AAChE,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,4BAA4B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAapF;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,sBAAsB,CAC1C,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,OAAO,CAAC,CAalB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,mCAAmC,CACvD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,eAAe,SAAuE,GACrF,OAAO,CAAC,MAAM,CAAC,CAmBjB;AAED,gFAAgF;AAChF,MAAM,WAAW,mBAAmB;IAClC,EAAE,EAAE,MAAM,CAAC;IACX,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,sEAAsE;AACtE,MAAM,WAAW,4BAA4B;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,cAAc,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,4BAA4B,EAAE,GAC5C,mBAAmB,EAAE,CAavB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,+BAA+B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAMrG;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAED;;GAEG;AACH,wBAAsB,sBAAsB,CAC1C,YAAY,EAAE,MAAM,EACpB,eAAe,CAAC,EAAE,MAAM,GACvB,OAAO,CAAC,IAAI,CAAC,CAQf;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAAG,IAAI,EAC1B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,GAAG,IAAI,GACtB,OAAO,CAAC,MAAM,CAAC,CAejB"}