@hotmeshio/long-tail 0.4.14 → 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/metadata.d.ts

@@ -35,6 +35,7 @@ export declare function claimByMetadata(input: {
     value: string;
     durationMinutes?: number;
     assignee?: string;
+    metadata?: Record<string, any>;
 }, auth: LTApiAuth): Promise<LTApiResult>;
 /**
  * Resolve an escalation by metadata key-value pair.
@@ -53,4 +54,5 @@ export declare function resolveByMetadata(input: {
     value: string;
     resolverPayload: Record<string, any>;
     assignee?: string;
+    metadata?: Record<string, any>;
 }, auth: LTApiAuth): Promise<LTApiResult>;

package/build/api/escalations/metadata.js

@@ -38,7 +38,6 @@ exports.claimByMetadata = claimByMetadata;
 exports.resolveByMetadata = resolveByMetadata;
 const escalationService = __importStar(require("../../services/escalation"));
 const userService = __importStar(require("../../services/user"));
-const publish_1 = require("../../lib/events/publish");
 const helpers_1 = require("./helpers");
 /**
  * Find escalations by a metadata key-value pair.
@@ -105,20 +104,11 @@ async function claimByMetadata(input, auth) {
                 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);
+        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' };
         }
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.claimed',
-            source: 'api',
-            workflowId: result.escalation.workflow_id || '',
-            workflowName: result.escalation.workflow_type || '',
-            taskQueue: result.escalation.task_queue || '',
-            escalationId: result.escalation.id,
-            status: 'claimed',
-            data: { assigned_to: claimUserId },
-        });
+        // Event published by service layer (services/escalation/crud.ts)
         return { status: 200, data: result };
     }
     catch (err) {
@@ -161,6 +151,10 @@ async function resolveByMetadata(input, auth) {
                 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 &&

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

@@ -145,11 +145,13 @@ 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');

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

@@ -20,9 +20,11 @@ export declare function findByMetadata(key: string, value: string, opts: ListOpt
 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

@@ -86,6 +86,8 @@ async function claimByMetadata(key, value, opts) {
         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),
@@ -97,6 +99,8 @@ async function resolveByMetadata(key, value, opts) {
     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),

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/metadata.js

@@ -58,7 +58,7 @@ function registerMetadataRoutes(router) {
     /**
      * POST /api/escalations/claim-by-metadata
      * Find and claim an escalation by metadata key-value pair.
-     * Body: { key, value, durationMinutes?, assignee? }
+     * Body: { key, value, durationMinutes?, assignee?, metadata? }
      */
     router.post('/claim-by-metadata', async (req, res) => {
         const result = await api.claimByMetadata({
@@ -66,13 +66,14 @@ function registerMetadataRoutes(router) {
             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? }
+     * Body: { key, value, resolverPayload, assignee?, metadata? }
      */
     router.post('/resolve-by-metadata', async (req, res) => {
         const result = await api.resolveByMetadata({
@@ -80,6 +81,7 @@ function registerMetadataRoutes(router) {
             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 });
     });

package/build/sdk/index.d.ts

@@ -162,12 +162,14 @@ export declare function createClient(options?: LTClientOptions): {
             value: string;
             durationMinutes?: number;
             assignee?: string;
+            metadata?: Record<string, any>;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         resolveByMetadata: (input: {
             key: string;
             value: string;
             resolverPayload: Record<string, any>;
             assignee?: string;
+            metadata?: Record<string, any>;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
     };
     workflows: {

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

@@ -49,4 +49,4 @@ export declare function findByMetadata(key: string, value: string, status?: stri
     escalations: LTEscalationRecord[];
     total: number;
 }>;
-export declare function claimByMetadata(key: string, value: string, userId: string, durationMinutes?: number): Promise<ClaimResult | null>;
+export declare function claimByMetadata(key: string, value: string, userId: string, durationMinutes?: number, metadata?: Record<string, any>): Promise<ClaimResult | null>;

package/build/services/escalation/crud.js

@@ -17,8 +17,11 @@ exports.getEscalationsByOriginId = getEscalationsByOriginId;
 exports.findByMetadata = findByMetadata;
 exports.claimByMetadata = claimByMetadata;
 const db_1 = require("../../lib/db");
+const publish_1 = require("../../lib/events/publish");
+const logger_1 = require("../../lib/logger");
 const sql_1 = require("./sql");
 async function createEscalation(input) {
+    logger_1.loggerRegistry.info(`[escalation-crud] createEscalation called for wf=${input.workflow_id} type=${input.type} caller=${new Error().stack?.split('\n')[2]?.trim()}`);
     const pool = (0, db_1.getPool)();
     // Ensure the role exists in lt_roles (FK constraint)
     await pool.query(sql_1.ENSURE_ROLE_EXISTS, [input.role]);
@@ -40,7 +43,18 @@ async function createEscalation(input) {
         input.trace_id || null,
         input.span_id || null,
     ]);
-    return rows[0];
+    const escalation = rows[0];
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.created',
+        source: 'service',
+        workflowId: escalation.workflow_id || '',
+        workflowName: escalation.workflow_type || '',
+        taskQueue: escalation.task_queue || '',
+        escalationId: escalation.id,
+        status: 'pending',
+        data: { type: input.type, role: input.role },
+    });
+    return escalation;
 }
 /**
  * Atomic claim operation. Does NOT change status — "claimed" is implicit
@@ -58,15 +72,39 @@ async function claimEscalation(id, userId, durationMinutes = 30) {
     if (rows.length === 0)
         return null;
     const row = rows[0];
+    const escalation = row;
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.claimed',
+        source: 'service',
+        workflowId: escalation.workflow_id || '',
+        workflowName: escalation.workflow_type || '',
+        taskQueue: escalation.task_queue || '',
+        escalationId: escalation.id,
+        status: 'claimed',
+        data: { assigned_to: userId },
+    });
     return {
-        escalation: row,
+        escalation,
         isExtension: row.prev_assigned_to === userId,
     };
 }
 async function resolveEscalation(id, resolverPayload) {
     const pool = (0, db_1.getPool)();
     const { rows } = await pool.query(sql_1.RESOLVE_ESCALATION, [id, JSON.stringify(resolverPayload)]);
-    return rows[0] || null;
+    const escalation = rows[0] || null;
+    if (escalation) {
+        (0, publish_1.publishEscalationEvent)({
+            type: 'escalation.resolved',
+            source: 'service',
+            workflowId: escalation.workflow_id || '',
+            workflowName: escalation.workflow_type || '',
+            taskQueue: escalation.task_queue || '',
+            escalationId: escalation.id,
+            status: 'resolved',
+            data: {},
+        });
+    }
+    return escalation;
 }
 /**
  * Bulk update priority for a set of escalations.
@@ -163,15 +201,27 @@ async function findByMetadata(key, value, status, limit = 50, offset = 0) {
         total: parseInt(countResult.rows[0].count, 10),
     };
 }
-async function claimByMetadata(key, value, userId, durationMinutes = 30) {
+async function claimByMetadata(key, value, userId, durationMinutes = 30, metadata) {
     const pool = (0, db_1.getPool)();
     const filter = JSON.stringify({ [key]: value });
-    const { rows } = await pool.query(sql_1.CLAIM_BY_METADATA, [filter, userId, durationMinutes]);
+    const metaPatch = metadata ? JSON.stringify(metadata) : null;
+    const { rows } = await pool.query(sql_1.CLAIM_BY_METADATA, [filter, userId, durationMinutes, metaPatch]);
     if (rows.length === 0)
         return null;
     const row = rows[0];
+    const escalation = row;
+    (0, publish_1.publishEscalationEvent)({
+        type: 'escalation.claimed',
+        source: 'service',
+        workflowId: escalation.workflow_id || '',
+        workflowName: escalation.workflow_type || '',
+        taskQueue: escalation.task_queue || '',
+        escalationId: escalation.id,
+        status: 'claimed',
+        data: { assigned_to: userId },
+    });
     return {
-        escalation: row,
+        escalation,
         isExtension: row.prev_assigned_to === userId,
     };
 }

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

@@ -22,5 +22,5 @@ export declare const LIST_DISTINCT_TYPES = "SELECT DISTINCT type FROM lt_escalat
 /** Find escalations by a single metadata key-value pair. */
 export declare const FIND_BY_METADATA = "SELECT * FROM lt_escalations\nWHERE metadata @> $1::jsonb\n  AND ($2::text IS NULL OR status = $2)\nORDER BY priority ASC, created_at ASC\nLIMIT $3 OFFSET $4";
 export declare const COUNT_BY_METADATA = "SELECT COUNT(*) FROM lt_escalations\nWHERE metadata @> $1::jsonb\n  AND ($2::text IS NULL OR status = $2)";
-/** Atomic claim by metadata: find one available escalation and claim it. */
-export declare const CLAIM_BY_METADATA = "WITH target AS (\n  SELECT id, assigned_to\n  FROM lt_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND (\n      assigned_to IS NULL\n      OR assigned_until <= NOW()\n      OR assigned_to = $2\n    )\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE SKIP LOCKED\n),\nupdated AS (\n  UPDATE lt_escalations e\n  SET assigned_to = $2,\n      claimed_at = NOW(),\n      assigned_until = NOW() + INTERVAL '1 minute' * $3\n  FROM target t\n  WHERE e.id = t.id\n  RETURNING e.*, t.assigned_to AS prev_assigned_to\n)\nSELECT * FROM updated";
+/** Atomic claim by metadata: find one available escalation, claim it, and optionally merge metadata. */
+export declare const CLAIM_BY_METADATA = "WITH target AS (\n  SELECT id, assigned_to\n  FROM lt_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND (\n      assigned_to IS NULL\n      OR assigned_until <= NOW()\n      OR assigned_to = $2\n    )\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE SKIP LOCKED\n),\nupdated AS (\n  UPDATE lt_escalations e\n  SET assigned_to = $2,\n      claimed_at = NOW(),\n      assigned_until = NOW() + INTERVAL '1 minute' * $3,\n      metadata = CASE WHEN $4::jsonb IS NOT NULL\n        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb\n        ELSE e.metadata END\n  FROM target t\n  WHERE e.id = t.id\n  RETURNING e.*, t.assigned_to AS prev_assigned_to\n)\nSELECT * FROM updated";

package/build/services/escalation/sql.js

@@ -145,7 +145,7 @@ exports.COUNT_BY_METADATA = `\
 SELECT COUNT(*) FROM lt_escalations
 WHERE metadata @> $1::jsonb
   AND ($2::text IS NULL OR status = $2)`;
-/** Atomic claim by metadata: find one available escalation and claim it. */
+/** Atomic claim by metadata: find one available escalation, claim it, and optionally merge metadata. */
 exports.CLAIM_BY_METADATA = `\
 WITH target AS (
   SELECT id, assigned_to
@@ -165,7 +165,10 @@ updated AS (
   UPDATE lt_escalations e
   SET assigned_to = $2,
       claimed_at = NOW(),
-      assigned_until = NOW() + INTERVAL '1 minute' * $3
+      assigned_until = NOW() + INTERVAL '1 minute' * $3,
+      metadata = CASE WHEN $4::jsonb IS NOT NULL
+        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb
+        ELSE e.metadata END
   FROM target t
   WHERE e.id = t.id
   RETURNING e.*, t.assigned_to AS prev_assigned_to

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

@@ -39,7 +39,6 @@ exports.ltEnrichEscalationRouting = ltEnrichEscalationRouting;
 exports.ltCreateEscalation = ltCreateEscalation;
 const escalationService = __importStar(require("../../escalation"));
 const logger_1 = require("../../../lib/logger");
-const publish_1 = require("../../../lib/events/publish");
 /**
  * Resolve an escalation record. Called by the interceptor after
  * detecting a re-run (resolver data present in the envelope).
@@ -107,15 +106,6 @@ async function ltCreateEscalation(input) {
         trace_id: input.traceId,
         span_id: input.spanId,
     });
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.created',
-        source: 'interceptor',
-        workflowId: input.workflowId || '',
-        workflowName: input.workflowType || '',
-        taskQueue: input.taskQueue || '',
-        escalationId: escalation.id,
-        status: 'pending',
-        data: { type: input.type, role: input.role },
-    });
+    // Event published by service layer (services/escalation/crud.ts)
     return escalation.id;
 }

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

@@ -81,16 +81,7 @@ async function ltCreateTask(input) {
         executing_as: input.executingAs,
         status: input.status,
     });
-    (0, publish_1.publishTaskEvent)({
-        type: 'task.created',
-        source: 'interceptor',
-        workflowId: input.workflowId,
-        workflowName: input.workflowType,
-        taskQueue: input.taskQueue || 'unknown',
-        taskId: task.id,
-        originId: input.originId,
-        status: input.status || 'pending',
-    });
+    // Event published by service layer (services/task/crud.ts)
     return task.id;
 }
 /**
@@ -109,19 +100,7 @@ async function ltCompleteTask(input) {
         data: input.data,
         milestones: input.milestones,
     });
-    // Publish task.completed event
-    if (input.workflowId) {
-        (0, publish_1.publishTaskEvent)({
-            type: 'task.completed',
-            source: 'orchestrator',
-            workflowId: input.workflowId,
-            workflowName: input.workflowName || 'unknown',
-            taskQueue: input.taskQueue || 'unknown',
-            taskId: input.taskId,
-            status: 'completed',
-            milestones: input.milestones,
-        });
-    }
+    // task.completed event published by service layer (services/task/crud.ts)
     // Publish milestone event from orchestrator context
     if (input.milestones?.length && input.workflowId) {
         (0, publish_1.publishMilestoneEvent)({

package/build/services/interceptor/completion.js

@@ -115,28 +115,8 @@ async function createAdvisoryEscalation(state, result) {
         traceId: state.traceId,
         spanId: state.spanId,
     });
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.created',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        escalationId,
-        originId: state.envelope?.lt?.originId,
-        status: 'pending',
-        data: result.data,
-    });
-    (0, publish_1.publishTaskEvent)({
-        type: 'task.escalated',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        originId: state.envelope?.lt?.originId,
-        status: 'needs_intervention',
-    });
+    // escalation.created event published by service layer (services/escalation/crud.ts)
+    // task.escalated event published by service layer (services/task/crud.ts)
     // Auto-claim to submitting user if known
     const userId = state.envelope?.lt?.userId;
     if (userId) {

package/build/services/interceptor/escalation.js

@@ -41,28 +41,8 @@ async function handleEscalation(state, result) {
         traceId: state.traceId,
         spanId: state.spanId,
     });
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.created',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        escalationId,
-        originId: state.envelope?.lt?.originId,
-        status: 'pending',
-        data: result.data,
-    });
-    (0, publish_1.publishTaskEvent)({
-        type: 'task.escalated',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        originId: state.envelope?.lt?.originId,
-        status: 'needs_intervention',
-    });
+    // escalation.created event published by service layer (services/escalation/crud.ts)
+    // task.escalated event published by service layer (services/task/crud.ts)
     return result;
 }
 /**
@@ -109,28 +89,9 @@ async function handleErrorEscalation(state, err) {
         traceId: state.traceId,
         spanId: state.spanId,
     });
-    (0, publish_1.publishEscalationEvent)({
-        type: 'escalation.created',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        escalationId: errorEscalationId,
-        originId: state.envelope?.lt?.originId,
-        status: 'pending',
-        data: { error: err.message },
-    });
-    (0, publish_1.publishTaskEvent)({
-        type: 'task.escalated',
-        source: 'interceptor',
-        workflowId: state.workflowId,
-        workflowName: state.workflowName,
-        taskQueue: state.taskQueue,
-        taskId: state.taskId,
-        originId: state.envelope?.lt?.originId,
-        status: 'needs_intervention',
-    });
+    // escalation.created event published by service layer (services/escalation/crud.ts)
+    // task.escalated event published by service layer (services/task/crud.ts)
+    // Publish workflow.failed event (error path only runs once — no replay guard needed)
     (0, publish_1.publishWorkflowEvent)({
         type: 'workflow.failed',
         source: 'interceptor',

package/build/services/interceptor/index.js

@@ -44,6 +44,7 @@ const escalation_1 = require("./escalation");
 const completion_1 = require("./completion");
 const lifecycle_1 = require("./lifecycle");
 const context_2 = require("../iam/context");
+const publish_1 = require("../../lib/events/publish");
 const envelope_1 = require("../iam/envelope");
 const DEFAULT_ACTIVITY_QUEUE = 'lt-interceptor';
 /**
@@ -104,13 +105,36 @@ function createLTInterceptor(options) {
             //    task creation, and escalation wiring.
             if (envelope?.metadata?.certified !== true) {
                 const toolCtx = (0, envelope_1.buildToolContextFromEnvelope)(envelope, wf.workflowId, wf.workflowTrace, wf.workflowSpan);
-                return toolCtx ? (0, context_2.runWithToolContext)(toolCtx, next) : next();
+                // Publish workflow events even for uncertified workflows
+                const taskQueue = (0, lifecycle_1.deriveTaskQueue)(wf);
+                (0, lifecycle_1.publishStartedEvents)(wf, taskQueue, undefined, wf.workflowId);
+                const result = toolCtx ? await (0, context_2.runWithToolContext)(toolCtx, next) : await next();
+                (0, publish_1.publishWorkflowEvent)({
+                    type: 'workflow.completed',
+                    source: 'interceptor',
+                    workflowId: wf.workflowId,
+                    workflowName: wf.workflowName,
+                    taskQueue,
+                    status: 'completed',
+                });
+                return result;
             }
             // 3. Load config — unregistered/uncertified workflows get ToolContext only
             const wfConfig = await activities.ltGetWorkflowConfig(wf.workflowName);
             if (!wfConfig) {
                 const toolCtx = (0, envelope_1.buildToolContextFromEnvelope)(envelope, wf.workflowId, wf.workflowTrace, wf.workflowSpan);
-                return toolCtx ? (0, context_2.runWithToolContext)(toolCtx, next) : next();
+                const taskQueue2 = (0, lifecycle_1.deriveTaskQueue)(wf);
+                (0, lifecycle_1.publishStartedEvents)(wf, taskQueue2, undefined, wf.workflowId);
+                const result2 = toolCtx ? await (0, context_2.runWithToolContext)(toolCtx, next) : await next();
+                (0, publish_1.publishWorkflowEvent)({
+                    type: 'workflow.completed',
+                    source: 'interceptor',
+                    workflowId: wf.workflowId,
+                    workflowName: wf.workflowName,
+                    taskQueue: taskQueue2,
+                    status: 'completed',
+                });
+                return result2;
             }
             const taskQueue = (0, lifecycle_1.deriveTaskQueue)(wf);
             // 3. Find existing task and handle re-run escalation resolution

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

@@ -37,7 +37,7 @@ export declare function resolveReRun(activities: ProxiedActivities, envelope: LT
  * Also injects originId back into the envelope for downstream consistency.
  */
 export declare function ensureTaskWithRouting(activities: ProxiedActivities, wf: WorkflowIdentity, envelope: LTEnvelope | undefined, existingTask: any | null, taskQueue: string, reRun: ReRunContext): Promise<TaskContext>;
-/** Publish workflow.started + task.started events. */
+/** Publish workflow.started event (guarded against replay). */
 export declare function publishStartedEvents(wf: WorkflowIdentity, taskQueue: string, taskId: string | undefined, originId: string): void;
 /** Complete a task and signal parent for plain (non-LTReturn) results. */
 export declare function completePlainResult(activities: ProxiedActivities, wf: WorkflowIdentity, taskQueue: string, taskId: string | undefined, routing: Record<string, any> | null, result: any): Promise<void>;

package/build/services/interceptor/lifecycle.js

@@ -13,6 +13,7 @@ exports.resolveReRun = resolveReRun;
 exports.ensureTaskWithRouting = ensureTaskWithRouting;
 exports.publishStartedEvents = publishStartedEvents;
 exports.completePlainResult = completePlainResult;
+const hotmesh_1 = require("@hotmeshio/hotmesh");
 const publish_1 = require("../../lib/events/publish");
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /** Extract workflow identity fields from the HotMesh context map. */
@@ -56,17 +57,7 @@ async function resolveReRun(activities, envelope, existingTask, wf, taskQueue) {
             escalationId: escalationId,
             resolverPayload: envelope.resolver,
         });
-        (0, publish_1.publishEscalationEvent)({
-            type: 'escalation.resolved',
-            source: 'interceptor',
-            workflowId: wf.workflowId,
-            workflowName: wf.workflowName,
-            taskQueue,
-            taskId: task?.id || existingTask?.id,
-            escalationId: escalationId,
-            originId: envelope?.lt?.originId,
-            status: 'resolved',
-        });
+        // escalation.resolved event published by service layer (services/escalation/crud.ts)
     }
     return { isReRun, task, metadata };
 }
@@ -128,28 +119,23 @@ async function ensureTaskWithRouting(activities, wf, envelope, existingTask, tas
     }
     return { taskId, routing, originId };
 }
-/** Publish workflow.started + task.started events. */
+/** Publish workflow.started event (guarded against replay). */
 function publishStartedEvents(wf, taskQueue, taskId, originId) {
-    (0, publish_1.publishWorkflowEvent)({
-        type: 'workflow.started',
-        source: 'interceptor',
-        workflowId: wf.workflowId,
-        workflowName: wf.workflowName,
-        taskQueue,
-        taskId,
-        originId,
-        status: 'running',
-    });
-    (0, publish_1.publishTaskEvent)({
-        type: 'task.started',
-        source: 'interceptor',
-        workflowId: wf.workflowId,
-        workflowName: wf.workflowName,
-        taskQueue,
-        taskId: taskId,
-        originId,
-        status: 'in_progress',
-    });
+    const { replay } = hotmesh_1.Durable.workflow.workflowInfo();
+    const isFirstExecution = Object.keys(replay).length === 0;
+    if (isFirstExecution) {
+        (0, publish_1.publishWorkflowEvent)({
+            type: 'workflow.started',
+            source: 'interceptor',
+            workflowId: wf.workflowId,
+            workflowName: wf.workflowName,
+            taskQueue,
+            taskId,
+            originId,
+            status: 'running',
+        });
+    }
+    // task.started event published by service layer (services/task/crud.ts)
 }
 /** Complete a task and signal parent for plain (non-LTReturn) results. */
 async function completePlainResult(activities, wf, taskQueue, taskId, routing, result) {

package/build/services/task/crud.js

@@ -8,6 +8,7 @@ exports.getTaskBySignalId = getTaskBySignalId;
 exports.getTaskByWorkflowId = getTaskByWorkflowId;
 exports.listTasks = listTasks;
 const db_1 = require("../../lib/db");
+const publish_1 = require("../../lib/events/publish");
 const sql_1 = require("./sql");
 async function createTask(input) {
     const pool = (0, db_1.getPool)();
@@ -30,7 +31,18 @@ async function createTask(input) {
         input.executing_as || null,
         input.status || null,
     ]);
-    return rows[0];
+    const task = rows[0];
+    (0, publish_1.publishTaskEvent)({
+        type: 'task.created',
+        source: 'service',
+        workflowId: task.workflow_id || '',
+        workflowName: task.workflow_type || '',
+        taskQueue: task.task_queue || '',
+        taskId: task.id,
+        originId: task.origin_id || undefined,
+        status: task.status || 'pending',
+    });
+    return task;
 }
 async function updateTask(id, input) {
     const pool = (0, db_1.getPool)();
@@ -59,7 +71,29 @@ async function updateTask(id, input) {
     }
     values.push(id);
     const { rows } = await pool.query(`UPDATE lt_tasks SET ${sets.join(', ')} WHERE id = $${idx} RETURNING *`, values);
-    return rows[0];
+    const task = rows[0];
+    // Publish status-driven events from the single write path
+    if (input.status && task) {
+        const STATUS_EVENTS = {
+            in_progress: 'task.started',
+            completed: 'task.completed',
+            needs_intervention: 'task.escalated',
+        };
+        const eventType = STATUS_EVENTS[input.status];
+        if (eventType) {
+            (0, publish_1.publishTaskEvent)({
+                type: eventType,
+                source: 'service',
+                workflowId: task.workflow_id || '',
+                workflowName: task.workflow_type || '',
+                taskQueue: task.task_queue || '',
+                taskId: task.id,
+                originId: task.origin_id || undefined,
+                status: input.status,
+            });
+        }
+    }
+    return task;
 }
 async function appendMilestones(id, milestones) {
     const pool = (0, db_1.getPool)();

package/docs/api/http/escalations.md

@@ -719,7 +719,7 @@ Finds one available (pending + unassigned/expired) escalation matching the metad
   "key": "orderId",
   "value": "order-123",
   "durationMinutes": 30,
-  "assignee": "station-operator-42"
+  "metadata": { "claimedBy": "jimbo", "station": "scanning" }
 }
 ```
 
@@ -728,7 +728,8 @@ Finds one available (pending + unassigned/expired) escalation matching the metad
 | `key` | `string` | **Required.** Metadata field name |
 | `value` | `string` | **Required.** Metadata field value |
 | `durationMinutes` | `number` | Claim duration (default 30) |
-| `assignee` | `string` | External user ID to claim as (resolved via `getUserByExternalId`) |
+| `assignee` | `string` | Claim as a Long Tail user (resolved via `getUserByExternalId`) |
+| `metadata` | `object` | Additional metadata to merge (new keys added, existing overwritten) |
 
 **Response 200:**
 
@@ -756,7 +757,7 @@ Finds the pending escalation, auto-claims if unclaimed, then resolves it. Suppor
   "key": "orderId",
   "value": "order-123",
   "resolverPayload": { "approved": true, "targetStatus": "completed" },
-  "assignee": "station-operator-42"
+  "metadata": { "completedBy": "jimbo" }
 }
 ```
 
@@ -765,6 +766,7 @@ Finds the pending escalation, auto-claims if unclaimed, then resolves it. Suppor
 | `key` | `string` | **Required.** Metadata field name |
 | `value` | `string` | **Required.** Metadata field value |
 | `resolverPayload` | `object` | **Required.** Resolution data passed to the workflow |
-| `assignee` | `string` | External user ID to resolve as |
+| `assignee` | `string` | Resolve as a Long Tail user (resolved via `getUserByExternalId`) |
+| `metadata` | `object` | Additional metadata to merge (new keys added, existing overwritten) |
 
 **Response 200:** Same as standard resolve endpoint.

package/docs/api/sdk/escalations.md

@@ -549,7 +549,7 @@ const result = await lt.escalations.claimByMetadata({
   key: 'orderId',
   value: 'order-123',
   durationMinutes: 30,
-  assignee: 'station-operator-42',  // optional external_id
+  metadata: { claimedBy: 'jimbo', station: 'scanning' },
 });
 ```
 
@@ -560,7 +560,8 @@ const result = await lt.escalations.claimByMetadata({
 | `key` | `string` | Yes | Metadata field name |
 | `value` | `string` | Yes | Metadata field value |
 | `durationMinutes` | `number` | No | Claim duration (default: 30) |
-| `assignee` | `string` | No | External user ID to claim as (resolved via `getUserByExternalId`) |
+| `assignee` | `string` | No | Claim as a Long Tail user (resolved via `getUserByExternalId`) |
+| `metadata` | `object` | No | Merge into escalation metadata (single atomic SQL call with the claim) |
 
 **Returns:** `LTApiResult<{ escalation, isExtension }>` -- 404 if no match, 409 if already claimed.
 
@@ -577,7 +578,7 @@ const result = await lt.escalations.resolveByMetadata({
   key: 'orderId',
   value: 'order-123',
   resolverPayload: { approved: true, targetStatus: 'completed' },
-  assignee: 'station-operator-42',
+  metadata: { completedBy: 'jimbo' },
 });
 ```
 
@@ -588,7 +589,8 @@ const result = await lt.escalations.resolveByMetadata({
 | `key` | `string` | Yes | Metadata field name |
 | `value` | `string` | Yes | Metadata field value |
 | `resolverPayload` | `object` | Yes | Resolution data passed to the workflow |
-| `assignee` | `string` | No | External user ID to resolve as |
+| `assignee` | `string` | No | Resolve as a Long Tail user (resolved via `getUserByExternalId`) |
+| `metadata` | `object` | No | Merge into escalation metadata before resolving |
 
 **Returns:** Same as `resolve` -- 404 if no match.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hotmeshio/long-tail",
-  "version": "0.4.14",
+  "version": "0.4.15",
   "description": "Long Tail Workflows — Durable AI workflows with human-in-the-loop escalation. Powered by PostgreSQL.",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",