@hotmeshio/long-tail 0.4.13 → 0.4.15

package/build/api/escalations/claim.js

@@ -71,16 +71,7 @@ async function claimEscalation(input, auth) {
         if (!result) {
             return { status: 409, error: 'Escalation not available for claim' };
         }
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.claimed',
-            source: 'api',
-            workflowId: escalation.workflow_id || '',
-            workflowName: escalation.workflow_type || '',
-            taskQueue: escalation.task_queue || '',
-            escalationId: id,
-            status: 'claimed',
-            data: { assigned_to: auth.userId },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 200, data: result };
     }
     catch (err) {

package/build/api/escalations/create.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createEscalation = createEscalation;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
-const publish_1 = require("../../lib/events/publish");
 // ── Create ────────────────────────────────────────────────────────────────
 /**
  * Create a standalone escalation (not tied to a workflow).
@@ -83,16 +82,7 @@ async function createEscalation(input, auth) {
             metadata: input.metadata,
             escalation_payload: input.escalation_payload,
         });
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.created',
-            source: 'api',
-            workflowId: '',
-            workflowName: '',
-            taskQueue: '',
-            escalationId: escalation.id,
-            status: 'pending',
-            data: { type: input.type, role },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 201, data: escalation };
     }
     catch (err) {

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

@@ -7,4 +7,18 @@ export declare function checkBulkPermission(userId: string, ids: string[]): Prom
     status: 403;
     error: string;
 }>;
+/**
+ * Resolve an optional assignee external_id to an internal userId.
+ * When omitted, returns the caller's userId from auth.
+ */
+export declare function resolveAssignee(assignee: string | undefined, auth: {
+    userId: string;
+}): Promise<{
+    userId: string;
+} | {
+    error: {
+        status: number;
+        error: string;
+    };
+}>;
 export declare function publishBulkClaimEvents(ids: string[], assignedTo: string): void;

package/build/api/escalations/helpers.js

@@ -36,6 +36,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getVisibleRoles = getVisibleRoles;
 exports.validateIds = validateIds;
 exports.checkBulkPermission = checkBulkPermission;
+exports.resolveAssignee = resolveAssignee;
 exports.publishBulkClaimEvents = publishBulkClaimEvents;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
@@ -64,6 +65,19 @@ async function checkBulkPermission(userId, ids) {
     }
     return { allowed: true };
 }
+/**
+ * Resolve an optional assignee external_id to an internal userId.
+ * When omitted, returns the caller's userId from auth.
+ */
+async function resolveAssignee(assignee, auth) {
+    if (!assignee)
+        return { userId: auth.userId };
+    const user = await userService.getUserByExternalId(assignee);
+    if (!user) {
+        return { error: { status: 404, error: `User not found for external_id: ${assignee}` } };
+    }
+    return { userId: user.id };
+}
 function publishBulkClaimEvents(ids, assignedTo) {
     for (const id of ids) {
         (0, publish_1.publishEscalationEvent)({

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

@@ -4,3 +4,4 @@ export { getEscalation, getEscalationsByWorkflowId, escalateToRole } from './sin
 export { claimEscalation, releaseEscalation } from './claim';
 export { releaseExpiredClaims, updatePriority, bulkClaim, bulkAssign, bulkEscalate, bulkTriage } from './bulk';
 export { resolveEscalation } from './resolve';
+export { findByMetadata, claimByMetadata, resolveByMetadata } from './metadata';

package/build/api/escalations/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-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.getEscalationStats = exports.listDistinctTypes = exports.listAvailableEscalations = exports.listEscalations = exports.createEscalation = void 0;
+exports.resolveByMetadata = exports.claimByMetadata = exports.findByMetadata = 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.getEscalationStats = 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");
@@ -24,3 +24,7 @@ Object.defineProperty(exports, "bulkEscalate", { enumerable: true, get: function
 Object.defineProperty(exports, "bulkTriage", { enumerable: true, get: function () { return bulk_1.bulkTriage; } });
 var resolve_1 = require("./resolve");
 Object.defineProperty(exports, "resolveEscalation", { enumerable: true, get: function () { return resolve_1.resolveEscalation; } });
+var metadata_1 = require("./metadata");
+Object.defineProperty(exports, "findByMetadata", { enumerable: true, get: function () { return metadata_1.findByMetadata; } });
+Object.defineProperty(exports, "claimByMetadata", { enumerable: true, get: function () { return metadata_1.claimByMetadata; } });
+Object.defineProperty(exports, "resolveByMetadata", { enumerable: true, get: function () { return metadata_1.resolveByMetadata; } });

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

@@ -0,0 +1,58 @@
+import type { LTApiAuth, LTApiResult } from '../../types/sdk';
+/**
+ * Find escalations by a metadata key-value pair.
+ *
+ * Uses JSONB containment (`@>`) backed by a GIN index.
+ * Results are RBAC-scoped to the caller's visible roles.
+ *
+ * @param input.key — metadata field name (e.g. `"orderId"`)
+ * @param input.value — metadata field value (e.g. `"order-123"`)
+ * @param input.status — optional status filter (e.g. `"pending"`)
+ * @returns `{ status: 200, data: { escalations, total } }`
+ */
+export declare function findByMetadata(input: {
+    key: string;
+    value: string;
+    status?: string;
+    limit?: number;
+    offset?: number;
+}, auth: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Claim an escalation by metadata key-value pair.
+ *
+ * Finds one available (pending + unassigned/expired) escalation matching
+ * the metadata and claims it atomically. Optionally resolves an assignee
+ * from an external_id.
+ *
+ * @param input.key — metadata field name
+ * @param input.value — metadata field value
+ * @param input.durationMinutes — claim duration (default 30)
+ * @param input.assignee — optional external_id of the user to claim as
+ * @returns `{ status: 200, data: { escalation, isExtension } }`
+ */
+export declare function claimByMetadata(input: {
+    key: string;
+    value: string;
+    durationMinutes?: number;
+    assignee?: string;
+    metadata?: Record<string, any>;
+}, auth: LTApiAuth): Promise<LTApiResult>;
+/**
+ * Resolve an escalation by metadata key-value pair.
+ *
+ * Finds the pending escalation, auto-claims if unclaimed, then delegates
+ * to the standard resolve logic (supports all 5 resolution paths).
+ *
+ * @param input.key — metadata field name
+ * @param input.value — metadata field value
+ * @param input.resolverPayload — resolution data for the workflow
+ * @param input.assignee — optional external_id of the resolving user
+ * @returns result from the standard resolve endpoint
+ */
+export declare function resolveByMetadata(input: {
+    key: string;
+    value: string;
+    resolverPayload: Record<string, any>;
+    assignee?: string;
+    metadata?: Record<string, any>;
+}, auth: LTApiAuth): Promise<LTApiResult>;

package/build/api/escalations/metadata.js

@@ -0,0 +1,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findByMetadata = findByMetadata;
+exports.claimByMetadata = claimByMetadata;
+exports.resolveByMetadata = resolveByMetadata;
+const escalationService = __importStar(require("../../services/escalation"));
+const userService = __importStar(require("../../services/user"));
+const helpers_1 = require("./helpers");
+/**
+ * Find escalations by a metadata key-value pair.
+ *
+ * Uses JSONB containment (`@>`) backed by a GIN index.
+ * Results are RBAC-scoped to the caller's visible roles.
+ *
+ * @param input.key — metadata field name (e.g. `"orderId"`)
+ * @param input.value — metadata field value (e.g. `"order-123"`)
+ * @param input.status — optional status filter (e.g. `"pending"`)
+ * @returns `{ status: 200, data: { escalations, total } }`
+ */
+async function findByMetadata(input, auth) {
+    try {
+        if (!input.key || !input.value) {
+            return { status: 400, error: 'key and value are required' };
+        }
+        const result = await escalationService.findByMetadata(input.key, input.value, input.status, input.limit, input.offset);
+        // RBAC: scope to visible roles
+        const visibleRoles = await (0, helpers_1.getVisibleRoles)(auth.userId);
+        if (visibleRoles) {
+            const roleSet = new Set(visibleRoles);
+            result.escalations = result.escalations.filter(e => roleSet.has(e.role));
+            result.total = result.escalations.length;
+        }
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Claim an escalation by metadata key-value pair.
+ *
+ * Finds one available (pending + unassigned/expired) escalation matching
+ * the metadata and claims it atomically. Optionally resolves an assignee
+ * from an external_id.
+ *
+ * @param input.key — metadata field name
+ * @param input.value — metadata field value
+ * @param input.durationMinutes — claim duration (default 30)
+ * @param input.assignee — optional external_id of the user to claim as
+ * @returns `{ status: 200, data: { escalation, isExtension } }`
+ */
+async function claimByMetadata(input, auth) {
+    try {
+        if (!input.key || !input.value) {
+            return { status: 400, error: 'key and value are required' };
+        }
+        const resolved = await (0, helpers_1.resolveAssignee)(input.assignee, auth);
+        if ('error' in resolved)
+            return resolved.error;
+        const claimUserId = resolved.userId;
+        // RBAC: find the candidate to check role membership before atomic claim
+        const candidates = await escalationService.findByMetadata(input.key, input.value, 'pending', 1, 0);
+        if (candidates.escalations.length === 0) {
+            return { status: 404, error: 'No pending escalation found for this metadata' };
+        }
+        const candidate = candidates.escalations[0];
+        const isSuperAdmin = await userService.isSuperAdmin(auth.userId);
+        if (!isSuperAdmin) {
+            const userHasRole = await userService.hasRole(claimUserId, candidate.role);
+            if (!userHasRole) {
+                return { status: 403, error: `User must have the "${candidate.role}" role to claim this escalation` };
+            }
+        }
+        const result = await escalationService.claimByMetadata(input.key, input.value, claimUserId, input.durationMinutes, input.metadata);
+        if (!result) {
+            return { status: 409, error: 'Escalation not available for claim' };
+        }
+        // Event published by service layer (services/escalation/crud.ts)
+        return { status: 200, data: result };
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}
+/**
+ * Resolve an escalation by metadata key-value pair.
+ *
+ * Finds the pending escalation, auto-claims if unclaimed, then delegates
+ * to the standard resolve logic (supports all 5 resolution paths).
+ *
+ * @param input.key — metadata field name
+ * @param input.value — metadata field value
+ * @param input.resolverPayload — resolution data for the workflow
+ * @param input.assignee — optional external_id of the resolving user
+ * @returns result from the standard resolve endpoint
+ */
+async function resolveByMetadata(input, auth) {
+    try {
+        if (!input.key || !input.value) {
+            return { status: 400, error: 'key and value are required' };
+        }
+        if (!input.resolverPayload) {
+            return { status: 400, error: 'resolverPayload is required' };
+        }
+        const candidates = await escalationService.findByMetadata(input.key, input.value, 'pending', 1, 0);
+        if (candidates.escalations.length === 0) {
+            return { status: 404, error: 'No pending escalation found for this metadata' };
+        }
+        const escalation = candidates.escalations[0];
+        const resolved = await (0, helpers_1.resolveAssignee)(input.assignee, auth);
+        if ('error' in resolved)
+            return resolved.error;
+        const resolveUserId = resolved.userId;
+        const isSuperAdmin = await userService.isSuperAdmin(auth.userId);
+        if (!isSuperAdmin) {
+            const userHasRole = await userService.hasRole(resolveUserId, escalation.role);
+            if (!userHasRole) {
+                return { status: 403, error: `User must have the "${escalation.role}" role` };
+            }
+        }
+        // Merge additional metadata if provided
+        if (input.metadata && Object.keys(input.metadata).length > 0) {
+            await escalationService.updateEscalationMetadata(escalation.id, input.metadata);
+        }
+        // Auto-claim if unclaimed or expired
+        const isClaimed = escalation.assigned_to &&
+            escalation.assigned_until &&
+            new Date(escalation.assigned_until) > new Date();
+        if (!isClaimed) {
+            await escalationService.claimEscalation(escalation.id, resolveUserId, 5);
+        }
+        // Delegate to the full resolve logic (handles all 5 resolution paths)
+        const { resolveEscalation } = await Promise.resolve().then(() => __importStar(require('./resolve')));
+        return resolveEscalation({ id: escalation.id, resolverPayload: input.resolverPayload }, auth);
+    }
+    catch (err) {
+        return { status: 500, error: err.message };
+    }
+}

package/build/api/escalations/resolve.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveEscalation = resolveEscalation;
 const escalationService = __importStar(require("../../services/escalation"));
 const taskService = __importStar(require("../../services/task"));
-const publish_1 = require("../../lib/events/publish");
 const escalation_strategy_1 = require("../../services/escalation-strategy");
 const ephemeral_1 = require("../../services/iam/ephemeral");
 const deployer_1 = require("../../services/yaml-workflow/deployer");
@@ -105,7 +104,7 @@ async function resolveViaConditionSignal(escalation, resolverPayload) {
     const client = (0, workers_1.createClient)();
     const handle = await client.workflow.getHandle(escalation.task_queue, escalation.workflow_type, escalation.workflow_id);
     await handle.signal(signalId, { ...resolverPayload, $escalation_id: escalation.id });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return signaledResult(escalation, escalation.workflow_id);
 }
 /** Path B: waitFor signal escalation — signal via YAML engine or Durable handle. */
@@ -129,12 +128,7 @@ async function resolveViaSignalRouting(escalation, resolverPayload) {
     if (signalRouting.engine !== 'yaml') {
         await escalationService.resolveEscalation(escalation.id, resolverPayload);
     }
-    publishResolvedEvent(escalation, {
-        workflowId: escalation.workflow_id || signalRouting.workflowId,
-        workflowName: escalation.workflow_type || signalRouting.workflowType,
-        taskQueue: escalation.task_queue || signalRouting.taskQueue || signalRouting.appId,
-        status: signalRouting.engine === 'yaml' ? 'signaled' : 'resolved',
-    });
+    // Event published by service layer (services/escalation/crud.ts)
     return signaledResult(escalation, signalRouting.workflowId || signalRouting.appId);
 }
 /** Path C: escalation strategy directed triage — start a triage workflow. */
@@ -165,7 +159,7 @@ async function resolveViaTriage(escalation, resolverPayload, triageEnvelope) {
         ...resolverPayload,
         _lt: { ...resolverPayload._lt, triaged: true, triageWorkflowId },
     });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return {
         status: 200,
         data: { started: true, escalationId: escalation.id, workflowId: triageWorkflowId, triage: true },
@@ -184,26 +178,13 @@ async function resolveViaRerun(escalation, envelope, resolverPayload) {
         workflowId: newWorkflowId,
         expire: 180,
     });
-    publishResolvedEvent(escalation);
+    // Event published by service layer (services/escalation/crud.ts)
     return {
         status: 200,
         data: { started: true, escalationId: escalation.id, workflowId: newWorkflowId },
     };
 }
 // ── Shared helpers ───────────────────────────────────────────────────────
-function publishResolvedEvent(escalation, overrides) {
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.resolved',
-        source: 'api',
-        workflowId: overrides?.workflowId || escalation.workflow_id || '',
-        workflowName: overrides?.workflowName || escalation.workflow_type || '',
-        taskQueue: overrides?.taskQueue || escalation.task_queue || '',
-        taskId: escalation.task_id,
-        escalationId: escalation.id,
-        originId: escalation.origin_id ?? undefined,
-        status: overrides?.status || 'resolved',
-    });
-}
 function signaledResult(escalation, workflowId) {
     return {
         status: 200,

package/build/bin/ltc.js

@@ -134,6 +134,25 @@ escCmd.command('release <id>')
 escCmd.command('resolve <id>')
     .requiredOption('--data <json>', 'Resolver payload (JSON string)')
     .action(wrap(esc.resolveEscalation));
+escCmd.command('find-by-meta <key> <value>')
+    .description('Find escalations by metadata key-value pair')
+    .option('--status <status>', 'Filter by status')
+    .option('--limit <n>', 'Max results')
+    .option('--json', 'JSON output')
+    .option('-q, --quiet', 'IDs only')
+    .action(wrap(esc.findByMetadata));
+escCmd.command('claim-by-meta <key> <value>')
+    .description('Claim an escalation by metadata key-value pair')
+    .option('--duration <minutes>', 'Claim duration in minutes')
+    .option('--assignee <external_id>', 'Claim on behalf of user (external_id)')
+    .option('--meta <json>', 'Merge metadata (JSON object, e.g. \'{"claimedBy":"jimbo"}\')')
+    .action(wrap(esc.claimByMetadata));
+escCmd.command('resolve-by-meta <key> <value>')
+    .description('Resolve an escalation by metadata key-value pair')
+    .option('--data <json>', 'Resolver payload (JSON string)')
+    .option('--assignee <external_id>', 'Resolve on behalf of user (external_id)')
+    .option('--meta <json>', 'Merge metadata (JSON object)')
+    .action(wrap(esc.resolveByMetadata));
 // ── Workflows ────────────────────────────────────────────────────────────
 const wfCmd = commander_1.program.command('workflows').alias('wf').description('Manage durable workflows');
 wfCmd.command('list')

package/build/lib/cli/commands/escalations.d.ts

@@ -16,4 +16,15 @@ export declare function releaseEscalation(id: string): Promise<void>;
 export declare function resolveEscalation(id: string, opts: {
     data?: string;
 }): Promise<void>;
+export declare function findByMetadata(key: string, value: string, opts: ListOptions): Promise<void>;
+export declare function claimByMetadata(key: string, value: string, opts: {
+    duration?: string;
+    assignee?: string;
+    meta?: string;
+}): Promise<void>;
+export declare function resolveByMetadata(key: string, value: string, opts: {
+    data?: string;
+    assignee?: string;
+    meta?: string;
+}): Promise<void>;
 export {};

package/build/lib/cli/commands/escalations.js

@@ -8,6 +8,9 @@ exports.getEscalation = getEscalation;
 exports.claimEscalation = claimEscalation;
 exports.releaseEscalation = releaseEscalation;
 exports.resolveEscalation = resolveEscalation;
+exports.findByMetadata = findByMetadata;
+exports.claimByMetadata = claimByMetadata;
+exports.resolveByMetadata = resolveByMetadata;
 const picocolors_1 = __importDefault(require("picocolors"));
 const client_1 = require("../client");
 const format_1 = require("../format");
@@ -67,3 +70,40 @@ async function resolveEscalation(id, opts) {
     });
     console.log(`\n  ${picocolors_1.default.green('✓')} Resolved ${picocolors_1.default.dim(id)}\n`);
 }
+// --- Metadata candidate key commands ----------------------------------------
+async function findByMetadata(key, value, opts) {
+    const params = new URLSearchParams({ key, value });
+    if (opts.status)
+        params.set('status', opts.status);
+    if (opts.limit)
+        params.set('limit', opts.limit);
+    const data = await (0, client_1.apiFetch)(`/escalations/by-metadata?${params}`);
+    (0, format_1.output)(data, data.escalations || [], COLUMNS, opts);
+}
+async function claimByMetadata(key, value, opts) {
+    const body = { key, value };
+    if (opts.duration)
+        body.durationMinutes = parseInt(opts.duration, 10);
+    if (opts.assignee)
+        body.assignee = opts.assignee;
+    if (opts.meta)
+        body.metadata = JSON.parse(opts.meta);
+    const data = await (0, client_1.apiFetch)('/escalations/claim-by-metadata', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+    console.log(`\n  ${picocolors_1.default.green('✓')} Claimed ${picocolors_1.default.dim(data.escalation?.id || '')} by ${key}=${value}\n`);
+}
+async function resolveByMetadata(key, value, opts) {
+    const resolverPayload = opts.data ? JSON.parse(opts.data) : {};
+    const body = { key, value, resolverPayload };
+    if (opts.assignee)
+        body.assignee = opts.assignee;
+    if (opts.meta)
+        body.metadata = JSON.parse(opts.meta);
+    await (0, client_1.apiFetch)('/escalations/resolve-by-metadata', {
+        method: 'POST',
+        body: JSON.stringify(body),
+    });
+    console.log(`\n  ${picocolors_1.default.green('✓')} Resolved by ${key}=${value}\n`);
+}

package/build/lib/db/schemas/010_metadata_gin.sql

@@ -0,0 +1,5 @@
+-- GIN index for JSONB containment queries on lt_escalations.metadata.
+-- Enables efficient lookups like: WHERE metadata @> '{"orderId":"order-123"}'::jsonb
+-- Uses jsonb_path_ops (smaller, faster for @> queries).
+CREATE INDEX IF NOT EXISTS idx_lt_escalations_metadata
+  ON lt_escalations USING GIN (metadata jsonb_path_ops);

package/build/lib/events/publish.js

@@ -9,12 +9,14 @@ exports.publishFileEvent = publishFileEvent;
 exports.publishAgentEvent = publishAgentEvent;
 exports.publishWorkflowEvent = publishWorkflowEvent;
 const index_1 = require("./index");
+const logger_1 = require("../logger");
 /**
  * Fire-and-forget publish helper. Swallows errors (best-effort).
  */
 function fireAndForget(event) {
     if (!index_1.eventRegistry.hasAdapters)
         return Promise.resolve();
+    logger_1.loggerRegistry.info(`[lt-pub] ${event.type} ${event.workflowId || ''} ${event.escalationId || event.taskId || ''}`);
     return index_1.eventRegistry.publish(event).catch(() => { });
 }
 /**

package/build/routes/escalations/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const list_1 = require("./list");
 const bulk_1 = require("./bulk");
+const metadata_1 = require("./metadata");
 const single_1 = require("./single");
 const resolve_1 = require("./resolve");
 const router = (0, express_1.Router)();
@@ -12,6 +13,8 @@ const router = (0, express_1.Router)();
 // POST /release-expired, PATCH /priority, POST /bulk-claim,
 // POST /bulk-assign, PATCH /bulk-escalate, POST /bulk-triage
 (0, bulk_1.registerBulkRoutes)(router);
+// GET /by-metadata, POST /claim-by-metadata, POST /resolve-by-metadata
+(0, metadata_1.registerMetadataRoutes)(router);
 // PATCH /:id/escalate, GET /by-workflow/:workflowId,
 // GET /:id, POST /:id/claim, POST /:id/release
 (0, single_1.registerSingleRoutes)(router);

package/build/routes/escalations/metadata.d.ts

@@ -0,0 +1,6 @@
+import type { Router } from 'express';
+/**
+ * Register metadata-based escalation lookup routes.
+ * Must be registered BEFORE parameterized /:id routes.
+ */
+export declare function registerMetadataRoutes(router: Router): void;

package/build/routes/escalations/metadata.js

@@ -0,0 +1,88 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMetadataRoutes = registerMetadataRoutes;
+const api = __importStar(require("../../api/escalations"));
+/**
+ * Register metadata-based escalation lookup routes.
+ * Must be registered BEFORE parameterized /:id routes.
+ */
+function registerMetadataRoutes(router) {
+    /**
+     * GET /api/escalations/by-metadata
+     * Find escalations by a metadata key-value pair.
+     * Query: key, value, status?, limit?, offset?
+     */
+    router.get('/by-metadata', async (req, res) => {
+        const result = await api.findByMetadata({
+            key: req.query.key,
+            value: req.query.value,
+            status: req.query.status,
+            limit: req.query.limit ? parseInt(req.query.limit, 10) : undefined,
+            offset: req.query.offset ? parseInt(req.query.offset, 10) : undefined,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
+    });
+    /**
+     * POST /api/escalations/claim-by-metadata
+     * Find and claim an escalation by metadata key-value pair.
+     * Body: { key, value, durationMinutes?, assignee?, metadata? }
+     */
+    router.post('/claim-by-metadata', async (req, res) => {
+        const result = await api.claimByMetadata({
+            key: req.body?.key,
+            value: req.body?.value,
+            durationMinutes: req.body?.durationMinutes,
+            assignee: req.body?.assignee,
+            metadata: req.body?.metadata,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
+    });
+    /**
+     * POST /api/escalations/resolve-by-metadata
+     * Find and resolve an escalation by metadata key-value pair.
+     * Body: { key, value, resolverPayload, assignee?, metadata? }
+     */
+    router.post('/resolve-by-metadata', async (req, res) => {
+        const result = await api.resolveByMetadata({
+            key: req.body?.key,
+            value: req.body?.value,
+            resolverPayload: req.body?.resolverPayload,
+            assignee: req.body?.assignee,
+            metadata: req.body?.metadata,
+        }, req.auth);
+        res.status(result.status).json(result.data ?? { error: result.error });
+    });
+}