@telora/daemon 0.22.239 → 0.22.289

package/dist/queries/escalations/escalation-field-bounds.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Bound every daemon escalation text field below the server's field limit.
+ *
+ * The escalation create endpoint (supabase/functions/_shared/validation.ts
+ * validateEscalationFields) refuses a description, whatWasTried or helpNeeded
+ * longer than ESCALATION_FIELD_MAX with a validation error that no resubmission
+ * can clear. Detector text embeds gate state -- failing-test lists, shortfall
+ * reasons, gate_state JSON -- whose length grows with the product's test suite,
+ * so a producer that composes blind sooner or later composes past the cap, and
+ * the filing (and the signal it carries) is lost. The chokepoint
+ * (supervision/escalation-filing.ts createEscalation) therefore fits EVERY field it sends
+ * through boundEscalationFields, whatever produced it.
+ *
+ * An over-cap field keeps its HEAD (where producers state the delivery and the
+ * cause) and its TAIL (where they point at the full detail, e.g. a log path),
+ * cuts the middle, and says so in-line: that it was shortened, from how many
+ * characters, and where the full text is. Producers that can summarize better
+ * than a middle cut (supervision/verify-gate-stall.ts) fit themselves first; this is
+ * the floor no path can go under.
+ *
+ * Pure; no imports.
+ */
+/** The server-side cap on each escalation text field (description, whatWasTried, helpNeeded). */
+export declare const ESCALATION_FIELD_MAX = 5000;
+/** The description cap. The same number as every other field; named for producers that fit a description. */
+export declare const ESCALATION_DESCRIPTION_MAX = 5000;
+/** The in-line note an over-cap field carries in place of its cut middle. */
+export declare function shortenedMarker(originalLength: number, cap?: number): string;
+/**
+ * Pure: fit one field under `cap`. A field at or under the cap is returned
+ * unchanged; an over-cap field keeps its head and tail around shortenedMarker.
+ * The result's length is always <= cap.
+ */
+export declare function boundEscalationField(text: string, cap?: number): string;
+/** The text fields a filing sends. */
+export interface EscalationTextFields {
+    description: string;
+    whatWasTried: string | undefined;
+    helpNeeded: string | undefined;
+}
+/** The bounded fields, plus the original length of each field that had to be shortened. */
+export interface BoundedEscalationFields extends EscalationTextFields {
+    /** field name -> original length, for every field that was shortened; empty when none was. */
+    shortened: Record<string, number>;
+}
+/** Pure: fit every text field of a filing under `cap`, recording which were shortened. */
+export declare function boundEscalationFields(fields: EscalationTextFields, cap?: number): BoundedEscalationFields;
+//# sourceMappingURL=escalation-field-bounds.d.ts.map

package/dist/queries/escalations/escalation-field-bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-field-bounds.d.ts","sourceRoot":"","sources":["../../../src/queries/escalations/escalation-field-bounds.ts"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,iGAAiG;AACjG,eAAO,MAAM,oBAAoB,OAAO,CAAC;AAEzC,6GAA6G;AAC7G,eAAO,MAAM,0BAA0B,OAAuB,CAAC;AAK/D,6EAA6E;AAC7E,wBAAgB,eAAe,CAAC,cAAc,EAAE,MAAM,EAAE,GAAG,GAAE,MAA6B,GAAG,MAAM,CAMlG;AASD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,GAAE,MAA6B,GAAG,MAAM,CAU7F;AAED,sCAAsC;AACtC,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;CAChC;AAED,2FAA2F;AAC3F,MAAM,WAAW,uBAAwB,SAAQ,oBAAoB;IACnE,8FAA8F;IAC9F,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACnC;AAED,0FAA0F;AAC1F,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,oBAAoB,EAC5B,GAAG,GAAE,MAA6B,GACjC,uBAAuB,CAazB"}

package/dist/queries/escalations/escalation-field-bounds.js

@@ -0,0 +1,84 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/queries/escalations/escalation-field-bounds.test.ts,
+//   packages/daemon/src/supervision/escalation-refusal.test.ts,
+//   packages/daemon/src/supervision/filing-chokepoint.test.ts,
+//   packages/daemon/src/supervision/stall-detectors.test.ts
+// PINNED-BY-END
+/**
+ * Bound every daemon escalation text field below the server's field limit.
+ *
+ * The escalation create endpoint (supabase/functions/_shared/validation.ts
+ * validateEscalationFields) refuses a description, whatWasTried or helpNeeded
+ * longer than ESCALATION_FIELD_MAX with a validation error that no resubmission
+ * can clear. Detector text embeds gate state -- failing-test lists, shortfall
+ * reasons, gate_state JSON -- whose length grows with the product's test suite,
+ * so a producer that composes blind sooner or later composes past the cap, and
+ * the filing (and the signal it carries) is lost. The chokepoint
+ * (supervision/escalation-filing.ts createEscalation) therefore fits EVERY field it sends
+ * through boundEscalationFields, whatever produced it.
+ *
+ * An over-cap field keeps its HEAD (where producers state the delivery and the
+ * cause) and its TAIL (where they point at the full detail, e.g. a log path),
+ * cuts the middle, and says so in-line: that it was shortened, from how many
+ * characters, and where the full text is. Producers that can summarize better
+ * than a middle cut (supervision/verify-gate-stall.ts) fit themselves first; this is
+ * the floor no path can go under.
+ *
+ * Pure; no imports.
+ */
+/** The server-side cap on each escalation text field (description, whatWasTried, helpNeeded). */
+export const ESCALATION_FIELD_MAX = 5000;
+/** The description cap. The same number as every other field; named for producers that fit a description. */
+export const ESCALATION_DESCRIPTION_MAX = ESCALATION_FIELD_MAX;
+/** Share of the kept budget given to the head; the rest keeps the tail. */
+const HEAD_SHARE = 0.7;
+/** The in-line note an over-cap field carries in place of its cut middle. */
+export function shortenedMarker(originalLength, cap = ESCALATION_FIELD_MAX) {
+    return (`\n\n[... shortened by the daemon to fit the ${cap}-character escalation field limit ` +
+        `(original ${originalLength} characters); the full text was written to the daemon log ` +
+        `(telora-daemon logs) when this escalation was filed ...]\n\n`);
+}
+/** True when index `i` would split a UTF-16 surrogate pair. */
+function splitsSurrogatePair(text, i) {
+    if (i <= 0 || i >= text.length)
+        return false;
+    const prev = text.charCodeAt(i - 1);
+    return prev >= 0xd800 && prev <= 0xdbff;
+}
+/**
+ * Pure: fit one field under `cap`. A field at or under the cap is returned
+ * unchanged; an over-cap field keeps its head and tail around shortenedMarker.
+ * The result's length is always <= cap.
+ */
+export function boundEscalationField(text, cap = ESCALATION_FIELD_MAX) {
+    if (text.length <= cap)
+        return text;
+    const marker = shortenedMarker(text.length, cap);
+    const budget = cap - marker.length;
+    if (budget <= 0)
+        return marker.slice(0, cap);
+    let head = Math.ceil(budget * HEAD_SHARE);
+    if (splitsSurrogatePair(text, head))
+        head -= 1;
+    let tailStart = text.length - (budget - head);
+    if (splitsSurrogatePair(text, tailStart))
+        tailStart += 1;
+    return `${text.slice(0, head)}${marker}${text.slice(tailStart)}`;
+}
+/** Pure: fit every text field of a filing under `cap`, recording which were shortened. */
+export function boundEscalationFields(fields, cap = ESCALATION_FIELD_MAX) {
+    const shortened = {};
+    const fit = (name, value) => {
+        if (value === undefined || value.length <= cap)
+            return value;
+        shortened[name] = value.length;
+        return boundEscalationField(value, cap);
+    };
+    return {
+        description: fit('description', fields.description),
+        whatWasTried: fit('whatWasTried', fields.whatWasTried),
+        helpNeeded: fit('helpNeeded', fields.helpNeeded),
+        shortened,
+    };
+}
+//# sourceMappingURL=escalation-field-bounds.js.map

package/dist/queries/escalations/escalation-field-bounds.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-field-bounds.js","sourceRoot":"","sources":["../../../src/queries/escalations/escalation-field-bounds.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,sFAAsF;AACtF,gEAAgE;AAChE,+DAA+D;AAC/D,4DAA4D;AAC5D,gBAAgB;AAEhB;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,iGAAiG;AACjG,MAAM,CAAC,MAAM,oBAAoB,GAAG,IAAI,CAAC;AAEzC,6GAA6G;AAC7G,MAAM,CAAC,MAAM,0BAA0B,GAAG,oBAAoB,CAAC;AAE/D,2EAA2E;AAC3E,MAAM,UAAU,GAAG,GAAG,CAAC;AAEvB,6EAA6E;AAC7E,MAAM,UAAU,eAAe,CAAC,cAAsB,EAAE,MAAc,oBAAoB;IACxF,OAAO,CACL,+CAA+C,GAAG,oCAAoC;QACtF,aAAa,cAAc,4DAA4D;QACvF,8DAA8D,CAC/D,CAAC;AACJ,CAAC;AAED,+DAA+D;AAC/D,SAAS,mBAAmB,CAAC,IAAY,EAAE,CAAS;IAClD,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM;QAAE,OAAO,KAAK,CAAC;IAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;IACpC,OAAO,IAAI,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,CAAC;AAC1C,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY,EAAE,MAAc,oBAAoB;IACnF,IAAI,IAAI,CAAC,MAAM,IAAI,GAAG;QAAE,OAAO,IAAI,CAAC;IACpC,MAAM,MAAM,GAAG,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjD,MAAM,MAAM,GAAG,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;IACnC,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;IAC7C,IAAI,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,CAAC;IAC1C,IAAI,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC;QAAE,IAAI,IAAI,CAAC,CAAC;IAC/C,IAAI,SAAS,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IAC9C,IAAI,mBAAmB,CAAC,IAAI,EAAE,SAAS,CAAC;QAAE,SAAS,IAAI,CAAC,CAAC;IACzD,OAAO,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,CAAC;AACnE,CAAC;AAeD,0FAA0F;AAC1F,MAAM,UAAU,qBAAqB,CACnC,MAA4B,EAC5B,MAAc,oBAAoB;IAElC,MAAM,SAAS,GAA2B,EAAE,CAAC;IAC7C,MAAM,GAAG,GAAG,CAA+B,IAAY,EAAE,KAAQ,EAAK,EAAE;QACtE,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,IAAI,GAAG;YAAE,OAAO,KAAK,CAAC;QAC7D,SAAS,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,CAAC;QAC/B,OAAO,oBAAoB,CAAC,KAAK,EAAE,GAAG,CAAM,CAAC;IAC/C,CAAC,CAAC;IACF,OAAO;QACL,WAAW,EAAE,GAAG,CAAC,aAAa,EAAE,MAAM,CAAC,WAAW,CAAC;QACnD,YAAY,EAAE,GAAG,CAAC,cAAc,EAAE,MAAM,CAAC,YAAY,CAAC;QACtD,UAAU,EAAE,GAAG,CAAC,YAAY,EAAE,MAAM,CAAC,UAAU,CAAC;QAChD,SAAS;KACV,CAAC;AACJ,CAAC"}

package/dist/queries/escalations/escalation-provenance.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Whatever a creation site holds when it files an escalation. Every field is
+ * optional; a site passes the subset it knows. The resolver derives the rest.
+ */
+export interface EscalationAnchor {
+    /** A delivery id (org_node, type='delivery'). The richest anchor. */
+    deliveryId?: string;
+    /** A focus id (product_focuses). */
+    focusId?: string;
+    /** An issue id (resolved to its delivery, then as a delivery). */
+    issueId?: string;
+    /** An agent session id (resolved to its delivery/focus). */
+    sessionId?: string;
+    /** A git branch name (best-effort: resolved via a session carrying it). */
+    branch?: string;
+}
+/** First-class provenance derived from an anchor. */
+export interface ResolvedProvenance {
+    productId?: string;
+    focusId?: string;
+    deliveryId?: string;
+}
+/**
+ * Derive first-class provenance from whatever anchor a creation site holds.
+ *
+ * Resolution precedence (richest first): deliveryId > issueId > sessionId >
+ * branch > focusId. A more specific anchor implies the broader scopes, so the
+ * first resolvable anchor wins and we stop. focusId, when also supplied, is
+ * merged in as a floor (it never gets clobbered to a worse value).
+ *
+ * NEVER throws -- returns {} when nothing resolves.
+ */
+export declare function resolveProvenance(anchor: EscalationAnchor): Promise<ResolvedProvenance>;
+//# sourceMappingURL=escalation-provenance.d.ts.map

package/dist/queries/escalations/escalation-provenance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"escalation-provenance.d.ts","sourceRoot":"","sources":["../../../src/queries/escalations/escalation-provenance.ts"],"names":[],"mappings":"AA4CA;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,oCAAoC;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,qDAAqD;AACrD,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAoHD;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,MAAM,EAAE,gBAAgB,GACvB,OAAO,CAAC,kBAAkB,CAAC,CA2C7B"}

package/dist/queries/escalations/escalation-provenance.js

@@ -0,0 +1,208 @@
+// PINNED-BY-BEGIN (generated by gen:pinned-by -- do not hand-edit; checked by lint:pinned-by)
+// Pinned by: packages/daemon/src/completion/completion-event/non-advanceable-thrash-guard.test.ts,
+//   packages/daemon/src/queries/escalations/escalation-provenance.test.ts
+// PINNED-BY-END
+/**
+ * Central escalation-provenance resolver.
+ *
+ * ONE helper derives {productId, focusId,
+ * deliveryId} from whatever anchor a creation site holds, so the shared
+ * createEscalation path can stamp the first-class provenance columns on
+ * agent_escalations. No site can file an anonymous escalation by
+ * construction -- it passes whatever anchor it has and the resolver fills
+ * in the rest.
+ *
+ * Derivation facts (the schema this depends on):
+ *   - A delivery IS an org_node carrying product_id + focus_id.
+ *   - A focus carries product_id.
+ * So:
+ *   - deliveryId -> resolve the delivery context to get focusId + productId.
+ *   - focusId    -> resolve focus to productId (best-effort via the
+ *                   active-focus listing; the focusId is always set verbatim).
+ *   - issueId    -> resolve issue.deliveryId, then treat as a delivery.
+ *   - sessionId  -> resolve the session row to its deliveryId/focusId.
+ *   - branch     -> best-effort via the session row carrying that branch; when
+ *                   no active session matches (e.g. crash recovery, where the
+ *                   owning session is already dead), fall back to the 8-char
+ *                   focus-key suffix encoded in the branch name and match it
+ *                   against the active focuses.
+ *
+ * INVARIANT: resolveProvenance NEVER throws. A missing/unresolvable anchor
+ * returns {} (or whatever partial provenance it could derive). Provenance is
+ * signal enrichment, not control flow -- a lookup failure must never abort
+ * the escalation it accompanies.
+ */
+import { getDeliveryContext, getIssueDelivery } from '../deliveries/deliveries.js';
+import { getActiveFocuses } from '../focuses/focus-discovery.js';
+import { getActiveSessions, daemonHostname } from '../sessions/sessions.js';
+import { createLogger } from '../../log/daemon-log.js';
+const log = createLogger({ module: 'escalation-provenance' });
+/**
+ * Resolve a delivery id to {productId, focusId, deliveryId}. Best-effort:
+ * returns at least { deliveryId } even when the context lookup fails.
+ */
+async function fromDelivery(deliveryId) {
+    const out = { deliveryId };
+    try {
+        const ctx = await getDeliveryContext(deliveryId);
+        if (ctx) {
+            // Delivery is transformed to the snake_case Delivery domain type
+            // (product_id); focus is the camelCase API shape (id).
+            if (ctx.delivery?.product_id)
+                out.productId = ctx.delivery.product_id ?? undefined;
+            const focusId = ctx.focus?.id;
+            if (focusId)
+                out.focusId = focusId;
+        }
+    }
+    catch (err) {
+        // Best-effort: keep the delivery id; leave focus/product unset.
+        log.debug('Best-effort: keep the delivery id; leave focus/product unset', { error: String(err?.message ?? err) });
+    }
+    return out;
+}
+/**
+ * Resolve a focus id to {productId, focusId}. Best-effort: the focusId is
+ * always returned; productId is filled when the active-focus listing carries
+ * it. (There is no single-focus getter in the query layer; this derives the
+ * product from the focuses the daemon already enumerates.)
+ */
+async function fromFocus(focusId) {
+    const out = { focusId };
+    try {
+        const focuses = await getActiveFocuses('');
+        const match = focuses.find((f) => f.focus_id === focusId);
+        if (match?.product_id)
+            out.productId = match.product_id;
+    }
+    catch (err) {
+        // Best-effort: keep the focus id; leave product unset.
+        log.debug('Best-effort: keep the focus id; leave product unset', { error: String(err?.message ?? err) });
+    }
+    return out;
+}
+/**
+ * Extract the 8-char focus-key suffix from an agent branch name
+ * (agent/<role>/<slug>-<8hexfocuskey>). Mirrors the parser crash-recovery uses
+ * off the worktree dir name; kept local so provenance has no back-dependency on
+ * the crash-recovery module.
+ */
+function focusKeyFromBranch(branch) {
+    const lastSegment = branch.split('/').pop() ?? branch;
+    const match = lastSegment.match(/-([0-9a-f]{8})$/);
+    return match ? match[1] : null;
+}
+/**
+ * Best-effort resolution of a branch's owning focus via its focus-key suffix,
+ * matched against the active focuses. Returns {} when the key cannot be parsed
+ * or no active focus carries it (e.g. an orphan whose focus is inactive -- that
+ * case is resolved upstream by the productId-scoped resolver and passed in as an
+ * explicit focusId instead).
+ */
+async function fromBranchFocusKey(branch) {
+    const focusKey = focusKeyFromBranch(branch);
+    if (!focusKey)
+        return {};
+    try {
+        const focuses = await getActiveFocuses('');
+        const match = focuses.find((f) => f.focus_id.startsWith(focusKey));
+        if (!match)
+            return {};
+        // Reuse fromFocus so productId is backfilled from the same listing.
+        return await fromFocus(match.focus_id);
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Resolve a session id (or a branch name) to its delivery/focus via the
+ * active-session listing, then enrich from the delivery. Best-effort. When a
+ * branch anchor matches no active session, fall back to the branch focus-key.
+ */
+async function fromSessionOrBranch(anchor) {
+    try {
+        // Scoped to this host: the session id / branch being resolved is one THIS
+        // daemon spawned, so its own live sessions are the only population that can
+        // match. A session-liveness read must name a scope (see SessionScope).
+        const sessions = await getActiveSessions({ daemonHostname: daemonHostname() });
+        const match = sessions.find((s) => (anchor.sessionId && s.id === anchor.sessionId) ||
+            (anchor.branch && s.branch_name === anchor.branch));
+        if (!match) {
+            // No live session carries this branch (the common crash-recovery case).
+            // Fall back to the focus-key encoded in the branch name.
+            return anchor.branch ? await fromBranchFocusKey(anchor.branch) : {};
+        }
+        if (match.delivery_id) {
+            // Delivery anchor is richest -- derive product/focus from it.
+            const fromDel = await fromDelivery(match.delivery_id);
+            // The session may carry a focus id even when the delivery context omits one.
+            if (!fromDel.focusId && match.focus_id)
+                fromDel.focusId = match.focus_id;
+            return fromDel;
+        }
+        const out = {};
+        if (match.focus_id) {
+            return { ...out, ...(await fromFocus(match.focus_id)) };
+        }
+        return out;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Derive first-class provenance from whatever anchor a creation site holds.
+ *
+ * Resolution precedence (richest first): deliveryId > issueId > sessionId >
+ * branch > focusId. A more specific anchor implies the broader scopes, so the
+ * first resolvable anchor wins and we stop. focusId, when also supplied, is
+ * merged in as a floor (it never gets clobbered to a worse value).
+ *
+ * NEVER throws -- returns {} when nothing resolves.
+ */
+export async function resolveProvenance(anchor) {
+    if (!anchor)
+        return {};
+    let resolved = {};
+    if (anchor.deliveryId) {
+        resolved = await fromDelivery(anchor.deliveryId);
+    }
+    else if (anchor.issueId) {
+        // Resolve issue -> delivery -> focus/product via the daemon_get_issue_delivery
+        // edge action. Best-effort: returns {} when the issue is not found.
+        try {
+            const issueDelivery = await getIssueDelivery(anchor.issueId);
+            if (issueDelivery) {
+                resolved = {
+                    deliveryId: issueDelivery.deliveryId,
+                    ...(issueDelivery.focusId ? { focusId: issueDelivery.focusId } : {}),
+                    ...(issueDelivery.productId ? { productId: issueDelivery.productId } : {}),
+                };
+            }
+        }
+        catch (err) {
+            // Best-effort: fall through with empty resolved.
+            log.debug('Best-effort: fall through with empty resolved', { error: String(err?.message ?? err) });
+        }
+    }
+    else if (anchor.sessionId || anchor.branch) {
+        resolved = await fromSessionOrBranch({ sessionId: anchor.sessionId, branch: anchor.branch });
+    }
+    // A directly supplied focusId is a floor: merge it in if resolution did not
+    // already produce one, and use it to backfill productId when missing.
+    if (!resolved.focusId && anchor.focusId) {
+        const fromF = await fromFocus(anchor.focusId);
+        // Prefer a resolved productId; otherwise take the focus-derived one. Build
+        // the result without ever introducing an explicit `productId: undefined`
+        // key (callers/tests treat absence and undefined differently).
+        const productId = resolved.productId ?? fromF.productId;
+        resolved = {
+            ...fromF,
+            ...resolved,
+            ...(productId !== undefined ? { productId } : {}),
+        };
+    }
+    return resolved;
+}
+//# sourceMappingURL=escalation-provenance.js.map

package/dist/queries/escalations/escalation-provenance.js.map

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

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

@@ -0,0 +1,259 @@
+/**
+ * Escalation queries: open-escalation dedup reads, and resolution.
+ *
+ * The filing chokepoint that CREATES a row (provenance, disposition routing,
+ * incident correlation, refusal memory) is supervision/escalation-filing.ts
+ * createEscalation, and the condition-cleared close-halves are
+ * supervision/escalation-clearing.ts; this module keeps the reads and the one
+ * resolve write they both build on. The issue CRUD lives in queries/deliveries/issues.ts.
+ *
+ * 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).
+ *
+ * History: docs/daemon/history-platform.md (queries/escalations/escalations.ts).
+ */
+import type { EscalationResolutionClass } from '@telora/daemon-core';
+/**
+ * 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(): Promise<PendingEscalation[]>;
+/** The team_failure row fields hasOpenTeamFailureEscalation reads (and hands a `holds` predicate). */
+export interface TeamFailureEscalationRow {
+    id: string;
+    status?: string | null;
+    escalationKind?: string | null;
+    focusId?: string | null;
+    metadata?: Record<string, unknown> | null;
+    disposition?: string | null;
+}
+/**
+ * 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, holds: (row: TeamFailureEscalationRow) => boolean): Promise<boolean>;
+/**
+ * DEDUP-only sibling of hasOpenTeamFailureEscalation, for the team_failure RE-FILE
+ * guards (completion/completion-event/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): 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[]): 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). Unlike
+ * hasOpenTeamFailureEscalation it takes no `holds` predicate (TEL-2): 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): 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.
+ * 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, opts?: {
+    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): 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): Promise<Array<{
+    id: string;
+    metadata: Record<string, unknown> | null;
+    disposition?: string | null;
+}>>;
+/**
+ * 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 (supervision/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): Promise<void>;
+//# sourceMappingURL=escalations.d.ts.map