@telora/daemon 0.22.245 → 0.22.289

package/dist/queries/holds.js

@@ -1,333 +0,0 @@
-// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
-// Pinned by: packages/daemon/src/queries/has-open-operator-hold-for-delivery.test.ts,
-//   packages/daemon/src/queries/incident-correlation.test.ts,
-//   packages/daemon/src/queries/no-directed-hold-producer.test.ts
-// PINNED-BY-END
-/**
- * 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.
- *
- * The operator family ALSO matches an open OBSERVATION anchored to the delivery
- * whose metadata.observation proposed_disposition is an operator-hold disposition.
- * The chokepoint in queries/escalations.ts createEscalation sends EVERY daemon
- * filing that names a human-owning disposition to the machine lane as an
- * observation (named act or not), so the observation form is how a daemon-detected
- * hold now arrives. Routing decides WHO resolves a condition; it does not clear
- * the condition. An uncleared condition keeps its delivery out of done whether an
- * agent or a human resolves it. A plain agent_resolvable filing (no observation)
- * still does not hold. A DIRECT needs_operator / external_wait row is one an agent
- * made human-facing through MCP escalate (metadata.human_act), or a legacy row;
- * both still hold. No hold here depends on a disposition only the daemon routed.
- *
- * isMachineStopObservation (below) is the focus-level sibling: a stop-kind
- * observation carrying its detector's proposed act keeps the machine stopped
- * (the respawn guard reads it through queries/escalations.ts).
- *
- * Plus two exclusion families the operator predicate drops, for a direct match
- * and an observation match alike: SELF_REPORT_STALL_HOLD_KINDS
- * (machine-filed alarms ABOUT a delivery's own cycling, so an alarm cannot
- * constitute the condition it reports) and REFUSED_OPERATOR_HOLD_KINDS (kinds that
- * name no human-only act -- refused at their filing surface and routed to bounded
- * re-work; a legacy row must not hold a delivery out of done).
- *
- * 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';
-import { DISPOSITION_AGENT_RESOLVABLE } from './escalation-dispositions.js';
-import { readObservation } from './filing-observation.js';
-import { readSymptoms } from './incident-correlation.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,
- * tested against ONE governing rule ("A hold must name a human act", 2026-07-28):
- * does the kind name a specific act ONLY a human can perform? A kind that names
- * one is a GENUINE hold and stays. A kind that names none must NOT hold a
- * delivery out of done: it is refused at its filing surface and routed into the
- * machine's own bounded re-work path, and any legacy row is EXCLUDED from this
- * predicate. (This rule GOVERNS -- it supersedes the older fixpoint-only test,
- * which read a kind's legitimacy from its re-arm behaviour; the two disagreed on
- * verify_evidence_unavailable and this rule is the one that wins.) The parallel
- * self-referential-alarm exclusion still applies too: an alarm ABOUT a delivery's
- * own cycling cannot constitute the hold it reports.
- *
- *   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. It IS the sole
- *     surviving human residue of the bounded re-work cap, and it names a human
- *     act (an operator must decide the unclearable delivery's fate), so it holds
- *     -- but it must not hold ITSELF, hence the exclusion below. EXCLUDE from the
- *     predicate for its own delivery (SELF_REPORT_STALL_HOLD_KINDS).
- *   verify_evidence_unavailable (verification-feedback.ts) -- NAMES NO HUMAN ACT.
- *     Its ask was "fix the diff range / confirm the merge / clear the delivery" --
- *     the gate reporting its own BLINDNESS, not work an operator must do. As of
- *     "A hold must name a human act" it is refused at the filing surface (nothing
- *     files it; the empty-bundle path re-enters bounded verify_failed re-work in
- *     verification-engine/feedback) and any legacy open row is EXCLUDED here
- *     (REFUSED_OPERATOR_HOLD_KINDS) so it cannot hold a delivery out of done.
- *     REFUSED + ROUTED, no longer a hold.
- *   schema_drift_blocked (listener-auto-advance.ts) -- an operator must apply a
- *     migration (a human-only act on external reality). KEEP.
- *   advance_blocked (delivery-advance-block.ts) -- dirty worktree / lockfile
- *     state an operator or agent must resolve on the host. KEEP.
- *   cd_push_failed (ci-escalation.ts) -- external CD state a human must act on.
- *     KEEP.
- *   ci_run_red (ci-sensor-loop.ts) -- fixing a failing CI gate is CODING work,
- *     so the sensor now files it as agent_resolvable anchored to a focus (the
- *     machine's next coding pass resolves it), NOT needs_operator. A
- *     needs_operator ci_run_red is only ever produced by the 24h agent_resolvable
- *     promotion backstop once the machine has failed to clear it. It is also
- *     focus-anchored (not delivery-anchored), so findOpenOperatorHoldForDelivery
- *     -- which keys on deliveryId -- never matches it regardless of disposition;
- *     the fail-closed integration->main merge gate (resolveCiMergeGate, reading
- *     the git ref) is what holds main out on a red, independent of this filing.
- *   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',
-];
-/**
- * escalation_kind discriminators that are REFUSED at their filing surface and
- * routed into the machine's own bounded re-work path because they NAME NO ACT
- * ONLY A HUMAN CAN PERFORM ("A hold must name a human act", 2026-07-28). Nothing
- * files these anymore, but a LEGACY row opened before the filing refusal deployed
- * must not hold its delivery out of done -- so it is excluded from the
- * operator-hold predicate here, and the delivery clears itself via re-work
- * instead of parking on a human inbox.
- *
- *   verify_evidence_unavailable -- the verify gate reporting its own blindness
- *     (empty judgeable bundle). Its ask named no human-only act; the empty-bundle
- *     path now re-enters bounded verify_failed re-work (verification-feedback.ts
- *     requeueEvidenceUnavailableAsRework), and verify_gate_unclearable (the
- *     iteration cap) is the sole surviving human residue.
- *
- * Daemon-local string literal for the same node:test module-mock-loader reason as
- * SELF_REPORT_STALL_HOLD_KINDS / OPERATOR_HOLD_DISPOSITIONS above.
- */
-export const REFUSED_OPERATOR_HOLD_KINDS = [
-    'verify_evidence_unavailable',
-];
-/**
- * escalation_kind discriminators whose filing reports a MACHINE STOP -- the daemon
- * has halted something and the detector proposed the act that ends it. Read from
- * the filing sites that name a humanAct and stop the machine; each stop is
- * enforced where its row is read:
- *
- *   team_failure -- completion/event-escalations.ts escalateNonAdvanceable and
- *     escalateDeliveryAdvancementStalled. Enforced by the respawn guard
- *     (focus/focus-respawn-guard.ts, via hasOpenTeamFailureEscalation).
- *   respawn_cycle_exhausted -- spawn/respawn-cycle-escalation.ts. Enforced by the
- *     durable spawn-cooldown `exhausted` latch (spawn/spawn-cooldown.ts), NOT by
- *     this row: the respawn guard does not read the kind, so the halt is
- *     disposition-independent, and the latch's spawn-independent recovery
- *     (clearSpawnCooldown on an auto-advance) is never stranded behind a row that
- *     nothing auto-resolves.
- *   review_handoff_exhausted (zero findings) -- completion/review-exit-escalations.ts.
- *     Enforced by the state cascade's kind-keyed breaker hold (any disposition).
- *
- * Not a stop kind: review_coverage_incomplete names no act; it is a machine
- * wait-state the coverage stabilizer clears, and the respawn guard reads it by
- * kind regardless of disposition.
- */
-export const MACHINE_STOP_KINDS = [
-    'team_failure',
-    'respawn_cycle_exhausted',
-    'review_handoff_exhausted',
-];
-/**
- * Pure: whether an escalation row is an OPEN machine-stop OBSERVATION -- a
- * MACHINE_STOP_KINDS row (typed kind column, metadata.kind fallback) whose
- * well-formed metadata.observation carries the detector's proposed_human_act.
- *
- * The ONE definition of "a machine-lane record that still stops the machine".
- * The filing chokepoint sends every daemon filing to the machine lane, so a
- * detector's named act no longer makes its row needs_operator; this predicate is
- * what keeps that stop holding. The respawn guard's machine-lane exclusion keeps
- * such a row blocking, and the routing decider treats it as immediately eligible
- * (a stopped focus spawns no team to decide it). A stop-kind observation with NO
- * proposed act is a plain record the incoming team resolves (TEL-2) -> false.
- * Disposition-independent: a row an agent made human-facing (needs_operator,
- * metadata.human_act) blocks on its disposition, not on this predicate.
- */
-export function isMachineStopObservation(row) {
-    if (row.status && !OPEN_ESCALATION_STATUSES.has(row.status))
-        return false;
-    const metaKind = row.metadata?.kind;
-    const kind = row.escalationKind ?? (typeof metaKind === 'string' ? metaKind : null);
-    if (kind === null || !MACHINE_STOP_KINDS.includes(kind))
-        return false;
-    return readObservation(row.metadata)?.proposed_human_act !== undefined;
-}
-/**
- * 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), or that is an observation proposing one (see
- * the module header). 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, deps = {}) {
-    return findOpenHoldForDelivery(deliveryId, OPERATOR_HOLD_DISPOSITIONS, focusId, 
-    // Two exclusions: (1) a machine-filed alarm ABOUT this delivery's own cycling
-    // must not satisfy the predicate that holds it (SELF_REPORT_STALL_HOLD_KINDS);
-    // (2) a kind that names no human-only act must not hold at all -- a legacy row
-    // is dropped and the delivery clears itself via re-work (REFUSED_OPERATOR_HOLD_KINDS).
-    new Set([...SELF_REPORT_STALL_HOLD_KINDS, ...REFUSED_OPERATOR_HOLD_KINDS]), deps);
-}
-/**
- * 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, deps = {}) {
-    return (await findOpenOperatorHoldForDelivery(deliveryId, focusId, deps)) !== null;
-}
-/**
- * Shared body for the disposition-keyed open-hold lookups
- * (findOpenOperatorHoldForDelivery). 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 -- or, when it is not, whose metadata.observation proposed a
- * disposition in the set (an observation hold; the result then carries
- * proposedDisposition). 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, deps = {}) {
-    const call = deps.callApi ?? callApi;
-    const holdSet = new Set(dispositions);
-    const fields = { statuses: ['pending', 'in_review'] };
-    if (focusId)
-        fields.focusId = focusId;
-    const result = await call('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)
-            continue;
-        const direct = disposition !== null && holdSet.has(disposition);
-        const kind = (typeof e.escalationKind === 'string' ? e.escalationKind : null) ??
-            (typeof meta?.kind === 'string' ? meta.kind : null);
-        // The row's own condition first, then each condition correlated onto it as a
-        // symptom (queries/incident-correlation.ts): an attached observation keeps the
-        // hold it proposed even when the row that absorbed it holds nothing itself.
-        const conditions = [
-            { kind, reportedKind: e.escalationKind ?? null, proposed: readObservation(meta)?.proposed_disposition ?? null },
-            ...readSymptoms(meta).map((s) => ({ kind: s.escalation_kind, reportedKind: s.escalation_kind, proposed: s.proposed_disposition ?? null })),
-        ];
-        const held = conditions.find(
-        // An observation proposing a hold disposition is the same uncleared condition,
-        // routed to the machine lane (see the module header). A self-referential stall
-        // alarm about this delivery must not hold it -- and the exclusions bind an
-        // observation of an excluded kind exactly as they bind a direct filing, so the
-        // fixpoint cannot return through the machine lane (or through a symptom).
-        (c) => (direct || (c.proposed !== null && holdSet.has(c.proposed))) &&
-            !(excludeKinds && c.kind !== null && excludeKinds.has(c.kind)));
-        if (!held)
-            continue;
-        return {
-            id: e.id,
-            escalationKind: held.reportedKind,
-            disposition: disposition ?? DISPOSITION_AGENT_RESOLVABLE,
-            ...(!direct && held.proposed !== null ? { proposedDisposition: held.proposed } : {}),
-        };
-    }
-    return null;
-}
-//# sourceMappingURL=holds.js.map

package/dist/queries/holds.js.map

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

package/dist/queries/incident-correlation.d.ts

@@ -1,291 +0,0 @@
-/**
- * Incident correlation over escalation rows: the ONE reducer every daemon filing
- * passes through (queries/escalations.ts createEscalation calls it).
- *
- * queries/cause-key.ts defines the two keys: a per-detector CAUSE key
- * (idempotency + dismissal memory) and the cross-detector INCIDENT key (the
- * execution anchor an observation is about). This module applies them to rows:
- *
- *  - STAMPING: every row filed with an anchor carries metadata.incident_key, and
- *    its own observation is seeded into metadata.symptoms.
- *  - CORRELATION (correlateFiling): a filing whose incident already has an open
- *    row IN ITS LANE is attached to that row as a symptom instead of becoming a
- *    second row. The I/O is injected (incidentIoOver builds it over callApi), so
- *    this module takes no value import of the API client.
- *  - KIND DEDUP: a row answers for its own kind, a hand-off row's originalKind (a
- *    historic promotion refile) / original_cause_key (that refile, or a routing
- *    decider's MCP filing carrying sourceCauseKey), and every symptom it carries,
- *    so the kind/column dedup reads in queries/escalations.ts see correlated and
- *    handed-off rows too.
- *
- * The attach/lane contract (decided 2026-09-12, reversible -- readers group rows
- * by metadata.incident_key and rely on exactly this):
- *
- *  1. LANE = the disposition the chokepoint SENDS (after routeFilingDisposition).
- *     A filing attaches only to an OPEN row of its incident whose disposition is
- *     the same; with no such row it opens one. The chokepoint sends EVERY daemon
- *     filing agent_resolvable (an observation, whatever disposition it proposed)
- *     or with no disposition, so a daemon filing attaches only to its incident's
- *     open agent_resolvable row (or its plain, disposition-less row) -- never into
- *     a human-lane row. Human-lane rows (needs_operator / external_wait carrying
- *     metadata.human_act) are made by AGENTS through the MCP escalate surface,
- *     which does not pass this reducer. findLaneIncidentRow still matches those
- *     lanes exactly, so it reads a store holding them correctly, but no daemon
- *     filing is sent in them. One incident has at most one open daemon-filed row
- *     per lane, and they share metadata.incident_key.
- *  2. A row's metadata.symptoms lists its OWN opening symptom plus exactly what
- *     attached to THAT row -- never a copy of another row's symptoms.
- *  3. A re-observed cause (the target row already carries its cause key as its
- *     own, original, or symptom cause key) writes nothing and files nothing. A
- *     site with no cause key gets the deterministic kind-scoped stand-in.
- *  4. Exempt in BOTH directions (neither attach nor are attached to): the
- *     INCIDENT_HOLD_KINDS, whose own row is read by kind as a spawn/cascade hold
- *     with a kind-keyed close-half. A cross-product filing (targetProductId) also
- *     never attaches -- the Nexus bridge resolves that row by its own id.
- *  5. A failed read or attach write degrades to filing the row (same incident
- *     key, own symptom only); correlation never loses a filing.
- *  6. A symptom is part of an incident only while its condition is live. When a
- *     close-half observes its condition clear it resolves its own-kind rows AND
- *     retires the matching ABSORBED symptoms from the other open rows in the same
- *     scope (retireClearedSymptoms): metadata.symptoms is rewritten without them
- *     and each is recorded under metadata.cleared_symptoms (bounded). A row's OWN
- *     opening symptom (its cause_key / original_cause_key / kind-scoped stand-in)
- *     is never retired this way -- that row closes only through its own kind's
- *     close-half. Readers (holds, dedup, the wedge arbiter) read only
- *     metadata.symptoms, so a retired symptom holds and suppresses nothing.
- *
- * Kept free of VALUE imports that reach @telora/daemon-core or the API client, so
- * the filing chokepoint can depend on it without dragging the mock-loader chain.
- */
-import type { EscalationResolutionClass } from '@telora/daemon-core';
-import { type IncidentSymptom } from './cause-key.js';
-import type { CallApiDeps } from './shared.js';
-/**
- * Kinds whose OWN open row is read BY KIND as a HOLD, released by a kind-keyed
- * close-half: team_failure (the respawn guard), review_coverage_incomplete (the
- * respawn guard, any disposition), review_handoff_exhausted (the state cascade's
- * breaker hold). Absorbing one into another row would
- * silently drop the hold, and absorbing another condition into one would be
- * closed by the hold's own close-half -- so they never correlate in either
- * direction (their rows still carry the shared incident_key).
- */
-export declare const INCIDENT_HOLD_KINDS: ReadonlySet<string>;
-/** The escalation row fields correlation reads (the escalation_list summary shape). */
-export interface IncidentRow {
-    id: string;
-    status?: string | null;
-    disposition?: string | null;
-    escalationKind?: string | null;
-    focusId?: string | null;
-    deliveryId?: string | null;
-    productId?: string | null;
-    createdAt?: string | null;
-    metadata?: Record<string, unknown> | null;
-}
-/** First-class provenance a filing resolved to (explicit params already applied). */
-export interface IncidentProvenance {
-    productId?: string;
-    focusId?: string;
-    deliveryId?: string;
-}
-/** The filing fields the incident key and symptoms are derived from. */
-export interface IncidentFilingInput {
-    escalationKind?: string;
-    description: string;
-    metadata?: Record<string, unknown>;
-    anchor?: {
-        branch?: string;
-    };
-    targetProductId?: string;
-}
-/** Pure: the incident key a metadata bag carries, or null. */
-export declare function readIncidentKey(metadata: unknown): string | null;
-/** Pure: the well-formed symptoms a metadata bag carries (malformed entries dropped). */
-export declare function readSymptoms(metadata: unknown): IncidentSymptom[];
-/**
- * Pure: the branch a filing is about, read from what the site already carries --
- * anchor.branch (merge + stuck-branch filings), then metadata.branch_name
- * (stuck_focus_branch), then metadata.branch (ci_run_red).
- */
-export declare function filingBranch(input: Pick<IncidentFilingInput, 'anchor' | 'metadata'>): string | null;
-/**
- * Pure: the incident key a filing is stamped with. An inbound notification kind
- * never joins an incident. An incident_key already in the filing's metadata wins
- * (a filing that carries its source's key forward); otherwise the key is
- * derived from the RESOLVED provenance (delivery -> focus -> branch|product).
- */
-export declare function resolveFilingIncidentKey(input: IncidentFilingInput, provenance: IncidentProvenance): string | null;
-/**
- * Pure: one filing's observation as an incident symptom. A filing with no
- * metadata.cause_key (a direct createEscalation site) gets a deterministic
- * kind-scoped stand-in, so a re-observation maps to the same symptom. The routed
- * observation's proposed disposition AND proposed human act ride on the symptom, so
- * neither is lost when the filing attaches to another row: every absorbed
- * detector's proposal reaches the routing decider, not only the opener's. A
- * metadata.human_act is carried too, but the daemon chokepoint never writes one, so
- * no daemon filing's symptom has it.
- */
-export declare function filingSymptom(input: IncidentFilingInput, key: string, observedAt: string): IncidentSymptom;
-/**
- * Pure: stamp a filing's metadata with its incident key and append its own
- * symptom to whatever symptoms it already carries (none for a fresh row, so the
- * opener is the first entry; a carried list otherwise).
- * A null key leaves the metadata untouched.
- */
-export declare function stampIncidentMetadata(input: IncidentFilingInput, key: string | null, observedAt: string): Record<string, unknown> | undefined;
-/** Pure: a row sits in the machine lane (agent_resolvable); everything else is human-facing. */
-export declare function isMachineLaneRow(row: Pick<IncidentRow, 'disposition'>): boolean;
-/** Pure: the cause keys recorded as symptoms on an OPEN row (idempotency survives correlation). */
-export declare function openRowSymptomCauseKeys(row: IncidentRow): string[];
-/** Pure: whether a filing may correlate at all (contract rule 4). */
-export declare function filingMayCorrelate(input: Pick<IncidentFilingInput, 'escalationKind' | 'targetProductId'>): boolean;
-/**
- * Pure: the OPEN row of incident `key` in the filing's lane (contract rule 1), or
- * null. Lane = the SENT disposition (null and undefined are one lane). Hold-kind
- * rows are never a target. Among several, the oldest wins (createdAt ascending;
- * rows without one keep list order, which escalation_list returns newest-first, so
- * a later entry is older).
- */
-export declare function findLaneIncidentRow(rows: readonly IncidentRow[], key: string, disposition: string | null | undefined): IncidentRow | null;
-/** Pure: whether a row already carries `causeKey` -- its own, its original, or a symptom's. */
-export declare function rowCarriesCause(row: IncidentRow, causeKey: string): boolean;
-/** The I/O correlation needs, injected so the reducer stays testable without the API client. */
-export interface IncidentAttachIo {
-    /** The OPEN rows (pending/in_review) a filing may attach to, narrowed server-side by focus when known. */
-    listOpenRows: (opts: {
-        focusId?: string;
-    }) => Promise<IncidentRow[]>;
-    /** Shallow-merge a metadata patch onto a row (escalation_update fields.metadata). */
-    updateMetadata: (escalationId: string, metadata: Record<string, unknown>) => Promise<void>;
-}
-/** The default correlation I/O over a callApi (escalation_list + escalation_update). */
-export declare function incidentIoOver(call: NonNullable<CallApiDeps['callApi']>): IncidentAttachIo;
-/** One filing about to be sent, as the reducer sees it. */
-export interface IncidentCorrelationInput {
-    /** The incident key the filing is stamped with (never null here). */
-    key: string;
-    /** The filing, carrying the ROUTED metadata (human_act / observation). */
-    filing: IncidentFilingInput;
-    /** The disposition the chokepoint sends (the lane). */
-    disposition: string | undefined;
-    /** The resolved focus, to narrow the open-row read. */
-    focusId?: string;
-    observedAt: string;
-}
-/** What the reducer decided. attached / already_carried mean no new row is filed. */
-export interface IncidentCorrelation {
-    outcome: 'attached' | 'already_carried' | 'open_row' | 'attach_failed';
-    /** The lane row attached to, carrying the cause, or whose attach failed; null for open_row. */
-    incidentRowId: string | null;
-    /** A log line for the chokepoint, when there is something to say. */
-    note: string | null;
-    warn: boolean;
-}
-/**
- * Correlate one filing onto its incident (the contract in the module header):
- * attach to the open lane row, report a re-observed cause, or tell the chokepoint
- * to file the row. Never throws -- a failed read or write degrades to open_row /
- * attach_failed, and the chokepoint files the row.
- */
-export declare function correlateFiling(input: IncidentCorrelationInput, io: IncidentAttachIo): Promise<IncidentCorrelation>;
-/**
- * Pure: whether a row answers for `kind` in a DEDUP read: its own column kind,
- * the legacy metadata.kind, a hand-off row's metadata.originalKind or
- * original_cause_key, or any symptom correlated onto it (by kind or by a cause key
- * minted for the kind, `<kind>::...`). Hold reads must NOT use this -- a handed-off
- * or absorbed condition has no close-half that would clear a hold keyed on it.
- */
-export declare function rowAnswersForKind(row: IncidentRow, kind: string): boolean;
-/** Pure: a symptom is an observation of `kind` -- by its kind, or by a cause key minted for the kind (`<kind>::...`). */
-export declare function symptomAnswersForKind(symptom: IncidentSymptom, kind: string): boolean;
-/**
- * Pure: whether a row is about `deliveryId` in a DEDUP read: the delivery_id
- * column, the metadata fallbacks, or an incident key naming the delivery (a
- * historic promotion refile is anchored to the focus, so only its carried key names it).
- */
-export declare function rowNamesDelivery(row: IncidentRow, deliveryId: string): boolean;
-/**
- * Pure: an OPEN row of `kind` on `focusId` -- the typed focus_id + escalation_kind
- * columns, or (back-compat, a row filed before the column promotion)
- * metadata.focusId + metadata.kind. With `matchCorrelated` (DEDUP reads only), also
- * a row on the focus answering for the kind as a hand-off row or a correlated
- * symptom (rowAnswersForKind).
- */
-export declare function isOpenFocusKindRow(row: IncidentRow, focusId: string, kind: string, matchCorrelated?: boolean): boolean;
-/**
- * Pure: an OPEN worktree-dirty-class row for `focusId` whose kind is in `kinds`.
- * Shared by hasOpenWorktreeDirtyEscalation (dedup, matchCorrelated) and
- * resolveOpenWorktreeDirtyEscalations (auto-close, never correlated: it must not
- * close a row whose own condition is a different one) so both agree on what counts.
- *
- * The status re-check is defense-in-depth. The live escalation_list handler
- * already honors the `statuses` filter server-side, but the invariant "a RESOLVED
- * worktree-dirty row must never suppress (or be re-resolved as) a legitimate new
- * escalation" must hold however the rows were fetched (custom `kinds`, a future
- * caller that forgets the statuses filter, etc.).
- */
-export declare function isOpenWorktreeDirtyMatch(row: IncidentRow, focusId: string, kinds: ReadonlySet<string>, matchCorrelated?: boolean): boolean;
-/** One retired symptom, recorded on its row under metadata.cleared_symptoms (snake_case JSONB). */
-export interface ClearedSymptom {
-    cause_key: string;
-    escalation_kind: string | null;
-    cleared_at: string;
-    resolution_class: string;
-}
-/**
- * A close-half's clearing event: WHICH absorbed symptoms its condition clearing
- * retires, and WHERE. `scope` must be at least as narrow as the close-half's own
- * row match; a row is touched only when it matches every scope field given, and an
- * EMPTY scope touches nothing (fail-safe: never org-wide).
- */
-export interface SymptomClearing {
-    /** Symptom kinds the event clears (symptomAnswersForKind). */
-    kinds?: readonly string[];
-    /** Exact symptom cause keys the event clears. */
-    causeKeys?: readonly string[];
-    scope: {
-        focusId?: string;
-        productId?: string;
-    };
-    /** The class of actor that observed the clearing (the close-half's own resolution class). */
-    resolutionClass: EscalationResolutionClass;
-}
-/** Pure: the well-formed cleared-symptom records a metadata bag carries. */
-export declare function readClearedSymptoms(metadata: unknown): ClearedSymptom[];
-/**
- * Pure: the cause keys that are a row's OWN -- its metadata.cause_key, a hand-off
- * row's original_cause_key, and the kind-scoped stand-in its opening symptom got
- * when filed without a cause key (filingSymptom). Never retired by retirement.
- */
-export declare function rowOwnCauseKeys(row: IncidentRow): Set<string>;
-/**
- * Pure: the metadata patch that retires a clearing's matching absorbed symptoms from
- * one row -- the remaining metadata.symptoms plus metadata.cleared_symptoms with each
- * retired one appended (de-duped by cause key, newest kept, bounded to
- * INCIDENT_SYMPTOM_CAP) -- or null when the row is closed, out of scope, or carries
- * nothing to retire. The row's own opening symptom is never retired.
- */
-export declare function symptomRetirementPatch(row: IncidentRow, clearing: SymptomClearing, clearedAt: string): {
-    symptoms: IncidentSymptom[];
-    cleared_symptoms: ClearedSymptom[];
-} | null;
-/** What a retirement pass did: symptoms retired, and warnings for the caller to log. */
-export interface SymptomRetirementOutcome {
-    retired: number;
-    warnings: string[];
-}
-/**
- * Retire a clearing's matching absorbed symptoms from the OPEN rows in its scope
- * (contract rule 6). `rows` reuses rows the close-half already read for the scope
- * (no second read); omitted, the open rows are read, narrowed by scope.focusId.
- * `skipIds` are the close-half's own rows (being resolved, not rewritten). A clearing
- * of hold kinds only reads nothing -- a hold kind is never absorbed (rule 4).
- * Best-effort and never throws: a failed read or write becomes a warning and the
- * pass continues. The write reads-then-writes like an attach (not atomic).
- */
-export declare function retireClearedSymptoms(clearing: SymptomClearing, io: IncidentAttachIo, opts?: {
-    rows?: readonly IncidentRow[];
-    skipIds?: readonly string[];
-    clearedAt?: string;
-}): Promise<SymptomRetirementOutcome>;
-//# sourceMappingURL=incident-correlation.d.ts.map

package/dist/queries/incident-correlation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"incident-correlation.d.ts","sourceRoot":"","sources":["../../src/queries/incident-correlation.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0DG;AAEH,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAQL,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK/C;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAIlD,CAAC;AAEH,uFAAuF;AACvF,MAAM,WAAW,WAAW;IAC1B,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,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C;AAED,qFAAqF;AACrF,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wEAAwE;AACxE,MAAM,WAAW,mBAAmB;IAClC,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAUD,8DAA8D;AAC9D,wBAAgB,eAAe,CAAC,QAAQ,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAGhE;AAED,yFAAyF;AACzF,wBAAgB,YAAY,CAAC,QAAQ,EAAE,OAAO,GAAG,eAAe,EAAE,CAIjE;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,QAAQ,GAAG,UAAU,CAAC,GAAG,MAAM,GAAG,IAAI,CAGnG;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,EAAE,UAAU,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAclH;AASD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,eAAe,CAiB1G;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,MAAM,GAAG,IAAI,EAClB,UAAU,EAAE,MAAM,GACjB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAOrC;AAUD,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,aAAa,CAAC,GAAG,OAAO,CAE/E;AAED,mGAAmG;AACnG,wBAAgB,uBAAuB,CAAC,GAAG,EAAE,WAAW,GAAG,MAAM,EAAE,CAElE;AAED,qEAAqE;AACrE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,gBAAgB,GAAG,iBAAiB,CAAC,GAAG,OAAO,CAGlH;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,SAAS,WAAW,EAAE,EAC5B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACrC,WAAW,GAAG,IAAI,CAWpB;AASD,+FAA+F;AAC/F,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAI3E;AAED,gGAAgG;AAChG,MAAM,WAAW,gBAAgB;IAC/B,0GAA0G;IAC1G,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACrE,qFAAqF;IACrF,cAAc,EAAE,CAAC,YAAY,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5F;AAED,wFAAwF;AACxF,wBAAgB,cAAc,CAAC,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,GAAG,gBAAgB,CAa1F;AAED,2DAA2D;AAC3D,MAAM,WAAW,wBAAwB;IACvC,qEAAqE;IACrE,GAAG,EAAE,MAAM,CAAC;IACZ,0EAA0E;IAC1E,MAAM,EAAE,mBAAmB,CAAC;IAC5B,uDAAuD;IACvD,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,qFAAqF;AACrF,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,UAAU,GAAG,iBAAiB,GAAG,UAAU,GAAG,eAAe,CAAC;IACvE,+FAA+F;IAC/F,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,qEAAqE;IACrE,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACpB,IAAI,EAAE,OAAO,CAAC;CACf;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,wBAAwB,EAAE,EAAE,EAAE,gBAAgB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAsBzH;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAMzE;AAED,yHAAyH;AACzH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAErF;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAK9E;AAID;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,eAAe,UAAQ,GAAG,OAAO,CAMpH;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,CAAC,MAAM,CAAC,EAC1B,eAAe,UAAQ,GACtB,OAAO,CAET;AAID,mGAAmG;AACnG,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,gBAAgB,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,8DAA8D;IAC9D,KAAK,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,iDAAiD;IACjD,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAChD,6FAA6F;IAC7F,eAAe,EAAE,yBAAyB,CAAC;CAC5C;AAED,4EAA4E;AAC5E,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,GAAG,cAAc,EAAE,CAUvE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAU7D;AAeD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,eAAe,EACzB,SAAS,EAAE,MAAM,GAChB;IAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;IAAC,gBAAgB,EAAE,cAAc,EAAE,CAAA;CAAE,GAAG,IAAI,CAgB5E;AAED,wFAAwF;AACxF,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,eAAe,EACzB,EAAE,EAAE,gBAAgB,EACpB,IAAI,GAAE;IAAE,IAAI,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAAC,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAO,GAC5F,OAAO,CAAC,wBAAwB,CAAC,CA0BnC"}