@hotmeshio/long-tail 0.1.0

package/build/services/escalation/crud.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEscalation = createEscalation;
+exports.claimEscalation = claimEscalation;
+exports.resolveEscalation = resolveEscalation;
+exports.updateEscalationsPriority = updateEscalationsPriority;
+exports.getEscalationRoles = getEscalationRoles;
+exports.releaseEscalation = releaseEscalation;
+exports.releaseExpiredClaims = releaseExpiredClaims;
+exports.escalateToRole = escalateToRole;
+exports.getEscalation = getEscalation;
+exports.getEscalationsByTaskId = getEscalationsByTaskId;
+exports.getEscalationsByWorkflowId = getEscalationsByWorkflowId;
+exports.updateEscalationMetadata = updateEscalationMetadata;
+exports.enrichEscalationRouting = enrichEscalationRouting;
+exports.getEscalationsByOriginId = getEscalationsByOriginId;
+const db_1 = require("../db");
+const sql_1 = require("./sql");
+async function createEscalation(input) {
+    const pool = (0, db_1.getPool)();
+    // Ensure the role exists in lt_roles (FK constraint)
+    await pool.query(sql_1.ENSURE_ROLE_EXISTS, [input.role]);
+    const { rows } = await pool.query(sql_1.CREATE_ESCALATION, [
+        input.type,
+        input.subtype,
+        input.description || null,
+        input.priority || 2,
+        input.task_id || null,
+        input.origin_id || null,
+        input.parent_id || null,
+        input.role,
+        input.envelope,
+        input.metadata ? JSON.stringify(input.metadata) : null,
+        input.escalation_payload || null,
+        input.workflow_id || null,
+        input.task_queue || null,
+        input.workflow_type || null,
+        input.trace_id || null,
+        input.span_id || null,
+    ]);
+    return rows[0];
+}
+/**
+ * Atomic claim operation. Does NOT change status — "claimed" is implicit
+ * via assigned_to + assigned_until > NOW().
+ *
+ * Conditions:
+ * - status = 'pending' (not resolved/cancelled)
+ * - Either: unassigned, expired claim, or same user (extension)
+ *
+ * Uses a CTE to capture the previous state so callers can detect extensions.
+ */
+async function claimEscalation(id, userId, durationMinutes = 30) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.CLAIM_ESCALATION, [id, userId, durationMinutes]);
+    if (rows.length === 0)
+        return null;
+    const row = rows[0];
+    return {
+        escalation: row,
+        isExtension: row.prev_assigned_to === userId,
+    };
+}
+async function resolveEscalation(id, resolverPayload) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.RESOLVE_ESCALATION, [id, JSON.stringify(resolverPayload)]);
+    return rows[0] || null;
+}
+/**
+ * Bulk update priority for a set of escalations.
+ * Only updates pending escalations.
+ */
+async function updateEscalationsPriority(ids, priority) {
+    if (ids.length === 0)
+        return 0;
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(sql_1.UPDATE_ESCALATIONS_PRIORITY, [priority, ids]);
+    return rowCount ?? 0;
+}
+/**
+ * Get the distinct roles for a set of escalation IDs.
+ * Used for permission validation before bulk operations.
+ */
+async function getEscalationRoles(ids) {
+    if (ids.length === 0)
+        return [];
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ESCALATION_ROLES, [ids]);
+    return rows.map((r) => r.role);
+}
+/**
+ * Release a single escalation claim back to the available pool.
+ * Only the assigned user (or superadmin via route) may release.
+ */
+async function releaseEscalation(id, userId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.RELEASE_ESCALATION, [id, userId]);
+    return rows[0] || null;
+}
+async function releaseExpiredClaims() {
+    const pool = (0, db_1.getPool)();
+    const { rowCount } = await pool.query(sql_1.RELEASE_EXPIRED_CLAIMS);
+    return rowCount || 0;
+}
+/**
+ * Reassign an escalation to a different role.
+ * Clears the current assignment so it becomes available to the new role.
+ */
+async function escalateToRole(id, targetRole) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.ESCALATE_TO_ROLE, [id, targetRole]);
+    return rows[0] || null;
+}
+async function getEscalation(id) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ESCALATION, [id]);
+    return rows[0] || null;
+}
+async function getEscalationsByTaskId(taskId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ESCALATIONS_BY_TASK_ID, [taskId]);
+    return rows;
+}
+async function getEscalationsByWorkflowId(workflowId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ESCALATIONS_BY_WORKFLOW_ID, [workflowId]);
+    return rows;
+}
+async function updateEscalationMetadata(id, patch) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.UPDATE_ESCALATION_METADATA, [id, JSON.stringify(patch)]);
+    return rows[0] || null;
+}
+async function enrichEscalationRouting(id, metadataPatch, workflowFields) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.ENRICH_ESCALATION_ROUTING, [
+        id,
+        JSON.stringify(metadataPatch),
+        workflowFields.workflowType || null,
+        workflowFields.workflowId || null,
+        workflowFields.taskQueue || null,
+        workflowFields.taskId || null,
+    ]);
+    return rows[0] || null;
+}
+async function getEscalationsByOriginId(originId) {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.GET_ESCALATIONS_BY_ORIGIN_ID, [originId]);
+    return rows;
+}

package/build/services/escalation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './crud';
+export * from './bulk';
+export * from './queries';

package/build/services/escalation/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./crud"), exports);
+__exportStar(require("./bulk"), exports);
+__exportStar(require("./queries"), exports);

package/build/services/escalation/queries.d.ts

@@ -0,0 +1,37 @@
+import type { LTEscalationRecord, LTEscalationStatus } from '../../types';
+import type { EscalationStats } from './types';
+export declare function getEscalationStats(visibleRoles?: string[], period?: string): Promise<EscalationStats>;
+export declare function listDistinctTypes(): Promise<string[]>;
+export declare function listEscalations(filters: {
+    status?: LTEscalationStatus;
+    role?: string;
+    type?: string;
+    subtype?: string;
+    assigned_to?: string;
+    priority?: number;
+    limit?: number;
+    offset?: number;
+    visibleRoles?: string[];
+    sort_by?: string;
+    order?: string;
+}): Promise<{
+    escalations: LTEscalationRecord[];
+    total: number;
+}>;
+/**
+ * List available escalations: pending AND (unassigned OR expired claim).
+ */
+export declare function listAvailableEscalations(filters: {
+    role?: string;
+    type?: string;
+    subtype?: string;
+    priority?: number;
+    limit?: number;
+    offset?: number;
+    visibleRoles?: string[];
+    sort_by?: string;
+    order?: string;
+}): Promise<{
+    escalations: LTEscalationRecord[];
+    total: number;
+}>;

package/build/services/escalation/queries.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEscalationStats = getEscalationStats;
+exports.listDistinctTypes = listDistinctTypes;
+exports.listEscalations = listEscalations;
+exports.listAvailableEscalations = listAvailableEscalations;
+const db_1 = require("../db");
+const types_1 = require("./types");
+const sql_1 = require("./sql");
+function buildOrderBy(sortBy, order, fallback = 'priority ASC, created_at ASC') {
+    if (!sortBy || !types_1.SORTABLE_COLUMNS.has(sortBy))
+        return fallback;
+    const dir = order === 'asc' ? 'ASC' : 'DESC';
+    return `${sortBy} ${dir}`;
+}
+async function getEscalationStats(visibleRoles, period) {
+    const pool = (0, db_1.getPool)();
+    const interval = types_1.VALID_PERIODS[period ?? '24h'] ?? '24 hours';
+    // Build optional RBAC filter
+    const roleFilter = visibleRoles ? `WHERE role = ANY($1::text[])` : '';
+    const roleFilterAnd = visibleRoles ? `AND role = ANY($1::text[])` : '';
+    const params = visibleRoles ? [visibleRoles] : [];
+    // Global counts
+    const { rows: [totals] } = await pool.query(`SELECT
+       COUNT(*) FILTER (WHERE status = 'pending') AS pending,
+       COUNT(*) FILTER (WHERE status = 'pending' AND assigned_to IS NOT NULL AND assigned_until > NOW()) AS claimed,
+       COUNT(*) FILTER (WHERE created_at > NOW() - INTERVAL '${interval}') AS created,
+       COUNT(*) FILTER (WHERE resolved_at > NOW() - INTERVAL '${interval}') AS resolved
+     FROM lt_escalations ${roleFilter}`, params);
+    // By-role breakdown (pending only)
+    const { rows: byRole } = await pool.query(`SELECT role,
+       COUNT(*) AS pending,
+       COUNT(*) FILTER (WHERE assigned_to IS NOT NULL AND assigned_until > NOW()) AS claimed
+     FROM lt_escalations
+     WHERE status = 'pending' ${roleFilterAnd}
+     GROUP BY role
+     ORDER BY COUNT(*) DESC`, params);
+    // By-type breakdown (within the time period)
+    const { rows: byType } = await pool.query(`SELECT type,
+       COUNT(*) FILTER (WHERE status = 'pending') AS pending,
+       COUNT(*) FILTER (WHERE status = 'pending' AND assigned_to IS NOT NULL AND assigned_until > NOW()) AS claimed,
+       COUNT(*) FILTER (WHERE resolved_at IS NOT NULL) AS resolved
+     FROM lt_escalations
+     WHERE created_at > NOW() - INTERVAL '${interval}' ${roleFilterAnd}
+     GROUP BY type
+     ORDER BY COUNT(*) DESC`, params);
+    return {
+        pending: parseInt(totals.pending),
+        claimed: parseInt(totals.claimed),
+        created: parseInt(totals.created),
+        resolved: parseInt(totals.resolved),
+        by_role: byRole.map((r) => ({
+            role: r.role,
+            pending: parseInt(r.pending),
+            claimed: parseInt(r.claimed),
+        })),
+        by_type: byType.map((r) => ({
+            type: r.type,
+            pending: parseInt(r.pending),
+            claimed: parseInt(r.claimed),
+            resolved: parseInt(r.resolved),
+        })),
+    };
+}
+async function listDistinctTypes() {
+    const pool = (0, db_1.getPool)();
+    const { rows } = await pool.query(sql_1.LIST_DISTINCT_TYPES);
+    return rows.map((r) => r.type);
+}
+async function listEscalations(filters) {
+    const pool = (0, db_1.getPool)();
+    const conditions = [];
+    const values = [];
+    let idx = 1;
+    // RBAC: scope to roles the user is a member of
+    if (filters.visibleRoles) {
+        conditions.push(`role = ANY($${idx++}::text[])`);
+        values.push(filters.visibleRoles);
+    }
+    if (filters.status) {
+        conditions.push(`status = $${idx++}`);
+        values.push(filters.status);
+    }
+    if (filters.role) {
+        conditions.push(`role = $${idx++}`);
+        values.push(filters.role);
+    }
+    if (filters.type) {
+        conditions.push(`type = $${idx++}`);
+        values.push(filters.type);
+    }
+    if (filters.subtype) {
+        conditions.push(`subtype = $${idx++}`);
+        values.push(filters.subtype);
+    }
+    if (filters.assigned_to) {
+        conditions.push(`assigned_to = $${idx++}`);
+        values.push(filters.assigned_to);
+    }
+    if (filters.priority) {
+        conditions.push(`priority = $${idx++}`);
+        values.push(filters.priority);
+    }
+    const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+    const limit = filters.limit || 50;
+    const offset = filters.offset || 0;
+    const orderBy = buildOrderBy(filters.sort_by, filters.order);
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(`SELECT COUNT(*) FROM lt_escalations ${where}`, values),
+        pool.query(`SELECT * FROM lt_escalations ${where} ORDER BY ${orderBy} LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
+    ]);
+    return {
+        escalations: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}
+/**
+ * List available escalations: pending AND (unassigned OR expired claim).
+ */
+async function listAvailableEscalations(filters) {
+    const pool = (0, db_1.getPool)();
+    const conditions = [
+        "status = 'pending'",
+        '(assigned_to IS NULL OR assigned_until <= NOW())',
+    ];
+    const values = [];
+    let idx = 1;
+    // RBAC: scope to roles the user is a member of
+    if (filters.visibleRoles) {
+        conditions.push(`role = ANY($${idx++}::text[])`);
+        values.push(filters.visibleRoles);
+    }
+    if (filters.role) {
+        conditions.push(`role = $${idx++}`);
+        values.push(filters.role);
+    }
+    if (filters.type) {
+        conditions.push(`type = $${idx++}`);
+        values.push(filters.type);
+    }
+    if (filters.subtype) {
+        conditions.push(`subtype = $${idx++}`);
+        values.push(filters.subtype);
+    }
+    if (filters.priority) {
+        conditions.push(`priority = $${idx++}`);
+        values.push(filters.priority);
+    }
+    const where = `WHERE ${conditions.join(' AND ')}`;
+    const limit = filters.limit || 50;
+    const offset = filters.offset || 0;
+    const orderBy = buildOrderBy(filters.sort_by, filters.order);
+    const [countResult, dataResult] = await Promise.all([
+        pool.query(`SELECT COUNT(*) FROM lt_escalations ${where}`, values),
+        pool.query(`SELECT * FROM lt_escalations ${where}
+       ORDER BY ${orderBy}
+       LIMIT $${idx++} OFFSET $${idx++}`, [...values, limit, offset]),
+    ]);
+    return {
+        escalations: dataResult.rows,
+        total: parseInt(countResult.rows[0].count, 10),
+    };
+}

package/build/services/escalation/sql.d.ts

@@ -0,0 +1,21 @@
+export declare const ENSURE_ROLE_EXISTS = "INSERT INTO lt_roles (role) VALUES ($1) ON CONFLICT DO NOTHING";
+export declare const CREATE_ESCALATION = "INSERT INTO lt_escalations\n  (type, subtype, description, priority, task_id,\n   origin_id, parent_id, role, envelope, metadata, escalation_payload,\n   workflow_id, task_queue, workflow_type, trace_id, span_id)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)\nRETURNING *";
+export declare const CLAIM_ESCALATION = "WITH prev AS (\n  SELECT assigned_to, assigned_until\n  FROM lt_escalations\n  WHERE id = $1\n),\nupdated AS (\n  UPDATE lt_escalations\n  SET assigned_to = $2,\n      claimed_at = NOW(),\n      assigned_until = NOW() + INTERVAL '1 minute' * $3\n  WHERE id = $1\n    AND status = 'pending'\n    AND (\n      assigned_to IS NULL\n      OR assigned_until <= NOW()\n      OR assigned_to = $2\n    )\n  RETURNING *\n)\nSELECT updated.*,\n       prev.assigned_to AS prev_assigned_to\nFROM updated\nCROSS JOIN prev";
+export declare const RESOLVE_ESCALATION = "UPDATE lt_escalations\nSET status = 'resolved',\n    resolved_at = NOW(),\n    resolver_payload = $2\nWHERE id = $1\n  AND status = 'pending'\nRETURNING *";
+export declare const UPDATE_ESCALATIONS_PRIORITY = "UPDATE lt_escalations\nSET priority = $1, updated_at = NOW()\nWHERE id = ANY($2::uuid[])\n  AND status = 'pending'";
+export declare const GET_ESCALATION_ROLES = "SELECT DISTINCT role FROM lt_escalations WHERE id = ANY($1::uuid[])";
+export declare const RELEASE_ESCALATION = "UPDATE lt_escalations\nSET assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL\nWHERE id = $1\n  AND status = 'pending'\n  AND assigned_to = $2\nRETURNING *";
+export declare const RELEASE_EXPIRED_CLAIMS = "UPDATE lt_escalations\nSET assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL\nWHERE status = 'pending'\n  AND assigned_to IS NOT NULL\n  AND assigned_until < NOW()";
+export declare const ESCALATE_TO_ROLE = "UPDATE lt_escalations\nSET role = $2,\n    assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL,\n    updated_at = NOW()\nWHERE id = $1\n  AND status = 'pending'\nRETURNING *";
+export declare const GET_ESCALATION = "SELECT * FROM lt_escalations WHERE id = $1";
+export declare const GET_ESCALATIONS_BY_TASK_ID = "SELECT * FROM lt_escalations WHERE task_id = $1 ORDER BY created_at DESC";
+export declare const GET_ESCALATIONS_BY_WORKFLOW_ID = "SELECT * FROM lt_escalations WHERE workflow_id = $1 ORDER BY created_at DESC";
+export declare const GET_ESCALATIONS_BY_ORIGIN_ID = "SELECT * FROM lt_escalations WHERE origin_id = $1 ORDER BY created_at DESC";
+/** Used by both bulkClaimEscalations and bulkAssignEscalations (identical SQL). */
+export declare const BULK_CLAIM = "UPDATE lt_escalations\nSET assigned_to = $1,\n    claimed_at = NOW(),\n    assigned_until = NOW() + INTERVAL '1 minute' * $2\nWHERE id = ANY($3::uuid[])\n  AND status = 'pending'\n  AND (\n    assigned_to IS NULL\n    OR assigned_until <= NOW()\n    OR assigned_to = $1\n  )";
+export declare const BULK_ASSIGN = "UPDATE lt_escalations\nSET assigned_to = $1,\n    claimed_at = NOW(),\n    assigned_until = NOW() + INTERVAL '1 minute' * $2\nWHERE id = ANY($3::uuid[])\n  AND status = 'pending'\n  AND (\n    assigned_to IS NULL\n    OR assigned_until <= NOW()\n    OR assigned_to = $1\n  )";
+export declare const BULK_ESCALATE_TO_ROLE = "UPDATE lt_escalations\nSET role = $1,\n    assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL,\n    updated_at = NOW()\nWHERE id = ANY($2::uuid[])\n  AND status = 'pending'";
+export declare const BULK_RESOLVE_FOR_TRIAGE = "UPDATE lt_escalations\nSET status = 'resolved',\n    resolved_at = NOW(),\n    resolver_payload = $1\nWHERE id = ANY($2::uuid[])\n  AND status = 'pending'\nRETURNING *";
+export declare const UPDATE_ESCALATION_METADATA = "UPDATE lt_escalations\nSET metadata = COALESCE(metadata, '{}'::jsonb) || $2::jsonb,\n    updated_at = NOW()\nWHERE id = $1\nRETURNING *";
+export declare const ENRICH_ESCALATION_ROUTING = "UPDATE lt_escalations\nSET metadata = COALESCE(metadata, '{}'::jsonb) || $2::jsonb,\n    workflow_type = COALESCE(workflow_type, $3),\n    workflow_id = COALESCE(workflow_id, $4),\n    task_queue = COALESCE(task_queue, $5),\n    task_id = COALESCE(task_id, $6),\n    updated_at = NOW()\nWHERE id = $1\nRETURNING *";
+export declare const LIST_DISTINCT_TYPES = "SELECT DISTINCT type FROM lt_escalations ORDER BY type";

package/build/services/escalation/sql.js

@@ -0,0 +1,135 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// Escalation SQL – externalized from crud.ts, bulk.ts, queries.ts
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIST_DISTINCT_TYPES = exports.ENRICH_ESCALATION_ROUTING = exports.UPDATE_ESCALATION_METADATA = exports.BULK_RESOLVE_FOR_TRIAGE = exports.BULK_ESCALATE_TO_ROLE = exports.BULK_ASSIGN = exports.BULK_CLAIM = exports.GET_ESCALATIONS_BY_ORIGIN_ID = exports.GET_ESCALATIONS_BY_WORKFLOW_ID = exports.GET_ESCALATIONS_BY_TASK_ID = exports.GET_ESCALATION = exports.ESCALATE_TO_ROLE = exports.RELEASE_EXPIRED_CLAIMS = exports.RELEASE_ESCALATION = exports.GET_ESCALATION_ROLES = exports.UPDATE_ESCALATIONS_PRIORITY = exports.RESOLVE_ESCALATION = exports.CLAIM_ESCALATION = exports.CREATE_ESCALATION = exports.ENSURE_ROLE_EXISTS = void 0;
+// --- Role management -------------------------------------------------------
+exports.ENSURE_ROLE_EXISTS = 'INSERT INTO lt_roles (role) VALUES ($1) ON CONFLICT DO NOTHING';
+// --- Single-record CRUD ---------------------------------------------------
+exports.CREATE_ESCALATION = `\
+INSERT INTO lt_escalations
+  (type, subtype, description, priority, task_id,
+   origin_id, parent_id, role, envelope, metadata, escalation_payload,
+   workflow_id, task_queue, workflow_type, trace_id, span_id)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16)
+RETURNING *`;
+exports.CLAIM_ESCALATION = `\
+WITH prev AS (
+  SELECT assigned_to, assigned_until
+  FROM lt_escalations
+  WHERE id = $1
+),
+updated AS (
+  UPDATE lt_escalations
+  SET assigned_to = $2,
+      claimed_at = NOW(),
+      assigned_until = NOW() + INTERVAL '1 minute' * $3
+  WHERE id = $1
+    AND status = 'pending'
+    AND (
+      assigned_to IS NULL
+      OR assigned_until <= NOW()
+      OR assigned_to = $2
+    )
+  RETURNING *
+)
+SELECT updated.*,
+       prev.assigned_to AS prev_assigned_to
+FROM updated
+CROSS JOIN prev`;
+exports.RESOLVE_ESCALATION = `\
+UPDATE lt_escalations
+SET status = 'resolved',
+    resolved_at = NOW(),
+    resolver_payload = $2
+WHERE id = $1
+  AND status = 'pending'
+RETURNING *`;
+exports.UPDATE_ESCALATIONS_PRIORITY = `\
+UPDATE lt_escalations
+SET priority = $1, updated_at = NOW()
+WHERE id = ANY($2::uuid[])
+  AND status = 'pending'`;
+exports.GET_ESCALATION_ROLES = 'SELECT DISTINCT role FROM lt_escalations WHERE id = ANY($1::uuid[])';
+exports.RELEASE_ESCALATION = `\
+UPDATE lt_escalations
+SET assigned_to = NULL,
+    assigned_until = NULL,
+    claimed_at = NULL
+WHERE id = $1
+  AND status = 'pending'
+  AND assigned_to = $2
+RETURNING *`;
+exports.RELEASE_EXPIRED_CLAIMS = `\
+UPDATE lt_escalations
+SET assigned_to = NULL,
+    assigned_until = NULL,
+    claimed_at = NULL
+WHERE status = 'pending'
+  AND assigned_to IS NOT NULL
+  AND assigned_until < NOW()`;
+exports.ESCALATE_TO_ROLE = `\
+UPDATE lt_escalations
+SET role = $2,
+    assigned_to = NULL,
+    assigned_until = NULL,
+    claimed_at = NULL,
+    updated_at = NOW()
+WHERE id = $1
+  AND status = 'pending'
+RETURNING *`;
+exports.GET_ESCALATION = 'SELECT * FROM lt_escalations WHERE id = $1';
+exports.GET_ESCALATIONS_BY_TASK_ID = 'SELECT * FROM lt_escalations WHERE task_id = $1 ORDER BY created_at DESC';
+exports.GET_ESCALATIONS_BY_WORKFLOW_ID = 'SELECT * FROM lt_escalations WHERE workflow_id = $1 ORDER BY created_at DESC';
+exports.GET_ESCALATIONS_BY_ORIGIN_ID = 'SELECT * FROM lt_escalations WHERE origin_id = $1 ORDER BY created_at DESC';
+// --- Bulk operations -------------------------------------------------------
+/** Used by both bulkClaimEscalations and bulkAssignEscalations (identical SQL). */
+exports.BULK_CLAIM = `\
+UPDATE lt_escalations
+SET assigned_to = $1,
+    claimed_at = NOW(),
+    assigned_until = NOW() + INTERVAL '1 minute' * $2
+WHERE id = ANY($3::uuid[])
+  AND status = 'pending'
+  AND (
+    assigned_to IS NULL
+    OR assigned_until <= NOW()
+    OR assigned_to = $1
+  )`;
+exports.BULK_ASSIGN = exports.BULK_CLAIM;
+exports.BULK_ESCALATE_TO_ROLE = `\
+UPDATE lt_escalations
+SET role = $1,
+    assigned_to = NULL,
+    assigned_until = NULL,
+    claimed_at = NULL,
+    updated_at = NOW()
+WHERE id = ANY($2::uuid[])
+  AND status = 'pending'`;
+exports.BULK_RESOLVE_FOR_TRIAGE = `\
+UPDATE lt_escalations
+SET status = 'resolved',
+    resolved_at = NOW(),
+    resolver_payload = $1
+WHERE id = ANY($2::uuid[])
+  AND status = 'pending'
+RETURNING *`;
+// --- Query helpers ---------------------------------------------------------
+exports.UPDATE_ESCALATION_METADATA = `\
+UPDATE lt_escalations
+SET metadata = COALESCE(metadata, '{}'::jsonb) || $2::jsonb,
+    updated_at = NOW()
+WHERE id = $1
+RETURNING *`;
+exports.ENRICH_ESCALATION_ROUTING = `\
+UPDATE lt_escalations
+SET metadata = COALESCE(metadata, '{}'::jsonb) || $2::jsonb,
+    workflow_type = COALESCE(workflow_type, $3),
+    workflow_id = COALESCE(workflow_id, $4),
+    task_queue = COALESCE(task_queue, $5),
+    task_id = COALESCE(task_id, $6),
+    updated_at = NOW()
+WHERE id = $1
+RETURNING *`;
+exports.LIST_DISTINCT_TYPES = 'SELECT DISTINCT type FROM lt_escalations ORDER BY type';

package/build/services/escalation/types.d.ts

@@ -0,0 +1,43 @@
+import type { LTEscalationRecord } from '../../types';
+export interface CreateEscalationInput {
+    type: string;
+    subtype: string;
+    description?: string;
+    priority?: number;
+    task_id?: string;
+    origin_id?: string;
+    parent_id?: string;
+    role: string;
+    envelope: string;
+    metadata?: Record<string, any>;
+    escalation_payload?: string;
+    workflow_id?: string;
+    task_queue?: string;
+    workflow_type?: string;
+    trace_id?: string;
+    span_id?: string;
+}
+export interface ClaimResult {
+    escalation: LTEscalationRecord;
+    isExtension: boolean;
+}
+export interface EscalationStats {
+    pending: number;
+    claimed: number;
+    created: number;
+    resolved: number;
+    by_role: {
+        role: string;
+        pending: number;
+        claimed: number;
+    }[];
+    by_type: {
+        type: string;
+        pending: number;
+        claimed: number;
+        resolved: number;
+    }[];
+}
+export declare const VALID_PERIODS: Record<string, string>;
+/** Columns allowed for user-chosen ORDER BY. */
+export declare const SORTABLE_COLUMNS: Set<string>;

package/build/services/escalation/types.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SORTABLE_COLUMNS = exports.VALID_PERIODS = void 0;
+exports.VALID_PERIODS = {
+    '1h': '1 hour',
+    '24h': '24 hours',
+    '7d': '7 days',
+    '30d': '30 days',
+};
+/** Columns allowed for user-chosen ORDER BY. */
+exports.SORTABLE_COLUMNS = new Set([
+    'created_at', 'updated_at', 'priority', 'resolved_at', 'role', 'type',
+]);

package/build/services/escalation-strategy/default.d.ts

@@ -0,0 +1,12 @@
+import type { LTEscalationStrategy, ResolutionContext, ResolutionDirective } from '../../types/escalation-strategy';
+/**
+ * Default escalation strategy.
+ *
+ * Always returns `{ action: 'rerun' }` — standard behavior where the
+ * resolver's payload is injected into the envelope and the original
+ * workflow is re-run. This is the strategy used when no MCP triage
+ * is configured.
+ */
+export declare class DefaultEscalationStrategy implements LTEscalationStrategy {
+    onResolution(_context: ResolutionContext): Promise<ResolutionDirective>;
+}

package/build/services/escalation-strategy/default.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultEscalationStrategy = void 0;
+/**
+ * Default escalation strategy.
+ *
+ * Always returns `{ action: 'rerun' }` — standard behavior where the
+ * resolver's payload is injected into the envelope and the original
+ * workflow is re-run. This is the strategy used when no MCP triage
+ * is configured.
+ */
+class DefaultEscalationStrategy {
+    async onResolution(_context) {
+        return { action: 'rerun' };
+    }
+}
+exports.DefaultEscalationStrategy = DefaultEscalationStrategy;

package/build/services/escalation-strategy/index.d.ts

@@ -0,0 +1,21 @@
+import type { LTEscalationStrategy } from '../../types/escalation-strategy';
+/**
+ * Singleton registry for the escalation strategy.
+ *
+ * Follows the same pattern as mcpRegistry (single adapter):
+ * - register(strategy) — set the active strategy
+ * - clear()            — reset (for tests)
+ *
+ * The strategy is consulted during escalation resolution to determine
+ * whether to perform a standard re-run or route to the MCP triage
+ * orchestrator for dynamic remediation.
+ */
+declare class LTEscalationStrategyRegistry {
+    private strategy;
+    register(strategy: LTEscalationStrategy): void;
+    clear(): void;
+    get hasStrategy(): boolean;
+    get current(): LTEscalationStrategy | null;
+}
+export declare const escalationStrategyRegistry: LTEscalationStrategyRegistry;
+export {};