@hotmeshio/long-tail 0.18.1 → 0.19.1

package/build/scripts/ortho-populate.js

@@ -178,7 +178,7 @@ async function ensureSideQuestRoles() {
         console.log(`[${ts()}] Entity declared on ${declared} role(s): order_id`);
 }
 // ── Side-quest escalations (standalone rows — no workflow behind them) ────────
-async function createSideEscalation(role, workflowId, orderId, runId, description, authorizedAt) {
+async function createSideEscalation(role, workflowId, orderId, runId, description, authorizedAt, facility) {
     try {
         await api('POST', '/api/escalations', {
             type: 'ortho-stage',
@@ -186,8 +186,8 @@ async function createSideEscalation(role, workflowId, orderId, runId, descriptio
             role,
             description,
             workflow_id: workflowId,
-            envelope: JSON.stringify({ order_id: orderId }),
-            metadata: { order_id: orderId, source: 'populate', run_id: runId, authorized_at: authorizedAt },
+            envelope: JSON.stringify({ order_id: orderId, ...(facility ? { facility } : {}) }),
+            metadata: { order_id: orderId, source: 'populate', run_id: runId, authorized_at: authorizedAt, ...(facility ? { facility } : {}) },
         });
         return true;
     }
@@ -261,7 +261,7 @@ async function resolveBatch(batchTag, runId) {
                 // order's authorized_at rides along from the ordering escalation.
                 if (esc.role === 'ordering') {
                     const orderId = esc.metadata?.order_id ?? '';
-                    await createSideEscalation('inserting', esc.workflow_id, orderId, runId, `Stuff inserts into shoes for ${orderId}`, esc.metadata?.authorized_at ?? new Date().toISOString());
+                    await createSideEscalation('inserting', esc.workflow_id, orderId, runId, `Stuff inserts into shoes for ${orderId}`, esc.metadata?.authorized_at ?? new Date().toISOString(), esc.metadata?.facility);
                 }
             }
             catch (err) {
@@ -275,6 +275,10 @@ async function resolveBatch(batchTag, runId) {
         return 0;
     }
 }
+// Two manufacturing sites — each order is assigned one at arrival and every
+// escalation it spawns carries it, so the Pace Board's facet scope
+// (facility = north|south) has real data to narrow.
+const FACILITIES = ['north', 'south'];
 async function runOrders(batchTag, runId, plan, target) {
     let done = false;
     const workflowIds = [];
@@ -295,6 +299,9 @@ async function runOrders(batchTag, runId, plan, target) {
                     data: {
                         order_id: order.orderId,
                         item_type: 'insole-standard',
+                        // Stamped on the envelope; the workflow applies it to every stage
+                        // escalation's metadata as the facility facet.
+                        facility: order.facility,
                         metadata: { source: 'populate', run_id: runId, authorized_at: authorizedAt },
                     },
                     metadata: { source: 'populate', run_id: runId, shoes: order.shoes },
@@ -308,7 +315,7 @@ async function runOrders(batchTag, runId, plan, target) {
                 continue;
             }
             if (order.shoes) {
-                const ok = await createSideEscalation('ordering', `${order.wfId}-shoes`, order.orderId, runId, `Order shoes for ${order.orderId}`, authorizedAt);
+                const ok = await createSideEscalation('ordering', `${order.wfId}-shoes`, order.orderId, runId, `Order shoes for ${order.orderId}`, authorizedAt, order.facility);
                 if (!ok)
                     target.value -= 2;
             }
@@ -372,6 +379,9 @@ async function main() {
         wfId: `${batchTag}-${i}`,
         orderId: `ORD-${runId}-${i}`,
         shoes: hasShoes(i),
+        // Pseudo-random per order (hashed on the workflow id): reproducible across
+        // re-runs, roughly balanced across both sites.
+        facility: FACILITIES[Math.floor(jitter(`${batchTag}-${i}`, 'facility') * FACILITIES.length)],
     }));
     const shoeCount = plan.filter((o) => o.shoes).length;
     // Each order resolves 8 manufacturing stages; a shoe order adds

package/build/sdk/index.d.ts

@@ -123,6 +123,7 @@ export declare function createClient(options?: LTClientOptions): {
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         getStationMetrics: (input: {
             period?: string;
+            facets?: Record<string, unknown>;
         }, auth?: LTApiAuth) => Promise<LTApiResult<any>>;
         get: (input: {
             id: string;

package/build/services/config/cache.js

@@ -16,6 +16,8 @@ async function loadAllConfigs() {
             consumes: c.consumes,
             toolTags: c.tool_tags || [],
             envelopeSchema: c.envelope_schema ?? null,
+            inputSchema: c.input_schema ?? null,
+            icon: c.icon ?? null,
             resolverSchema: c.resolver_schema ?? null,
             cronSchedule: c.cron_schedule ?? null,
             executeAs: c.execute_as ?? null,

package/build/services/config/read.js

@@ -26,6 +26,8 @@ async function getWorkflowConfig(workflowType) {
         consumes: wf.consumes || [],
         tool_tags: wf.tool_tags || [],
         envelope_schema: wf.envelope_schema ?? null,
+        input_schema: wf.input_schema ?? null,
+        icon: wf.icon ?? null,
         resolver_schema: wf.resolver_schema ?? null,
         cron_schedule: wf.cron_schedule ?? null,
         execute_as: wf.execute_as ?? null,
@@ -64,6 +66,8 @@ async function listWorkflowConfigs() {
         consumes: wf.consumes || [],
         tool_tags: wf.tool_tags || [],
         envelope_schema: wf.envelope_schema ?? null,
+        input_schema: wf.input_schema ?? null,
+        icon: wf.icon ?? null,
         resolver_schema: wf.resolver_schema ?? null,
         cron_schedule: wf.cron_schedule ?? null,
         execute_as: wf.execute_as ?? null,

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

@@ -5,13 +5,13 @@ export declare const LIST_ALL_WORKFLOWS = "SELECT * FROM lt_config_workflows ORD
 export declare const LIST_ALL_ROLES = "SELECT * FROM lt_config_roles ORDER BY workflow_type, role";
 export declare const LIST_ALL_INVOCATION_ROLES = "SELECT * FROM lt_config_invocation_roles ORDER BY workflow_type, role";
 export declare const ENSURE_ROLE_EXISTS = "INSERT INTO lt_roles (role) VALUES ($1) ON CONFLICT DO NOTHING";
-export declare const UPSERT_WORKFLOW = "INSERT INTO lt_config_workflows\n  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)\nON CONFLICT (workflow_type) DO UPDATE SET\n  invocable = EXCLUDED.invocable,\n  task_queue = EXCLUDED.task_queue,\n  default_role = EXCLUDED.default_role,\n  description = EXCLUDED.description,\n  consumes = EXCLUDED.consumes,\n  envelope_schema = EXCLUDED.envelope_schema,\n  resolver_schema = EXCLUDED.resolver_schema,\n  cron_schedule = EXCLUDED.cron_schedule,\n  tool_tags = EXCLUDED.tool_tags,\n  execute_as = EXCLUDED.execute_as,\n  certified = EXCLUDED.certified,\n  read_safe = EXCLUDED.read_safe";
+export declare const UPSERT_WORKFLOW = "INSERT INTO lt_config_workflows\n  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe, input_schema, icon)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)\nON CONFLICT (workflow_type) DO UPDATE SET\n  invocable = EXCLUDED.invocable,\n  task_queue = EXCLUDED.task_queue,\n  default_role = EXCLUDED.default_role,\n  description = EXCLUDED.description,\n  consumes = EXCLUDED.consumes,\n  envelope_schema = EXCLUDED.envelope_schema,\n  resolver_schema = EXCLUDED.resolver_schema,\n  cron_schedule = EXCLUDED.cron_schedule,\n  tool_tags = EXCLUDED.tool_tags,\n  execute_as = EXCLUDED.execute_as,\n  certified = EXCLUDED.certified,\n  read_safe = EXCLUDED.read_safe,\n  input_schema = EXCLUDED.input_schema,\n  icon = EXCLUDED.icon";
 export declare const DELETE_CONFIG_ROLES = "DELETE FROM lt_config_roles WHERE workflow_type = $1";
 export declare const INSERT_CONFIG_ROLE = "INSERT INTO lt_config_roles (workflow_type, role) VALUES ($1, $2)";
 export declare const DELETE_INVOCATION_ROLES = "DELETE FROM lt_config_invocation_roles WHERE workflow_type = $1";
 export declare const INSERT_INVOCATION_ROLE = "INSERT INTO lt_config_invocation_roles (workflow_type, role) VALUES ($1, $2)";
 export declare const DELETE_WORKFLOW = "DELETE FROM lt_config_workflows WHERE workflow_type = $1";
-export declare const SEED_WORKFLOW_CONFIG = "INSERT INTO lt_config_workflows\n  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)\nON CONFLICT (workflow_type) DO NOTHING";
+export declare const SEED_WORKFLOW_CONFIG = "INSERT INTO lt_config_workflows\n  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe, input_schema, icon)\nVALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)\nON CONFLICT (workflow_type) DO NOTHING";
 export declare const SEED_CONFIG_ROLE = "INSERT INTO lt_config_roles (workflow_type, role) VALUES ($1, $2)\nON CONFLICT (workflow_type, role) DO NOTHING";
 export declare const SEED_INVOCATION_ROLE = "INSERT INTO lt_config_invocation_roles (workflow_type, role) VALUES ($1, $2)\nON CONFLICT (workflow_type, role) DO NOTHING";
 export declare const GET_PROVIDER_DATA = "SELECT workflow_type, data, completed_at\n  FROM lt_tasks\n WHERE origin_id = $1\n   AND workflow_type = ANY($2)\n   AND status = 'completed'\n ORDER BY completed_at DESC";

package/build/services/config/sql.js

@@ -23,8 +23,8 @@ exports.ENSURE_ROLE_EXISTS = `\
 INSERT INTO lt_roles (role) VALUES ($1) ON CONFLICT DO NOTHING`;
 exports.UPSERT_WORKFLOW = `\
 INSERT INTO lt_config_workflows
-  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe, input_schema, icon)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 ON CONFLICT (workflow_type) DO UPDATE SET
   invocable = EXCLUDED.invocable,
   task_queue = EXCLUDED.task_queue,
@@ -37,7 +37,9 @@ ON CONFLICT (workflow_type) DO UPDATE SET
   tool_tags = EXCLUDED.tool_tags,
   execute_as = EXCLUDED.execute_as,
   certified = EXCLUDED.certified,
-  read_safe = EXCLUDED.read_safe`;
+  read_safe = EXCLUDED.read_safe,
+  input_schema = EXCLUDED.input_schema,
+  icon = EXCLUDED.icon`;
 exports.DELETE_CONFIG_ROLES = `\
 DELETE FROM lt_config_roles WHERE workflow_type = $1`;
 exports.INSERT_CONFIG_ROLE = `\
@@ -53,8 +55,8 @@ DELETE FROM lt_config_workflows WHERE workflow_type = $1`;
 // ------------------------------------------------------------------ //
 exports.SEED_WORKFLOW_CONFIG = `\
 INSERT INTO lt_config_workflows
-  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe)
-VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)
+  (workflow_type, invocable, task_queue, default_role, description, consumes, envelope_schema, resolver_schema, cron_schedule, tool_tags, execute_as, certified, read_safe, input_schema, icon)
+VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15)
 ON CONFLICT (workflow_type) DO NOTHING`;
 exports.SEED_CONFIG_ROLE = `\
 INSERT INTO lt_config_roles (workflow_type, role) VALUES ($1, $2)

package/build/services/config/write.js

@@ -53,6 +53,8 @@ async function replaceWorkflowConfig(config, certified) {
             config.execute_as ?? null,
             certified,
             config.read_safe ?? false,
+            config.input_schema ?? null,
+            config.icon ?? null,
         ]);
         // Replace roles
         await client.query(sql_1.DELETE_CONFIG_ROLES, [config.workflow_type]);
@@ -114,6 +116,8 @@ async function seedWorkflowConfig(config) {
         config.execute_as ?? null,
         resolveCertified(config),
         config.read_safe ?? false,
+        config.input_schema ?? null,
+        config.icon ?? null,
     ]);
     const inserted = (rowCount ?? 0) > 0;
     if (inserted) {
@@ -144,6 +148,10 @@ async function seedWorkflowConfig(config) {
                 drifts.push('envelope_schema');
             if (JSON.stringify(config.resolver_schema) !== JSON.stringify(existing.resolver_schema))
                 drifts.push('resolver_schema');
+            if (JSON.stringify(config.input_schema ?? null) !== JSON.stringify(existing.input_schema ?? null))
+                drifts.push('input_schema');
+            if ((config.icon ?? null) !== (existing.icon ?? null))
+                drifts.push('icon');
             if (drifts.length) {
                 logger_1.loggerRegistry.warn(`[long-tail] config drift: ${config.workflow_type} — ${drifts.join(', ')} differ between code and DB`);
             }
@@ -181,7 +189,9 @@ async function applyWorkflowConfig(config) {
             sortedEqual(existing.roles ?? [], config.roles ?? []) &&
             sortedEqual(existing.invocation_roles ?? [], config.invocation_roles ?? []) &&
             (0, node_util_1.isDeepStrictEqual)(existing.envelope_schema ?? null, config.envelope_schema ?? null) &&
-            (0, node_util_1.isDeepStrictEqual)(existing.resolver_schema ?? null, config.resolver_schema ?? null);
+            (0, node_util_1.isDeepStrictEqual)(existing.resolver_schema ?? null, config.resolver_schema ?? null) &&
+            (0, node_util_1.isDeepStrictEqual)(existing.input_schema ?? null, config.input_schema ?? null) &&
+            (existing.icon ?? null) === (config.icon ?? null);
         if (unchanged)
             return 'unchanged';
     }

package/build/services/escalation/batch.js

@@ -4,6 +4,7 @@ exports.resolveBatchItem = resolveBatchItem;
 exports.resolveBatchItemBySignalKey = resolveBatchItemBySignalKey;
 exports.resolveBatchItemByMetadata = resolveBatchItemByMetadata;
 const escalation_wire_1 = require("../../lib/events/escalation-wire");
+const uuid_1 = require("../../lib/uuid");
 const client_1 = require("./client");
 const crud_1 = require("./crud");
 const map_1 = require("./map");
@@ -15,6 +16,8 @@ const map_1 = require("./map");
  * outcomes publish nothing — the row was untouched.
  */
 async function resolveBatchItem(id, itemKey, payload, metadata, assertClaim, resolvedBy) {
+    if (!(0, uuid_1.isUuid)(id))
+        return { outcome: 'not-found', remaining: -1, escalation: null };
     const client = await (0, client_1.escalations)();
     const result = await client.resolveBatchItem({
         id,

package/build/services/escalation/bulk.js

@@ -8,6 +8,7 @@ exports.bulkUnassignEscalations = bulkUnassignEscalations;
 exports.bulkEscalateToRole = bulkEscalateToRole;
 exports.bulkCancelEscalations = bulkCancelEscalations;
 exports.bulkResolveForTriage = bulkResolveForTriage;
+const uuid_1 = require("../../lib/uuid");
 const db_1 = require("../../lib/db");
 const client_1 = require("./client");
 const map_1 = require("./map");
@@ -17,6 +18,7 @@ const sql_1 = require("./sql");
  * Items already claimed by another active user are skipped.
  */
 async function bulkClaimEscalations(ids, userId, durationMinutes = 30) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return { claimed: 0, skipped: 0 };
     const client = await (0, client_1.escalations)();
@@ -27,6 +29,7 @@ async function bulkClaimEscalations(ids, userId, durationMinutes = 30) {
  * Items already claimed by another active user are skipped.
  */
 async function bulkAssignEscalations(ids, targetUserId, durationMinutes = 30) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return { assigned: 0, skipped: 0 };
     const client = await (0, client_1.escalations)();
@@ -60,6 +63,7 @@ async function bulkAssignEscalationsByQuery(query, targetUserId, durationMinutes
  * returned row carries its pre-update assignee for the event.
  */
 async function bulkReassignEscalations(ids, targetUserId, durationMinutes = 30) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return { assigned: 0, skipped: 0, changes: [] };
     await (0, client_1.ensureEscalationCompatView)();
@@ -77,6 +81,7 @@ async function bulkReassignEscalations(ids, targetUserId, durationMinutes = 30)
  * statement; unclaimed and terminal rows are skipped.
  */
 async function bulkUnassignEscalations(ids) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return { unassigned: 0, skipped: 0, changes: [] };
     await (0, client_1.ensureEscalationCompatView)();
@@ -93,6 +98,7 @@ async function bulkUnassignEscalations(ids) {
  * Clears assignment on all affected rows.
  */
 async function bulkEscalateToRole(ids, targetRole) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return 0;
     const client = await (0, client_1.escalations)();
@@ -104,6 +110,7 @@ async function bulkEscalateToRole(ids, targetRole) {
  * successfully cancelled.
  */
 async function bulkCancelEscalations(ids) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return { cancelled: 0, skipped: 0 };
     const client = await (0, client_1.escalations)();
@@ -126,6 +133,7 @@ async function bulkCancelEscalations(ids) {
  * `pending`; only the returned rows enter triage.
  */
 async function bulkResolveForTriage(ids, hint) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return [];
     const client = await (0, client_1.escalations)();

package/build/services/escalation/crud.js

@@ -29,6 +29,7 @@ const db_1 = require("../../lib/db");
 const publish_1 = require("../../lib/events/publish");
 const escalation_wire_1 = require("../../lib/events/escalation-wire");
 const escalation_1 = require("../../types/escalation");
+const uuid_1 = require("../../lib/uuid");
 const client_1 = require("./client");
 const queries_1 = require("./queries");
 const map_1 = require("./map");
@@ -95,6 +96,8 @@ async function createEscalation(input) {
  * user re-claims (extends expiry). Returns null when the row is not claimable.
  */
 async function claimEscalation(id, userId, durationMinutes = 30) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     const result = await client.claim({ id, assignee: userId, durationMinutes });
     if (!result.ok)
@@ -132,6 +135,8 @@ async function claimEscalation(id, userId, durationMinutes = 30) {
  * the stored `resolver_payload`.
  */
 async function resolveEscalation(id, resolverPayload, metadata, assertClaim, resolvedBy) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     // `assertClaim` rides the SDK's guarded UPDATE: no active claim lock may
     // stand against this assignee, or the resolve blocks (claim-expired /
@@ -169,6 +174,7 @@ async function resolveEscalation(id, resolverPayload, metadata, assertClaim, res
  * `resolveEscalation` (which delivers the signal).
  */
 async function resolveEscalationsByIds(ids, resolverPayload, metadata) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return [];
     const client = await (0, client_1.escalations)();
@@ -209,6 +215,12 @@ async function resolveEscalationsByIds(ids, resolverPayload, metadata) {
 async function resolveEscalationsAllOrNone(items, metadata, assertAssignee, resolvedBy) {
     if (items.length === 0)
         return { ok: true, escalations: [] };
+    // A malformed id blocks the batch exactly like a well-formed missing one —
+    // and never reaches the uuid cast.
+    const malformed = items.filter((i) => !(0, uuid_1.isUuid)(i.id));
+    if (malformed.length > 0) {
+        return { ok: false, failed: malformed.map((i) => ({ id: i.id, reason: 'not-found' })) };
+    }
     const client = await (0, client_1.escalations)();
     const result = await client.resolveAllOrNone({ items, metadata, assertAssignee, resolvedBy });
     if (!result.ok)
@@ -235,6 +247,7 @@ async function resolveEscalationsAllOrNone(items, metadata, assertAssignee, reso
  * fields — signal routing shape, `metadata.form_schema` for redaction.
  */
 async function getEscalationsByIds(ids) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return [];
     const client = await (0, client_1.escalations)();
@@ -278,6 +291,8 @@ async function resolveEscalationBySignalKey(signalKey, resolverPayload, metadata
  * already terminal.
  */
 async function cancelEscalation(id) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     const result = await client.cancel(id);
     if (!result.ok)
@@ -301,6 +316,7 @@ async function cancelEscalation(id) {
  * updated.
  */
 async function updateEscalationsPriority(ids, priority) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return 0;
     const client = await (0, client_1.escalations)();
@@ -311,6 +327,7 @@ async function updateEscalationsPriority(ids, priority) {
  * Used for permission validation before bulk operations.
  */
 async function getEscalationRoles(ids) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return [];
     const client = await (0, client_1.escalations)();
@@ -323,6 +340,7 @@ async function getEscalationRoles(ids) {
  * write_self by ownership (assigned_to = caller). One query, no N+1.
  */
 async function getEscalationScopeRows(ids) {
+    ids = (0, uuid_1.onlyUuids)(ids);
     if (ids.length === 0)
         return [];
     const client = await (0, client_1.escalations)();
@@ -344,6 +362,8 @@ async function getEscalationScopeRows(ids) {
  * stays loud.
  */
 async function releaseEscalation(id, userId, opts) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     const result = await client.release({ id, assignee: userId });
     if (!result.ok)
@@ -381,6 +401,8 @@ async function releaseExpiredClaims() {
  * Clears the current assignment so it becomes available to the new role.
  */
 async function escalateToRole(id, targetRole) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     // The departing role is read before the move: the returned entry already
     // carries the target role, and role-scoped subscribers of the OLD queue
@@ -414,6 +436,8 @@ async function escalateToRole(id, targetRole) {
     return escalation;
 }
 async function getEscalation(id) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     const entry = await client.get(id);
     return entry ? (0, map_1.toEscalationRecord)(entry) : null;
@@ -474,6 +498,8 @@ async function cancelEscalationsByWorkflowId(workflowId) {
     return rows.length;
 }
 async function enrichEscalationRouting(id, metadataPatch, workflowFields) {
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     const client = await (0, client_1.escalations)();
     const entry = await client.update({
         id,

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

@@ -54,6 +54,19 @@ export declare function listFacetKeys(opts: {
     selfRoles?: string[];
     meUserId?: string;
 }): Promise<string[]>;
+/**
+ * Distinct VALUES for one metadata facet key, visible to the caller — feeds
+ * the value picker (e.g. facility → [north, south]) so a bound scope offers
+ * real choices. Role-scoped with the same predicate as {@link listFacetKeys};
+ * the key is parameterized (never interpolated) and charset-validated, so a
+ * malformed key returns [] rather than reaching an unguarded path.
+ */
+export declare function listFacetValues(key: string, opts: {
+    global?: boolean;
+    visibleRoles?: string[];
+    selfRoles?: string[];
+    meUserId?: string;
+}): Promise<string[]>;
 export declare function getEscalationStats(visibleRoles?: string[], period?: string): Promise<EscalationStats>;
 export declare function listDistinctTypes(): Promise<string[]>;
 export declare function listEscalations(filters: {
@@ -108,4 +121,4 @@ export declare function listAvailableEscalations(filters: {
 export declare function invalidateEscalationAggregates(): void;
 /** Test hook: drop cached period metrics AND escalation stats so tests observe fresh rows. */
 export declare function resetStationMetricsCache(): void;
-export declare function getStationMetrics(visibleRoles: string[] | undefined, period?: string): Promise<StationMetric[]>;
+export declare function getStationMetrics(visibleRoles: string[] | undefined, period?: string, facets?: Record<string, unknown>): Promise<StationMetric[]>;

package/build/services/escalation/queries.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.searchEscalationsFaceted = searchEscalationsFaceted;
 exports.getEscalationWithFormSchema = getEscalationWithFormSchema;
 exports.listFacetKeys = listFacetKeys;
+exports.listFacetValues = listFacetValues;
 exports.getEscalationStats = getEscalationStats;
 exports.listDistinctTypes = listDistinctTypes;
 exports.listEscalations = listEscalations;
@@ -42,13 +43,13 @@ function buildSearchOrderBy(sortBy, order) {
     }
     return 'priority ASC, created_at ASC';
 }
-const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const uuid_1 = require("../../lib/uuid");
 /**
  * The id arm of the correlation search binds a uuid param only when the term
  * parses as one — comparing `id::text = $term` casts the uuid column and has
  * no index path, which drags the whole OR into a full history scan.
  */
-const asUuidOrNull = (term) => term && UUID_RE.test(term) ? term : null;
+const asUuidOrNull = (term) => term && uuid_1.UUID_RE.test(term) ? term : null;
 /**
  * Server-side free-text search over the `lt_escalations` view. Runs when a
  * caller supplies a non-empty `search` term — the SDK `client.list()` cannot do
@@ -155,6 +156,9 @@ async function searchEscalationsFaceted(opts) {
  * cast is guarded, so a non-numeric pin simply falls through to the latest form.
  */
 async function getEscalationWithFormSchema(id) {
+    // A non-UUID is definitionally not-found — it must never reach the uuid cast.
+    if (!(0, uuid_1.isUuid)(id))
+        return null;
     await (0, client_1.ensureEscalationCompatView)();
     const pool = (0, db_1.getPool)();
     const { rows } = await pool.query(`SELECT e.*, COALESCE(ps.form_schema, r.form_schema) AS resolved_form_schema
@@ -216,6 +220,39 @@ async function listFacetKeys(opts) {
     }
     return [...actualKeys].sort();
 }
+// Mirrors the server-side facet key rule — metadata keys become a JSON path,
+// so a lookup key is strictly validated before it reaches SQL.
+const FACET_KEY_RE = /^[a-zA-Z0-9_]+$/;
+/**
+ * Distinct VALUES for one metadata facet key, visible to the caller — feeds
+ * the value picker (e.g. facility → [north, south]) so a bound scope offers
+ * real choices. Role-scoped with the same predicate as {@link listFacetKeys};
+ * the key is parameterized (never interpolated) and charset-validated, so a
+ * malformed key returns [] rather than reaching an unguarded path.
+ */
+async function listFacetValues(key, opts) {
+    if (!FACET_KEY_RE.test(key))
+        return [];
+    await (0, client_1.ensureEscalationCompatView)();
+    const pool = (0, db_1.getPool)();
+    const params = [key];
+    const clauses = ["jsonb_typeof(metadata) = 'object'", 'metadata ? $1'];
+    if (!opts.global) {
+        const ai = params.push(opts.visibleRoles?.length ? opts.visibleRoles : null);
+        const si = params.push(opts.selfRoles?.length ? opts.selfRoles : null);
+        const mi = params.push(opts.meUserId || null);
+        clauses.push(`(($${ai}::text[] IS NULL AND $${si}::text[] IS NULL)
+        OR ($${ai}::text[] IS NOT NULL AND role = ANY($${ai}))
+        OR ($${si}::text[] IS NOT NULL AND role = ANY($${si}) AND assigned_to = $${mi}))`);
+    }
+    const { rows } = await pool.query(`SELECT DISTINCT metadata->>$1 AS value
+       FROM public.lt_escalations
+      WHERE ${clauses.join('\n        AND ')}
+        AND metadata->>$1 IS NOT NULL
+      ORDER BY value
+      LIMIT 200`, params);
+    return rows.map((r) => r.value);
+}
 // Escalation stats back the home + overview surfaces and refresh on every
 // escalation event. As of hotmesh 0.25.0 the SDK stats query reads three
 // bounded, index-only sources (pending backlog, created window, resolved
@@ -388,7 +425,7 @@ function resetStationMetricsCache() {
     invalidateEscalationAggregates();
 }
 const toNum = (v) => (v != null ? Number(v) : null);
-async function getStationMetrics(visibleRoles, period) {
+async function getStationMetrics(visibleRoles, period, facets) {
     await (0, client_1.ensureEscalationCompatView)();
     // hasOwnProperty: a caller-supplied period like 'constructor' must fall back
     // to 24h, not resolve to an inherited Object.prototype member.
@@ -396,13 +433,18 @@ async function getStationMetrics(visibleRoles, period) {
         ? types_1.VALID_PERIODS[period]
         : '24 hours';
     const roles = visibleRoles ?? null;
+    // Facet scope rides both queries as a GIN-served `metadata @>` arm; null = no
+    // filter. It never widens role scope — it only narrows within it.
+    const facetJson = facets && Object.keys(facets).length ? JSON.stringify(facets) : null;
     const pool = (0, db_1.getPool)();
     // Live counts: always fresh (cheap — bounded pending working set).
-    // Period metrics: cached ~30s, single-flight (expensive percentile sort).
-    const cacheKey = `${period ?? '24h'}::${roles ? [...roles].sort().join(',') : 'ALL'}`;
+    // Period metrics: cached ~30s, single-flight (expensive percentile sort). The
+    // facet scope is part of the cache key — a scoped board never reads unscoped
+    // rows, and vice versa.
+    const cacheKey = `${period ?? '24h'}::${roles ? [...roles].sort().join(',') : 'ALL'}::${facetJson ?? ''}`;
     const [countsResult, periodRows] = await Promise.all([
-        pool.query(sql_1.STATION_LIVE_COUNTS_SQL, [roles]),
-        stationPeriodCache.resolve(cacheKey, async () => (await pool.query(sql_1.STATION_PERIOD_METRICS_SQL, [roles, intervalStr])).rows),
+        pool.query(sql_1.STATION_LIVE_COUNTS_SQL, [roles, facetJson]),
+        stationPeriodCache.resolve(cacheKey, async () => (await pool.query(sql_1.STATION_PERIOD_METRICS_SQL, [roles, intervalStr, facetJson])).rows),
     ]);
     const periodByRole = new Map(periodRows.map((r) => [r.role, r]));
     return countsResult.rows.map((c) => {

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

@@ -80,6 +80,7 @@ export declare const RESOLVE_BY_METADATA_ATOMIC = "WITH target AS MATERIALIZED (
  * Live counts — pending, active claims, and priority (past-threshold) per role.
  *
  * $1 TEXT[] — role filter (NULL = all roles / superadmin).
+ * $2 JSONB  — metadata facet scope (NULL = no filter; `metadata @>`, GIN-served).
  *
  * Hits idx_hmsh_esc_pending_role_created (role, created_at DESC) WHERE
  * status='pending'. The pending working set is bounded by real backlog depth,
@@ -102,13 +103,14 @@ export declare const RESOLVE_BY_METADATA_ATOMIC = "WITH target AS MATERIALIZED (
  * with a facet configured, items missing the key or holding an unparseable
  * value do not count (NULL age never passes the comparison).
  */
-export declare const STATION_LIVE_COUNTS_SQL = "\nWITH role_targets AS (\n  SELECT role, sla_minutes, priority_threshold_minutes, priority_facet\n  FROM lt_roles\n  WHERE ($1::text[] IS NULL OR role = ANY($1::text[]))\n),\nlive_counts AS (\n  SELECT\n    e.role,\n    COUNT(*)                                                                         AS pending,\n    COUNT(*) FILTER (WHERE e.assigned_to IS NOT NULL AND e.assigned_until > NOW())  AS claimed,\n    COUNT(*) FILTER (\n      WHERE COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) IS NOT NULL\n        AND (e.assigned_to IS NULL OR e.assigned_until IS NULL OR e.assigned_until <= NOW())\n        AND CASE\n          WHEN rt.priority_facet IS NULL THEN e.created_at\n          WHEN pg_input_is_valid(e.metadata->>rt.priority_facet, 'timestamptz')\n            THEN (e.metadata->>rt.priority_facet)::timestamptz\n          ELSE NULL\n        END < NOW() - (COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) * INTERVAL '1 minute')\n    )                                                                                AS priority_count\n  FROM hmsh_escalations e\n  JOIN role_targets rt ON rt.role = e.role\n  WHERE e.status = 'pending'\n  GROUP BY e.role\n)\nSELECT\n  rt.role,\n  COALESCE(lc.pending,        0) AS pending,\n  COALESCE(lc.claimed,        0) AS claimed,\n  COALESCE(lc.priority_count, 0) AS priority_count\nFROM role_targets rt\nLEFT JOIN live_counts lc ON lc.role = rt.role\nORDER BY rt.role\n";
+export declare const STATION_LIVE_COUNTS_SQL = "\nWITH role_targets AS (\n  SELECT role, sla_minutes, priority_threshold_minutes, priority_facet\n  FROM lt_roles\n  WHERE ($1::text[] IS NULL OR role = ANY($1::text[]))\n),\nlive_counts AS (\n  SELECT\n    e.role,\n    COUNT(*)                                                                         AS pending,\n    COUNT(*) FILTER (WHERE e.assigned_to IS NOT NULL AND e.assigned_until > NOW())  AS claimed,\n    COUNT(*) FILTER (\n      WHERE COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) IS NOT NULL\n        AND (e.assigned_to IS NULL OR e.assigned_until IS NULL OR e.assigned_until <= NOW())\n        AND CASE\n          WHEN rt.priority_facet IS NULL THEN e.created_at\n          WHEN pg_input_is_valid(e.metadata->>rt.priority_facet, 'timestamptz')\n            THEN (e.metadata->>rt.priority_facet)::timestamptz\n          ELSE NULL\n        END < NOW() - (COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) * INTERVAL '1 minute')\n    )                                                                                AS priority_count\n  FROM hmsh_escalations e\n  JOIN role_targets rt ON rt.role = e.role\n  WHERE e.status = 'pending'\n    AND ($2::jsonb IS NULL OR e.metadata @> $2::jsonb)\n  GROUP BY e.role\n)\nSELECT\n  rt.role,\n  COALESCE(lc.pending,        0) AS pending,\n  COALESCE(lc.claimed,        0) AS claimed,\n  COALESCE(lc.priority_count, 0) AS priority_count\nFROM role_targets rt\nLEFT JOIN live_counts lc ON lc.role = rt.role\nORDER BY rt.role\n";
 /**
  * Period metrics — resolved count, throughput efficiency, and P99/P50/avg/max
  * latency for wait (queue time) and work (processing) per role.
  *
  * $1 TEXT[]   — role filter (NULL = all roles / superadmin).
  * $2 INTERVAL — time window (e.g. '24 hours', '15 minutes').
+ * $3 JSONB    — metadata facet scope (NULL = no filter; `metadata @>`, GIN-served).
  *
  * Hits idx_hmsh_esc_resolved_cover (role, resolved_at DESC, claimed_at,
  * created_at) WHERE status='resolved' — a covering index, so the percentile
@@ -119,4 +121,4 @@ export declare const STATION_LIVE_COUNTS_SQL = "\nWITH role_targets AS (\n  SELE
  * mix of resolved + in-flight — a clean "how did completed work perform?" read.
  * throughput_pct is NULL when the role has no target_per_hour (NULLIF guard).
  */
-export declare const STATION_PERIOD_METRICS_SQL = "\nWITH role_targets AS (\n  SELECT role, target_per_hour\n  FROM lt_roles\n  WHERE ($1::text[] IS NULL OR role = ANY($1::text[]))\n),\nperiod_metrics AS (\n  SELECT\n    e.role,\n    COUNT(*)                                                                         AS resolved,\n    ROUND((PERCENTILE_CONT(0.99) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p99_wait_min,\n    ROUND((PERCENTILE_CONT(0.50) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p50_wait_min,\n    ROUND((AVG(EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS avg_wait_min,\n    ROUND((MAX(EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS max_wait_min,\n    ROUND((PERCENTILE_CONT(0.99) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p99_work_min,\n    ROUND((PERCENTILE_CONT(0.50) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p50_work_min,\n    ROUND((AVG(EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS avg_work_min,\n    ROUND((MAX(EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS max_work_min\n  FROM hmsh_escalations e\n  WHERE e.status = 'resolved'\n    AND e.resolved_at >= NOW() - $2::interval\n    AND ($1::text[] IS NULL OR e.role = ANY($1::text[]))\n  GROUP BY e.role\n)\nSELECT\n  rt.role,\n  COALESCE(pm.resolved, 0) AS resolved,\n  ROUND(\n    (COALESCE(pm.resolved, 0)::numeric\n      / NULLIF(rt.target_per_hour::numeric * EXTRACT(EPOCH FROM $2::interval) / 3600.0, 0)\n      * 100\n    )::numeric, 1\n  )                        AS throughput_pct,\n  pm.p99_wait_min,\n  pm.p50_wait_min,\n  pm.avg_wait_min,\n  pm.max_wait_min,\n  pm.p99_work_min,\n  pm.p50_work_min,\n  pm.avg_work_min,\n  pm.max_work_min\nFROM role_targets rt\nLEFT JOIN period_metrics pm ON pm.role = rt.role\nORDER BY rt.role\n";
+export declare const STATION_PERIOD_METRICS_SQL = "\nWITH role_targets AS (\n  SELECT role, target_per_hour\n  FROM lt_roles\n  WHERE ($1::text[] IS NULL OR role = ANY($1::text[]))\n),\nperiod_metrics AS (\n  SELECT\n    e.role,\n    COUNT(*)                                                                         AS resolved,\n    ROUND((PERCENTILE_CONT(0.99) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p99_wait_min,\n    ROUND((PERCENTILE_CONT(0.50) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p50_wait_min,\n    ROUND((AVG(EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS avg_wait_min,\n    ROUND((MAX(EXTRACT(EPOCH FROM (e.claimed_at - e.created_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS max_wait_min,\n    ROUND((PERCENTILE_CONT(0.99) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p99_work_min,\n    ROUND((PERCENTILE_CONT(0.50) WITHIN GROUP (\n      ORDER BY EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS p50_work_min,\n    ROUND((AVG(EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS avg_work_min,\n    ROUND((MAX(EXTRACT(EPOCH FROM (e.resolved_at - e.claimed_at)) / 60)\n      FILTER (WHERE e.claimed_at IS NOT NULL))::numeric, 3)                        AS max_work_min\n  FROM hmsh_escalations e\n  WHERE e.status = 'resolved'\n    AND e.resolved_at >= NOW() - $2::interval\n    AND ($1::text[] IS NULL OR e.role = ANY($1::text[]))\n    AND ($3::jsonb IS NULL OR e.metadata @> $3::jsonb)\n  GROUP BY e.role\n)\nSELECT\n  rt.role,\n  COALESCE(pm.resolved, 0) AS resolved,\n  ROUND(\n    (COALESCE(pm.resolved, 0)::numeric\n      / NULLIF(rt.target_per_hour::numeric * EXTRACT(EPOCH FROM $2::interval) / 3600.0, 0)\n      * 100\n    )::numeric, 1\n  )                        AS throughput_pct,\n  pm.p99_wait_min,\n  pm.p50_wait_min,\n  pm.avg_wait_min,\n  pm.max_wait_min,\n  pm.p99_work_min,\n  pm.p50_work_min,\n  pm.avg_work_min,\n  pm.max_work_min\nFROM role_targets rt\nLEFT JOIN period_metrics pm ON pm.role = rt.role\nORDER BY rt.role\n";

package/build/services/escalation/sql.js

@@ -270,6 +270,7 @@ LEFT JOIN written ON written.id = target.id`;
  * Live counts — pending, active claims, and priority (past-threshold) per role.
  *
  * $1 TEXT[] — role filter (NULL = all roles / superadmin).
+ * $2 JSONB  — metadata facet scope (NULL = no filter; `metadata @>`, GIN-served).
  *
  * Hits idx_hmsh_esc_pending_role_created (role, created_at DESC) WHERE
  * status='pending'. The pending working set is bounded by real backlog depth,
@@ -316,6 +317,7 @@ live_counts AS (
   FROM hmsh_escalations e
   JOIN role_targets rt ON rt.role = e.role
   WHERE e.status = 'pending'
+    AND ($2::jsonb IS NULL OR e.metadata @> $2::jsonb)
   GROUP BY e.role
 )
 SELECT
@@ -333,6 +335,7 @@ ORDER BY rt.role
  *
  * $1 TEXT[]   — role filter (NULL = all roles / superadmin).
  * $2 INTERVAL — time window (e.g. '24 hours', '15 minutes').
+ * $3 JSONB    — metadata facet scope (NULL = no filter; `metadata @>`, GIN-served).
  *
  * Hits idx_hmsh_esc_resolved_cover (role, resolved_at DESC, claimed_at,
  * created_at) WHERE status='resolved' — a covering index, so the percentile
@@ -377,6 +380,7 @@ period_metrics AS (
   WHERE e.status = 'resolved'
     AND e.resolved_at >= NOW() - $2::interval
     AND ($1::text[] IS NULL OR e.role = ANY($1::text[]))
+    AND ($3::jsonb IS NULL OR e.metadata @> $3::jsonb)
   GROUP BY e.role
 )
 SELECT

package/build/services/interceptor/index.js

@@ -47,6 +47,11 @@ 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';
+/** The result payload a completed event carries: the workflow's `data` when it returned the envelope shape. */
+function resultData(result) {
+    const data = result?.data;
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : undefined;
+}
 /**
  * Register the Long Tail interceptors in a single call.
  *
@@ -120,6 +125,7 @@ function createLTInterceptor(options) {
                     workflowName: wf.workflowName,
                     taskQueue: taskQueue0,
                     status: 'completed',
+                    data: resultData(result0),
                 });
                 return result0;
             }
@@ -138,6 +144,7 @@ function createLTInterceptor(options) {
                     workflowName: wf.workflowName,
                     taskQueue: taskQueue2,
                     status: 'completed',
+                    data: resultData(result2),
                 });
                 return result2;
             }