@hotmeshio/long-tail 0.14.0 → 0.14.3

package/build/api/escalations/bulk.d.ts

@@ -49,6 +49,9 @@ export declare function bulkClaim(input: {
  * @param input.query — `{ role, facets? }` selector (query form)
  * @param input.targetUserId — user to assign to
  * @param input.durationMinutes — assignment duration (default: 30)
+ * @param input.reassign — also take over rows under a LIVE claim (ids form
+ *   only; requires admin/superadmin). Default false: live claims are skipped
+ *   and counted in `skipped`.
  * @param auth — authenticated user context
  * @returns `{ status: 200, data: { assigned, skipped } }`
  */
@@ -60,6 +63,21 @@ export declare function bulkAssign(input: {
     };
     targetUserId: string;
     durationMinutes?: number;
+    reassign?: boolean;
+}, auth: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Return claimed escalations to the available pool — the admin override of
+ * someone else's live claim (self-return stays the release verb). One
+ * guarded statement; unclaimed and terminal rows are skipped. Publishes a
+ * `released` event per returned row with the acting admin in the delta.
+ *
+ * RBAC: admin/superadmin (global escalation access) only.
+ *
+ * @param input.ids — array of escalation UUIDs
+ * @returns `{ status: 200, data: { unassigned, skipped } }`
+ */
+export declare function bulkUnassign(input: {
+    ids?: string[];
 }, auth: LTApiAuth): Promise<LTApiResult>;
 /**
  * Route multiple escalations to a different role.

package/build/api/escalations/bulk.js

@@ -37,6 +37,7 @@ exports.releaseExpiredClaims = releaseExpiredClaims;
 exports.updatePriority = updatePriority;
 exports.bulkClaim = bulkClaim;
 exports.bulkAssign = bulkAssign;
+exports.bulkUnassign = bulkUnassign;
 exports.bulkEscalate = bulkEscalate;
 exports.bulkTriage = bulkTriage;
 const escalationService = __importStar(require("../../services/escalation"));
@@ -133,12 +134,15 @@ async function bulkClaim(input, auth) {
  * @param input.query — `{ role, facets? }` selector (query form)
  * @param input.targetUserId — user to assign to
  * @param input.durationMinutes — assignment duration (default: 30)
+ * @param input.reassign — also take over rows under a LIVE claim (ids form
+ *   only; requires admin/superadmin). Default false: live claims are skipped
+ *   and counted in `skipped`.
  * @param auth — authenticated user context
  * @returns `{ status: 200, data: { assigned, skipped } }`
  */
 async function bulkAssign(input, auth) {
     try {
-        const { ids, query, targetUserId, durationMinutes } = input;
+        const { ids, query, targetUserId, durationMinutes, reassign } = input;
         if (!targetUserId || typeof targetUserId !== 'string') {
             return { status: 400, error: 'targetUserId is required' };
         }
@@ -147,6 +151,14 @@ async function bulkAssign(input, auth) {
         if (hasIds === hasQuery) {
             return { status: 400, error: 'provide exactly one of ids or query' };
         }
+        if (reassign === true && hasQuery) {
+            return { status: 400, error: 'reassign requires the ids form' };
+        }
+        // Taking over a LIVE claim is a management override — stricter than
+        // pre-assigning pool rows, which role-scoped admins may do.
+        if (reassign === true && !(await (0, helpers_1.hasGlobalEscalationAccess)(auth.userId))) {
+            return { status: 403, error: 'Forbidden: reassign requires admin access' };
+        }
         if (hasQuery) {
             if (!query.role || typeof query.role !== 'string') {
                 return { status: 400, error: 'query.role is required' };
@@ -186,6 +198,14 @@ async function bulkAssign(input, auth) {
                 }
             }
         }
+        if (reassign === true) {
+            const result = await escalationService.bulkReassignEscalations(ids, targetUserId, durationMinutes ?? 30);
+            if (result.assigned > 0) {
+                const priorById = new Map(result.changes.map((c) => [c.id, c.prior_assignee]));
+                (0, helpers_1.publishBulkClaimEvents)(result.changes.map((c) => c.id), targetUserId, undefined, priorById);
+            }
+            return { status: 200, data: { assigned: result.assigned, skipped: result.skipped } };
+        }
         const result = await escalationService.bulkAssignEscalations(ids, targetUserId, durationMinutes ?? 30);
         if (result.assigned > 0)
             (0, helpers_1.publishBulkClaimEvents)(ids, targetUserId);
@@ -195,6 +215,34 @@ async function bulkAssign(input, auth) {
         return { status: 500, error: err.message };
     }
 }
+/**
+ * Return claimed escalations to the available pool — the admin override of
+ * someone else's live claim (self-return stays the release verb). One
+ * guarded statement; unclaimed and terminal rows are skipped. Publishes a
+ * `released` event per returned row with the acting admin in the delta.
+ *
+ * RBAC: admin/superadmin (global escalation access) only.
+ *
+ * @param input.ids — array of escalation UUIDs
+ * @returns `{ status: 200, data: { unassigned, skipped } }`
+ */
+async function bulkUnassign(input, auth) {
+    try {
+        if (!(0, helpers_1.validateIds)(input.ids ?? [])) {
+            return { status: 400, error: 'ids must be a non-empty array' };
+        }
+        if (!(await (0, helpers_1.hasGlobalEscalationAccess)(auth.userId))) {
+            return { status: 403, error: 'Forbidden: unassign requires admin access' };
+        }
+        const result = await escalationService.bulkUnassignEscalations(input.ids);
+        if (result.unassigned > 0)
+            (0, helpers_1.publishBulkReleaseEvents)(result.changes, auth.userId);
+        return { status: 200, data: { unassigned: result.unassigned, skipped: result.skipped } };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
 /**
  * Route multiple escalations to a different role.
  *

package/build/api/escalations/claim.d.ts

@@ -21,12 +21,15 @@ export declare function claimEscalation(input: {
  * Release a claimed escalation back to the pool.
  *
  * Only the user who holds the claim can release it. Publishes a
- * `escalation.released` event.
+ * `escalation.released` event unless `quiet` — the identical release with no
+ * event, for bookkeeping releases that are not lifecycle transitions.
  *
  * @param input.id — escalation UUID
+ * @param input.quiet — suppress the `released` event (default: loud)
  * @param auth — authenticated user context
  * @returns `{ status: 200, data: { escalation } }` or 409
  */
 export declare function releaseEscalation(input: {
     id: string;
+    quiet?: boolean;
 }, auth: LTApiAuth): Promise<LTApiResult>;

package/build/api/escalations/claim.js

@@ -81,9 +81,11 @@ async function claimEscalation(input, auth) {
  * Release a claimed escalation back to the pool.
  *
  * Only the user who holds the claim can release it. Publishes a
- * `escalation.released` event.
+ * `escalation.released` event unless `quiet` — the identical release with no
+ * event, for bookkeeping releases that are not lifecycle transitions.
  *
  * @param input.id — escalation UUID
+ * @param input.quiet — suppress the `released` event (default: loud)
  * @param auth — authenticated user context
  * @returns `{ status: 200, data: { escalation } }` or 409
  */
@@ -97,7 +99,9 @@ async function releaseEscalation(input, auth) {
         const manageDenied = await (0, helpers_1.assertQueueManageAccess)(auth.userId, escalation.role);
         if (manageDenied)
             return manageDenied;
-        const result = await escalationService.releaseEscalation(input.id, auth.userId);
+        const result = await escalationService.releaseEscalation(input.id, auth.userId, {
+            quiet: input.quiet === true,
+        });
         if (!result) {
             return { status: 409, error: 'Escalation not found or not claimed by you' };
         }

package/build/api/escalations/helpers.d.ts

@@ -150,4 +150,14 @@ export declare function publishBulkReassignEvents(beforeRows: Array<{
     id: string;
     role: string;
 }>, targetRole: string): void;
-export declare function publishBulkClaimEvents(ids: string[], assignedTo: string, knownRole?: string): void;
+export declare function publishBulkClaimEvents(ids: string[], assignedTo: string, knownRole?: string, priorById?: Map<string, string | null>): void;
+/**
+ * Per-row released events for an admin unassign — the row returns to the
+ * pool under the same verb a self-release produces, with the acting admin in
+ * the delta.
+ */
+export declare function publishBulkReleaseEvents(changes: Array<{
+    id: string;
+    role: string;
+    prior_assignee: string | null;
+}>, releasedBy: string): void;

package/build/api/escalations/helpers.js

@@ -46,6 +46,7 @@ exports.resolveAssignee = resolveAssignee;
 exports.ensureRoleMembership = ensureRoleMembership;
 exports.publishBulkReassignEvents = publishBulkReassignEvents;
 exports.publishBulkClaimEvents = publishBulkClaimEvents;
+exports.publishBulkReleaseEvents = publishBulkReleaseEvents;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
 const publish_1 = require("../../lib/events/publish");
@@ -283,10 +284,11 @@ function publishBulkReassignEvents(beforeRows, targetRole) {
         }
     }
 }
-function publishBulkClaimEvents(ids, assignedTo, knownRole) {
+function publishBulkClaimEvents(ids, assignedTo, knownRole, priorById) {
     // The claimed subject carries each row's role token. Query-form callers
     // already know the single role; id-form callers resolve roles with one
-    // indexed read. Fire-and-forget, like every event publish.
+    // indexed read. Fire-and-forget, like every event publish. `priorById`
+    // (reassign) adds the displaced assignee to each row's delta.
     void (async () => {
         const roleById = new Map();
         if (knownRole) {
@@ -299,6 +301,7 @@ function publishBulkClaimEvents(ids, assignedTo, knownRole) {
                 roleById.set(row.id, row.role);
         }
         for (const id of ids) {
+            const prior = priorById?.get(id);
             (0, publish_1.publishEscalationEvent)({
                 type: 'escalation.claimed',
                 source: 'api',
@@ -310,8 +313,32 @@ function publishBulkClaimEvents(ids, assignedTo, knownRole) {
                 status: 'claimed',
                 // Bulk exception to the one-shape convention (see lib/events/escalation-wire.ts):
                 // delta + `bulk: true`, no per-row fetch. Subscribers fetch by id for detail.
-                data: { assigned_to: assignedTo, bulk: true },
+                data: { assigned_to: assignedTo, bulk: true, ...(prior ? { reassigned_from: prior } : {}) },
             });
         }
     })().catch(() => { });
 }
+/**
+ * Per-row released events for an admin unassign — the row returns to the
+ * pool under the same verb a self-release produces, with the acting admin in
+ * the delta.
+ */
+function publishBulkReleaseEvents(changes, releasedBy) {
+    for (const change of changes) {
+        void (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.released',
+            source: 'api',
+            workflowId: '',
+            workflowName: '',
+            taskQueue: '',
+            escalationId: change.id,
+            role: change.role,
+            status: 'released',
+            data: {
+                released_by: releasedBy,
+                bulk: true,
+                ...(change.prior_assignee ? { unassigned_from: change.prior_assignee } : {}),
+            },
+        });
+    }
+}

package/build/api/escalations/index.d.ts

@@ -2,7 +2,7 @@ export { createEscalation } from './create';
 export { listEscalations, listAvailableEscalations, listDistinctTypes, listFacetKeys, getEscalationStats, getStationMetrics } from './list';
 export { getEscalation, getEscalationsByWorkflowId, escalateToRole } from './single';
 export { claimEscalation, releaseEscalation } from './claim';
-export { releaseExpiredClaims, updatePriority, bulkClaim, bulkAssign, bulkEscalate, bulkTriage } from './bulk';
+export { releaseExpiredClaims, updatePriority, bulkClaim, bulkAssign, bulkUnassign, bulkEscalate, bulkTriage } from './bulk';
 export { resolveEscalation, resolveBySignalKey, resolveByIds, resolveAllOrNone } from './resolve';
 export { findByMetadata, claimByMetadata, resolveByMetadata } from './metadata';
 export { cancelSingleEscalation, bulkCancel } from './cancel';

package/build/api/escalations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.timelineByFacet = exports.aggregateByFacets = exports.claimByFacets = exports.claimGroups = exports.searchByFacets = exports.bulkCancel = exports.cancelSingleEscalation = exports.resolveByMetadata = exports.claimByMetadata = exports.findByMetadata = exports.resolveAllOrNone = exports.resolveByIds = exports.resolveBySignalKey = exports.resolveEscalation = exports.bulkTriage = exports.bulkEscalate = exports.bulkAssign = exports.bulkClaim = exports.updatePriority = exports.releaseExpiredClaims = exports.releaseEscalation = exports.claimEscalation = exports.escalateToRole = exports.getEscalationsByWorkflowId = exports.getEscalation = exports.getStationMetrics = exports.getEscalationStats = exports.listFacetKeys = exports.listDistinctTypes = exports.listAvailableEscalations = exports.listEscalations = exports.createEscalation = void 0;
+exports.timelineByFacet = exports.aggregateByFacets = exports.claimByFacets = exports.claimGroups = exports.searchByFacets = exports.bulkCancel = exports.cancelSingleEscalation = exports.resolveByMetadata = exports.claimByMetadata = exports.findByMetadata = exports.resolveAllOrNone = exports.resolveByIds = exports.resolveBySignalKey = exports.resolveEscalation = exports.bulkTriage = exports.bulkEscalate = exports.bulkUnassign = exports.bulkAssign = exports.bulkClaim = exports.updatePriority = exports.releaseExpiredClaims = exports.releaseEscalation = exports.claimEscalation = exports.escalateToRole = exports.getEscalationsByWorkflowId = exports.getEscalation = exports.getStationMetrics = exports.getEscalationStats = exports.listFacetKeys = exports.listDistinctTypes = exports.listAvailableEscalations = exports.listEscalations = exports.createEscalation = void 0;
 var create_1 = require("./create");
 Object.defineProperty(exports, "createEscalation", { enumerable: true, get: function () { return create_1.createEscalation; } });
 var list_1 = require("./list");
@@ -22,6 +22,7 @@ Object.defineProperty(exports, "releaseExpiredClaims", { enumerable: true, get:
 Object.defineProperty(exports, "updatePriority", { enumerable: true, get: function () { return bulk_1.updatePriority; } });
 Object.defineProperty(exports, "bulkClaim", { enumerable: true, get: function () { return bulk_1.bulkClaim; } });
 Object.defineProperty(exports, "bulkAssign", { enumerable: true, get: function () { return bulk_1.bulkAssign; } });
+Object.defineProperty(exports, "bulkUnassign", { enumerable: true, get: function () { return bulk_1.bulkUnassign; } });
 Object.defineProperty(exports, "bulkEscalate", { enumerable: true, get: function () { return bulk_1.bulkEscalate; } });
 Object.defineProperty(exports, "bulkTriage", { enumerable: true, get: function () { return bulk_1.bulkTriage; } });
 var resolve_1 = require("./resolve");

package/build/index.js

@@ -167,6 +167,10 @@ async function main() {
             },
         },
         examples: true,
+        features: {
+            // The examples ship the full scan demo (schemes 10/11); surface it.
+            scanCodes: true,
+        },
         mcp: {
             server: { enabled: true },
         },

package/build/routes/escalations/bulk.js

@@ -54,9 +54,15 @@ function registerBulkRoutes(router) {
             query: req.body?.query,
             targetUserId: req.body?.targetUserId,
             durationMinutes: req.body?.durationMinutes,
+            // Take over live claims too (ids form; admin/superadmin only).
+            reassign: req.body?.reassign === true,
         }, req.auth);
         res.status(result.status).json(result.data ?? { error: result.error });
     });
+    router.post('/bulk-unassign', async (req, res) => {
+        const result = await api.bulkUnassign({ ids: req.body?.ids }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
+    });
     router.patch('/bulk-escalate', async (req, res) => {
         const result = await api.bulkEscalate({ ids: req.body?.ids, targetRole: req.body?.targetRole }, req.auth);
         res.status(result.status).json(result.data ?? { error: result.error });

package/build/routes/escalations/single.js

@@ -84,12 +84,14 @@ function registerSingleRoutes(router) {
      * Release a claimed escalation back to the available pool.
      * Only the assigned actor (token user, or the badged person when an
      * X-LT-Acting-Token grant rides the request) may release their own claim.
+     * `quiet: true` in the body performs the identical release without the
+     * `released` event — bookkeeping releases only; default stays loud.
      */
     router.post('/:id/release', async (req, res) => {
         const auth = await (0, acting_1.effectiveWorkAuth)(req, res);
         if (!auth)
             return;
-        const result = await api.releaseEscalation({ id: req.params.id }, auth);
+        const result = await api.releaseEscalation({ id: req.params.id, quiet: req.body?.quiet === true }, auth);
         res.status(result.status).json(result.data ?? { error: result.error });
     });
     /**

package/build/sdk/index.d.ts

@@ -139,6 +139,7 @@ export declare function createClient(options?: LTClientOptions): {
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         release: (input: {
             id: string;
+            quiet?: boolean;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         resolve: (input: {
             id: string;
@@ -180,6 +181,10 @@ export declare function createClient(options?: LTClientOptions): {
             };
             targetUserId: string;
             durationMinutes?: number;
+            reassign?: boolean;
+        }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
+        bulkUnassign: (input: {
+            ids?: string[];
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         bulkEscalate: (input: {
             ids: string[];

package/build/sdk/index.js

@@ -136,6 +136,7 @@ function createClient(options = {}) {
             updatePriority: bindAuth(escalationsApi.updatePriority, auth),
             bulkClaim: bindAuth(escalationsApi.bulkClaim, auth),
             bulkAssign: bindAuth(escalationsApi.bulkAssign, auth),
+            bulkUnassign: bindAuth(escalationsApi.bulkUnassign, auth),
             bulkEscalate: bindAuth(escalationsApi.bulkEscalate, auth),
             bulkTriage: bindAuth(escalationsApi.bulkTriage, auth),
             findByMetadata: bindAuth(escalationsApi.findByMetadata, auth),

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

@@ -1,4 +1,10 @@
 import type { LTEscalationRecord } from '../../types';
+/** One row touched by a reassign/unassign, with its pre-update assignee. */
+export interface AssignmentChange {
+    id: string;
+    role: string;
+    prior_assignee: string | null;
+}
 /**
  * Bulk claim escalations for a user.
  * Items already claimed by another active user are skipped.
@@ -29,6 +35,27 @@ export declare function bulkAssignEscalationsByQuery(query: {
     assigned: number;
     ids: string[];
 }>;
+/**
+ * Reassign pending rows to a user, INCLUDING rows under a live claim — the
+ * management override plain assign is not (claimMany skips live claims). One
+ * guarded statement; rows not returned were terminal or missing. Each
+ * returned row carries its pre-update assignee for the event.
+ */
+export declare function bulkReassignEscalations(ids: string[], targetUserId: string, durationMinutes?: number): Promise<{
+    assigned: number;
+    skipped: number;
+    changes: AssignmentChange[];
+}>;
+/**
+ * Return pending claimed rows to the available pool (admin override of
+ * someone else's claim — self-return stays the release verb). One guarded
+ * statement; unclaimed and terminal rows are skipped.
+ */
+export declare function bulkUnassignEscalations(ids: string[]): Promise<{
+    unassigned: number;
+    skipped: number;
+    changes: AssignmentChange[];
+}>;
 /**
  * Bulk reassign escalations to a different role.
  * Clears assignment on all affected rows.

package/build/services/escalation/bulk.js

@@ -3,11 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.bulkClaimEscalations = bulkClaimEscalations;
 exports.bulkAssignEscalations = bulkAssignEscalations;
 exports.bulkAssignEscalationsByQuery = bulkAssignEscalationsByQuery;
+exports.bulkReassignEscalations = bulkReassignEscalations;
+exports.bulkUnassignEscalations = bulkUnassignEscalations;
 exports.bulkEscalateToRole = bulkEscalateToRole;
 exports.bulkCancelEscalations = bulkCancelEscalations;
 exports.bulkResolveForTriage = bulkResolveForTriage;
+const db_1 = require("../../lib/db");
 const client_1 = require("./client");
 const map_1 = require("./map");
+const sql_1 = require("./sql");
 /**
  * Bulk claim escalations for a user.
  * Items already claimed by another active user are skipped.
@@ -49,6 +53,41 @@ async function bulkAssignEscalationsByQuery(query, targetUserId, durationMinutes
     });
     return { assigned: claimed, ids: entries.map((e) => e.id) };
 }
+/**
+ * Reassign pending rows to a user, INCLUDING rows under a live claim — the
+ * management override plain assign is not (claimMany skips live claims). One
+ * guarded statement; rows not returned were terminal or missing. Each
+ * returned row carries its pre-update assignee for the event.
+ */
+async function bulkReassignEscalations(ids, targetUserId, durationMinutes = 30) {
+    if (ids.length === 0)
+        return { assigned: 0, skipped: 0, changes: [] };
+    await (0, client_1.ensureEscalationCompatView)();
+    const { rows } = await (0, db_1.getPool)().query(sql_1.BULK_REASSIGN, [ids, targetUserId, durationMinutes]);
+    const changes = rows.map((r) => ({
+        id: r.id,
+        role: r.role,
+        prior_assignee: r.prior_assignee ?? null,
+    }));
+    return { assigned: rows.length, skipped: ids.length - rows.length, changes };
+}
+/**
+ * Return pending claimed rows to the available pool (admin override of
+ * someone else's claim — self-return stays the release verb). One guarded
+ * statement; unclaimed and terminal rows are skipped.
+ */
+async function bulkUnassignEscalations(ids) {
+    if (ids.length === 0)
+        return { unassigned: 0, skipped: 0, changes: [] };
+    await (0, client_1.ensureEscalationCompatView)();
+    const { rows } = await (0, db_1.getPool)().query(sql_1.BULK_UNASSIGN, [ids]);
+    const changes = rows.map((r) => ({
+        id: r.id,
+        role: r.role,
+        prior_assignee: r.prior_assignee ?? null,
+    }));
+    return { unassigned: rows.length, skipped: ids.length - rows.length, changes };
+}
 /**
  * Bulk reassign escalations to a different role.
  * Clears assignment on all affected rows.

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

@@ -134,8 +134,16 @@ export declare function getEscalationScopeRows(ids: string[]): Promise<{
 /**
  * Release a single escalation claim back to the available pool.
  * Only the assigned user (or superadmin via route) may release.
- */
-export declare function releaseEscalation(id: string, userId: string): Promise<LTEscalationRecord | null>;
+ *
+ * `quiet` performs the identical release without publishing the `released`
+ * event — for bookkeeping releases (a dispatcher's held-skip loop frees rows
+ * every ranking window) that are not lifecycle transitions. Faceted machine
+ * claims are already silent; this is the release-side counterpart. Default
+ * stays loud.
+ */
+export declare function releaseEscalation(id: string, userId: string, opts?: {
+    quiet?: boolean;
+}): Promise<LTEscalationRecord | null>;
 /**
  * Sweep expired claims back to the available pool, returning the count cleared.
  * Availability is already query-time in the implicit model, but long-tail's

package/build/services/escalation/crud.js

@@ -328,24 +328,32 @@ async function getEscalationScopeRows(ids) {
 /**
  * Release a single escalation claim back to the available pool.
  * Only the assigned user (or superadmin via route) may release.
+ *
+ * `quiet` performs the identical release without publishing the `released`
+ * event — for bookkeeping releases (a dispatcher's held-skip loop frees rows
+ * every ranking window) that are not lifecycle transitions. Faceted machine
+ * claims are already silent; this is the release-side counterpart. Default
+ * stays loud.
  */
-async function releaseEscalation(id, userId) {
+async function releaseEscalation(id, userId, opts) {
     const client = await (0, client_1.escalations)();
     const result = await client.release({ id, assignee: userId });
     if (!result.ok)
         return null;
     const released = (0, map_1.toEscalationRecord)(result.entry);
-    publishEscalationChange({
-        type: 'escalation.released',
-        source: 'service',
-        workflowId: released.workflow_id || '',
-        workflowName: released.workflow_type || '',
-        taskQueue: released.task_queue || '',
-        escalationId: released.id,
-        role: released.role,
-        status: 'released',
-        data: (0, escalation_wire_1.escalationEventData)(released, { released_by: userId }),
-    });
+    if (!opts?.quiet) {
+        publishEscalationChange({
+            type: 'escalation.released',
+            source: 'service',
+            workflowId: released.workflow_id || '',
+            workflowName: released.workflow_type || '',
+            taskQueue: released.task_queue || '',
+            escalationId: released.id,
+            role: released.role,
+            status: 'released',
+            data: (0, escalation_wire_1.escalationEventData)(released, { released_by: userId }),
+        });
+    }
     return released;
 }
 /**

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

@@ -8,6 +8,23 @@
  * table. Clears both `assigned_until` and `claim_expires_at`.
  */
 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()";
+/**
+ * Reassign: hand pending rows to a user, INCLUDING rows under a live claim —
+ * the management override that plain assign (claimMany, which skips live
+ * claims) deliberately is not. One statement: the CTE reads each row's
+ * pre-update assignee (CTEs share one snapshot), so callers get
+ * prior_assignee for the event with no read-then-write window. An in-flight
+ * resolve by the prior assignee fails its claim assertion once assigned_to
+ * changes.
+ */
+export declare const BULK_REASSIGN = "WITH prior AS (\n  SELECT id, assigned_to FROM public.hmsh_escalations WHERE id = ANY($1::uuid[])\n)\nUPDATE public.hmsh_escalations e\nSET assigned_to = $2,\n    assigned_until = NOW() + ($3::int * interval '1 minute'),\n    claimed_at = NOW(),\n    updated_at = NOW()\nFROM prior\nWHERE e.id = prior.id\n  AND e.status = 'pending'\nRETURNING e.*, prior.assigned_to AS prior_assignee";
+/**
+ * Unassign: return pending claimed rows to the available pool (an admin
+ * override of someone else's claim — self-return stays the release verb).
+ * Clears the same field set as RELEASE_EXPIRED_CLAIMS, without the expiry
+ * predicate.
+ */
+export declare const BULK_UNASSIGN = "WITH prior AS (\n  SELECT id, assigned_to FROM public.hmsh_escalations WHERE id = ANY($1::uuid[])\n)\nUPDATE public.hmsh_escalations e\nSET assigned_to = NULL,\n    assigned_until = NULL,\n    claimed_at = NULL,\n    claim_expires_at = NULL,\n    updated_at = NOW()\nFROM prior\nWHERE e.id = prior.id\n  AND e.status = 'pending'\n  AND e.assigned_to IS NOT NULL\nRETURNING e.*, prior.assigned_to AS prior_assignee";
 /** Count matching the search WHERE (params $1–$13). */
 export declare const COUNT_SEARCH_ESCALATIONS = "SELECT COUNT(*)::int AS total\n  FROM public.lt_escalations\n  WHERE ($1::text IS NULL OR status = $1)\n    AND ($2::text IS NULL OR role = $2)\n    AND (\n         ($3::text[] IS NULL AND $10::text[] IS NULL)\n      OR ($3::text[] IS NOT NULL AND role = ANY($3))\n      OR ($10::text[] IS NOT NULL AND role = ANY($10) AND assigned_to = $11)\n    )\n    AND ($4::text IS NULL OR type = $4)\n    AND ($5::text IS NULL OR subtype = $5)\n    AND ($6::int IS NULL OR priority = $6)\n    AND ($7::text IS NULL OR assigned_to = $7)\n    AND ($8::boolean IS NULL OR available = $8)\n    AND ($12::jsonb IS NULL OR metadata @> $12)\n    AND ($9::text IS NULL OR origin_id = $9 OR workflow_id = $9\n      OR ($13::uuid IS NOT NULL AND id = $13::uuid))";
 /**

package/build/services/escalation/sql.js

@@ -11,7 +11,7 @@
 // `hmsh_escalations` here rather than composed from generic SDK calls.
 // ---------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STATION_PERIOD_METRICS_SQL = exports.STATION_LIVE_COUNTS_SQL = exports.RESOLVE_BY_METADATA_ATOMIC = exports.COUNT_SEARCH_ESCALATIONS = exports.RELEASE_EXPIRED_CLAIMS = void 0;
+exports.STATION_PERIOD_METRICS_SQL = exports.STATION_LIVE_COUNTS_SQL = exports.RESOLVE_BY_METADATA_ATOMIC = exports.COUNT_SEARCH_ESCALATIONS = exports.BULK_UNASSIGN = exports.BULK_REASSIGN = exports.RELEASE_EXPIRED_CLAIMS = void 0;
 exports.searchEscalationsQuery = searchEscalationsQuery;
 /**
  * Sweep expired claims back to the available pool.
@@ -32,6 +32,49 @@ SET assigned_to = NULL,
 WHERE status = 'pending'
   AND assigned_to IS NOT NULL
   AND assigned_until <= NOW()`;
+/**
+ * Reassign: hand pending rows to a user, INCLUDING rows under a live claim —
+ * the management override that plain assign (claimMany, which skips live
+ * claims) deliberately is not. One statement: the CTE reads each row's
+ * pre-update assignee (CTEs share one snapshot), so callers get
+ * prior_assignee for the event with no read-then-write window. An in-flight
+ * resolve by the prior assignee fails its claim assertion once assigned_to
+ * changes.
+ */
+exports.BULK_REASSIGN = `\
+WITH prior AS (
+  SELECT id, assigned_to FROM public.hmsh_escalations WHERE id = ANY($1::uuid[])
+)
+UPDATE public.hmsh_escalations e
+SET assigned_to = $2,
+    assigned_until = NOW() + ($3::int * interval '1 minute'),
+    claimed_at = NOW(),
+    updated_at = NOW()
+FROM prior
+WHERE e.id = prior.id
+  AND e.status = 'pending'
+RETURNING e.*, prior.assigned_to AS prior_assignee`;
+/**
+ * Unassign: return pending claimed rows to the available pool (an admin
+ * override of someone else's claim — self-return stays the release verb).
+ * Clears the same field set as RELEASE_EXPIRED_CLAIMS, without the expiry
+ * predicate.
+ */
+exports.BULK_UNASSIGN = `\
+WITH prior AS (
+  SELECT id, assigned_to FROM public.hmsh_escalations WHERE id = ANY($1::uuid[])
+)
+UPDATE public.hmsh_escalations e
+SET assigned_to = NULL,
+    assigned_until = NULL,
+    claimed_at = NULL,
+    claim_expires_at = NULL,
+    updated_at = NOW()
+FROM prior
+WHERE e.id = prior.id
+  AND e.status = 'pending'
+  AND e.assigned_to IS NOT NULL
+RETURNING e.*, prior.assigned_to AS prior_assignee`;
 /**
  * Escalation search by correlation id.
  *

package/build/system/mcp-servers/admin/escalations.js

@@ -417,7 +417,7 @@ function registerEscalationTools(server) {
     // mirrors POST /api/escalations/bulk-assign
     server.registerTool('bulk_assign', {
         title: 'Bulk Assign',
-        description: 'Assign multiple escalations to a specific user.',
+        description: 'Assign multiple escalations to a specific user. Rows under a live claim are skipped unless reassign=true (the admin takeover).',
         inputSchema: schemas_1.bulkAssignSchema,
     }, async (args) => {
         const result = await escalationBulkApi.bulkAssign(args, await systemAuth());
@@ -426,6 +426,18 @@ function registerEscalationTools(server) {
         }
         return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
     });
+    // mirrors POST /api/escalations/bulk-unassign
+    server.registerTool('bulk_unassign', {
+        title: 'Bulk Unassign',
+        description: 'Return claimed escalations to the available pool — the admin override of a live claim. Unclaimed and terminal rows are skipped.',
+        inputSchema: schemas_1.bulkUnassignSchema,
+    }, async (args) => {
+        const result = await escalationBulkApi.bulkUnassign(args, await systemAuth());
+        if (result.error) {
+            return { content: [{ type: 'text', text: JSON.stringify({ error: result.error }) }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(result.data) }] };
+    });
     // mirrors PATCH /api/escalations/bulk-escalate
     server.registerTool('bulk_escalate', {
         title: 'Bulk Escalate',

package/build/system/mcp-servers/admin/schemas.d.ts

@@ -1301,14 +1301,24 @@ export declare const bulkAssignSchema: z.ZodObject<{
     ids: z.ZodArray<z.ZodString, "many">;
     targetUserId: z.ZodString;
     durationMinutes: z.ZodOptional<z.ZodNumber>;
+    reassign: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     ids: string[];
     targetUserId: string;
     durationMinutes?: number | undefined;
+    reassign?: boolean | undefined;
 }, {
     ids: string[];
     targetUserId: string;
     durationMinutes?: number | undefined;
+    reassign?: boolean | undefined;
+}>;
+export declare const bulkUnassignSchema: z.ZodObject<{
+    ids: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    ids: string[];
+}, {
+    ids: string[];
 }>;
 export declare const bulkEscalateSchema: z.ZodObject<{
     ids: z.ZodArray<z.ZodString, "many">;