@hotmeshio/hotmesh 0.22.1 → 0.22.3

package/build/services/store/providers/postgres/postgres.js

@@ -49,12 +49,12 @@ class PostgresStoreService extends __1.StoreService {
       (namespace, app_id, signal_key, topic, workflow_id, task_queue, workflow_type,
        type, subtype, entity, description, role, priority,
        origin_id, parent_id, initiated_by, created_by, trace_id, span_id,
-       escalation_payload, metadata, envelope, expires_at)
+       task_id, escalation_payload, metadata, envelope, expires_at)
     VALUES
       ($1, $2, $3, $4, $5, $6, $7,
        $8, $9, $10, $11, $12, $13,
        $14, $15, $16, $17, $18, $19,
-       $20, $21, $22, $23)
+       $20, $21, $22, $23, $24)
     ON CONFLICT (namespace, app_id, signal_key) WHERE signal_key IS NOT NULL DO NOTHING`;
         //Instead of directly referencing the 'pg' package and methods like 'query',
         //  the PostgresStore wraps the 'pg' client in a class that implements
@@ -1400,7 +1400,7 @@ class PostgresStoreService extends __1.StoreService {
         }
     }
     _escalationInsertParams(params) {
-        const { namespace, appId, signalKey, topic, workflowId, taskQueue, workflowType, type, subtype, entity, description, role, priority, originId, parentId, initiatedBy, createdBy, traceId, spanId, escalationPayload, metadata, envelope, expiresAt, } = params;
+        const { namespace, appId, signalKey, topic, workflowId, taskQueue, workflowType, type, subtype, entity, description, role, priority, originId, parentId, initiatedBy, createdBy, traceId, spanId, taskId, escalationPayload, metadata, envelope, expiresAt, } = params;
         return [
             namespace ?? 'hmsh',
             appId ?? 'hmsh',
@@ -1421,6 +1421,7 @@ class PostgresStoreService extends __1.StoreService {
             createdBy ?? null,
             traceId ?? null,
             spanId ?? null,
+            taskId ?? null,
             escalationPayload ? JSON.stringify(escalationPayload) : null,
             metadata ? JSON.stringify(metadata) : null,
             envelope ? JSON.stringify(envelope) : null,
@@ -1447,22 +1448,22 @@ class PostgresStoreService extends __1.StoreService {
      * rows that already exist are skipped and `null` is returned for them.
      */
     async createEscalationForMigration(params) {
-        const { id, namespace, appId, signalKey, topic, workflowId, taskQueue, workflowType, type, subtype, entity, description, role, priority, originId, parentId, initiatedBy, createdBy, traceId, spanId, escalationPayload, metadata, envelope, expiresAt, status, assignedTo, claimExpiresAt, claimedAt, resolvedAt, resolverPayload, milestones, createdAt, updatedAt, } = params;
+        const { id, namespace, appId, signalKey, topic, workflowId, taskQueue, workflowType, type, subtype, entity, description, role, priority, originId, parentId, initiatedBy, createdBy, traceId, spanId, taskId, escalationPayload, metadata, envelope, expiresAt, status, assignedTo, claimExpiresAt, claimedAt, resolvedAt, resolverPayload, milestones, createdAt, updatedAt, } = params;
         const result = await this.pgClient.query(`
       INSERT INTO public.hmsh_escalations
         (id, namespace, app_id, signal_key, topic, workflow_id, task_queue, workflow_type,
          type, subtype, entity, description, role, priority,
-         origin_id, parent_id, initiated_by, created_by, trace_id, span_id,
+         origin_id, parent_id, initiated_by, created_by, trace_id, span_id, task_id,
          escalation_payload, metadata, envelope, expires_at,
          status, assigned_to, claim_expires_at, claimed_at, resolved_at,
          resolver_payload, milestones, created_at, updated_at)
       VALUES
         ($1,  $2,  $3,  $4,  $5,  $6,  $7,  $8,
          $9,  $10, $11, $12, $13, $14,
-         $15, $16, $17, $18, $19, $20,
-         $21, $22, $23, $24,
-         $25, $26, $27, $28, $29,
-         $30, $31, $32, $33)
+         $15, $16, $17, $18, $19, $20, $21,
+         $22, $23, $24, $25,
+         $26, $27, $28, $29, $30,
+         $31, $32, $33, $34)
       ON CONFLICT (id) DO NOTHING
       RETURNING *
     `, [
@@ -1486,6 +1487,7 @@ class PostgresStoreService extends __1.StoreService {
             createdBy ?? null,
             traceId ?? null,
             spanId ?? null,
+            taskId ?? null,
             escalationPayload ? JSON.stringify(escalationPayload) : null,
             metadata ? JSON.stringify(metadata) : null,
             envelope ? JSON.stringify(envelope) : null,
@@ -1510,16 +1512,20 @@ class PostgresStoreService extends __1.StoreService {
         const result = await this.pgClient.query(`SELECT * FROM public.hmsh_escalations WHERE signal_key = $1${namespace ? ' AND namespace = $2' : ''}`, namespace ? [signalKey, namespace] : [signalKey]);
         return result.rows[0] ?? null;
     }
-    async listEscalations(params = {}) {
-        const { namespace, role, type, subtype, entity, status, assignedTo, workflowId, originId, limit = 50, offset = 0 } = params;
+    _escalationFilterConditions(params, startIdx = 1) {
+        const { namespace, role, roles, type, subtype, entity, status, assignedTo, workflowId, originId, available, priority, metadata, ids, taskId } = params;
         const conditions = [];
         const values = [];
-        let idx = 1;
+        let idx = startIdx;
         if (namespace) {
             conditions.push(`namespace = $${idx++}`);
             values.push(namespace);
         }
-        if (role) {
+        if (roles?.length) {
+            conditions.push(`role = ANY($${idx++}::text[])`);
+            values.push(roles);
+        }
+        else if (role) {
             conditions.push(`role = $${idx++}`);
             values.push(role);
         }
@@ -1551,97 +1557,153 @@ class PostgresStoreService extends __1.StoreService {
             conditions.push(`origin_id = $${idx++}`);
             values.push(originId);
         }
+        if (priority !== undefined) {
+            conditions.push(`priority = $${idx++}`);
+            values.push(priority);
+        }
+        if (metadata) {
+            conditions.push(`metadata @> $${idx++}::jsonb`);
+            values.push(JSON.stringify(metadata));
+        }
+        if (ids?.length) {
+            conditions.push(`id = ANY($${idx++}::uuid[])`);
+            values.push(ids);
+        }
+        if (taskId) {
+            conditions.push(`task_id = $${idx++}`);
+            values.push(taskId);
+        }
+        if (available === true) {
+            conditions.push(`(assigned_to IS NULL OR (assigned_until IS NOT NULL AND assigned_until <= NOW()))`);
+        }
+        if (available === false) {
+            conditions.push(`(assigned_to IS NOT NULL AND (assigned_until IS NULL OR assigned_until > NOW()))`);
+        }
+        return { conditions, values, idx };
+    }
+    async listEscalations(params = {}) {
+        const { sortBy, sortOrder, orderBy: orderByParam, limit = 50, offset = 0 } = params;
+        const { conditions, values, idx } = this._escalationFilterConditions(params);
         const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        let orderByClause;
+        if (orderByParam?.length) {
+            const allowed = new Set(['priority', 'created_at', 'updated_at', 'resolved_at', 'role', 'type']);
+            const parts = orderByParam
+                .filter(o => allowed.has(o.column))
+                .map(o => `${o.column} ${o.direction === 'desc' ? 'DESC' : 'ASC'}`);
+            orderByClause = parts.length ? `ORDER BY ${parts.join(', ')}` : 'ORDER BY priority ASC, created_at DESC';
+        }
+        else {
+            const col = sortBy === 'updated_at' ? 'updated_at' : sortBy === 'created_at' ? 'created_at' : 'priority';
+            const dir = sortOrder === 'desc' ? 'DESC' : 'ASC';
+            orderByClause = col === 'priority'
+                ? `ORDER BY priority ${dir}, created_at DESC`
+                : `ORDER BY ${col} ${dir}`;
+        }
         values.push(limit, offset);
-        const result = await this.pgClient.query(`SELECT * FROM public.hmsh_escalations ${where} ORDER BY priority ASC, created_at ASC LIMIT $${idx++} OFFSET $${idx}`, values);
+        const result = await this.pgClient.query(`SELECT *,
+         (assigned_to IS NULL OR (assigned_until IS NOT NULL AND assigned_until <= NOW())) AS available
+       FROM public.hmsh_escalations ${where} ${orderByClause} LIMIT $${idx} OFFSET $${idx + 1}`, values);
         return result.rows;
     }
+    async countEscalations(params = {}) {
+        const { conditions, values } = this._escalationFilterConditions(params);
+        const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
+        const result = await this.pgClient.query(`SELECT COUNT(*)::int AS total FROM public.hmsh_escalations ${where}`, values);
+        return result.rows[0]?.total ?? 0;
+    }
     async claimEscalation(params) {
         const { id, namespace, assignee = '', durationMinutes = 1 } = params;
-        // all_rows: reads the row without locking, so we can distinguish 'not-found' vs 'conflict'
-        // target: attempts the lock; SKIP LOCKED means a locked row is skipped without error
-        // claimed: performs the UPDATE only if target succeeded
-        // The final SELECT always returns exactly 1 row via the dummy left-join — no second round-trip.
+        // all_rows: unlocked read to distinguish 'not-found' vs 'conflict'.
+        // target: captures prior_assigned_to for isExtension; locks only when claimable.
+        // claimed: writes both assigned_until and claim_expires_at (same value).
         const result = await this.pgClient.query(`
       WITH all_rows AS MATERIALIZED (
         SELECT id FROM public.hmsh_escalations
         WHERE id = $1 ${namespace ? 'AND namespace = $4' : ''}
       ),
       target AS MATERIALIZED (
-        SELECT id FROM public.hmsh_escalations
+        SELECT id, assigned_to AS prior_assigned_to FROM public.hmsh_escalations
         WHERE id = $1
           ${namespace ? 'AND namespace = $4' : ''}
           AND status = 'pending'
-          AND (assigned_to IS NULL OR claim_expires_at <= NOW() OR assigned_to = $2)
+          AND (assigned_to IS NULL OR assigned_until IS NULL OR assigned_until <= NOW() OR assigned_to = $2)
         LIMIT 1
         FOR UPDATE SKIP LOCKED
       ),
       claimed AS (
         UPDATE public.hmsh_escalations
-        SET status           = 'claimed',
-            assigned_to      = $2,
+        SET assigned_to      = $2,
             claimed_at       = NOW(),
             claim_expires_at = NOW() + ($3 * INTERVAL '1 minute'),
+            assigned_until   = NOW() + ($3 * INTERVAL '1 minute'),
             updated_at       = NOW()
         FROM target WHERE public.hmsh_escalations.id = target.id
-        RETURNING public.hmsh_escalations.*
+        RETURNING public.hmsh_escalations.*, target.prior_assigned_to
       )
       SELECT c.*, (SELECT EXISTS(SELECT 1 FROM all_rows)) AS row_exists
       FROM (VALUES(1)) AS dummy(v)
       LEFT JOIN claimed c ON true
     `, namespace ? [id, assignee, durationMinutes, namespace] : [id, assignee, durationMinutes]);
         const row = result.rows[0];
-        if (row?.id)
-            return { ok: true, entry: row };
+        if (row?.id) {
+            const isExtension = row.prior_assigned_to === assignee;
+            return { ok: true, entry: row, isExtension };
+        }
         if (row?.row_exists)
             return { ok: false, reason: 'conflict' };
         return { ok: false, reason: 'not-found' };
     }
     async claimEscalationByMetadata(params) {
-        const { key, value, namespace, assignee = '', durationMinutes = 1, roles } = params;
+        const { key, value, namespace, assignee = '', durationMinutes = 1, roles, metadata: mergeMeta } = params;
         const filter = JSON.stringify({ [key]: value });
-        // all_candidates: counts ALL matching rows (any status) to distinguish 'not-found' vs 'conflict'
-        // target: attempts the lock on the highest-priority pending row; SKIP LOCKED skips already-claimed ones
-        // claimed: performs the UPDATE atomically from target
-        // The dummy left-join ensures exactly 1 row is always returned so candidatesExist is always visible.
+        const mergeJson = mergeMeta ? JSON.stringify(mergeMeta) : null;
+        // $1=filter $2=assignee $3=duration $4=roles $5=mergeJson [$6=namespace]
+        const nsClause = namespace ? 'namespace = $6 AND' : '';
+        const queryParams = namespace
+            ? [filter, assignee, durationMinutes, roles ?? null, mergeJson, namespace]
+            : [filter, assignee, durationMinutes, roles ?? null, mergeJson];
         const result = await this.pgClient.query(`
       WITH all_candidates AS MATERIALIZED (
         SELECT id FROM public.hmsh_escalations
-        WHERE ${namespace ? 'namespace = $5 AND' : ''}
+        WHERE ${nsClause}
               metadata @> $1::jsonb
           AND ($4::text[] IS NULL OR role = ANY($4::text[]))
       ),
       target AS MATERIALIZED (
-        SELECT id FROM public.hmsh_escalations
-        WHERE ${namespace ? 'namespace = $5 AND' : ''}
+        SELECT id, assigned_to AS prior_assigned_to FROM public.hmsh_escalations
+        WHERE ${nsClause}
               metadata @> $1::jsonb
           AND ($4::text[] IS NULL OR role = ANY($4::text[]))
           AND status = 'pending'
-          AND (assigned_to IS NULL OR claim_expires_at <= NOW() OR assigned_to = $2)
+          AND (assigned_to IS NULL OR assigned_until IS NULL OR assigned_until <= NOW() OR assigned_to = $2)
         ORDER BY priority ASC, created_at ASC
         LIMIT 1
         FOR UPDATE SKIP LOCKED
       ),
       claimed AS (
         UPDATE public.hmsh_escalations
-        SET status           = 'claimed',
-            assigned_to      = $2,
+        SET assigned_to      = $2,
             claimed_at       = NOW(),
             claim_expires_at = NOW() + ($3 * INTERVAL '1 minute'),
+            assigned_until   = NOW() + ($3 * INTERVAL '1 minute'),
+            metadata         = CASE WHEN $5::jsonb IS NOT NULL
+                                    THEN COALESCE(public.hmsh_escalations.metadata, '{}'::jsonb) || $5::jsonb
+                                    ELSE public.hmsh_escalations.metadata END,
             updated_at       = NOW()
         FROM target WHERE public.hmsh_escalations.id = target.id
-        RETURNING public.hmsh_escalations.*
+        RETURNING public.hmsh_escalations.*, target.prior_assigned_to
       )
       SELECT c.*, (SELECT COUNT(*)::int FROM all_candidates) AS candidates_exist
       FROM (VALUES(1)) AS dummy(v)
       LEFT JOIN claimed c ON true
-    `, namespace
-            ? [filter, assignee, durationMinutes, roles ?? null, namespace]
-            : [filter, assignee, durationMinutes, roles ?? null]);
+    `, queryParams);
         const row = result.rows[0];
         const candidatesExist = row?.candidates_exist ?? 0;
-        if (row?.id)
-            return { ok: true, entry: row, candidatesExist };
+        if (row?.id) {
+            const isExtension = row.prior_assigned_to === assignee;
+            return { ok: true, entry: row, candidatesExist, isExtension };
+        }
         return {
             ok: false,
             reason: candidatesExist > 0 ? 'conflict' : 'not-found',
@@ -1650,14 +1712,11 @@ class PostgresStoreService extends __1.StoreService {
     }
     async releaseEscalation(params) {
         const { id, namespace, assignee } = params;
-        // Single CTE: SELECT FOR UPDATE locks the row, UPDATE releases it iff assignee matches.
-        // Left-join exposes target_id even when the UPDATE did not fire (wrong-assignee case).
-        // No second round-trip — assignee check and UPDATE are one atomic statement.
         const result = await this.pgClient.query(`
       WITH target AS MATERIALIZED (
         SELECT id, assigned_to FROM public.hmsh_escalations
         WHERE id = $1 ${namespace ? 'AND namespace = $3' : ''}
-          AND status = 'claimed'
+          AND status = 'pending' AND assigned_to IS NOT NULL
         FOR UPDATE
       ),
       released AS (
@@ -1667,135 +1726,93 @@ class PostgresStoreService extends __1.StoreService {
         FROM target
         WHERE public.hmsh_escalations.id = target.id
           AND ($2::text IS NULL OR target.assigned_to = $2)
-        RETURNING public.hmsh_escalations.id
+        RETURNING public.hmsh_escalations.*
       )
-      SELECT t.id AS target_id, t.assigned_to AS current_assignee, r.id AS released_id
+      SELECT t.id AS target_id, t.assigned_to AS current_assignee,
+        row_to_json(r)::jsonb AS entry_json
       FROM target t
       LEFT JOIN released r ON r.id = t.id
     `, namespace ? [id, assignee ?? null, namespace] : [id, assignee ?? null]);
         const row = result.rows[0];
         if (!row)
             return { ok: false, reason: 'not-found' };
-        if (!row.released_id)
+        if (!row.entry_json)
             return { ok: false, reason: 'wrong-assignee' };
-        return { ok: true };
+        return { ok: true, entry: row.entry_json };
     }
     async resolveEscalation(params) {
         const { id, namespace, resolverPayload } = params;
-        const result = await this.pgClient.query(`
-      WITH target AS MATERIALIZED (
-        SELECT id, signal_key, topic, status FROM public.hmsh_escalations
-        WHERE id = $1 ${namespace ? 'AND namespace = $3' : ''}
-        LIMIT 1 FOR UPDATE
-      ),
-      resolved AS (
-        UPDATE public.hmsh_escalations
-        SET status           = 'resolved',
-            resolved_at      = NOW(),
-            resolver_payload = $2,
-            updated_at       = NOW()
-        FROM target
-        WHERE public.hmsh_escalations.id = target.id
-          AND target.status IN ('pending', 'claimed')
-        RETURNING public.hmsh_escalations.id
-      )
-      SELECT t.signal_key, t.topic, t.status AS prior_status,
-        CASE
-          WHEN r.id IS NOT NULL THEN 'resolved'
-          WHEN t.id IS NULL     THEN 'not-found'
-          WHEN t.status = 'cancelled' THEN 'already-cancelled'
-          ELSE 'already-resolved'
-        END AS outcome
-      FROM (SELECT * FROM target) t
-      FULL OUTER JOIN (SELECT id FROM resolved) r ON r.id = t.id
-    `, namespace
-            ? [id, resolverPayload ? JSON.stringify(resolverPayload) : null, namespace]
-            : [id, resolverPayload ? JSON.stringify(resolverPayload) : null]);
-        if (!result.rows[0] || result.rows[0].outcome === 'not-found')
-            return { ok: false, reason: 'not-found' };
-        if (result.rows[0].outcome === 'already-cancelled')
-            return { ok: false, reason: 'already-cancelled' };
-        if (result.rows[0].outcome === 'already-resolved')
-            return { ok: false, reason: 'already-resolved' };
-        return { ok: true, signalKey: result.rows[0].signal_key, topic: result.rows[0].topic };
+        const payloadJson = resolverPayload ? JSON.stringify(resolverPayload) : null;
+        // Explicit transaction: FOR UPDATE locks the row; WHERE guard on UPDATE is the TOCTOU
+        // barrier — a concurrent caller whose UPDATE matches 0 rows sees 'already-resolved'.
+        // On crash before COMMIT neither write lands; on crash after COMMIT both are durable.
+        // The resolved row's signal_key is the durable proof for recovery sweeps.
+        await this.pgClient.query('BEGIN');
+        try {
+            const lockResult = await this.pgClient.query(`SELECT id, signal_key, topic, status FROM public.hmsh_escalations
+         WHERE id = $1 ${namespace ? 'AND namespace = $2' : ''} FOR UPDATE`, namespace ? [id, namespace] : [id]);
+            if (!lockResult.rows[0]) {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'not-found' };
+            }
+            const { signal_key, topic, status } = lockResult.rows[0];
+            if (status === 'cancelled') {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'already-cancelled' };
+            }
+            const updateResult = await this.pgClient.query(`UPDATE public.hmsh_escalations
+         SET status = 'resolved', resolved_at = NOW(), resolver_payload = $2, updated_at = NOW()
+         WHERE id = $1 ${namespace ? 'AND namespace = $3' : ''} AND status = 'pending'
+         RETURNING *`, namespace ? [id, payloadJson, namespace] : [id, payloadJson]);
+            if (!updateResult.rows[0]) {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'already-resolved' };
+            }
+            await this.pgClient.query('COMMIT');
+            return { ok: true, entry: updateResult.rows[0], signalKey: signal_key, topic };
+        }
+        catch (e) {
+            await this.pgClient.query('ROLLBACK');
+            throw e;
+        }
     }
     async resolveEscalationByMetadata(params) {
         const { key, value, namespace, resolverPayload, roles } = params;
         const filter = JSON.stringify({ [key]: value });
-        const result = await this.pgClient.query(`
-      WITH target AS MATERIALIZED (
-        SELECT id, signal_key, topic, status FROM public.hmsh_escalations
-        WHERE ${namespace ? 'namespace = $4 AND' : ''}
-              metadata @> $1::jsonb
-          AND ($3::text[] IS NULL OR role = ANY($3::text[]))
-        ORDER BY priority ASC, created_at ASC
-        LIMIT 1 FOR UPDATE
-      ),
-      resolved AS (
-        UPDATE public.hmsh_escalations
-        SET status           = 'resolved',
-            resolved_at      = NOW(),
-            resolver_payload = $2,
-            updated_at       = NOW()
-        FROM target
-        WHERE public.hmsh_escalations.id = target.id
-          AND target.status IN ('pending', 'claimed')
-        RETURNING public.hmsh_escalations.id
-      )
-      SELECT t.signal_key, t.topic, t.status AS prior_status,
-        CASE
-          WHEN r.id IS NOT NULL THEN 'resolved'
-          WHEN t.id IS NULL     THEN 'not-found'
-          WHEN t.status = 'cancelled' THEN 'already-cancelled'
-          ELSE 'already-resolved'
-        END AS outcome
-      FROM (SELECT * FROM target) t
-      FULL OUTER JOIN (SELECT id FROM resolved) r ON r.id = t.id
-    `, namespace
-            ? [filter, resolverPayload ? JSON.stringify(resolverPayload) : null, roles ?? null, namespace]
-            : [filter, resolverPayload ? JSON.stringify(resolverPayload) : null, roles ?? null]);
-        if (!result.rows[0] || result.rows[0].outcome === 'not-found')
-            return { ok: false, reason: 'not-found' };
-        if (result.rows[0].outcome === 'already-cancelled')
-            return { ok: false, reason: 'already-cancelled' };
-        if (result.rows[0].outcome === 'already-resolved')
-            return { ok: false, reason: 'already-resolved' };
-        return { ok: true, signalKey: result.rows[0].signal_key, topic: result.rows[0].topic };
-    }
-    /**
-     * Queues the escalation UPDATE into an existing transaction without executing it.
-     * Used by client.ts resolve() to commit the status change atomically with signal delivery.
-     */
-    queueResolveEscalation(params, transaction) {
-        const { id, namespace, resolverPayload } = params;
-        const sql = namespace
-            ? `UPDATE public.hmsh_escalations
-         SET status = 'resolved', resolved_at = NOW(), resolver_payload = $2, updated_at = NOW()
-         WHERE id = $1 AND namespace = $3 AND status IN ('pending', 'claimed')`
-            : `UPDATE public.hmsh_escalations
+        const payloadJson = resolverPayload ? JSON.stringify(resolverPayload) : null;
+        await this.pgClient.query('BEGIN');
+        try {
+            const lockResult = await this.pgClient.query(`SELECT id, signal_key, topic, status FROM public.hmsh_escalations
+         WHERE ${namespace ? 'namespace = $3 AND' : ''}
+               metadata @> $1::jsonb
+           AND ($2::text[] IS NULL OR role = ANY($2::text[]))
+           AND status IN ('pending', 'cancelled')
+         ORDER BY priority ASC, created_at ASC
+         LIMIT 1 FOR UPDATE`, namespace ? [filter, roles ?? null, namespace] : [filter, roles ?? null]);
+            if (!lockResult.rows[0]) {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'not-found' };
+            }
+            const { id, signal_key, topic, status } = lockResult.rows[0];
+            if (status === 'cancelled') {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'already-cancelled' };
+            }
+            const updateResult = await this.pgClient.query(`UPDATE public.hmsh_escalations
          SET status = 'resolved', resolved_at = NOW(), resolver_payload = $2, updated_at = NOW()
-         WHERE id = $1 AND status IN ('pending', 'claimed')`;
-        const sqlParams = namespace
-            ? [id, resolverPayload ? JSON.stringify(resolverPayload) : null, namespace]
-            : [id, resolverPayload ? JSON.stringify(resolverPayload) : null];
-        transaction.addCommand(sql, sqlParams, 'number');
-    }
-    /**
-     * Finds the highest-priority pending or claimed escalation matching the given metadata filter.
-     * Used by client.ts resolveByMetadata() to get routing info before building the atomic transaction.
-     */
-    async findEscalationByMetadata(key, value, roles, namespace) {
-        const filter = JSON.stringify({ [key]: value });
-        const result = await this.pgClient.query(`
-      SELECT * FROM public.hmsh_escalations
-      WHERE ${namespace ? 'namespace = $3 AND' : ''}
-            metadata @> $1::jsonb
-        AND ($2::text[] IS NULL OR role = ANY($2::text[]))
-        AND status IN ('pending', 'claimed')
-      ORDER BY priority ASC, created_at ASC
-      LIMIT 1
-    `, namespace ? [filter, roles, namespace] : [filter, roles]);
-        return result.rows[0] ?? null;
+         WHERE id = $1 AND status = 'pending'
+         RETURNING *`, [id, payloadJson]);
+            if (!updateResult.rows[0]) {
+                await this.pgClient.query('ROLLBACK');
+                return { ok: false, reason: 'already-resolved' };
+            }
+            await this.pgClient.query('COMMIT');
+            return { ok: true, entry: updateResult.rows[0], signalKey: signal_key, topic };
+        }
+        catch (e) {
+            await this.pgClient.query('ROLLBACK');
+            throw e;
+        }
     }
     async cancelEscalation(id, namespace) {
         const result = await this.pgClient.query(`
@@ -1809,7 +1826,7 @@ class PostgresStoreService extends __1.StoreService {
         SET status = 'cancelled', updated_at = NOW()
         FROM target
         WHERE public.hmsh_escalations.id = target.id
-          AND target.status IN ('pending', 'claimed')
+          AND target.status = 'pending'
         RETURNING public.hmsh_escalations.id
       )
       SELECT t.id, t.status AS prior_status,
@@ -1839,13 +1856,13 @@ class PostgresStoreService extends __1.StoreService {
           claim_expires_at = NULL,
           updated_at       = NOW()
       WHERE id = $1 ${namespace ? 'AND namespace = $3' : ''}
-        AND status IN ('pending', 'claimed')
+        AND status = 'pending'
       RETURNING *
     `, namespace ? [id, targetRole, namespace] : [id, targetRole]);
         return result.rows[0] ?? null;
     }
     async updateEscalation(params) {
-        const { id, namespace, description, priority, role, metadata, envelope, signalKey, topic, workflowId, taskQueue, workflowType, expiresAt } = params;
+        const { id, namespace, description, priority, role, taskId, metadata, envelope, signalKey, topic, workflowId, taskQueue, workflowType, expiresAt } = params;
         const sets = [];
         const values = [id];
         let idx = 2;
@@ -1861,6 +1878,10 @@ class PostgresStoreService extends __1.StoreService {
             sets.push(`role = $${idx++}`);
             values.push(role);
         }
+        if (taskId !== undefined) {
+            sets.push(`task_id = $${idx++}`);
+            values.push(taskId);
+        }
         if (envelope !== undefined) {
             sets.push(`envelope = $${idx++}`);
             values.push(JSON.stringify(envelope));
@@ -1915,16 +1936,134 @@ class PostgresStoreService extends __1.StoreService {
     `, namespace ? [id, JSON.stringify(stamped), namespace] : [id, JSON.stringify(stamped)]);
         return result.rows[0] ?? null;
     }
-    async releaseExpiredEscalations(namespace) {
-        const result = await this.pgClient.query(`
-      UPDATE public.hmsh_escalations
-      SET status = 'pending', assigned_to = NULL, assigned_until = NULL,
-          claimed_at = NULL, claim_expires_at = NULL, updated_at = NOW()
-      WHERE status = 'claimed'
-        AND claim_expires_at <= NOW()
-        ${namespace ? 'AND namespace = $1' : ''}
-    `, namespace ? [namespace] : []);
+    async claimManyEscalations(params) {
+        const { ids, namespace, assignee, durationMinutes = 1 } = params;
+        const result = await this.pgClient.query(`UPDATE public.hmsh_escalations
+       SET assigned_to      = $1,
+           claimed_at       = NOW(),
+           claim_expires_at = NOW() + ($2 * INTERVAL '1 minute'),
+           assigned_until   = NOW() + ($2 * INTERVAL '1 minute'),
+           updated_at       = NOW()
+       WHERE id = ANY($3::uuid[])
+         ${namespace ? 'AND namespace = $4' : ''}
+         AND status = 'pending'
+         AND (assigned_to IS NULL OR assigned_until IS NULL OR assigned_until <= NOW() OR assigned_to = $1)`, namespace ? [assignee, durationMinutes, ids, namespace] : [assignee, durationMinutes, ids]);
+        const claimed = result.rowCount ?? 0;
+        return { claimed, skipped: ids.length - claimed };
+    }
+    async escalateManyEscalationsToRole(params) {
+        const { ids, namespace, targetRole } = params;
+        const result = await this.pgClient.query(`UPDATE public.hmsh_escalations
+       SET role             = $1,
+           status           = 'pending',
+           assigned_to      = NULL,
+           assigned_until   = NULL,
+           claimed_at       = NULL,
+           claim_expires_at = NULL,
+           updated_at       = NOW()
+       WHERE id = ANY($2::uuid[])
+         ${namespace ? 'AND namespace = $3' : ''}
+         AND status = 'pending'`, namespace ? [targetRole, ids, namespace] : [targetRole, ids]);
+        return result.rowCount ?? 0;
+    }
+    async updateManyEscalationsPriority(params) {
+        const { ids, namespace, priority } = params;
+        const result = await this.pgClient.query(`UPDATE public.hmsh_escalations
+       SET priority = $1, updated_at = NOW()
+       WHERE id = ANY($2::uuid[])
+         ${namespace ? 'AND namespace = $3' : ''}
+         AND status = 'pending'`, namespace ? [priority, ids, namespace] : [priority, ids]);
         return result.rowCount ?? 0;
     }
+    async resolveManyEscalations(params) {
+        const { ids, namespace, resolverPayload } = params;
+        const payloadJson = resolverPayload ? JSON.stringify(resolverPayload) : null;
+        const result = await this.pgClient.query(`UPDATE public.hmsh_escalations
+       SET status           = 'resolved',
+           resolved_at      = NOW(),
+           resolver_payload = $1,
+           updated_at       = NOW()
+       WHERE id = ANY($2::uuid[])
+         ${namespace ? 'AND namespace = $3' : ''}
+         AND status = 'pending'
+       RETURNING *`, namespace ? [payloadJson, ids, namespace] : [payloadJson, ids]);
+        return result.rows;
+    }
+    async escalationStats(params = {}) {
+        const { namespace, roles, period = '24h' } = params;
+        if (roles !== undefined && roles.length === 0) {
+            return { pending: 0, claimed: 0, created: 0, resolved: 0, by_role: [], by_type: [] };
+        }
+        const hoursMap = { '1h': 1, '24h': 24, '7d': 168, '30d': 720 };
+        const hours = hoursMap[period] ?? 24;
+        const queryParams = [hours];
+        let idx = 2;
+        const nsClause = namespace ? `AND namespace = $${idx++}` : '';
+        const rolClause = roles?.length ? `AND role = ANY($${idx++}::text[])` : '';
+        if (namespace)
+            queryParams.push(namespace);
+        if (roles?.length)
+            queryParams.push(roles);
+        const result = await this.pgClient.query(`
+      WITH base AS (
+        SELECT * FROM public.hmsh_escalations
+        WHERE true ${nsClause} ${rolClause}
+      ),
+      totals AS (
+        SELECT
+          COUNT(*) FILTER (WHERE status = 'pending')::int AS pending,
+          COUNT(*) FILTER (WHERE status = 'pending'
+            AND assigned_to IS NOT NULL
+            AND assigned_until IS NOT NULL AND assigned_until > NOW())::int AS claimed,
+          COUNT(*) FILTER (WHERE created_at  >= NOW() - ($1 * INTERVAL '1 hour'))::int AS created,
+          COUNT(*) FILTER (WHERE resolved_at >= NOW() - ($1 * INTERVAL '1 hour'))::int AS resolved
+        FROM base
+      ),
+      by_role AS (
+        SELECT role,
+          COUNT(*) FILTER (WHERE status = 'pending')::int AS pending,
+          COUNT(*) FILTER (WHERE status = 'pending'
+            AND assigned_to IS NOT NULL
+            AND assigned_until IS NOT NULL AND assigned_until > NOW())::int AS claimed
+        FROM base WHERE role IS NOT NULL
+        GROUP BY role
+      ),
+      by_type AS (
+        SELECT type,
+          COUNT(*) FILTER (WHERE status = 'pending')::int AS pending,
+          COUNT(*) FILTER (WHERE status = 'pending'
+            AND assigned_to IS NOT NULL
+            AND assigned_until IS NOT NULL AND assigned_until > NOW())::int AS claimed,
+          COUNT(*) FILTER (WHERE resolved_at >= NOW() - ($1 * INTERVAL '1 hour'))::int AS resolved
+        FROM base WHERE type IS NOT NULL
+        GROUP BY type
+      )
+      SELECT
+        t.pending, t.claimed, t.created, t.resolved,
+        COALESCE((SELECT json_agg(json_build_object('role',role,'pending',pending,'claimed',claimed)) FROM by_role), '[]'::json) AS by_role,
+        COALESCE((SELECT json_agg(json_build_object('type',type,'pending',pending,'claimed',claimed,'resolved',resolved)) FROM by_type), '[]'::json) AS by_type
+      FROM totals t
+    `, queryParams);
+        const row = result.rows[0];
+        return {
+            pending: row.pending ?? 0,
+            claimed: row.claimed ?? 0,
+            created: row.created ?? 0,
+            resolved: row.resolved ?? 0,
+            by_role: row.by_role ?? [],
+            by_type: row.by_type ?? [],
+        };
+    }
+    async listDistinctEscalationTypes(namespace) {
+        const result = await this.pgClient.query(`SELECT DISTINCT type FROM public.hmsh_escalations
+       WHERE type IS NOT NULL ${namespace ? 'AND namespace = $1' : ''}
+       ORDER BY type`, namespace ? [namespace] : []);
+        return result.rows.map((r) => r.type);
+    }
+    async releaseExpiredEscalations(_namespace) {
+        // No-op in the implicit claim model: availability is computed at query time from
+        // assigned_until, so no background sweep is needed to release expired claims.
+        return 0;
+    }
 }
 exports.PostgresStoreService = PostgresStoreService;