@hotmeshio/long-tail 0.7.4 → 0.8.0

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

@@ -45,15 +45,32 @@ export declare function searchEscalationsQuery(orderBy: string): string;
  */
 export declare const RESOLVE_BY_METADATA_ATOMIC = "WITH target AS MATERIALIZED (\n  SELECT *\n  FROM public.hmsh_escalations\n  WHERE metadata @> $1::jsonb\n    AND status = 'pending'\n    AND (\n         $5::text[] IS NULL\n      OR role = ANY($5)\n      OR (role = ANY($6::text[]) AND assigned_to = $2)\n    )\n  ORDER BY priority ASC, created_at ASC\n  LIMIT 1\n  FOR UPDATE\n),\nclaimed AS (\n  UPDATE public.hmsh_escalations e\n  SET assigned_to = COALESCE(e.assigned_to, $2),\n      claimed_at = COALESCE(e.claimed_at, NOW()),\n      assigned_until = CASE\n        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.assigned_until\n        ELSE NOW() + INTERVAL '5 minutes' END,\n      claim_expires_at = CASE\n        WHEN e.assigned_to IS NOT NULL AND e.assigned_until > NOW() THEN e.claim_expires_at\n        ELSE NOW() + INTERVAL '5 minutes' END,\n      metadata = CASE WHEN $4::jsonb IS NOT NULL\n        THEN COALESCE(e.metadata, '{}'::jsonb) || $4::jsonb\n        ELSE e.metadata END,\n      updated_at = NOW()\n  FROM target\n  WHERE e.id = target.id\n    AND target.signal_key IS NULL\n  RETURNING e.*\n),\nresolved AS (\n  UPDATE public.hmsh_escalations e\n  SET status = 'resolved',\n      resolved_at = NOW(),\n      resolver_payload = $3,\n      updated_at = NOW()\n  FROM claimed\n  WHERE e.id = claimed.id\n    AND (claimed.metadata->>'signal_id') IS NULL\n  RETURNING e.*\n)\nSELECT\n  resolved.*,\n  target.id AS target_id,\n  target.metadata->>'signal_id' AS signal_id,\n  target.signal_key AS signal_key,\n  target.workflow_id AS target_workflow_id,\n  target.workflow_type AS target_workflow_type,\n  target.task_queue AS target_task_queue,\n  (target.assigned_to IS NOT NULL\n    AND target.assigned_until IS NOT NULL\n    AND target.assigned_until > NOW()) AS signal_already_claimed,\n  CASE WHEN resolved.id IS NOT NULL THEN 'resolved' ELSE 'signal_required' END AS outcome\nFROM target\nLEFT JOIN resolved ON resolved.id = target.id";
 /**
- * Live counts — pending, active claims, and past-SLA (in_arrears) per role.
+ * Live counts — pending, active claims, and priority (past-threshold) per role.
  *
  * $1 TEXT[] — role filter (NULL = all roles / superadmin).
  *
  * Hits idx_hmsh_esc_pending_role_created (role, created_at DESC) WHERE
  * status='pending'. The pending working set is bounded by real backlog depth,
  * so this stays cheap as historical volume grows — safe on the hot refresh path.
+ *
+ * priority_count is the Pace Board rebalance signal: pending AND unclaimed
+ * items older than the role's threshold. One signal, two per-role dials with
+ * fallbacks so it works from sla_minutes alone:
+ *
+ *   age origin — priority_facet metadata key (an ISO 8601 UTC timestamp, e.g.
+ *                the order's authorized date) when set, else created_at.
+ *   threshold  — priority_threshold_minutes when set, else sla_minutes.
+ *
+ * Claimed items are excluded — they are already in someone's hands; the count
+ * is what the floor must still pull forward. The GIN metadata index only
+ * serves containment, not age comparisons, so the facet read rides the same
+ * bounded pending scan as the other counts. The cast is guarded by
+ * pg_input_is_valid inside a CASE (Postgres does not promise AND evaluation
+ * order) so one malformed metadata value can never break the stats query;
+ * 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\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 rt.sla_minutes IS NOT NULL\n        AND e.created_at < NOW() - (rt.sla_minutes * INTERVAL '1 minute')\n    )                                                                                AS in_arrears\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.in_arrears, 0) AS in_arrears\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  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.

package/build/services/escalation/sql.js

@@ -192,7 +192,7 @@ LEFT JOIN resolved ON resolved.id = target.id`;
 // path is wasteful: percentile aggregates sort every qualifying resolved row,
 // while the live counts are cheap and bounded. So the two halves are separated:
 //
-//   STATION_LIVE_COUNTS_SQL    — pending / claimed / in_arrears. Cheap, always
+//   STATION_LIVE_COUNTS_SQL    — pending / claimed / priority_count. Cheap, always
 //                                run fresh. Scans only pending rows (backlog is
 //                                bounded no matter how much history accrues).
 //   STATION_PERIOD_METRICS_SQL — resolved / throughput / latency percentiles.
@@ -204,17 +204,34 @@ LEFT JOIN resolved ON resolved.id = target.id`;
 // and the service merges them by role into one StationMetric per station.
 // ---------------------------------------------------------------------------
 /**
- * Live counts — pending, active claims, and past-SLA (in_arrears) per role.
+ * Live counts — pending, active claims, and priority (past-threshold) per role.
  *
  * $1 TEXT[] — role filter (NULL = all roles / superadmin).
  *
  * Hits idx_hmsh_esc_pending_role_created (role, created_at DESC) WHERE
  * status='pending'. The pending working set is bounded by real backlog depth,
  * so this stays cheap as historical volume grows — safe on the hot refresh path.
+ *
+ * priority_count is the Pace Board rebalance signal: pending AND unclaimed
+ * items older than the role's threshold. One signal, two per-role dials with
+ * fallbacks so it works from sla_minutes alone:
+ *
+ *   age origin — priority_facet metadata key (an ISO 8601 UTC timestamp, e.g.
+ *                the order's authorized date) when set, else created_at.
+ *   threshold  — priority_threshold_minutes when set, else sla_minutes.
+ *
+ * Claimed items are excluded — they are already in someone's hands; the count
+ * is what the floor must still pull forward. The GIN metadata index only
+ * serves containment, not age comparisons, so the facet read rides the same
+ * bounded pending scan as the other counts. The cast is guarded by
+ * pg_input_is_valid inside a CASE (Postgres does not promise AND evaluation
+ * order) so one malformed metadata value can never break the stats query;
+ * with a facet configured, items missing the key or holding an unparseable
+ * value do not count (NULL age never passes the comparison).
  */
 exports.STATION_LIVE_COUNTS_SQL = `
 WITH role_targets AS (
-  SELECT role, sla_minutes
+  SELECT role, sla_minutes, priority_threshold_minutes, priority_facet
   FROM lt_roles
   WHERE ($1::text[] IS NULL OR role = ANY($1::text[]))
 ),
@@ -224,9 +241,15 @@ live_counts AS (
     COUNT(*)                                                                         AS pending,
     COUNT(*) FILTER (WHERE e.assigned_to IS NOT NULL AND e.assigned_until > NOW())  AS claimed,
     COUNT(*) FILTER (
-      WHERE rt.sla_minutes IS NOT NULL
-        AND e.created_at < NOW() - (rt.sla_minutes * INTERVAL '1 minute')
-    )                                                                                AS in_arrears
+      WHERE COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) IS NOT NULL
+        AND (e.assigned_to IS NULL OR e.assigned_until IS NULL OR e.assigned_until <= NOW())
+        AND CASE
+          WHEN rt.priority_facet IS NULL THEN e.created_at
+          WHEN pg_input_is_valid(e.metadata->>rt.priority_facet, 'timestamptz')
+            THEN (e.metadata->>rt.priority_facet)::timestamptz
+          ELSE NULL
+        END < NOW() - (COALESCE(rt.priority_threshold_minutes, rt.sla_minutes) * INTERVAL '1 minute')
+    )                                                                                AS priority_count
   FROM hmsh_escalations e
   JOIN role_targets rt ON rt.role = e.role
   WHERE e.status = 'pending'
@@ -234,9 +257,9 @@ live_counts AS (
 )
 SELECT
   rt.role,
-  COALESCE(lc.pending,    0) AS pending,
-  COALESCE(lc.claimed,    0) AS claimed,
-  COALESCE(lc.in_arrears, 0) AS in_arrears
+  COALESCE(lc.pending,        0) AS pending,
+  COALESCE(lc.claimed,        0) AS claimed,
+  COALESCE(lc.priority_count, 0) AS priority_count
 FROM role_targets rt
 LEFT JOIN live_counts lc ON lc.role = rt.role
 ORDER BY rt.role

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

@@ -50,7 +50,13 @@ export interface StationMetric {
     pending: number;
     claimed: number;
     resolved: number;
-    in_arrears: number;
+    /**
+     * Pending, unclaimed items past the role's threshold — the Pace Board
+     * rebalance signal. Age is measured from the role's priority_facet metadata
+     * timestamp (created_at when unset) against priority_threshold_minutes
+     * (sla_minutes when unset). 0 when neither threshold is configured.
+     */
+    priority_count: number;
     /** resolved_in_period / (target_per_hour × period_hours) × 100. Null when no target set. */
     throughput_pct: number | null;
     wait: StationMetricPeriod;

package/build/services/role/index.js

@@ -139,6 +139,8 @@ async function updateRoleMetadata(role, input) {
         provided('sla_minutes'), input.sla_minutes ?? null,
         provided('target_per_hour'), input.target_per_hour ?? null,
         provided('worker_count'), input.worker_count ?? null,
+        provided('priority_threshold_minutes'), input.priority_threshold_minutes ?? null,
+        provided('priority_facet'), input.priority_facet ?? null,
         input.change_summary ?? null,
         provided('upstream_roles'), upstreams,
     ]);

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

@@ -27,15 +27,15 @@ export declare const DELETE_ROLE = "\n  DELETE FROM lt_roles WHERE role = $1";
  * evaluated against the pre-update row), current_schema_version advances and
  * the post-update schema pair is snapshotted into lt_role_schemas. A no-change
  * save leaves the version alone and the snapshot INSERT conflicts away.
- * $22 = optional change summary recorded on the snapshot.
+ * $26 = optional change summary recorded on the snapshot.
  *
- * Upstream inputs ($23 = provided sentinel, $24 = replacement set) sync in the
+ * Upstream inputs ($27 = provided sentinel, $28 = replacement set) sync in the
  * same statement with replace semantics. The two CTEs deliberately avoid
  * touching the same row: the DELETE only removes rows leaving the set, and the
  * INSERT's ON CONFLICT DO NOTHING skips rows that stay (delete+insert of the
  * SAME key in one statement would silently drop it — CTEs share a snapshot).
  */
-export declare const UPDATE_ROLE_METADATA = "\n  WITH updated AS (\n    UPDATE lt_roles SET\n      title           = CASE WHEN $2::boolean  THEN $3                                ELSE title           END,\n      description     = CASE WHEN $4::boolean  THEN $5                                ELSE description     END,\n      form_schema     = CASE WHEN $6::boolean  THEN $7::jsonb                         ELSE form_schema     END,\n      metadata_schema = CASE WHEN $8::boolean  THEN $9::jsonb                         ELSE metadata_schema END,\n      properties      = CASE WHEN $10::boolean THEN COALESCE($11::jsonb, '{}'::jsonb) ELSE properties      END,\n      ops_visible     = CASE WHEN $12::boolean THEN $13::boolean                      ELSE ops_visible     END,\n      parent_role     = CASE WHEN $14::boolean THEN $15                               ELSE parent_role     END,\n      sla_minutes     = CASE WHEN $16::boolean THEN $17::numeric                      ELSE sla_minutes     END,\n      target_per_hour = CASE WHEN $18::boolean THEN $19::numeric                      ELSE target_per_hour END,\n      worker_count    = CASE WHEN $20::boolean THEN $21::int                          ELSE worker_count    END,\n      current_schema_version = CASE\n        WHEN ($6::boolean AND $7::jsonb IS DISTINCT FROM form_schema)\n          OR ($8::boolean AND $9::jsonb IS DISTINCT FROM metadata_schema)\n        THEN COALESCE(current_schema_version, 0) + 1\n        ELSE current_schema_version END\n    WHERE role = $1\n    RETURNING\n      role, title, description, form_schema, metadata_schema, properties,\n      ops_visible, parent_role, sla_minutes, target_per_hour, worker_count,\n      current_schema_version\n  ), snapshot AS (\n    INSERT INTO lt_role_schemas (role, version, form_schema, metadata_schema, change_summary)\n    SELECT role, current_schema_version, form_schema, metadata_schema, $22\n    FROM updated\n    WHERE ($6::boolean OR $8::boolean) AND current_schema_version IS NOT NULL\n    ON CONFLICT (role, version) DO NOTHING\n  ), upstream_prune AS (\n    DELETE FROM lt_role_upstreams\n    WHERE $23::boolean AND role = $1 AND upstream_role <> ALL($24::text[])\n  ), upstream_add AS (\n    INSERT INTO lt_role_upstreams (role, upstream_role)\n    SELECT $1, u FROM unnest($24::text[]) AS u\n    WHERE $23::boolean\n    ON CONFLICT DO NOTHING\n  )\n  SELECT * FROM updated";
+export declare const UPDATE_ROLE_METADATA = "\n  WITH updated AS (\n    UPDATE lt_roles SET\n      title           = CASE WHEN $2::boolean  THEN $3                                ELSE title           END,\n      description     = CASE WHEN $4::boolean  THEN $5                                ELSE description     END,\n      form_schema     = CASE WHEN $6::boolean  THEN $7::jsonb                         ELSE form_schema     END,\n      metadata_schema = CASE WHEN $8::boolean  THEN $9::jsonb                         ELSE metadata_schema END,\n      properties      = CASE WHEN $10::boolean THEN COALESCE($11::jsonb, '{}'::jsonb) ELSE properties      END,\n      ops_visible     = CASE WHEN $12::boolean THEN $13::boolean                      ELSE ops_visible     END,\n      parent_role     = CASE WHEN $14::boolean THEN $15                               ELSE parent_role     END,\n      sla_minutes     = CASE WHEN $16::boolean THEN $17::numeric                      ELSE sla_minutes     END,\n      target_per_hour = CASE WHEN $18::boolean THEN $19::numeric                      ELSE target_per_hour END,\n      worker_count    = CASE WHEN $20::boolean THEN $21::int                          ELSE worker_count    END,\n      priority_threshold_minutes\n                      = CASE WHEN $22::boolean THEN $23::numeric                      ELSE priority_threshold_minutes END,\n      priority_facet  = CASE WHEN $24::boolean THEN $25                               ELSE priority_facet  END,\n      current_schema_version = CASE\n        WHEN ($6::boolean AND $7::jsonb IS DISTINCT FROM form_schema)\n          OR ($8::boolean AND $9::jsonb IS DISTINCT FROM metadata_schema)\n        THEN COALESCE(current_schema_version, 0) + 1\n        ELSE current_schema_version END\n    WHERE role = $1\n    RETURNING\n      role, title, description, form_schema, metadata_schema, properties,\n      ops_visible, parent_role, sla_minutes, target_per_hour, worker_count,\n      priority_threshold_minutes, priority_facet,\n      current_schema_version\n  ), snapshot AS (\n    INSERT INTO lt_role_schemas (role, version, form_schema, metadata_schema, change_summary)\n    SELECT role, current_schema_version, form_schema, metadata_schema, $26\n    FROM updated\n    WHERE ($6::boolean OR $8::boolean) AND current_schema_version IS NOT NULL\n    ON CONFLICT (role, version) DO NOTHING\n  ), upstream_prune AS (\n    DELETE FROM lt_role_upstreams\n    WHERE $27::boolean AND role = $1 AND upstream_role <> ALL($28::text[])\n  ), upstream_add AS (\n    INSERT INTO lt_role_upstreams (role, upstream_role)\n    SELECT $1, u FROM unnest($28::text[]) AS u\n    WHERE $27::boolean\n    ON CONFLICT DO NOTHING\n  )\n  SELECT * FROM updated";
 export declare const GET_ROLE_FORM_SCHEMA = "\n  SELECT form_schema FROM lt_roles WHERE role = $1";
 export declare const GET_ROLE_METADATA_SCHEMA = "\n  SELECT metadata_schema FROM lt_roles WHERE role = $1";
 export declare const GET_ROLE_UPSTREAMS = "\n  SELECT upstream_role FROM lt_role_upstreams WHERE role = $1 ORDER BY upstream_role";
@@ -46,7 +46,7 @@ export declare const GET_ROLE_SCHEMA_VERSION = "\n  SELECT s.role, s.version, s.
  * versioned its schema still answers, with version NULL).
  */
 export declare const GET_ROLE_SCHEMA_CURRENT = "\n  SELECT r.role, r.current_schema_version AS version, r.form_schema,\n         r.metadata_schema, s.change_summary, s.created_at,\n         r.current_schema_version AS latest_version\n  FROM lt_roles r\n  LEFT JOIN lt_role_schemas s\n    ON s.role = r.role AND s.version = r.current_schema_version\n  WHERE r.role = $1";
-export declare const LIST_ROLES_WITH_DETAILS = "\n  WITH\n  user_counts AS (\n    SELECT role, COUNT(DISTINCT user_id)::int AS cnt\n    FROM lt_user_roles\n    GROUP BY role\n  ),\n  chain_counts AS (\n    SELECT role, COUNT(*)::int AS cnt\n    FROM (\n      SELECT source_role AS role FROM lt_config_role_escalations\n      UNION ALL\n      SELECT target_role AS role FROM lt_config_role_escalations\n    ) c\n    GROUP BY role\n  ),\n  workflow_counts AS (\n    SELECT role, COUNT(*)::int AS cnt\n    FROM lt_config_roles\n    GROUP BY role\n  ),\n  upstreams AS (\n    SELECT role, array_agg(upstream_role ORDER BY upstream_role) AS ups\n    FROM lt_role_upstreams\n    GROUP BY role\n  )\n  SELECT\n    r.role,\n    r.title,\n    r.description,\n    r.form_schema,\n    r.metadata_schema,\n    r.properties,\n    r.ops_visible,\n    r.parent_role,\n    r.sla_minutes,\n    r.target_per_hour,\n    r.worker_count,\n    r.current_schema_version,\n    COALESCE(up.ups, '{}') AS upstream_roles,\n    COALESCE(uc.cnt, 0) AS user_count,\n    COALESCE(cc.cnt, 0) AS chain_count,\n    COALESCE(wc.cnt, 0) AS workflow_count\n  FROM lt_roles r\n  LEFT JOIN user_counts uc ON uc.role = r.role\n  LEFT JOIN chain_counts cc ON cc.role = r.role\n  LEFT JOIN workflow_counts wc ON wc.role = r.role\n  LEFT JOIN upstreams up ON up.role = r.role\n  ORDER BY r.role";
+export declare const LIST_ROLES_WITH_DETAILS = "\n  WITH\n  user_counts AS (\n    SELECT role, COUNT(DISTINCT user_id)::int AS cnt\n    FROM lt_user_roles\n    GROUP BY role\n  ),\n  chain_counts AS (\n    SELECT role, COUNT(*)::int AS cnt\n    FROM (\n      SELECT source_role AS role FROM lt_config_role_escalations\n      UNION ALL\n      SELECT target_role AS role FROM lt_config_role_escalations\n    ) c\n    GROUP BY role\n  ),\n  workflow_counts AS (\n    SELECT role, COUNT(*)::int AS cnt\n    FROM lt_config_roles\n    GROUP BY role\n  ),\n  upstreams AS (\n    SELECT role, array_agg(upstream_role ORDER BY upstream_role) AS ups\n    FROM lt_role_upstreams\n    GROUP BY role\n  )\n  SELECT\n    r.role,\n    r.title,\n    r.description,\n    r.form_schema,\n    r.metadata_schema,\n    r.properties,\n    r.ops_visible,\n    r.parent_role,\n    r.sla_minutes,\n    r.target_per_hour,\n    r.worker_count,\n    r.priority_threshold_minutes,\n    r.priority_facet,\n    r.current_schema_version,\n    COALESCE(up.ups, '{}') AS upstream_roles,\n    COALESCE(uc.cnt, 0) AS user_count,\n    COALESCE(cc.cnt, 0) AS chain_count,\n    COALESCE(wc.cnt, 0) AS workflow_count\n  FROM lt_roles r\n  LEFT JOIN user_counts uc ON uc.role = r.role\n  LEFT JOIN chain_counts cc ON cc.role = r.role\n  LEFT JOIN workflow_counts wc ON wc.role = r.role\n  LEFT JOIN upstreams up ON up.role = r.role\n  ORDER BY r.role";
 export declare const COUNT_USER_ROLE_REFS = "\n  SELECT COUNT(*)::int AS cnt FROM lt_user_roles WHERE role = $1";
 export declare const COUNT_CHAIN_REFS = "\n  SELECT COUNT(*)::int AS cnt\n  FROM lt_config_role_escalations\n  WHERE source_role = $1 OR target_role = $1";
 export declare const COUNT_WORKFLOW_REFS = "\n  SELECT COUNT(*)::int AS cnt FROM lt_config_roles WHERE role = $1";

package/build/services/role/sql.js

@@ -61,9 +61,9 @@ exports.DELETE_ROLE = `
  * evaluated against the pre-update row), current_schema_version advances and
  * the post-update schema pair is snapshotted into lt_role_schemas. A no-change
  * save leaves the version alone and the snapshot INSERT conflicts away.
- * $22 = optional change summary recorded on the snapshot.
+ * $26 = optional change summary recorded on the snapshot.
  *
- * Upstream inputs ($23 = provided sentinel, $24 = replacement set) sync in the
+ * Upstream inputs ($27 = provided sentinel, $28 = replacement set) sync in the
  * same statement with replace semantics. The two CTEs deliberately avoid
  * touching the same row: the DELETE only removes rows leaving the set, and the
  * INSERT's ON CONFLICT DO NOTHING skips rows that stay (delete+insert of the
@@ -82,6 +82,9 @@ exports.UPDATE_ROLE_METADATA = `
       sla_minutes     = CASE WHEN $16::boolean THEN $17::numeric                      ELSE sla_minutes     END,
       target_per_hour = CASE WHEN $18::boolean THEN $19::numeric                      ELSE target_per_hour END,
       worker_count    = CASE WHEN $20::boolean THEN $21::int                          ELSE worker_count    END,
+      priority_threshold_minutes
+                      = CASE WHEN $22::boolean THEN $23::numeric                      ELSE priority_threshold_minutes END,
+      priority_facet  = CASE WHEN $24::boolean THEN $25                               ELSE priority_facet  END,
       current_schema_version = CASE
         WHEN ($6::boolean AND $7::jsonb IS DISTINCT FROM form_schema)
           OR ($8::boolean AND $9::jsonb IS DISTINCT FROM metadata_schema)
@@ -91,20 +94,21 @@ exports.UPDATE_ROLE_METADATA = `
     RETURNING
       role, title, description, form_schema, metadata_schema, properties,
       ops_visible, parent_role, sla_minutes, target_per_hour, worker_count,
+      priority_threshold_minutes, priority_facet,
       current_schema_version
   ), snapshot AS (
     INSERT INTO lt_role_schemas (role, version, form_schema, metadata_schema, change_summary)
-    SELECT role, current_schema_version, form_schema, metadata_schema, $22
+    SELECT role, current_schema_version, form_schema, metadata_schema, $26
     FROM updated
     WHERE ($6::boolean OR $8::boolean) AND current_schema_version IS NOT NULL
     ON CONFLICT (role, version) DO NOTHING
   ), upstream_prune AS (
     DELETE FROM lt_role_upstreams
-    WHERE $23::boolean AND role = $1 AND upstream_role <> ALL($24::text[])
+    WHERE $27::boolean AND role = $1 AND upstream_role <> ALL($28::text[])
   ), upstream_add AS (
     INSERT INTO lt_role_upstreams (role, upstream_role)
-    SELECT $1, u FROM unnest($24::text[]) AS u
-    WHERE $23::boolean
+    SELECT $1, u FROM unnest($28::text[]) AS u
+    WHERE $27::boolean
     ON CONFLICT DO NOTHING
   )
   SELECT * FROM updated`;
@@ -184,6 +188,8 @@ exports.LIST_ROLES_WITH_DETAILS = `
     r.sla_minutes,
     r.target_per_hour,
     r.worker_count,
+    r.priority_threshold_minutes,
+    r.priority_facet,
     r.current_schema_version,
     COALESCE(up.ups, '{}') AS upstream_roles,
     COALESCE(uc.cnt, 0) AS user_count,

package/build/services/role/types.d.ts

@@ -25,6 +25,18 @@ export interface RoleDetail {
     target_per_hour: number | null;
     /** Capacity at this station (people or machines). Part of the ops triangle. */
     worker_count: number | null;
+    /**
+     * Max age (minutes) before a pending, unclaimed escalation counts toward the
+     * Pace Board priority count. Falls back to sla_minutes when null.
+     */
+    priority_threshold_minutes: number | null;
+    /**
+     * lt_escalations.metadata key holding the age origin for the priority count
+     * as an ISO 8601 UTC timestamp (e.g. the order's authorized date). Falls
+     * back to created_at when null. When set, items missing the key or holding
+     * an unparseable value are not counted.
+     */
+    priority_facet: string | null;
     /**
      * Version of the live form_schema/metadata_schema pair. Advances whenever a
      * schema field changes; each version is snapshotted in lt_role_schemas so
@@ -74,6 +86,8 @@ export interface UpdateRoleInput {
     sla_minutes?: number | null;
     target_per_hour?: number | null;
     worker_count?: number | null;
+    priority_threshold_minutes?: number | null;
+    priority_facet?: string | null;
     /**
      * Replace the upstream-input set (omitted = preserve; null or [] = clear).
      * Every entry must name an existing role other than this one.

package/build/start/workers.js

@@ -173,6 +173,7 @@ async function startWorkers(startConfig, workers, builtinMcpServerFactories) {
                         workflow_type: workflowType,
                         task_queue: w.taskQueue,
                         invocable: c.invocable ?? false,
+                        certified: c.certified,
                         default_role: c.defaultRole ?? 'reviewer',
                         description: c.description ?? null,
                         roles: c.roles ?? [],

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

@@ -234,6 +234,7 @@ export declare const listWorkflowConfigsSchema: z.ZodObject<{}, "strip", z.ZodTy
 export declare const upsertWorkflowConfigSchema: z.ZodObject<{
     workflow_type: z.ZodString;
     invocable: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    certified: z.ZodOptional<z.ZodBoolean>;
     task_queue: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
     default_role: z.ZodDefault<z.ZodOptional<z.ZodString>>;
     description: z.ZodDefault<z.ZodOptional<z.ZodNullable<z.ZodString>>>;
@@ -259,8 +260,10 @@ export declare const upsertWorkflowConfigSchema: z.ZodObject<{
     resolver_schema: Record<string, any> | null;
     cron_schedule: string | null;
     execute_as: string | null;
+    certified?: boolean | undefined;
 }, {
     workflow_type: string;
+    certified?: boolean | undefined;
     invocable?: boolean | undefined;
     task_queue?: string | null | undefined;
     default_role?: string | undefined;
@@ -562,6 +565,8 @@ export declare const updateRoleSchema: z.ZodObject<{
     sla_minutes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     target_per_hour: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
     worker_count: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    priority_threshold_minutes: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    priority_facet: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     upstream_roles: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     change_summary: z.ZodOptional<z.ZodString>;
 }, "strip", z.ZodTypeAny, {
@@ -576,6 +581,8 @@ export declare const updateRoleSchema: z.ZodObject<{
     sla_minutes?: number | null | undefined;
     target_per_hour?: number | null | undefined;
     worker_count?: number | null | undefined;
+    priority_threshold_minutes?: number | null | undefined;
+    priority_facet?: string | null | undefined;
     upstream_roles?: string[] | null | undefined;
     change_summary?: string | undefined;
 }, {
@@ -590,6 +597,8 @@ export declare const updateRoleSchema: z.ZodObject<{
     sla_minutes?: number | null | undefined;
     target_per_hour?: number | null | undefined;
     worker_count?: number | null | undefined;
+    priority_threshold_minutes?: number | null | undefined;
+    priority_facet?: string | null | undefined;
     upstream_roles?: string[] | null | undefined;
     change_summary?: string | undefined;
 }>;

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

@@ -14,6 +14,7 @@ exports.claimByFacetsSchema = exports.claimGroupsSchema = exports.searchByFacets
  * deep-instantiation errors in the registerTool() generic.
  */
 const zod_1 = require("zod");
+const facet_sql_1 = require("../../../services/escalation/facet-sql");
 // ── tasks (routes/tasks.ts) ─────────────────────────────────────────────────
 exports.findTasksSchema = zod_1.z.object({
     status: zod_1.z.string().optional().describe('Filter: pending, completed, etc.'),
@@ -102,6 +103,8 @@ exports.listWorkflowConfigsSchema = zod_1.z.object({});
 exports.upsertWorkflowConfigSchema = zod_1.z.object({
     workflow_type: zod_1.z.string().describe('Workflow function name'),
     invocable: zod_1.z.boolean().optional().default(false),
+    certified: zod_1.z.boolean().optional()
+        .describe('Explicit HITL certification (interceptor treatment). Omitted → derived from roles/consumes presence.'),
     task_queue: zod_1.z.string().nullable().optional().default(null),
     default_role: zod_1.z.string().optional().default('reviewer'),
     description: zod_1.z.string().nullable().optional().default(null),
@@ -116,7 +119,7 @@ exports.upsertWorkflowConfigSchema = zod_1.z.object({
     cron_schedule: zod_1.z.string().nullable().optional().default(null),
 });
 exports.deleteWorkflowConfigSchema = zod_1.z.object({
-    workflow_type: zod_1.z.string().describe('Workflow type to de-certify'),
+    workflow_type: zod_1.z.string().describe('Workflow type to unregister (deletes the registration row)'),
 });
 // ── workflows (routes/workflows/invocation.ts + discovery.ts) ───────────────
 exports.listDiscoveredWorkflowsSchema = zod_1.z.object({
@@ -242,6 +245,8 @@ exports.updateRoleSchema = zod_1.z.object({
     sla_minutes: zod_1.z.number().nullable().optional().describe('Target resolution time in minutes. One of the capacity settings: target_per_hour = worker_count / (sla_minutes / 60)'),
     target_per_hour: zod_1.z.number().nullable().optional().describe('Intended throughput (items resolved per hour). Drives the station pace baseline on the Operations view.'),
     worker_count: zod_1.z.number().nullable().optional().describe('Capacity at this station (staff or machine count). One of the capacity settings.'),
+    priority_threshold_minutes: zod_1.z.number().min(0).nullable().optional().describe('Max age in minutes before a pending unclaimed escalation counts toward the Pace Board priority count. Falls back to sla_minutes when null.'),
+    priority_facet: zod_1.z.string().regex(facet_sql_1.FACET_KEY).nullable().optional().describe('lt_escalations.metadata key holding the age origin for the priority count as an ISO 8601 UTC timestamp (e.g. authorized_at). Falls back to created_at when null. When set, items missing the key or holding an unparseable value are not counted.'),
     upstream_roles: zod_1.z.array(zod_1.z.string()).nullable().optional().describe('Replace the set of roles this station draws input from across other sequences (parent_role stays the single prior step in its own sequence). Omitted = preserve; null or [] = clear.'),
     change_summary: zod_1.z.string().optional().describe('Recorded on the schema version snapshot when this update changes form_schema or metadata_schema'),
 });

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

@@ -196,7 +196,8 @@ function registerUserTools(server) {
         description: 'Update role metadata with PATCH semantics — omitted fields keep their ' +
             'values. Covers display name, description, form/metadata schemas, the ' +
             'free properties bag, ops_visible flag, parent role, and the typed ' +
-            'operational targets (sla_minutes, target_per_hour, worker_count).',
+            'operational targets (sla_minutes, target_per_hour, worker_count, ' +
+            'priority_threshold_minutes, priority_facet).',
         inputSchema: schemas_1.updateRoleSchema,
     }, async (args) => {
         const updated = await roleService.updateRoleMetadata(args.role, {
@@ -210,6 +211,8 @@ function registerUserTools(server) {
             sla_minutes: args.sla_minutes,
             target_per_hour: args.target_per_hour,
             worker_count: args.worker_count,
+            priority_threshold_minutes: args.priority_threshold_minutes,
+            priority_facet: args.priority_facet,
             upstream_roles: args.upstream_roles,
             change_summary: args.change_summary,
         });

package/build/system/mcp-servers/admin/workflow-config.js

@@ -75,6 +75,7 @@ function registerWorkflowConfigTools(server) {
         const config = await configService.upsertWorkflowConfig({
             workflow_type: args.workflow_type,
             invocable: args.invocable,
+            certified: args.certified,
             task_queue: args.task_queue,
             default_role: args.default_role,
             description: args.description,