@hotmeshio/long-tail 0.5.2 → 0.5.4

package/build/services/escalation/queries.js

@@ -4,167 +4,82 @@ exports.getEscalationStats = getEscalationStats;
 exports.listDistinctTypes = listDistinctTypes;
 exports.listEscalations = listEscalations;
 exports.listAvailableEscalations = listAvailableEscalations;
-const db_1 = require("../../lib/db");
+const client_1 = require("./client");
+const map_1 = require("./map");
 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}`;
+/**
+ * Default sort is priority ASC, created_at ASC. A user-chosen `sort_by` maps to
+ * a single column (DESC unless `order='asc'`), matching the legacy behavior.
+ */
+function buildOrderBy(sortBy, order) {
+    if (sortBy && types_1.SORTABLE_COLUMNS.has(sortBy)) {
+        return [{ column: sortBy, direction: order === 'asc' ? 'asc' : 'desc' }];
+    }
+    return [
+        { column: 'priority', direction: 'asc' },
+        { column: 'created_at', direction: 'asc' },
+    ];
 }
 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),
-        })),
-    };
+    const client = await (0, client_1.escalations)();
+    return client.stats({
+        roles: visibleRoles,
+        period: period,
+    });
 }
 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);
+    const client = await (0, client_1.escalations)();
+    return client.listDistinctTypes();
 }
 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);
-        // Only return active claims — expired claims are back in the available pool
-        conditions.push('assigned_until > NOW()');
-    }
-    if (filters.claimed) {
-        // All actively claimed escalations (by anyone)
-        conditions.push('assigned_to IS NOT NULL');
-        conditions.push('assigned_until > NOW()');
-    }
-    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),
+    const client = await (0, client_1.escalations)();
+    // Shared filter — passed to both list() and count() so totals stay in sync.
+    const where = {
+        status: filters.status,
+        role: filters.role,
+        type: filters.type,
+        subtype: filters.subtype,
+        priority: filters.priority,
+        roles: filters.visibleRoles,
     };
+    if (filters.assigned_to)
+        where.assignedTo = filters.assigned_to;
+    // Active claim semantics: assigned_to-active and `claimed` both mean "held now".
+    if (filters.assigned_to || filters.claimed)
+        where.available = false;
+    const [rows, total] = await Promise.all([
+        client.list({
+            ...where,
+            orderBy: buildOrderBy(filters.sort_by, filters.order),
+            limit: filters.limit ?? 50,
+            offset: filters.offset ?? 0,
+        }),
+        client.count(where),
+    ]);
+    return { escalations: (0, map_1.toEscalationRecords)(rows), total };
 }
 /**
  * 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),
+    const client = await (0, client_1.escalations)();
+    const where = {
+        status: 'pending',
+        available: true,
+        role: filters.role,
+        type: filters.type,
+        subtype: filters.subtype,
+        priority: filters.priority,
+        roles: filters.visibleRoles,
     };
+    const [rows, total] = await Promise.all([
+        client.list({
+            ...where,
+            orderBy: buildOrderBy(filters.sort_by, filters.order),
+            limit: filters.limit ?? 50,
+            offset: filters.offset ?? 0,
+        }),
+        client.count(where),
+    ]);
+    return { escalations: (0, map_1.toEscalationRecords)(rows), total };
 }

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

@@ -1,42 +1,23 @@
-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";
-/** Find escalations by a single metadata key-value pair. Window function for total count. */
-export declare const FIND_BY_METADATA = "SELECT *, COUNT(*) OVER() AS _total\nFROM lt_escalations\nWHERE metadata @> $1::jsonb\n  AND ($2::text IS NULL OR status = $2)\nORDER BY priority ASC, created_at ASC\nLIMIT $3 OFFSET $4";
 /**
- * Atomic claim by metadata with inline RBAC.
- * $1 = metadata filter (jsonb), $2 = userId, $3 = durationMinutes,
- * $4 = metadata patch (jsonb, nullable), $5 = allowed roles (text[], null = no filter)
+ * Sweep expired claims back to the available pool.
+ *
+ * In the implicit-claim model an expired claim is already available at query
+ * time (`assigned_until <= NOW()`), so this is a cosmetic cleanup — but it is
+ * long-tail's public contract (returns a count, clears `assigned_to`) and the
+ * SDK's `releaseExpired()` is a no-op, so it runs as direct SQL on the shared
+ * table. Clears both `assigned_until` and `claim_expires_at`.
  */
-export declare const CLAIM_BY_METADATA_GUARDED = "WITH target AS MATERIALIZED (\n  SELECT id, assigned_to\n  FROM lt_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND (assigned_to IS NULL OR assigned_until <= NOW() OR assigned_to = $2)\n    AND ($5::text[] IS NULL OR role = ANY($5))\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE SKIP LOCKED\n),\nupdated AS (\n  UPDATE lt_escalations e\n  SET assigned_to = $2,\n      claimed_at = NOW(),\n      assigned_until = NOW() + INTERVAL '1 minute' * $3,\n      metadata = CASE WHEN $4::jsonb IS NOT NULL\n        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb\n        ELSE e.metadata END,\n      updated_at = NOW()\n  FROM target t\n  WHERE e.id = t.id\n  RETURNING e.*, t.assigned_to AS prev_assigned_to\n)\nSELECT *,\n  (SELECT COUNT(*) FROM lt_escalations WHERE metadata @> $1::jsonb AND status = 'pending') AS candidates_exist\nFROM updated";
+export declare const RELEASE_EXPIRED_CLAIMS = "UPDATE public.hmsh_escalations\nSET assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL,\n    claim_expires_at = NULL,\n    updated_at = NOW()\nWHERE status = 'pending'\n  AND assigned_to IS NOT NULL\n  AND assigned_until <= NOW()";
 /**
  * Atomic resolve by metadata with signal guard.
  *
  * Single query, two outcomes:
- * 1. No signal_id → claim + resolve atomically. `resolved` is populated.
- * 2. signal_id present → resolve CTE skips (guard in WHERE). `resolved` is null,
- *    but `target_id`, `signal_id`, `workflow_id`, `task_queue`, `workflow_type`
- *    are returned so the caller can signal the workflow directly.
+ * 1. No `metadata.signal_id` → claim + resolve atomically. `resolved` is populated.
+ * 2. `metadata.signal_id` present → resolve CTE skips (guard in WHERE). `resolved`
+ *    is null, but `target_id`, `signal_id`, and workflow routing are returned so
+ *    the caller can signal the workflow directly.
  *
  * $1 = metadata filter (jsonb), $2 = userId, $3 = resolver_payload (jsonb),
  * $4 = metadata patch (jsonb, nullable), $5 = allowed roles (text[], null = no filter)
  */
-export declare const RESOLVE_BY_METADATA_ATOMIC = "WITH target AS MATERIALIZED (\n  SELECT *\n  FROM lt_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND ($5::text[] IS NULL OR role = ANY($5))\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE\n),\nclaimed AS (\n  UPDATE lt_escalations e\n  SET assigned_to = COALESCE(e.assigned_to, $2),\n      claimed_at = COALESCE(e.claimed_at, NOW()),\n      assigned_until = CASE\n        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.assigned_until\n        ELSE NOW() + INTERVAL '5 minutes' END,\n      metadata = CASE WHEN $4::jsonb IS NOT NULL\n        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb\n        ELSE e.metadata END\n  FROM target\n  WHERE e.id = target.id\n    AND (target.metadata->>'signal_id') IS NULL\n  RETURNING e.*\n),\nresolved AS (\n  UPDATE lt_escalations e\n  SET status = 'resolved',\n      resolved_at = NOW(),\n      resolver_payload = $3,\n      updated_at = NOW()\n  FROM claimed\n  WHERE e.id = claimed.id\n  RETURNING e.*\n)\nSELECT\n  resolved.*,\n  target.id AS target_id,\n  target.metadata->>'signal_id' AS signal_id,\n  target.workflow_id AS target_workflow_id,\n  target.workflow_type AS target_workflow_type,\n  target.task_queue AS target_task_queue,\n  CASE WHEN resolved.id IS NOT NULL THEN 'resolved' ELSE 'signal_required' END AS outcome\nFROM target\nLEFT JOIN resolved ON resolved.id = target.id";
+export declare const RESOLVE_BY_METADATA_ATOMIC = "WITH target AS MATERIALIZED (\n  SELECT *\n  FROM public.hmsh_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND ($5::text[] IS NULL OR role = ANY($5))\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE\n),\nclaimed AS (\n  UPDATE public.hmsh_escalations e\n  SET assigned_to = COALESCE(e.assigned_to, $2),\n      claimed_at = COALESCE(e.claimed_at, NOW()),\n      assigned_until = CASE\n        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.assigned_until\n        ELSE NOW() + INTERVAL '5 minutes' END,\n      claim_expires_at = CASE\n        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.claim_expires_at\n        ELSE NOW() + INTERVAL '5 minutes' END,\n      metadata = CASE WHEN $4::jsonb IS NOT NULL\n        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb\n        ELSE e.metadata END,\n      updated_at = NOW()\n  FROM target\n  WHERE e.id = target.id\n    AND (target.metadata->>'signal_id') IS NULL\n  RETURNING e.*\n),\nresolved AS (\n  UPDATE public.hmsh_escalations e\n  SET status = 'resolved',\n      resolved_at = NOW(),\n      resolver_payload = $3,\n      updated_at = NOW()\n  FROM claimed\n  WHERE e.id = claimed.id\n  RETURNING e.*\n)\nSELECT\n  resolved.*,\n  target.id AS target_id,\n  target.metadata->>'signal_id' AS signal_id,\n  target.workflow_id AS target_workflow_id,\n  target.workflow_type AS target_workflow_type,\n  target.task_queue AS target_task_queue,\n  CASE WHEN resolved.id IS NOT NULL THEN 'resolved' ELSE 'signal_required' END AS outcome\nFROM target\nLEFT JOIN resolved ON resolved.id = target.id";

package/build/services/escalation/sql.js

@@ -1,188 +1,44 @@
 "use strict";
 // ---------------------------------------------------------------------------
-// Escalation SQL – externalized from crud.ts, bulk.ts, queries.ts
+// Escalation SQL
+//
+// The escalation service operates through `client.escalations.*` over
+// `public.hmsh_escalations`. The single exception is the resolve-by-metadata
+// signal guard: long-tail must NOT resolve a signal-backed row in the DB (it
+// signals the paused workflow instead, and the workflow interceptor resolves
+// durably). That decision plus the find + claim + resolve must be one atomic
+// statement to avoid a TOCTOU window, so it is expressed directly against
+// `hmsh_escalations` here rather than composed from generic SDK calls.
 // ---------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RESOLVE_BY_METADATA_ATOMIC = exports.CLAIM_BY_METADATA_GUARDED = exports.FIND_BY_METADATA = 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.RESOLVE_BY_METADATA_ATOMIC = exports.RELEASE_EXPIRED_CLAIMS = void 0;
+/**
+ * Sweep expired claims back to the available pool.
+ *
+ * In the implicit-claim model an expired claim is already available at query
+ * time (`assigned_until <= NOW()`), so this is a cosmetic cleanup — but it is
+ * long-tail's public contract (returns a count, clears `assigned_to`) and the
+ * SDK's `releaseExpired()` is a no-op, so it runs as direct SQL on the shared
+ * table. Clears both `assigned_until` and `claim_expires_at`.
+ */
 exports.RELEASE_EXPIRED_CLAIMS = `\
-UPDATE lt_escalations
+UPDATE public.hmsh_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,
+    claim_expires_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';
-// --- Metadata candidate key lookups -----------------------------------------
-/** Find escalations by a single metadata key-value pair. Window function for total count. */
-exports.FIND_BY_METADATA = `\
-SELECT *, COUNT(*) OVER() AS _total
-FROM lt_escalations
-WHERE metadata @> $1::jsonb
-  AND ($2::text IS NULL OR status = $2)
-ORDER BY priority ASC, created_at ASC
-LIMIT $3 OFFSET $4`;
-/**
- * Atomic claim by metadata with inline RBAC.
- * $1 = metadata filter (jsonb), $2 = userId, $3 = durationMinutes,
- * $4 = metadata patch (jsonb, nullable), $5 = allowed roles (text[], null = no filter)
- */
-exports.CLAIM_BY_METADATA_GUARDED = `\
-WITH target AS MATERIALIZED (
-  SELECT id, assigned_to
-  FROM lt_escalations
-  WHERE metadata @> $1::jsonb
-    AND status = 'pending'
-    AND (assigned_to IS NULL OR assigned_until <= NOW() OR assigned_to = $2)
-    AND ($5::text[] IS NULL OR role = ANY($5))
-  ORDER BY priority ASC, created_at ASC
-  LIMIT 1
-  FOR UPDATE SKIP LOCKED
-),
-updated AS (
-  UPDATE lt_escalations e
-  SET assigned_to = $2,
-      claimed_at = NOW(),
-      assigned_until = NOW() + INTERVAL '1 minute' * $3,
-      metadata = CASE WHEN $4::jsonb IS NOT NULL
-        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb
-        ELSE e.metadata END,
-      updated_at = NOW()
-  FROM target t
-  WHERE e.id = t.id
-  RETURNING e.*, t.assigned_to AS prev_assigned_to
-)
-SELECT *,
-  (SELECT COUNT(*) FROM lt_escalations WHERE metadata @> $1::jsonb AND status = 'pending') AS candidates_exist
-FROM updated`;
+WHERE status = 'pending'
+  AND assigned_to IS NOT NULL
+  AND assigned_until <= NOW()`;
 /**
  * Atomic resolve by metadata with signal guard.
  *
  * Single query, two outcomes:
- * 1. No signal_id → claim + resolve atomically. `resolved` is populated.
- * 2. signal_id present → resolve CTE skips (guard in WHERE). `resolved` is null,
- *    but `target_id`, `signal_id`, `workflow_id`, `task_queue`, `workflow_type`
- *    are returned so the caller can signal the workflow directly.
+ * 1. No `metadata.signal_id` → claim + resolve atomically. `resolved` is populated.
+ * 2. `metadata.signal_id` present → resolve CTE skips (guard in WHERE). `resolved`
+ *    is null, but `target_id`, `signal_id`, and workflow routing are returned so
+ *    the caller can signal the workflow directly.
  *
  * $1 = metadata filter (jsonb), $2 = userId, $3 = resolver_payload (jsonb),
  * $4 = metadata patch (jsonb, nullable), $5 = allowed roles (text[], null = no filter)
@@ -190,7 +46,7 @@ FROM updated`;
 exports.RESOLVE_BY_METADATA_ATOMIC = `\
 WITH target AS MATERIALIZED (
   SELECT *
-  FROM lt_escalations
+  FROM public.hmsh_escalations
   WHERE metadata @> $1::jsonb
     AND status = 'pending'
     AND ($5::text[] IS NULL OR role = ANY($5))
@@ -199,22 +55,26 @@ WITH target AS MATERIALIZED (
   FOR UPDATE
 ),
 claimed AS (
-  UPDATE lt_escalations e
+  UPDATE public.hmsh_escalations e
   SET assigned_to = COALESCE(e.assigned_to, $2),
       claimed_at = COALESCE(e.claimed_at, NOW()),
       assigned_until = CASE
         WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.assigned_until
         ELSE NOW() + INTERVAL '5 minutes' END,
+      claim_expires_at = CASE
+        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.claim_expires_at
+        ELSE NOW() + INTERVAL '5 minutes' END,
       metadata = CASE WHEN $4::jsonb IS NOT NULL
         THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb
-        ELSE e.metadata END
+        ELSE e.metadata END,
+      updated_at = NOW()
   FROM target
   WHERE e.id = target.id
     AND (target.metadata->>'signal_id') IS NULL
   RETURNING e.*
 ),
 resolved AS (
-  UPDATE lt_escalations e
+  UPDATE public.hmsh_escalations e
   SET status = 'resolved',
       resolved_at = NOW(),
       resolver_payload = $3,

package/build/services/export/post-process.js

@@ -111,16 +111,35 @@ function postProcessExecution(execution) {
     if (toAdd.length > 0) {
         events.push(...toAdd);
     }
-    // Sort by execution_index first — it reflects the true workflow sequence.
-    // Timestamps are unreliable for ordering (e.g. signal_wait_started gets
-    // the workflow start time). Fall back to timestamp only when index is absent.
+    // Order the stream in three bands: the workflow_execution_started bookend
+    // first, the workflow_execution_completed/failed bookend last, and the
+    // activity/signal events in between. Within the middle band, execution_index
+    // reflects the true workflow sequence (timestamps are unreliable — e.g.
+    // signal_wait_started gets the workflow start time), so sort by it and fall
+    // back to timestamp only when index is absent or tied.
+    //
+    // The bookends carry no execution_index; without explicit banding the
+    // completed event would sort to the front alongside started. (HotMesh's
+    // exporter does not index the terminal event.)
+    const band = (e) => {
+        if (e.event_type === 'workflow_execution_started')
+            return 0;
+        if (e.event_type === 'workflow_execution_completed' ||
+            e.event_type === 'workflow_execution_failed')
+            return 2;
+        return 1;
+    };
     events.sort((a, b) => {
+        const bandA = band(a);
+        const bandB = band(b);
+        if (bandA !== bandB)
+            return bandA - bandB;
         const idxA = a.attributes.execution_index ?? -1;
         const idxB = b.attributes.execution_index ?? -1;
         if (idxA !== -1 && idxB !== -1 && idxA !== idxB)
             return idxA - idxB;
         if (idxA !== -1 && idxB === -1)
-            return 1; // indexed after non-indexed (workflow_started)
+            return 1;
         if (idxA === -1 && idxB !== -1)
             return -1;
         // Same index (scheduled/completed pairs) — sort by timestamp

package/build/services/interceptor/activities/config.js

@@ -12,7 +12,11 @@ const ltconfig_1 = require("../../../modules/ltconfig");
  * TTL cache — most calls resolve from memory without hitting the DB.
  */
 async function ltGetWorkflowConfig(workflowName) {
-    return ltconfig_1.ltConfig.getResolvedConfig(workflowName);
+    // Gate on REGISTRATION (a row in lt_config_workflows), not certification:
+    // every registered workflow gets interceptor task/escalation/orchestrator
+    // treatment. Certification (roles/consumes) governs RBAC and provider
+    // injection, not whether the workflow is tracked.
+    return ltconfig_1.ltConfig.getRegisteredConfig(workflowName);
 }
 /**
  * Get provider data for a workflow's consumers by looking up

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

@@ -1,3 +1,4 @@
+import type { Types } from '@hotmeshio/hotmesh';
 /**
  * Register the Long Tail interceptors in a single call.
  *
@@ -12,6 +13,8 @@ export declare function registerLT(connection: {
 }, options?: {
     taskQueue?: string;
     defaultRole?: string;
+    /** SDK system-event sink — wired so the activity worker emits lifecycle events. */
+    events?: Types.EventsConfig;
 }): Promise<void>;
 /**
  * The Long Tail interceptor wraps every registered workflow.