@telora/daemon 0.20.57 → 0.20.78

package/dist/queries/agent-resolvable-promotion.d.ts

@@ -0,0 +1,87 @@
+/**
+ * agent_resolvable promotion safety net (delivery "agent_resolvable never
+ * reaches the human inbox", TEL-3).
+ *
+ * agent_resolvable filings are machine-owned: hidden from the operator inbox
+ * (TEL-1) and ridden into the focus's next coding spawn to be resolved (TEL-2).
+ * That is only safe if a filing the machine CANNOT actually clear eventually
+ * surfaces to a human -- otherwise it lingers forever, invisible. This module is
+ * that backstop: an agent_resolvable filing that has stayed open past a bound
+ * (it rode into many spawn cycles and none resolved it -- "bounded failures") is
+ * PROMOTED to a human by resolving the machine-routed row and refiling the same
+ * content as a needs_operator escalation, which the operator inbox DOES show.
+ *
+ * Why age, not a per-row attempt counter: escalation_update accepts only
+ * status/notes/answer (no disposition or metadata writes without a separate edge
+ * deploy), and there is no per-focus "sessions since T" query. Open-age is the
+ * deploy-safe, restart-safe, count-free proxy for "it survived N spawn cycles
+ * unresolved" -- every spawn that rode it in and exited without clearing it is a
+ * failed attempt, and those accumulate as elapsed open time.
+ *
+ * Promotion is idempotent: the needs_operator refile rides the shared cause-keyed
+ * gate keyed on the original escalation id, and the source row is resolved in the
+ * same step, so a filing is promoted at most once.
+ */
+import { type AgentResolvableItem } from './issues.js';
+import { type FileEscalationIdempotentParams, type FileEscalationIdempotentResult } from './escalation-suppression.js';
+/** Default hours an agent_resolvable filing may stay open before promotion. */
+export declare const DEFAULT_AGENT_RESOLVABLE_PROMOTE_HOURS = 24;
+/**
+ * Resolve the promotion threshold (hours -> ms) from the typed, Zod-validated
+ * env-config -- the single declaration site for every operational knob
+ * (packages/daemon-core/src/env-config.ts). An unset value yields the schema
+ * default (DEFAULT_AGENT_RESOLVABLE_PROMOTE_HOURS); an invalid one fails loudly
+ * at startup rather than silently degrading to a default here.
+ *
+ * Same shape as resolveStuckBranchThresholdMs in merge-back-loop.ts.
+ */
+export declare function resolveAgentResolvablePromoteMs(env?: NodeJS.ProcessEnv): number;
+/**
+ * Pure: split the open agent_resolvable filings into the ones that should still
+ * RIDE into this spawn and the ones that are past the age bound and should be
+ * PROMOTED to a human. A filing with an unparseable/absent createdAt is treated
+ * as fresh (ride) -- promotion must never fire on a missing timestamp.
+ */
+export declare function partitionAgentResolvableByAge(items: readonly AgentResolvableItem[], nowMs: number, thresholdMs: number): {
+    ride: AgentResolvableItem[];
+    promote: AgentResolvableItem[];
+};
+/** The cause key that makes a promotion refile idempotent (one per original filing). */
+export declare function agentResolvablePromotionCauseKey(originalEscalationId: string): string;
+/** escalation_kind for a promoted (formerly agent_resolvable) filing. */
+export declare const AGENT_RESOLVABLE_PROMOTED_KIND = "agent_resolvable_promoted";
+/**
+ * Pure: build the needs_operator refile params for a filing the machine could
+ * not resolve autonomously. Carries the original description + kind so the
+ * operator sees what was tried and why it now needs them; anchored to the focus.
+ */
+export declare function buildAgentResolvablePromotionParams(item: AgentResolvableItem, ctx: {
+    organizationId: string;
+    focusId: string;
+    productId?: string;
+}, ageHours: number): FileEscalationIdempotentParams;
+/** Injected IO for the promotion reconcile (real defaults; tests inject stubs). */
+export interface AgentResolvablePromotionDeps {
+    listOpen: (focusId: string) => Promise<AgentResolvableItem[]>;
+    markResolved: (id: string, notes?: string) => Promise<void>;
+    file: (params: FileEscalationIdempotentParams) => Promise<FileEscalationIdempotentResult>;
+    now: () => number;
+    thresholdMs: number;
+}
+/**
+ * Reconcile a focus's open agent_resolvable filings and return the ones that
+ * should ride into THIS spawn. Over-age filings are promoted (needs_operator
+ * refile + resolve the source) so they leave the machine lane and reach the
+ * human inbox; the rest are returned to ride in as before.
+ *
+ * Best-effort per filing: a promotion failure is logged and the filing is left
+ * to ride (it will be retried next spawn), never thrown -- reconciling must never
+ * block a spawn. This is the single entry point the spawn path calls instead of
+ * listOpenAgentResolvableForFocus.
+ */
+export declare function reconcileAgentResolvableForFocus(ctx: {
+    organizationId: string;
+    focusId: string;
+    productId?: string;
+}, deps?: Partial<AgentResolvablePromotionDeps>): Promise<AgentResolvableItem[]>;
+//# sourceMappingURL=agent-resolvable-promotion.d.ts.map

package/dist/queries/agent-resolvable-promotion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-resolvable-promotion.d.ts","sourceRoot":"","sources":["../../src/queries/agent-resolvable-promotion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAOH,OAAO,EAGL,KAAK,mBAAmB,EACzB,MAAM,aAAa,CAAC;AACrB,OAAO,EAEL,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACpC,MAAM,6BAA6B,CAAC;AAMrC,+EAA+E;AAC/E,eAAO,MAAM,sCAAsC,KAAK,CAAC;AAEzD;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CAE5F;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,mBAAmB,EAAE,EACrC,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,GAClB;IAAE,IAAI,EAAE,mBAAmB,EAAE,CAAC;IAAC,OAAO,EAAE,mBAAmB,EAAE,CAAA;CAAE,CAYjE;AAED,wFAAwF;AACxF,wBAAgB,gCAAgC,CAAC,oBAAoB,EAAE,MAAM,GAAG,MAAM,CAErF;AAED,yEAAyE;AACzE,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,mBAAmB,EACzB,GAAG,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACpE,QAAQ,EAAE,MAAM,GACf,8BAA8B,CAiChC;AAED,mFAAmF;AACnF,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,mBAAmB,EAAE,CAAC,CAAC;IAC9D,YAAY,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5D,IAAI,EAAE,CAAC,MAAM,EAAE,8BAA8B,KAAK,OAAO,CAAC,8BAA8B,CAAC,CAAC;IAC1F,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAYD;;;;;;;;;;GAUG;AACH,wBAAsB,gCAAgC,CACpD,GAAG,EAAE;IAAE,cAAc,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAE,EACpE,IAAI,GAAE,OAAO,CAAC,4BAA4B,CAAM,GAC/C,OAAO,CAAC,mBAAmB,EAAE,CAAC,CA2BhC"}

package/dist/queries/agent-resolvable-promotion.js

@@ -0,0 +1,152 @@
+/**
+ * agent_resolvable promotion safety net (delivery "agent_resolvable never
+ * reaches the human inbox", TEL-3).
+ *
+ * agent_resolvable filings are machine-owned: hidden from the operator inbox
+ * (TEL-1) and ridden into the focus's next coding spawn to be resolved (TEL-2).
+ * That is only safe if a filing the machine CANNOT actually clear eventually
+ * surfaces to a human -- otherwise it lingers forever, invisible. This module is
+ * that backstop: an agent_resolvable filing that has stayed open past a bound
+ * (it rode into many spawn cycles and none resolved it -- "bounded failures") is
+ * PROMOTED to a human by resolving the machine-routed row and refiling the same
+ * content as a needs_operator escalation, which the operator inbox DOES show.
+ *
+ * Why age, not a per-row attempt counter: escalation_update accepts only
+ * status/notes/answer (no disposition or metadata writes without a separate edge
+ * deploy), and there is no per-focus "sessions since T" query. Open-age is the
+ * deploy-safe, restart-safe, count-free proxy for "it survived N spawn cycles
+ * unresolved" -- every spawn that rode it in and exited without clearing it is a
+ * failed attempt, and those accumulate as elapsed open time.
+ *
+ * Promotion is idempotent: the needs_operator refile rides the shared cause-keyed
+ * gate keyed on the original escalation id, and the source row is resolved in the
+ * same step, so a filing is promoted at most once.
+ */
+import { ESCALATION_REASONS, ESCALATION_DISPOSITIONS, loadEnvConfig, } from '@telora/daemon-core';
+import { markEscalationResolved as defaultMarkEscalationResolved, listOpenAgentResolvableForFocus as defaultListOpenAgentResolvableForFocus, } from './issues.js';
+import { fileEscalationIdempotent as defaultFileEscalationIdempotent, } from './escalation-suppression.js';
+import { computeCauseKey } from './cause-key.js';
+import { createLogger } from '../log.js';
+const log = createLogger({ module: 'escalations' });
+/** Default hours an agent_resolvable filing may stay open before promotion. */
+export const DEFAULT_AGENT_RESOLVABLE_PROMOTE_HOURS = 24;
+/**
+ * Resolve the promotion threshold (hours -> ms) from the typed, Zod-validated
+ * env-config -- the single declaration site for every operational knob
+ * (packages/daemon-core/src/env-config.ts). An unset value yields the schema
+ * default (DEFAULT_AGENT_RESOLVABLE_PROMOTE_HOURS); an invalid one fails loudly
+ * at startup rather than silently degrading to a default here.
+ *
+ * Same shape as resolveStuckBranchThresholdMs in merge-back-loop.ts.
+ */
+export function resolveAgentResolvablePromoteMs(env = process.env) {
+    return loadEnvConfig(env).TELORA_AGENT_RESOLVABLE_PROMOTE_HOURS * 3_600_000;
+}
+/**
+ * Pure: split the open agent_resolvable filings into the ones that should still
+ * RIDE into this spawn and the ones that are past the age bound and should be
+ * PROMOTED to a human. A filing with an unparseable/absent createdAt is treated
+ * as fresh (ride) -- promotion must never fire on a missing timestamp.
+ */
+export function partitionAgentResolvableByAge(items, nowMs, thresholdMs) {
+    const ride = [];
+    const promote = [];
+    for (const item of items) {
+        const createdMs = Date.parse(item.createdAt);
+        if (Number.isNaN(createdMs) || nowMs - createdMs <= thresholdMs) {
+            ride.push(item);
+        }
+        else {
+            promote.push(item);
+        }
+    }
+    return { ride, promote };
+}
+/** The cause key that makes a promotion refile idempotent (one per original filing). */
+export function agentResolvablePromotionCauseKey(originalEscalationId) {
+    return computeCauseKey('agent_resolvable_promoted', { escalationId: originalEscalationId });
+}
+/** escalation_kind for a promoted (formerly agent_resolvable) filing. */
+export const AGENT_RESOLVABLE_PROMOTED_KIND = 'agent_resolvable_promoted';
+/**
+ * Pure: build the needs_operator refile params for a filing the machine could
+ * not resolve autonomously. Carries the original description + kind so the
+ * operator sees what was tried and why it now needs them; anchored to the focus.
+ */
+export function buildAgentResolvablePromotionParams(item, ctx, ageHours) {
+    const originalKind = item.escalationKind ?? 'agent_resolvable';
+    return {
+        causeKey: agentResolvablePromotionCauseKey(item.id),
+        organizationId: ctx.organizationId,
+        issueId: null,
+        reasonType: ESCALATION_REASONS.BLOCKED_BY_EXTERNAL,
+        // It was machine-routable, but the machine had ~ageHours of spawn cycles to
+        // clear it and did not -- a human must now take it.
+        disposition: ESCALATION_DISPOSITIONS.NEEDS_OPERATOR,
+        anchor: { focusId: ctx.focusId },
+        ...(ctx.productId ? { productId: ctx.productId } : {}),
+        escalationKind: AGENT_RESOLVABLE_PROMOTED_KIND,
+        description: `A machine-routable (agent_resolvable) filing has stayed open ~${ageHours}h ` +
+            `without the daemon's spawns clearing it, so it is promoted to you.\n\n` +
+            `**Original kind:** ${originalKind}\n` +
+            `**Original filing:** ${item.id}\n\n` +
+            `${item.description}`,
+        whatWasTried: `The filing rode into the focus's coding spawns for ~${ageHours}h ` +
+            `(disposition agent_resolvable) but was never resolved, so the machine has ` +
+            `exhausted its autonomous attempts.`,
+        helpNeeded: `Resolve the underlying condition manually, or re-file with clearer intent if ` +
+            `the machine cannot act on it.`,
+        metadata: {
+            cause: AGENT_RESOLVABLE_PROMOTED_KIND,
+            originalEscalationId: item.id,
+            originalKind,
+            ageHours,
+        },
+    };
+}
+function defaultDeps() {
+    return {
+        listOpen: defaultListOpenAgentResolvableForFocus,
+        markResolved: defaultMarkEscalationResolved,
+        file: defaultFileEscalationIdempotent,
+        now: () => Date.now(),
+        thresholdMs: resolveAgentResolvablePromoteMs(),
+    };
+}
+/**
+ * Reconcile a focus's open agent_resolvable filings and return the ones that
+ * should ride into THIS spawn. Over-age filings are promoted (needs_operator
+ * refile + resolve the source) so they leave the machine lane and reach the
+ * human inbox; the rest are returned to ride in as before.
+ *
+ * Best-effort per filing: a promotion failure is logged and the filing is left
+ * to ride (it will be retried next spawn), never thrown -- reconciling must never
+ * block a spawn. This is the single entry point the spawn path calls instead of
+ * listOpenAgentResolvableForFocus.
+ */
+export async function reconcileAgentResolvableForFocus(ctx, deps = {}) {
+    const d = { ...defaultDeps(), ...deps };
+    const open = await d.listOpen(ctx.focusId);
+    const { ride, promote } = partitionAgentResolvableByAge(open, d.now(), d.thresholdMs);
+    for (const item of promote) {
+        const ageHours = Math.max(1, Math.floor((d.now() - Date.parse(item.createdAt)) / 3_600_000));
+        try {
+            const result = await d.file(buildAgentResolvablePromotionParams(item, ctx, ageHours));
+            // Only retire the machine-routed row once the human-facing refile is in
+            // place (filed OR already suppressed by a prior promotion) -- never resolve
+            // the source without a landing spot, which would drop the signal entirely.
+            if (result.filed || result.suppressed) {
+                await d.markResolved(item.id, `Promoted to a needs_operator escalation after ~${ageHours}h open without ` +
+                    `autonomous resolution (agent_resolvable -> needs_operator).`);
+                log.info(`[escalations] Promoted agent_resolvable ${item.id} to needs_operator (focus ${ctx.focusId}, ~${ageHours}h)`);
+            }
+        }
+        catch (err) {
+            log.warn(`[escalations] Failed to promote agent_resolvable ${item.id} for focus ${ctx.focusId}: ${err.message}`);
+            // Leave it to ride this spawn; next reconcile retries the promotion.
+            ride.push(item);
+        }
+    }
+    return ride;
+}
+//# sourceMappingURL=agent-resolvable-promotion.js.map

package/dist/queries/agent-resolvable-promotion.js.map

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

package/dist/queries/cause-key.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Deterministic escalation cause keys (PURE, no I/O).
+ *
+ * An escalation's CAUSE KEY identifies the underlying cause a detector observed,
+ * derived from the escalation's kind plus its identifying SUBJECT. Two filings
+ * with the same cause key are about the same underlying fact; the idempotent
+ * filing gate (queries/escalation-suppression.ts) uses the key so one cause
+ * appears in the inbox at most once while unresolved, and a dismissed cause stays
+ * silent until its subject state actually changes.
+ *
+ * The key encodes the subject, so "the subject state changed" is expressed
+ * simply: a new subject (a new sha going red) yields a DIFFERENT key and re-files
+ * naturally, while the same subject (the same sha re-observed) yields the SAME
+ * key and is suppressed. This is what makes dismissal-memory fall out of a plain
+ * string comparison instead of a bespoke diff.
+ *
+ * Recipes (from the focus "An escalation is a verdict, not a log line"):
+ *   - ci_run_red                                  -> sha + branch
+ *   - verify_gate_unclearable / verify_evidence_unavailable -> deliveryId + guard
+ *   - stuck_focus_branch / wedged_focus (stuck/wedged detectors) -> focusId + blockage kind
+ *   - team_failure (team-exit filings)            -> focusId + session-exit marker
+ */
+/** A subject is a flat bag of identifying strings (nullable/undefined dropped). */
+export type CauseKeySubject = Record<string, string | null | undefined>;
+/**
+ * Compute a deterministic cause key from a kind + subject bag.
+ *
+ * Deterministic and order-insensitive: the subject entries are sorted by key, so
+ * `{sha, branch}` and `{branch, sha}` yield the same key. Null/undefined values
+ * are dropped (an absent subject field never changes the key vs. omitting it).
+ * Same (kind, subject) -> same key; any changed subject value -> different key.
+ */
+export declare function computeCauseKey(kind: string, subject: CauseKeySubject): string;
+/** ci_run_red: keyed on the sha + branch the red CI run belongs to. */
+export declare function ciRunRedCauseKey(sha: string, branch: string): string;
+/**
+ * verify_gate_unclearable / verify_evidence_unavailable and any other
+ * delivery+guard detector: keyed on the delivery and (optionally) the blocking
+ * guard. Omit `guard` for a strictly PER-DELIVERY key: both stall detectors file
+ * at most one open row per delivery regardless of which guard is blocking, so
+ * they key on the delivery alone (a per-guard key would let a guard-name change
+ * re-file). Detectors that genuinely differ by guard pass it through.
+ */
+export declare function deliveryGuardCauseKey(kind: string, deliveryId: string, guard?: string): string;
+/**
+ * stuck/wedged focus detectors (stuck_focus_branch, wedged_focus, ...): keyed on
+ * the focus and the kind of blockage observed.
+ */
+export declare function focusBlockageCauseKey(kind: string, focusId: string, blockage: string): string;
+/**
+ * team-exit filings (team_failure): keyed on the focus and a session-exit marker
+ * so one blocked team exit collapses to a single cause key regardless of how many
+ * partial filings a team attempts (the burst pattern).
+ */
+export declare function teamExitCauseKey(focusId: string, sessionExit: string): string;
+/**
+ * daemon-staleness handover (propagation_stale): keyed on the specific version
+ * gap (running + newest). A per-daemon singleton signal -- one running version --
+ * so it needs no product/focus in the key. A dismissal silences THIS exact gap;
+ * when `newest` advances (a different gap) it re-files, and a catch-up simply
+ * stops the signal (auto-resolved).
+ */
+export declare function daemonStalenessCauseKey(running: string, newest: string): string;
+//# sourceMappingURL=cause-key.d.ts.map

package/dist/queries/cause-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cause-key.d.ts","sourceRoot":"","sources":["../../src/queries/cause-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,mFAAmF;AACnF,MAAM,MAAM,eAAe,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAC,CAAC;AAExE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,MAAM,CAM9E;AAID,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEpE;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9F;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE/E"}

package/dist/queries/cause-key.js

@@ -0,0 +1,79 @@
+/**
+ * Deterministic escalation cause keys (PURE, no I/O).
+ *
+ * An escalation's CAUSE KEY identifies the underlying cause a detector observed,
+ * derived from the escalation's kind plus its identifying SUBJECT. Two filings
+ * with the same cause key are about the same underlying fact; the idempotent
+ * filing gate (queries/escalation-suppression.ts) uses the key so one cause
+ * appears in the inbox at most once while unresolved, and a dismissed cause stays
+ * silent until its subject state actually changes.
+ *
+ * The key encodes the subject, so "the subject state changed" is expressed
+ * simply: a new subject (a new sha going red) yields a DIFFERENT key and re-files
+ * naturally, while the same subject (the same sha re-observed) yields the SAME
+ * key and is suppressed. This is what makes dismissal-memory fall out of a plain
+ * string comparison instead of a bespoke diff.
+ *
+ * Recipes (from the focus "An escalation is a verdict, not a log line"):
+ *   - ci_run_red                                  -> sha + branch
+ *   - verify_gate_unclearable / verify_evidence_unavailable -> deliveryId + guard
+ *   - stuck_focus_branch / wedged_focus (stuck/wedged detectors) -> focusId + blockage kind
+ *   - team_failure (team-exit filings)            -> focusId + session-exit marker
+ */
+/**
+ * Compute a deterministic cause key from a kind + subject bag.
+ *
+ * Deterministic and order-insensitive: the subject entries are sorted by key, so
+ * `{sha, branch}` and `{branch, sha}` yield the same key. Null/undefined values
+ * are dropped (an absent subject field never changes the key vs. omitting it).
+ * Same (kind, subject) -> same key; any changed subject value -> different key.
+ */
+export function computeCauseKey(kind, subject) {
+    const parts = Object.entries(subject)
+        .filter(([, v]) => v !== null && v !== undefined && v !== '')
+        .map(([k, v]) => `${k}=${v}`)
+        .sort();
+    return `${kind}::${parts.join('|')}`;
+}
+// ── Named recipes (one per detector family) ──────────────────────────
+/** ci_run_red: keyed on the sha + branch the red CI run belongs to. */
+export function ciRunRedCauseKey(sha, branch) {
+    return computeCauseKey('ci_run_red', { sha, branch });
+}
+/**
+ * verify_gate_unclearable / verify_evidence_unavailable and any other
+ * delivery+guard detector: keyed on the delivery and (optionally) the blocking
+ * guard. Omit `guard` for a strictly PER-DELIVERY key: both stall detectors file
+ * at most one open row per delivery regardless of which guard is blocking, so
+ * they key on the delivery alone (a per-guard key would let a guard-name change
+ * re-file). Detectors that genuinely differ by guard pass it through.
+ */
+export function deliveryGuardCauseKey(kind, deliveryId, guard) {
+    return computeCauseKey(kind, { deliveryId, guard });
+}
+/**
+ * stuck/wedged focus detectors (stuck_focus_branch, wedged_focus, ...): keyed on
+ * the focus and the kind of blockage observed.
+ */
+export function focusBlockageCauseKey(kind, focusId, blockage) {
+    return computeCauseKey(kind, { focusId, blockage });
+}
+/**
+ * team-exit filings (team_failure): keyed on the focus and a session-exit marker
+ * so one blocked team exit collapses to a single cause key regardless of how many
+ * partial filings a team attempts (the burst pattern).
+ */
+export function teamExitCauseKey(focusId, sessionExit) {
+    return computeCauseKey('team_failure', { focusId, sessionExit });
+}
+/**
+ * daemon-staleness handover (propagation_stale): keyed on the specific version
+ * gap (running + newest). A per-daemon singleton signal -- one running version --
+ * so it needs no product/focus in the key. A dismissal silences THIS exact gap;
+ * when `newest` advances (a different gap) it re-files, and a catch-up simply
+ * stops the signal (auto-resolved).
+ */
+export function daemonStalenessCauseKey(running, newest) {
+    return computeCauseKey('propagation_stale', { running, newest });
+}
+//# sourceMappingURL=cause-key.js.map

package/dist/queries/cause-key.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cause-key.js","sourceRoot":"","sources":["../../src/queries/cause-key.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,IAAY,EAAE,OAAwB;IACpE,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;SAClC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,CAAC;SAC5D,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;SAC5B,IAAI,EAAE,CAAC;IACV,OAAO,GAAG,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;AACvC,CAAC;AAED,wEAAwE;AAExE,uEAAuE;AACvE,MAAM,UAAU,gBAAgB,CAAC,GAAW,EAAE,MAAc;IAC1D,OAAO,eAAe,CAAC,YAAY,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY,EAAE,UAAkB,EAAE,KAAc;IACpF,OAAO,eAAe,CAAC,IAAI,EAAE,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC,CAAC;AACtD,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,qBAAqB,CAAC,IAAY,EAAE,OAAe,EAAE,QAAgB;IACnF,OAAO,eAAe,CAAC,IAAI,EAAE,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,CAAC;AACtD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAe,EAAE,WAAmB;IACnE,OAAO,eAAe,CAAC,cAAc,EAAE,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CAAC;AACnE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,OAAe,EAAE,MAAc;IACrE,OAAO,eAAe,CAAC,mBAAmB,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;AACnE,CAAC"}

package/dist/queries/escalation-suppression.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Cause-keyed escalation suppression + idempotent filing.
+ *
+ * Generalizes the narrow per-delivery precedent (hasOpenEscalationForDelivery in
+ * queries/issues.ts) to EVERY daemon detector via a deterministic cause key
+ * (queries/cause-key.ts). Two properties, both DB-backed so they survive a daemon
+ * restart:
+ *
+ *   1. Idempotent while open. While a filing carrying this cause key is OPEN
+ *      (pending or in_review), a detector re-observing the same cause does not
+ *      file again -- across ticks, restarts, and detector kinds.
+ *
+ *   2. Dismissal memory. A DISMISSED filing carrying this cause key keeps the
+ *      cause silent: the same cause cannot re-file until its subject state
+ *      changes. Because the subject is encoded IN the cause key, a changed subject
+ *      (a NEW sha going red) yields a DIFFERENT key with no matching dismissed row
+ *      and re-files naturally; the SAME sha re-observed yields the SAME key and is
+ *      suppressed no matter how many scans re-observe it.
+ *
+ * A RESOLVED filing does NOT suppress: resolve means the cause was addressed, so a
+ * recurrence should re-file. This is achieved simply by excluding 'resolved' from
+ * the suppression status set below.
+ *
+ * The cause key is stamped into agent_escalations.metadata.cause_key at file time.
+ * metadata JSONB is already persisted by escalation_create and returned by
+ * escalation_list, so this stays entirely daemon-side -- no migration or edge
+ * change is required (the AC's sanctioned "the cause key can live in metadata plus
+ * a suppression check at file time" path).
+ */
+import { createEscalation, type CreateEscalationParams } from './issues.js';
+/** Minimal escalation row shape the cause-key suppression check reads. */
+interface CauseKeyEscalationRow {
+    id: string;
+    status?: string | null;
+    metadata?: Record<string, unknown> | null;
+}
+/**
+ * Dependency seam. The real implementations query the Telora API / file via
+ * createEscalation; tests inject stubs to avoid the fragile bare-specifier
+ * `mock.module` path under tsx (same rationale as the stall-detectors /
+ * verification-feedback deps seams).
+ */
+export interface EscalationSuppressionDeps {
+    /** Fetch the open+dismissed escalation rows to scan for a matching cause key. */
+    listSuppressingEscalations?: (opts: {
+        focusId?: string;
+    }) => Promise<CauseKeyEscalationRow[]>;
+    /** File a fresh escalation (defaults to the real createEscalation). */
+    createEscalation?: typeof createEscalation;
+}
+/**
+ * True when an OPEN (pending/in_review) or DISMISSED escalation already carries
+ * this cause key -- i.e. a new filing for the same cause must be suppressed.
+ *
+ * Narrows server-side by open+dismissed statuses (and by focusId when supplied,
+ * honored by the live escalation_list handler) so the 500-row page is scoped to
+ * the relevant rows rather than the org's newest 500. The cause-key match itself
+ * is client-side because cause_key lives in metadata JSONB, not a column.
+ */
+export declare function hasSuppressedCauseKey(causeKey: string, opts?: {
+    focusId?: string;
+}, deps?: EscalationSuppressionDeps): Promise<boolean>;
+/** Params for an idempotent, cause-keyed filing. */
+export interface FileEscalationIdempotentParams extends CreateEscalationParams {
+    /** The deterministic cause key (queries/cause-key.ts). Stamped into metadata.cause_key. */
+    causeKey: string;
+}
+/** Outcome of an idempotent filing attempt. */
+export interface FileEscalationIdempotentResult {
+    /** Whether a new escalation row was created this call. */
+    filed: boolean;
+    /** Whether the call was suppressed by an existing open/dismissed cause-key row. */
+    suppressed: boolean;
+    /** The new escalation id when filed; null when suppressed or the create returned no id. */
+    escalationId: string | null;
+}
+/**
+ * File an escalation ONLY if its cause key is not already suppressed (open or
+ * dismissed). The cause key is stamped into metadata.cause_key so a later
+ * re-observation of the same cause is suppressed by hasSuppressedCauseKey.
+ *
+ * This is the single filing entry point every daemon detector should route
+ * through. It replaces per-detector ad-hoc dedup (hasOpenEscalationForDelivery,
+ * hasOpenWorktreeDirtyEscalation, hasOpenWedgedFocusEscalation, in-memory Sets)
+ * with one cause-keyed gate that also carries dismissal memory.
+ */
+export declare function fileEscalationIdempotent(params: FileEscalationIdempotentParams, deps?: EscalationSuppressionDeps): Promise<FileEscalationIdempotentResult>;
+export {};
+//# sourceMappingURL=escalation-suppression.d.ts.map

package/dist/queries/escalation-suppression.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-suppression.d.ts","sourceRoot":"","sources":["../../src/queries/escalation-suppression.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAGH,OAAO,EAAE,gBAAgB,EAAE,KAAK,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAY5E,0EAA0E;AAC1E,UAAU,qBAAqB;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CAC3C;AAED;;;;;GAKG;AACH,MAAM,WAAW,yBAAyB;IACxC,iFAAiF;IACjF,0BAA0B,CAAC,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAAC;IAC9F,uEAAuE;IACvE,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAC;CAC5C;AAsBD;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,IAAI,GAAE;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAO,EAC/B,IAAI,GAAE,yBAA8B,GACnC,OAAO,CAAC,OAAO,CAAC,CAOlB;AAED,oDAAoD;AACpD,MAAM,WAAW,8BAA+B,SAAQ,sBAAsB;IAC5E,2FAA2F;IAC3F,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,+CAA+C;AAC/C,MAAM,WAAW,8BAA8B;IAC7C,0DAA0D;IAC1D,KAAK,EAAE,OAAO,CAAC;IACf,mFAAmF;IACnF,UAAU,EAAE,OAAO,CAAC;IACpB,2FAA2F;IAC3F,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAED;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,8BAA8B,EACtC,IAAI,GAAE,yBAA8B,GACnC,OAAO,CAAC,8BAA8B,CAAC,CAmBzC"}

package/dist/queries/escalation-suppression.js

@@ -0,0 +1,98 @@
+/**
+ * Cause-keyed escalation suppression + idempotent filing.
+ *
+ * Generalizes the narrow per-delivery precedent (hasOpenEscalationForDelivery in
+ * queries/issues.ts) to EVERY daemon detector via a deterministic cause key
+ * (queries/cause-key.ts). Two properties, both DB-backed so they survive a daemon
+ * restart:
+ *
+ *   1. Idempotent while open. While a filing carrying this cause key is OPEN
+ *      (pending or in_review), a detector re-observing the same cause does not
+ *      file again -- across ticks, restarts, and detector kinds.
+ *
+ *   2. Dismissal memory. A DISMISSED filing carrying this cause key keeps the
+ *      cause silent: the same cause cannot re-file until its subject state
+ *      changes. Because the subject is encoded IN the cause key, a changed subject
+ *      (a NEW sha going red) yields a DIFFERENT key with no matching dismissed row
+ *      and re-files naturally; the SAME sha re-observed yields the SAME key and is
+ *      suppressed no matter how many scans re-observe it.
+ *
+ * A RESOLVED filing does NOT suppress: resolve means the cause was addressed, so a
+ * recurrence should re-file. This is achieved simply by excluding 'resolved' from
+ * the suppression status set below.
+ *
+ * The cause key is stamped into agent_escalations.metadata.cause_key at file time.
+ * metadata JSONB is already persisted by escalation_create and returned by
+ * escalation_list, so this stays entirely daemon-side -- no migration or edge
+ * change is required (the AC's sanctioned "the cause key can live in metadata plus
+ * a suppression check at file time" path).
+ */
+import { callApi } from './shared.js';
+import { createEscalation } from './issues.js';
+import { createLogger } from '../log.js';
+const log = createLogger({ module: 'escalations' });
+/**
+ * Statuses that SUPPRESS a re-file for a cause key: OPEN (pending/in_review)
+ * gives idempotency-while-open; DISMISSED gives dismissal-memory. 'resolved' is
+ * deliberately ABSENT -- a resolved cause may recur and should re-file.
+ */
+const SUPPRESSING_STATUSES = ['pending', 'in_review', 'dismissed'];
+async function defaultListSuppressingEscalations(opts) {
+    const result = await callApi('escalation_list', {
+        fields: {
+            statuses: SUPPRESSING_STATUSES,
+            ...(opts.focusId ? { focusId: opts.focusId } : {}),
+        },
+        limit: 500,
+    });
+    return result.escalations ?? [];
+}
+/** Read metadata.cause_key off a row, tolerating the loose JSONB shape. */
+function rowCauseKey(row) {
+    const meta = row.metadata ?? null;
+    const key = meta?.cause_key;
+    return typeof key === 'string' ? key : null;
+}
+/**
+ * True when an OPEN (pending/in_review) or DISMISSED escalation already carries
+ * this cause key -- i.e. a new filing for the same cause must be suppressed.
+ *
+ * Narrows server-side by open+dismissed statuses (and by focusId when supplied,
+ * honored by the live escalation_list handler) so the 500-row page is scoped to
+ * the relevant rows rather than the org's newest 500. The cause-key match itself
+ * is client-side because cause_key lives in metadata JSONB, not a column.
+ */
+export async function hasSuppressedCauseKey(causeKey, opts = {}, deps = {}) {
+    const list = deps.listSuppressingEscalations ?? defaultListSuppressingEscalations;
+    const rows = await list({ focusId: opts.focusId });
+    return rows.some((e) => {
+        if (e.status && !SUPPRESSING_STATUSES.includes(e.status))
+            return false;
+        return rowCauseKey(e) === causeKey;
+    });
+}
+/**
+ * File an escalation ONLY if its cause key is not already suppressed (open or
+ * dismissed). The cause key is stamped into metadata.cause_key so a later
+ * re-observation of the same cause is suppressed by hasSuppressedCauseKey.
+ *
+ * This is the single filing entry point every daemon detector should route
+ * through. It replaces per-detector ad-hoc dedup (hasOpenEscalationForDelivery,
+ * hasOpenWorktreeDirtyEscalation, hasOpenWedgedFocusEscalation, in-memory Sets)
+ * with one cause-keyed gate that also carries dismissal memory.
+ */
+export async function fileEscalationIdempotent(params, deps = {}) {
+    const { causeKey, ...createParams } = params;
+    const _createEscalation = deps.createEscalation ?? createEscalation;
+    const suppressed = await hasSuppressedCauseKey(causeKey, { focusId: createParams.focusId ?? createParams.anchor?.focusId }, deps);
+    if (suppressed) {
+        log.info(`[escalations] Suppressed duplicate filing for cause key "${causeKey}" (open or dismissed row exists)`);
+        return { filed: false, suppressed: true, escalationId: null };
+    }
+    const { escalationId } = await _createEscalation({
+        ...createParams,
+        metadata: { ...(createParams.metadata ?? {}), cause_key: causeKey },
+    });
+    return { filed: true, suppressed: false, escalationId };
+}
+//# sourceMappingURL=escalation-suppression.js.map

package/dist/queries/escalation-suppression.js.map

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