@telora/daemon 0.22.239 → 0.22.289

package/dist/supervision/holds.js

@@ -0,0 +1,352 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/composition/review-holds-context.test.ts,
+//   packages/daemon/src/focus/spawn-focus-team-guard-wiring.test.ts,
+//   packages/daemon/src/queries/escalations/spawn-team-failure-guard.test.ts,
+//   packages/daemon/src/supervision/has-open-operator-hold-for-delivery.test.ts,
+//   packages/daemon/src/supervision/incident-correlation.test.ts,
+//   packages/daemon/src/supervision/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 supervision/escalation-filing.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 applies it through rowHoldsRespawn).
+ *
+ * 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).
+ *
+ * The escalation-row readers it applies are queries (queries/escalations/filing-observation.ts,
+ * queries/escalations/incident-record.ts); this module decides what they mean for a delivery.
+ *
+ * History: docs/daemon/history-platform.md (supervision/holds.ts).
+ *
+ * @module supervision/holds
+ */
+import { callApi } from '../queries/api-client/shared.js';
+import { DISPOSITION_AGENT_RESOLVABLE, OPEN_ESCALATION_STATUSES } from '../queries/escalations/escalation-dispositions.js';
+import { readObservation } from '../queries/escalations/filing-observation.js';
+import { readSymptoms } from '../queries/escalations/incident-record.js';
+import { evaluateStop } from './stop-registry.js';
+/**
+ * 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 (focus-poller-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/stall-escalations/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 (supervision/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/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;
+}
+/**
+ * Pure: whether an open escalation row HOLDS the focus's respawn (TEL-2) -- the
+ * predicate the respawn guard hands queries/escalations/escalations.ts
+ * hasOpenTeamFailureEscalation (the coverage lookup is deliberately not given
+ * it: that wait-state parks whatever its disposition). A MACHINE-owned (agent_resolvable) row is a
+ * RECORD the incoming team resolves, not a hold -- EXCEPT a machine-stop
+ * observation (isMachineStopObservation): the chokepoint sends every daemon
+ * filing agent_resolvable, so a detector that proposed the act ending its stop
+ * (non-advanceable, advancement-stalled) keeps blocking on that proposal. A null
+ * / needs_intent / needs_operator row (agent-filed or legacy) still holds.
+ */
+export function rowHoldsRespawn(row) {
+    return !(row.disposition === DISPOSITION_AGENT_RESOLVABLE && !isMachineStopObservation(row));
+}
+/**
+ * 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) {
+    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]));
+}
+/**
+ * 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;
+}
+/**
+ * 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) {
+    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 ?? []) {
+        const meta = e.metadata ?? null;
+        const rowOpen = !(e.status && !OPEN_ESCALATION_STATUSES.has(e.status));
+        const anchoredToDelivery = e.deliveryId === deliveryId || meta?.deliveryId === deliveryId;
+        const disposition = (typeof e.disposition === 'string' ? e.disposition : null) ??
+            (typeof meta?.disposition === 'string' ? meta.disposition : null);
+        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 (supervision/incident-correlation.ts): an attached observation keeps the
+        // hold it proposed even when the row that absorbed it holds nothing itself.
+        const conditions = rowOpen && anchoredToDelivery
+            ? [
+                { 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 })),
+            ]
+            : [];
+        // 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). The
+        // decision is the registry's operator_hold_escalation row.
+        const verdict = evaluateStop('operator_hold_escalation', {
+            rowOpen,
+            anchoredToDelivery,
+            disposition,
+            conditions: conditions.map((c) => ({ kind: c.kind, proposedDisposition: c.proposed })),
+            holdDispositions: dispositions,
+            excludedKinds: excludeKinds ? [...excludeKinds] : [],
+        });
+        const held = verdict === null ? undefined : conditions[verdict.conditionIndex];
+        if (!verdict || !held)
+            continue;
+        return {
+            id: e.id,
+            escalationKind: held.reportedKind,
+            disposition: disposition ?? DISPOSITION_AGENT_RESOLVABLE,
+            ...(!verdict.direct && held.proposed !== null ? { proposedDisposition: held.proposed } : {}),
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=holds.js.map

package/dist/supervision/holds.js.map

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

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

@@ -0,0 +1,242 @@
+/**
+ * Incident correlation over escalation rows: the ONE reducer every daemon filing
+ * passes through (supervision/escalation-filing.ts createEscalation calls it).
+ *
+ * queries/escalations/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/escalations.ts see correlated and
+ *    handed-off rows too. Those row predicates (rowAnswersForKind and its
+ *    siblings) are readers, defined in queries/escalations/incident-record.ts.
+ *
+ * The attach/lane contract (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, and the INCIDENT_STANDALONE_KINDS, a condition
+ *     the operator must read as its own row (matched by escalation_kind or, for a
+ *     fileEscalation filing, metadata.machine_discriminator). 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.
+ *
+ * History: docs/daemon/history-platform.md (supervision/incident-correlation.ts).
+ */
+import type { EscalationResolutionClass } from '@telora/daemon-core';
+import { type IncidentSymptom } from '../queries/escalations/cause-key.js';
+import type { CallApi } from '../queries/api-client/shared.js';
+import { type ClearedSymptom, type IncidentRow } from '../queries/escalations/incident-record.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>;
+/**
+ * Kinds that must stand as their OWN row: the condition is read as a record of
+ * its own, and folded into another row it is not read at all. verify_judge_incurable
+ * is a verify hold that makes no model call until its input changes
+ * (verify/outcome-routing/verification-model-unavailable-hold.ts); absorbed into a
+ * row already open on the focus, the operator could not tell why it stopped.
+ */
+export declare const INCIDENT_STANDALONE_KINDS: ReadonlySet<string>;
+/** 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 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: 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' | 'metadata'>): 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
+ * and standalone-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: 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>;
+/**
+ * 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 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/supervision/incident-correlation.d.ts.map

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