@telora/daemon 0.22.245 → 0.22.289

package/dist/queries/escalations.d.ts

@@ -1,425 +0,0 @@
-/**
- * Escalation queries: creation, open-escalation dedup reads, and resolution.
- *
- * Split out of queries/issues.ts (file-size limit); the issue CRUD stays there
- * and re-exports this module so existing importers of queries/issues.js keep
- * working -- the same shape as the queries/holds.ts split.
- *
- * This module must NOT take a runtime (value) import of `@telora/daemon-core`
- * (type imports only): under the node:test module-mock loader a bare `@telora/*`
- * value specifier dies with ERR_MODULE_NOT_FOUND (see escalation-dispositions.ts).
- */
-import type { EscalationResolutionClass } from '@telora/daemon-core';
-import { type CallApiDeps } from './shared.js';
-import { resolveProvenance, type EscalationAnchor } from '../completion/escalation-provenance.js';
-import { type HumanAct } from './filing-observation.js';
-import { type FilingRefusal, type SendEscalationCreateDeps } from './escalation-refusal.js';
-import { type IncidentRow, type SymptomClearing } from './incident-correlation.js';
-/**
- * Parameters for creating an escalation request.
- */
-export interface CreateEscalationParams {
-    organizationId: string;
-    /** Session context (informational only -- not forwarded to the edge fn). Optional for daemon-side non-team callers. */
-    sessionId?: string;
-    issueId: string | null;
-    reasonType: string;
-    description: string;
-    whatWasTried?: string;
-    helpNeeded?: string;
-    /**
-     * Optional discriminator for the kind of escalation (e.g. 'stuck_focus_branch').
-     * Persisted on `agent_escalations.escalation_kind` when present.
-     */
-    escalationKind?: string;
-    /**
-     * Optional structured metadata (e.g. { branch_name, focus_id }).
-     * Persisted on `agent_escalations.metadata` when present.
-     */
-    metadata?: Record<string, unknown>;
-    /**
-     * Optional first-class provenance: where this escalation came from.
-     * Persisted on the agent_escalations product_id/focus_id/delivery_id
-     * columns. Prefer deriving these via resolveProvenance(anchor) so no
-     * site files an anonymous escalation when an anchor is available.
-     */
-    productId?: string;
-    focusId?: string;
-    deliveryId?: string;
-    /**
-     * Optional disposition: the resolution routing axis (who/what can resolve
-     * this). Distinct from escalationKind (the diagnosis). One of
-     * EscalationDisposition. Persisted on agent_escalations.disposition.
-     */
-    disposition?: string;
-    /**
-     * Optional cross-product TARGET provenance: the product this escalation is a
-     * blocker AGAINST (distinct from productId, which is the SOURCE product the
-     * escalation came from). Forwarded to the edge as fields.targetProductId. The
-     * edge escalation_create handler may or may not persist this on the
-     * agent_escalations.target_product_id column yet -- the escalation -> Nexus
-     * bridge does not depend on that, since the audit row also carries the target
-     * in metadata.target_product_id.
-     */
-    targetProductId?: string;
-    /**
-     * Optional provenance anchor: whatever the creation site holds (a delivery,
-     * focus, issue, session id, or branch). When present, the shared path runs
-     * resolveProvenance(anchor) and stamps the derived product/focus/delivery
-     * columns -- so no site files an anonymous escalation when an anchor is
-     * available. Explicitly-passed productId/focusId/deliveryId on params WIN
-     * over the derived values (caller intent beats derivation).
-     */
-    anchor?: EscalationAnchor;
-    /**
-     * The act the detector PROPOSES only a human can perform (irreversible / outward /
-     * unreachable capability), or NO_HUMAN_ACT. Never a route: it travels as
-     * metadata.observation.proposed_human_act on the machine-lane observation
-     * (queries/filing-observation.ts routeFilingDisposition).
-     */
-    humanAct?: HumanAct | null;
-}
-/**
- * Injectable deps for createEscalation: callApi (writes the row) + resolveProvenance
- * (derives the anchor's product/focus/delivery columns). Tests inject fakes THROUGH
- * deps, registering ZERO mock.module; production callers pass nothing.
- */
-export interface CreateEscalationDeps extends SendEscalationCreateDeps {
-    resolveProvenance?: typeof resolveProvenance;
-    /** ISO-8601 clock for the symptom's observed_at (and a refusal's refused_at). */
-    now?: () => string;
-}
-/** Outcome of a filing through the chokepoint. */
-export interface CreateEscalationResult {
-    /** The row filed; null when correlated onto an existing row (or the create returned no id). */
-    escalationId: string | null;
-    /** Whether the filing was attached to (or already carried by) its incident's open lane row instead of filed. */
-    correlated?: boolean;
-    /** The lane row it correlated onto, or whose attach failed before this row was filed; else null. */
-    incidentEscalationId?: string | null;
-    /** Set when the server refused the filing non-transiently (queries/escalation-refusal.ts); escalationId is then its refusal record's. */
-    refusal?: FilingRefusal;
-}
-/**
- * Create an escalation request -- the single filing chokepoint. Provenance is
- * derived from `anchor` via resolveProvenance (explicit productId/focusId/deliveryId
- * win; a derivation miss degrades, never aborts). The disposition is routed by
- * routeFilingDisposition: a daemon filing enters the machine lane WHATEVER
- * disposition it names -- needs_operator / external_wait / needs_intent /
- * needs_clarification are sent agent_resolvable as an observation carrying the
- * proposed disposition and any proposed human act. The daemon files no
- * human-facing row; only an agent that has assembled the intent ladder makes a
- * filing human-facing (MCP escalate). A stop or hold the detector reported stays
- * in force on its observation (queries/holds.ts isMachineStopObservation and
- * findOpenOperatorHoldForDelivery). The RESOLVED provenance (plus a branch the site carries) yields metadata.incident_key
- * (a key already in metadata wins; inbound-notification kinds carry none), and the
- * ONE incident reducer (queries/incident-correlation.ts correlateFiling) either
- * attaches the filing to its incident's open row in the same lane -- no row filed
- * -- or the row is filed stamped with the key and its own symptom.
- */
-export declare function createEscalation(params: CreateEscalationParams, deps?: CreateEscalationDeps): Promise<CreateEscalationResult>;
-/**
- * Minimal shape of an escalation row returned by listPendingEscalations.
- * Only includes the fields needed by the merge-back loop.
- */
-export interface PendingEscalation {
-    id: string;
-    reasonType: string;
-    description: string;
-    whatWasTried: string | null;
-    helpNeeded: string | null;
-    escalationKind?: string | null;
-    focusId?: string | null;
-    metadata?: Record<string, unknown> | null;
-}
-/**
- * List open (not-yet-resolved) escalations for the organization.
- *
- * Returns rows with status in `('pending', 'in_review')` -- both are
- * "open" from a dedup perspective. An operator may move a stuck-branch
- * escalation to `in_review` while triaging; the merge-back loop must
- * still treat it as suppressing duplicates so it does not file a second
- * `pending` row for the same branch.
- *
- * Used by the merge-back loop to detect when a branch already has an
- * unresolved merge-conflict escalation, and to find existing stuck-branch
- * escalations for dedup / auto-resolution.
- */
-export declare function listPendingEscalations(deps?: CallApiDeps): Promise<PendingEscalation[]>;
-/**
- * Returns true when an open (status pending or in_review) team_failure
- * escalation exists for the given focus.
- *
- * Used by the focus-executor spawn precondition to prevent respawning a
- * team that has already given up on a focus. The escalation row is the
- * signal "this focus is not currently workable"; until a human resolves
- * it, the daemon should not spend cycles re-deriving the same conclusion.
- *
- * Dedup matches on the first-class `focus_id` column (stamped via the
- * anchor since Delivery B of the Escalation Signal Richness focus). A
- * metadata.focusId fallback covers any rows that predate the migration's
- * backfill and landed in the deployment window before the daemon restarted.
- */
-export declare function hasOpenTeamFailureEscalation(focusId: string, deps?: CallApiDeps, opts?: {
-    excludeAgentResolvable?: boolean;
-}): Promise<boolean>;
-/**
- * DEDUP-only sibling of hasOpenTeamFailureEscalation, for the team_failure RE-FILE
- * guards (completion/event.ts): also counts an open row on the focus answering for
- * team_failure as a promotion refile (originalKind / original_cause_key) or a
- * carried symptom, so a promoted team_failure is not re-filed. The respawn guard
- * keeps the kind-column read -- a HOLD must not match a condition whose kind-keyed
- * close-half would never release it.
- */
-export declare function hasOpenTeamFailureEscalationForDedup(focusId: string, deps?: CallApiDeps): Promise<boolean>;
-/**
- * Returns true when an open (status pending or in_review) escalation exists
- * for the given delivery + kind discriminator.
- *
- * Now that the advance-block class is a first-class `escalation_kind`
- * ('advance_blocked', added to the DB CHECK + ESCALATION_KINDS) and the
- * delivery is a first-class `delivery_id` column, dedup matches on the
- * COLUMNS in preference to the metadata bag. A metadata fallback is retained
- * for back-compat with rows already open at deploy time (filed before this
- * promotion, which carry the discriminator only in metadata.kind /
- * metadata.deliveryId). A pure DEDUP read, so it also sees a promotion refile
- * (metadata.originalKind + the delivery's carried incident_key) and a symptom
- * correlated onto the delivery's incident row (rowAnswersForKind / rowNamesDelivery).
- *
- * Used by the delivery advance-block path so a delivery stuck across many
- * polls files exactly one open escalation instead of one per tick.
- */
-export declare function hasOpenEscalationForDelivery(deliveryId: string, escalationKind: string): Promise<boolean>;
-/**
- * escalation_kind discriminators for the two focus-merge worktree-dirty
- * classes. Declared as daemon-local string constants (not imported from
- * @telora/daemon-core's ESCALATION_KINDS) on purpose: the daemon consumes the
- * registry-PUBLISHED daemon-core, so it cannot reference newly-added enum
- * members until a build that depends on a daemon-core publish carrying them.
- * They ARE now in daemon-core (ESCALATION_KINDS.MERGE_CONFLICT /
- * .MERGE_REFUSED_DIRTY, shipped in 0.2.45) for other consumers (frontend, MCP),
- * but the daemon keeps the local strings so this code does not depend on the
- * publish ordering. The DB CHECK is the real constraint -- loosened by the
- * agent_escalations_kind_merge_classes migration to admit these two values --
- * and the daemon stamps them as plain strings.
- * (advance_blocked already shipped in daemon-core as ESCALATION_KINDS.ADVANCE_BLOCKED.)
- */
-export declare const MERGE_CONFLICT_ESCALATION_KIND = "merge_conflict";
-export declare const MERGE_REFUSED_DIRTY_ESCALATION_KIND = "merge_refused_dirty";
-/**
- * The worktree-dirty escalation classes: a single physical fact (one focus
- * worktree with uncommitted changes) can be observed by three independent
- * daemon paths -- the delivery advance-block guard (advance_blocked), the
- * focus-merge dirty-worktree refusal (merge_refused_dirty), and the
- * focus-merge conflict path (merge_conflict). They are siblings: when one is
- * already open for a focus, the others should suppress rather than pile on.
- */
-export declare const WORKTREE_DIRTY_ESCALATION_KINDS: readonly string[];
-/**
- * Returns true when an open (status pending or in_review) worktree-dirty-class
- * escalation exists for the given FOCUS.
- *
- * This generalizes hasOpenEscalationForDelivery from per-delivery to
- * focus/worktree grain. A dirty worktree is a property of one focus worktree
- * shared by all of the focus's deliveries, so deduping per delivery emits N
- * rows for one physical fact. Keying on the focus collapses them to one.
- *
- * It also collapses ACROSS escalation classes: by default the sibling set is
- * { advance_blocked, merge_conflict, merge_refused_dirty }, so an open
- * advance-block escalation suppresses a merge-refuse one (and vice versa) --
- * one dirty-worktree fact yields at most one open escalation regardless of how
- * many code paths observe it. Pass `kinds` to narrow the sibling set.
- *
- * Dedup matches on the typed `focus_id` + `escalation_kind` COLUMNS in
- * preference to the metadata bag, with a metadata fallback (metadata.focusId /
- * metadata.kind) for rows already open at deploy time. Because it queries the
- * DB rather than an in-memory Set, the dedup survives a daemon restart.
- *
- * The request narrows server-side by `focusId` + open `statuses` (both honored
- * by the live escalation_list handler) so the 500-row page is scoped to this
- * focus's open rows, not the org's newest 500 -- closing the gap where a busy
- * org could push the matching sibling off the page. The status + focus + kind
- * predicate is ALSO applied client-side (isOpenWorktreeDirtyMatch) as
- * defense-in-depth.
- */
-export declare function hasOpenWorktreeDirtyEscalation(focusId: string, kinds?: readonly string[], deps?: CallApiDeps): Promise<boolean>;
-/** The escalation_kind filed by the planning-wedge watchdog. */
-export declare const WEDGED_FOCUS_ESCALATION_KIND = "wedged_focus";
-/**
- * Returns true when an OPEN (status pending or in_review) wedged_focus
- * escalation already exists for the given FOCUS.
- *
- * The planning-wedge watchdog re-evaluates every poll tick, so without a dedup
- * it would file an identical wedged_focus row each tick the focus stays wedged
- * (the 172-duplicate storm class). Keying on the focus + escalation_kind COLUMNS
- * collapses the threshold-crossing escalation to at most one open row per focus.
- *
- * Delegates to hasOpenFocusEscalation (server-side focusId + open-status narrowing,
- * client-side re-check). Because it queries the DB rather than an in-memory Set,
- * the dedup SURVIVES A DAEMON RESTART -- a restart cannot re-storm a wedged focus.
- */
-export declare function hasOpenWedgedFocusEscalation(focusId: string): Promise<boolean>;
-/**
- * The escalation_kind the review-exit drift-streak breaker files when a focus
- * branch keeps advancing DURING each review pass (review-exit-escalations.ts).
- * Named here so the respawn guard and the filer agree on the exact string.
- */
-export declare const REVIEW_COVERAGE_INCOMPLETE_ESCALATION_KIND = "review_coverage_incomplete";
-/**
- * Returns true when an open (status pending or in_review)
- * review_coverage_incomplete escalation exists for the given focus.
- *
- * Used by the respawn guard so a focus whose drift-streak breaker has already
- * fired parks its re-review spawns instead of burning a review cycle every
- * spawn cooldown while the escalation sits open (the 2026-08-06 incident: the
- * breaker fired 4 minutes in, but nothing stopped the loop for 4.5h). Mirrors
- * hasOpenTeamFailureEscalation's excludeAgentResolvable (TEL-2), but the respawn
- * guard does NOT pass it: the coverage hold is a machine wait-state the coverage
- * stabilizer clears, so it parks the spawn whatever its disposition.
- */
-export declare function hasOpenReviewCoverageIncompleteEscalation(focusId: string, deps?: CallApiDeps, opts?: {
-    excludeAgentResolvable?: boolean;
-}): Promise<boolean>;
-/**
- * Returns true when an OPEN (status pending or in_review) escalation of the
- * given `escalationKind` already exists for the given FOCUS. Generic per-focus
- * dedup (review_window_stalled, wedged_focus, the review breakers): one open row
- * per focus across poll ticks and daemon restarts. Narrows server-side by
- * focusId + open statuses and re-applies status/focus/kind client-side.
- * Dedup callers pass no opts (every open row counts, observations included).
- *
- * `matchCorrelated` is for PURE dedup reads only: it also counts a promotion
- * refile (metadata.originalKind) and a symptom correlated onto an open incident
- * row on the focus. It is opt-in because two callers read this as a HOLD (the
- * respawn guard's review_coverage_incomplete, the state cascade's breaker hold),
- * and a promoted or absorbed condition has no close-half that would release it.
- */
-export declare function hasOpenFocusEscalation(focusId: string, escalationKind: string, deps?: CallApiDeps, opts?: {
-    excludeAgentResolvable?: boolean;
-    matchCorrelated?: boolean;
-}): Promise<boolean>;
-/**
- * List the escalation_kind of every OPEN (pending/in_review) escalation naming a
- * focus -- the raw evidence the wedge-cause arbiter (TEL-3) draws on -- plus every
- * symptom kind correlated onto those rows, so a cause absorbed into an incident
- * row still counts. Any-kind (no server kind filter); the caller narrows to wedge
- * causes. Column-first with the metadata.focusId fallback for pre-backfill rows.
- */
-export declare function listOpenFocusEscalationKinds(focusId: string, deps?: CallApiDeps): Promise<string[]>;
-/**
- * Read the OPEN (pending or in_review) escalations of `escalationKind` for a
- * focus, returning each row's id + metadata + disposition. The read sibling of
- * resolveOpenFocusEscalationsOfKind, for close-halves whose clearing condition
- * is per-row (e.g. review_coverage_incomplete clears only when the focus branch
- * has stabilized at the tip recorded in the row's metadata at filing).
- */
-export declare function listOpenFocusEscalationsOfKind(focusId: string, escalationKind: string, deps?: CallApiDeps): Promise<Array<{
-    id: string;
-    metadata: Record<string, unknown> | null;
-    disposition?: string | null;
-}>>;
-/**
- * The close half for a per-FOCUS escalation kind: resolve every open (pending or
- * in_review) escalation of `escalationKind` for the focus, once the daemon has
- * observed its clearing condition. Mirrors resolveOpenWorktreeDirtyEscalations
- * (the delivery-scoped precedent) for the focus-scoped blocking kinds that
- * applyRespawnGuard reads as a spawn block (team_failure) -- so a machine-filed
- * spawn block clears itself the moment its own condition (genuine progress)
- * clears, and the armed focus resumes spawning with no human act.
- *
- * Best-effort: a resolve failure for one row is logged and skipped, never thrown,
- * so the caller's primary work (advancing a delivery) is not blocked. Returns the
- * count resolved.
- */
-export declare function resolveOpenFocusEscalationsOfKind(focusId: string, escalationKind: string, resolutionClass: EscalationResolutionClass, resolutionNotes: string, deps?: CallApiDeps): Promise<number>;
-/**
- * Retire a clearing's absorbed symptoms over the API (incident-correlation.ts retireClearedSymptoms,
- * rule 6) -- for the resolve helpers here and for sweeps elsewhere that resolve their own rows.
- * Best-effort: logs, never throws. Returns the count of symptoms retired.
- */
-export declare function retireAbsorbedSymptoms(clearing: SymptomClearing, opts?: {
-    rows?: readonly IncidentRow[];
-    skipIds?: readonly string[];
-}, deps?: CallApiDeps): Promise<number>;
-/**
- * The escalation kinds that describe a focus that cannot converge -- the review
- * hand-off breaker family plus team_failure. When the focus DOES converge, each
- * of these rows describes nothing and must retire itself (there is no reason for
- * a converged focus to carry a pending operator row). The review kinds and
- * event-escalations' team_failure also stamp `terminates_when: 'focus_converged'`
- * in their metadata; the stalled-team-backstop team_failure files through a
- * causeKey path without metadata, so this kind list is the robust matcher.
- */
-export declare const FOCUS_CONVERGENCE_TERMINATED_KINDS: ReadonlySet<string>;
-/**
- * Retire every open (pending/in_review) escalation on a focus that carries a
- * focus-convergence terminator -- either its kind is in
- * FOCUS_CONVERGENCE_TERMINATED_KINDS or its metadata declares
- * `terminates_when: 'focus_converged'`. Called from the review-exit convergence
- * hook when the focus converges (its verify deliveries reached done and
- * review_requested_at cleared): the rows describe a focus that could not
- * converge, and it just did, so they are resolved auto_swept with a note naming
- * the converging review. Best-effort per row; returns the count resolved.
- */
-export declare function resolveConvergedFocusEscalations(focusId: string, resolutionNotes: string, deps?: CallApiDeps): Promise<number>;
-/**
- * Auto-resolve the open worktree-dirty escalations for a focus once their
- * underlying condition has cleared (the worktree is observed clean again, or a
- * merge conflict has been merged through). Lists the open rows for the focus
- * narrowed to `kinds`, resolves each with a daemon-remediation note, and
- * returns the count resolved.
- *
- * This is the close half of the disposition-aware model: an agent_resolvable
- * condition that auto-remediates should also stop showing in the human inbox
- * the moment it clears, instead of lingering as a resolved-in-fact but
- * still-pending row. Best-effort: a resolve failure for one row is logged and
- * skipped, never thrown, so the caller's primary work is not blocked.
- *
- * Callers MUST pass `kinds` narrowed to the conditions the clearing event
- * actually resolves -- e.g. a clean worktree clears advance_blocked /
- * merge_refused_dirty but NOT merge_conflict (a content conflict is not a dirty
- * worktree), and a successful merge clears merge_conflict.
- *
- * `resolutionClass` is REQUIRED: the class of actor that observed the clearing
- * (the daemon's condition-cleared callers pass 'auto_swept').
- */
-export declare function resolveOpenWorktreeDirtyEscalations(focusId: string, kinds: readonly string[], resolutionClass: EscalationResolutionClass, resolutionNotes?: string, deps?: CallApiDeps): Promise<number>;
-/**
- * Returns true when an OPEN (status pending or in_review) PRD machine escalation
- * of the given `discriminator` already exists for the given PRD.
- *
- * PRD machine escalations are filed via escalations.fileEscalation with a machine
- * `kind` -- carried in metadata.machine_discriminator (NOT the escalation_kind
- * CHECK enum) -- and the prd id folded from `details` into metadata.prdId. So
- * dedup matches on those two metadata fields. Parameterizing the discriminator
- * lets every cadence-reachable PRD escalation path share ONE idempotency guard:
- * the steward divergence path ('prd_divergence_steward_escalation') AND the
- * reflex no-surviving-path fallback ('prd_divergence_no_surviving_path'), both of
- * which would otherwise flood identically (the 172-duplicate storm class).
- *
- * Because it queries the DB rather than a process-lifetime in-memory Set, the
- * dedup SURVIVES A DAEMON RESTART: the escalation storm this prevents (identical
- * pending rows filed every cadence tick) cannot recur after a restart, unlike the
- * no-arm-role Set whose intentional restart-renotify semantics stay untouched.
- *
- * The request narrows server-side by metadata->>prdId (metadataPrdId, honored by
- * the live escalation_list handler) so a busy org cannot page this PRD's row off
- * the 500-row window. The metadata predicate is ALSO applied client-side as
- * defense-in-depth AND so the dedup works before the edge-fn filter deploys
- * (edge changes propagate via the separate INFRA pipeline) -- an unknown
- * metadataPrdId field is simply ignored server-side until then.
- */
-export declare function hasOpenPrdEscalation(prdId: string, discriminator: string): Promise<boolean>;
-/**
- * Mark an escalation as resolved, recording WHO actually resolved it.
- *
- * `resolutionClass` is REQUIRED and typed: every daemon close path must state the
- * class of actor it observed (a condition-cleared sweep or a promotion/demotion
- * refile is 'auto_swept'; an agent's own progress is 'agent_session'). It feeds
- * the routing-quality mis-route measurement (queries/routing-quality.ts), which
- * differences a filing's declared disposition against this recorded class --
- * when it was optional no caller passed it, so every resolved row read null and
- * the measurement fail-opened forever on judged=0.
- */
-export declare function markEscalationResolved(escalationId: string, resolutionClass: EscalationResolutionClass, resolutionNotes?: string, deps?: CallApiDeps): Promise<void>;
-//# sourceMappingURL=escalations.d.ts.map

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

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