@hotmeshio/hotmesh 0.22.2 → 0.22.3

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hotmeshio/hotmesh",
-    "version": "0.22.2",
+    "version": "0.22.3",
     "description": "Durable Workflow",
     "main": "./build/index.js",
     "types": "./build/index.d.ts",
@@ -88,6 +88,7 @@
         "test:unit": "vitest run tests/unit",
         "prove": "docker compose exec hotmesh npx vitest run tests/durable 2>&1 | tee /tmp/hmsh-durable.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-durable.txt | tail -5",
         "prove:escalations": "docker compose exec hotmesh npx vitest run tests/durable/escalations/postgres.test.ts 2>&1 | tee /tmp/hmsh-escalations.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-escalations.txt | tail -5",
+        "prove:migrations": "docker compose exec hotmesh npx vitest run tests/durable/migrations/postgres.test.ts 2>&1 | tee /tmp/hmsh-migrations.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-migrations.txt | tail -5",
         "prove:functional": "docker compose exec hotmesh npx vitest run tests/functional 2>&1 | tee /tmp/hmsh-functional.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-functional.txt | tail -5",
         "prove:all": "docker compose exec hotmesh npx vitest run tests/ 2>&1 | tee /tmp/hmsh-all.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-all.txt | tail -5",
         "prove:file": "f() { docker compose exec hotmesh npx vitest run \"$@\" 2>&1 | tee /tmp/hmsh-file.txt && grep -E 'FAIL|Tests |Files ' /tmp/hmsh-file.txt | tail -5; }; f"

package/build/services/escalations/client.d.ts

@@ -1,13 +1,13 @@
 import { HotMesh } from '../hotmesh';
 import { Connection } from '../../types/durable';
-import { EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams, MigrateEscalationParams } from '../../types/hmsh_escalations';
-type GetHotMeshFn = (topic: string | null, namespace?: string) => Promise<HotMesh>;
+import { EscalationEntry, ClaimEscalationResult, ClaimByMetadataResult, ReleaseEscalationResult, ResolveEscalationResult, CancelEscalationResult, ListEscalationsParams, StatsEscalationsParams, EscalationStats, CreateEscalationParams, UpdateEscalationParams, AppendMilestonesParams, ClaimEscalationParams, ClaimByMetadataParams, ReleaseEscalationParams, ResolveEscalationParams, ResolveByMetadataParams, EscalateToRoleParams, MigrateEscalationParams, ClaimManyParams, EscalateManyToRoleParams, UpdateManyPriorityParams, ResolveManyParams } from '../../types/hmsh_escalations';
+export type GetHotMeshFn = (topic: string | null, namespace?: string) => Promise<HotMesh>;
 export interface EscalationClientConfig {
     /** Postgres connection options — used when creating a standalone EscalationClient. */
     connection?: Connection;
     /**
      * Inject a pre-existing `getHotMeshClient` function (e.g. from Durable.Client).
-     * When provided, the client reuses the caller's engine pool — no second connection.
+     * When provided, the client reuses the caller's engine pool — no extra connections.
      */
     getHotMeshClient?: GetHotMeshFn;
 }
@@ -48,7 +48,6 @@ export interface EscalationClientConfig {
  */
 export declare class EscalationClientService {
     private readonly _engine;
-    private readonly _connection?;
     static instances: Map<string, HotMesh | Promise<HotMesh>>;
     constructor(config?: EscalationClientConfig);
     private _makeEngineFactory;
@@ -57,7 +56,7 @@ export declare class EscalationClientService {
     /**
      * Returns all escalation rows matching the given filters. Each row includes
      * a computed `available` field (true = claimable). Supports `sortBy`,
-     * `sortOrder`, and multi-role `roles[]` filter.
+     * `sortOrder`, `orderBy[]`, and multi-role `roles[]` filter.
      */
     list(params?: ListEscalationsParams): Promise<EscalationEntry[]>;
     /**
@@ -84,12 +83,14 @@ export declare class EscalationClientService {
     /**
      * Atomically claims an escalation by UUID. Implicit model: `status` stays
      * `'pending'`; claim is expressed via `assigned_to` + `assigned_until`.
+     * Returns `isExtension: true` when the same assignee re-claims a row they already hold.
      */
     claim(params: ClaimEscalationParams): Promise<ClaimEscalationResult>;
     /**
      * Atomically claims the highest-priority pending escalation whose `metadata`
-     * contains the given key/value. Returns `isExtension: true` when the same
-     * assignee re-claims a row they already hold (extends the expiry).
+     * contains the given key/value. Optionally merges `metadata` into the claimed row
+     * in the same atomic UPDATE. Returns `isExtension: true` when the same assignee
+     * re-claims a row they already hold (extends the expiry).
      */
     claimByMetadata(params: ClaimByMetadataParams): Promise<ClaimByMetadataResult>;
     /** Releases a claimed escalation, returning it to available status. */
@@ -105,14 +106,17 @@ export declare class EscalationClientService {
      */
     cancel(id: string, namespace?: string): Promise<CancelEscalationResult>;
     /**
-     * Signal-first resolve: marks the escalation resolved **and** delivers the
-     * signal to the waiting workflow in a single held transaction. If signal
-     * delivery fails, the transaction rolls back — `committed: false`.
+     * Resolves a pending escalation by UUID. Uses an explicit Postgres transaction
+     * with FOR UPDATE + WHERE guard: only one concurrent caller can commit the
+     * status change; the committed resolved row with its `signal_key` is the
+     * durable proof. Signal delivery is best-effort post-commit — the resolved
+     * row is the recovery record for any missed delivery. Returns the updated
+     * row as `entry` on success.
      */
     resolve(params: ResolveEscalationParams, namespace?: string): Promise<ResolveEscalationResult>;
     /**
      * Resolves the highest-priority matching escalation by metadata filter,
-     * then delivers its signal.
+     * then delivers its signal. Same transaction + WHERE guard semantics as `resolve()`.
      */
     resolveByMetadata(params: ResolveByMetadataParams, namespace?: string): Promise<ResolveEscalationResult>;
     /**
@@ -125,6 +129,40 @@ export declare class EscalationClientService {
      * from `assigned_until`. Kept for API compatibility.
      */
     releaseExpired(namespace?: string): Promise<number>;
+    /**
+     * Bulk-claims up to `ids.length` pending escalations in one statement.
+     * Returns `{ claimed, skipped }` — skipped rows are either already claimed
+     * by another assignee or non-existent. Implicit-claim semantics apply.
+     */
+    claimMany(params: ClaimManyParams): Promise<{
+        claimed: number;
+        skipped: number;
+    }>;
+    /**
+     * Bulk-reassigns pending escalations to a new role, clearing any current claim.
+     * Returns the count of rows updated.
+     */
+    escalateManyToRole(params: EscalateManyToRoleParams): Promise<number>;
+    /**
+     * Bulk-updates priority for pending escalations. Returns the count of rows updated.
+     */
+    updateManyPriority(params: UpdateManyPriorityParams): Promise<number>;
+    /**
+     * Bulk-resolves pending escalations by id-set. No signal delivery — intended
+     * for redirect-to-triage flows where no workflow is waiting. Returns the
+     * resolved rows.
+     */
+    resolveMany(params: ResolveManyParams): Promise<EscalationEntry[]>;
+    /**
+     * Returns dashboard-ready escalation counts. `period` controls the window
+     * used for `created` and `resolved` counts (default `'24h'`). When `roles`
+     * is an empty array, all counts are zero (RBAC guard).
+     */
+    stats(params?: StatsEscalationsParams): Promise<EscalationStats>;
+    /**
+     * Returns the sorted list of distinct `type` values in the escalations table.
+     * Useful for populating filter dropdowns.
+     */
+    listDistinctTypes(namespace?: string): Promise<string[]>;
     static shutdown(): Promise<void>;
 }
-export {};

package/build/services/escalations/client.js

@@ -48,7 +48,6 @@ class EscalationClientService {
             this._engine = config.getHotMeshClient;
         }
         else if (config.connection) {
-            this._connection = config.connection;
             this._engine = this._makeEngineFactory(config.connection);
         }
         else {
@@ -114,7 +113,7 @@ class EscalationClientService {
     /**
      * Returns all escalation rows matching the given filters. Each row includes
      * a computed `available` field (true = claimable). Supports `sortBy`,
-     * `sortOrder`, and multi-role `roles[]` filter.
+     * `sortOrder`, `orderBy[]`, and multi-role `roles[]` filter.
      */
     async list(params) {
         const hm = await this._engine(null, params?.namespace);
@@ -162,6 +161,7 @@ class EscalationClientService {
     /**
      * Atomically claims an escalation by UUID. Implicit model: `status` stays
      * `'pending'`; claim is expressed via `assigned_to` + `assigned_until`.
+     * Returns `isExtension: true` when the same assignee re-claims a row they already hold.
      */
     async claim(params) {
         const hm = await this._engine(null, params.namespace);
@@ -169,8 +169,9 @@ class EscalationClientService {
     }
     /**
      * Atomically claims the highest-priority pending escalation whose `metadata`
-     * contains the given key/value. Returns `isExtension: true` when the same
-     * assignee re-claims a row they already hold (extends the expiry).
+     * contains the given key/value. Optionally merges `metadata` into the claimed row
+     * in the same atomic UPDATE. Returns `isExtension: true` when the same assignee
+     * re-claims a row they already hold (extends the expiry).
      */
     async claimByMetadata(params) {
         const hm = await this._engine(null, params.namespace);
@@ -198,14 +199,18 @@ class EscalationClientService {
         return hm.engine.store.cancelEscalation(id, namespace);
     }
     /**
-     * Signal-first resolve: marks the escalation resolved **and** delivers the
-     * signal to the waiting workflow in a single held transaction. If signal
-     * delivery fails, the transaction rolls back — `committed: false`.
+     * Resolves a pending escalation by UUID. Uses an explicit Postgres transaction
+     * with FOR UPDATE + WHERE guard: only one concurrent caller can commit the
+     * status change; the committed resolved row with its `signal_key` is the
+     * durable proof. Signal delivery is best-effort post-commit — the resolved
+     * row is the recovery record for any missed delivery. Returns the updated
+     * row as `entry` on success.
      */
     async resolve(params, namespace) {
         const ns = (params.namespace ?? namespace) ?? factory_1.APP_ID;
         const hm = await this._engine(null, ns);
-        const dbResult = await hm.engine.store.resolveEscalation({ id: params.id, resolverPayload: params.resolverPayload });
+        const store = hm.engine.store;
+        const dbResult = await store.resolveEscalation({ id: params.id, resolverPayload: params.resolverPayload });
         if (!dbResult.ok)
             return dbResult;
         if (dbResult.signalKey) {
@@ -214,16 +219,17 @@ class EscalationClientService {
                 data: params.resolverPayload ?? {},
             });
         }
-        return { ok: true };
+        return { ok: true, entry: dbResult.entry };
     }
     /**
      * Resolves the highest-priority matching escalation by metadata filter,
-     * then delivers its signal.
+     * then delivers its signal. Same transaction + WHERE guard semantics as `resolve()`.
      */
     async resolveByMetadata(params, namespace) {
         const ns = (params.namespace ?? namespace) ?? factory_1.APP_ID;
         const hm = await this._engine(null, ns);
-        const dbResult = await hm.engine.store.resolveEscalationByMetadata({ key: params.key, value: params.value, resolverPayload: params.resolverPayload, roles: params.roles });
+        const store = hm.engine.store;
+        const dbResult = await store.resolveEscalationByMetadata({ key: params.key, value: params.value, resolverPayload: params.resolverPayload, roles: params.roles });
         if (!dbResult.ok)
             return dbResult;
         if (dbResult.signalKey) {
@@ -232,7 +238,7 @@ class EscalationClientService {
                 data: params.resolverPayload ?? {},
             });
         }
-        return { ok: true };
+        return { ok: true, entry: dbResult.entry };
     }
     /**
      * Full-fidelity migration: inserts an escalation row preserving the original
@@ -251,6 +257,58 @@ class EscalationClientService {
         const hm = await this._engine(null, namespace);
         return hm.engine.store.releaseExpiredEscalations(namespace);
     }
+    // ─── Bulk operations ────────────────────────────────────────────────────────
+    /**
+     * Bulk-claims up to `ids.length` pending escalations in one statement.
+     * Returns `{ claimed, skipped }` — skipped rows are either already claimed
+     * by another assignee or non-existent. Implicit-claim semantics apply.
+     */
+    async claimMany(params) {
+        const hm = await this._engine(null, params.namespace);
+        return hm.engine.store.claimManyEscalations(params);
+    }
+    /**
+     * Bulk-reassigns pending escalations to a new role, clearing any current claim.
+     * Returns the count of rows updated.
+     */
+    async escalateManyToRole(params) {
+        const hm = await this._engine(null, params.namespace);
+        return hm.engine.store.escalateManyEscalationsToRole(params);
+    }
+    /**
+     * Bulk-updates priority for pending escalations. Returns the count of rows updated.
+     */
+    async updateManyPriority(params) {
+        const hm = await this._engine(null, params.namespace);
+        return hm.engine.store.updateManyEscalationsPriority(params);
+    }
+    /**
+     * Bulk-resolves pending escalations by id-set. No signal delivery — intended
+     * for redirect-to-triage flows where no workflow is waiting. Returns the
+     * resolved rows.
+     */
+    async resolveMany(params) {
+        const hm = await this._engine(null, params.namespace);
+        return hm.engine.store.resolveManyEscalations(params);
+    }
+    // ─── Aggregates ─────────────────────────────────────────────────────────────
+    /**
+     * Returns dashboard-ready escalation counts. `period` controls the window
+     * used for `created` and `resolved` counts (default `'24h'`). When `roles`
+     * is an empty array, all counts are zero (RBAC guard).
+     */
+    async stats(params) {
+        const hm = await this._engine(null, params?.namespace);
+        return hm.engine.store.escalationStats(params ?? {});
+    }
+    /**
+     * Returns the sorted list of distinct `type` values in the escalations table.
+     * Useful for populating filter dropdowns.
+     */
+    async listDistinctTypes(namespace) {
+        const hm = await this._engine(null, namespace);
+        return hm.engine.store.listDistinctEscalationTypes(namespace);
+    }
     static async shutdown() {
         for (const [_, instance] of EscalationClientService.instances) {
             (await instance).stop();

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

@@ -166,6 +166,145 @@ const KVTables = (context) => ({
         ON ${jobsTable} (key) WHERE is_live;
       `);
         }
+        // v0.22.0: origin_id, parent_id on per-app jobs table (workflow lineage).
+        // ADD COLUMN IF NOT EXISTS on a nullable column with no DEFAULT is catalog-only
+        // in PG11+ — no table rewrite, brief AccessExclusiveLock only.
+        await client.query(`
+      ALTER TABLE ${jobsTable} ADD COLUMN IF NOT EXISTS origin_id TEXT;
+    `);
+        await client.query(`
+      ALTER TABLE ${jobsTable} ADD COLUMN IF NOT EXISTS parent_id TEXT;
+    `);
+        // Partial indexes — only cover the opt-in rows so build is near-instant.
+        const { rows: originIdxRows } = await client.query(`SELECT 1 FROM pg_indexes WHERE indexname = $1 AND schemaname = $2 LIMIT 1`, [`idx_${schemaName}_jobs_origin`, schemaName]);
+        if (originIdxRows.length === 0) {
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_${schemaName}_jobs_origin
+          ON ${jobsTable}(origin_id) WHERE origin_id IS NOT NULL;
+      `);
+        }
+        const { rows: parentIdxRows } = await client.query(`SELECT 1 FROM pg_indexes WHERE indexname = $1 AND schemaname = $2 LIMIT 1`, [`idx_${schemaName}_jobs_parent`, schemaName]);
+        if (parentIdxRows.length === 0) {
+            await client.query(`
+        CREATE INDEX IF NOT EXISTS idx_${schemaName}_jobs_parent
+          ON ${jobsTable}(parent_id) WHERE parent_id IS NOT NULL;
+      `);
+        }
+        // ─── v0.22.0+: public.hmsh_escalations global table migrations ───────────
+        // Use the fixed advisory XACT lock so concurrent deployments of DIFFERENT
+        // appIds (each holding their own per-appId session lock) don't race on the
+        // shared public table DDL. Transaction-level lock auto-releases on commit/rollback.
+        await client.query('BEGIN');
+        await client.query('SELECT pg_advisory_xact_lock($1)', [0x484D5348]);
+        // v0.22.0: create hmsh_escalations if missing (upgrade from pre-0.22.x).
+        // Column list matches createTables() exactly; task_id is NOT here because
+        // the ADD COLUMN below is the canonical way to add it to both fresh and
+        // existing tables in a single idempotent statement.
+        await client.query(`
+      CREATE TABLE IF NOT EXISTS public.hmsh_escalations (
+        id               UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+        namespace        TEXT NOT NULL,
+        app_id           TEXT NOT NULL,
+        signal_key       TEXT,
+        topic            TEXT,
+        workflow_id      TEXT,
+        task_queue       TEXT,
+        workflow_type    TEXT,
+        type             TEXT,
+        subtype          TEXT,
+        entity           TEXT,
+        description      TEXT,
+        role             TEXT,
+        status           TEXT NOT NULL DEFAULT 'pending',
+        priority         INT  NOT NULL DEFAULT 5,
+        assigned_to      TEXT,
+        assigned_until   TIMESTAMPTZ,
+        claimed_at       TIMESTAMPTZ,
+        claim_expires_at TIMESTAMPTZ,
+        resolved_at      TIMESTAMPTZ,
+        escalation_payload JSONB,
+        resolver_payload   JSONB,
+        envelope           JSONB,
+        metadata           JSONB,
+        origin_id          TEXT,
+        parent_id          TEXT,
+        initiated_by       TEXT,
+        created_by         TEXT,
+        milestones         JSONB NOT NULL DEFAULT '[]',
+        trace_id           TEXT,
+        span_id            TEXT,
+        expires_at         TIMESTAMPTZ,
+        created_at         TIMESTAMPTZ NOT NULL DEFAULT NOW(),
+        updated_at         TIMESTAMPTZ NOT NULL DEFAULT NOW()
+      );
+    `);
+        // v0.22.3: task_id column — catalog-only ADD COLUMN (nullable TEXT, no DEFAULT,
+        // no table rewrite). IF NOT EXISTS makes this idempotent across all upgrade paths.
+        await client.query(`
+      ALTER TABLE public.hmsh_escalations ADD COLUMN IF NOT EXISTS task_id TEXT;
+    `);
+        // Ensure signal_key unique index exists.
+        await client.query(`
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_hmsh_esc_signal_key
+        ON public.hmsh_escalations(namespace, app_id, signal_key)
+        WHERE signal_key IS NOT NULL;
+    `);
+        // v0.22.0: idx_hmsh_esc_available — predicate must be status='pending'.
+        // Fresh 0.22.0 installs may have this with the correct predicate already;
+        // ensure it exists.
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_available
+        ON public.hmsh_escalations(namespace, app_id, role, priority ASC, created_at ASC)
+        WHERE status = 'pending';
+    `);
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_available_expiry
+        ON public.hmsh_escalations(namespace, app_id, role, assigned_until, created_at DESC);
+    `);
+        // v0.22.2: idx_hmsh_esc_assigned predicate changed from status='claimed' to
+        // status='pending' to match the implicit claim model. If the old predicate
+        // is present, drop and recreate so claimEscalation / list queries use it.
+        const { rows: assignedDefRows } = await client.query(`
+      SELECT indexdef FROM pg_indexes WHERE indexname = 'idx_hmsh_esc_assigned' LIMIT 1
+    `);
+        if (assignedDefRows.length > 0 &&
+            assignedDefRows[0].indexdef.includes("status = 'claimed'")) {
+            await client.query(`DROP INDEX IF EXISTS idx_hmsh_esc_assigned;`);
+        }
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_assigned
+        ON public.hmsh_escalations(assigned_to, assigned_until, created_at DESC)
+        WHERE status = 'pending' AND assigned_to IS NOT NULL;
+    `);
+        // v0.22.2: claim_expiry sweeper index is obsolete (releaseExpiredEscalations
+        // is a no-op in the implicit-claim model — availability is query-time computed).
+        await client.query(`DROP INDEX IF EXISTS idx_hmsh_esc_claim_expiry;`);
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_entity
+        ON public.hmsh_escalations(namespace, app_id, entity, created_at DESC)
+        WHERE entity IS NOT NULL;
+    `);
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_workflow
+        ON public.hmsh_escalations(workflow_id)
+        WHERE workflow_id IS NOT NULL;
+    `);
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_origin
+        ON public.hmsh_escalations(origin_id)
+        WHERE origin_id IS NOT NULL;
+    `);
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_metadata
+        ON public.hmsh_escalations USING GIN(metadata jsonb_path_ops);
+    `);
+        // v0.22.3: task_id partial index.
+        await client.query(`
+      CREATE INDEX IF NOT EXISTS idx_hmsh_esc_task
+        ON public.hmsh_escalations(task_id)
+        WHERE task_id IS NOT NULL;
+    `);
+        await client.query('COMMIT');
     },
     async createTables(client, appName) {
         try {
@@ -253,16 +392,15 @@ const KVTables = (context) => ({
               CREATE INDEX IF NOT EXISTS idx_hmsh_esc_available_expiry
                 ON public.hmsh_escalations(namespace, app_id, role, assigned_until, created_at DESC);
             `);
+                        // idx_hmsh_esc_assigned: implicit-claim model uses status='pending', not 'claimed'
+                        await client.query(`DROP INDEX IF EXISTS idx_hmsh_esc_assigned;`);
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_hmsh_esc_assigned
                 ON public.hmsh_escalations(assigned_to, assigned_until, created_at DESC)
-                WHERE status = 'claimed' AND assigned_to IS NOT NULL;
-            `);
-                        await client.query(`
-              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_claim_expiry
-                ON public.hmsh_escalations(claim_expires_at)
-                WHERE status = 'claimed';
+                WHERE status = 'pending' AND assigned_to IS NOT NULL;
             `);
+                        // idx_hmsh_esc_claim_expiry: no longer used (releaseExpiredEscalations is a no-op)
+                        await client.query(`DROP INDEX IF EXISTS idx_hmsh_esc_claim_expiry;`);
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_hmsh_esc_entity
                 ON public.hmsh_escalations(namespace, app_id, entity, created_at DESC)
@@ -281,6 +419,15 @@ const KVTables = (context) => ({
                         await client.query(`
               CREATE INDEX IF NOT EXISTS idx_hmsh_esc_metadata
                 ON public.hmsh_escalations USING GIN(metadata jsonb_path_ops);
+            `);
+                        // task_id: nullable passthrough column for downstream compat (no FK)
+                        await client.query(`
+              ALTER TABLE public.hmsh_escalations ADD COLUMN IF NOT EXISTS task_id TEXT;
+            `);
+                        await client.query(`
+              CREATE INDEX IF NOT EXISTS idx_hmsh_esc_task
+                ON public.hmsh_escalations(task_id)
+                WHERE task_id IS NOT NULL;
             `);
                         break;
                     case 'relational_connection':

package/build/services/store/providers/postgres/postgres.d.ts

@@ -246,6 +246,7 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
     createEscalationForMigration(params: import('../../../../types/hmsh_escalations').MigrateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     getEscalation(id: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     getEscalationBySignalKey(signalKey: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    private _escalationFilterConditions;
     listEscalations(params?: import('../../../../types/hmsh_escalations').ListEscalationsParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry[]>;
     countEscalations(params?: import('../../../../types/hmsh_escalations').ListEscalationsParams): Promise<number>;
     claimEscalation(params: import('../../../../types/hmsh_escalations').ClaimEscalationParams): Promise<import('../../../../types/hmsh_escalations').ClaimEscalationResult>;
@@ -259,26 +260,19 @@ declare class PostgresStoreService extends StoreService<ProviderClient, Provider
         signalKey?: string | null;
         topic?: string | null;
     }>;
-    /**
-     * 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: {
-        id: string;
-        namespace?: string;
-        resolverPayload?: Record<string, unknown>;
-    }, transaction: {
-        addCommand: (sql: string, params: any[], returnType: string) => any;
-    }): void;
-    /**
-     * 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.
-     */
-    findEscalationByMetadata(key: string, value: string, roles: string[] | null, namespace?: string): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     cancelEscalation(id: string, namespace?: string): Promise<import('../../../../types/hmsh_escalations').CancelEscalationResult>;
     escalateEscalationToRole(params: import('../../../../types/hmsh_escalations').EscalateToRoleParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     updateEscalation(params: import('../../../../types/hmsh_escalations').UpdateEscalationParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
     appendEscalationMilestones(params: import('../../../../types/hmsh_escalations').AppendMilestonesParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry | null>;
+    claimManyEscalations(params: import('../../../../types/hmsh_escalations').ClaimManyParams): Promise<{
+        claimed: number;
+        skipped: number;
+    }>;
+    escalateManyEscalationsToRole(params: import('../../../../types/hmsh_escalations').EscalateManyToRoleParams): Promise<number>;
+    updateManyEscalationsPriority(params: import('../../../../types/hmsh_escalations').UpdateManyPriorityParams): Promise<number>;
+    resolveManyEscalations(params: import('../../../../types/hmsh_escalations').ResolveManyParams): Promise<import('../../../../types/hmsh_escalations').EscalationEntry[]>;
+    escalationStats(params?: import('../../../../types/hmsh_escalations').StatsEscalationsParams): Promise<import('../../../../types/hmsh_escalations').EscalationStats>;
+    listDistinctEscalationTypes(namespace?: string): Promise<string[]>;
     releaseExpiredEscalations(_namespace?: string): Promise<number>;
 }
 export { PostgresStoreService };