@cadenza.io/service 2.20.1 → 2.21.0

package/dist/index.js

@@ -105,6 +105,30 @@ var LOCAL_ROUTINE_PERSISTENCE_KEYS = [
   "__routineCreatedAt",
   "__routineIsMeta"
 ];
+var BULKY_EXECUTION_PERSISTENCE_KEYS = [
+  "rows",
+  "joinedContexts",
+  "serviceInstances",
+  "serviceInstanceLeases",
+  "serviceInstanceTransports",
+  "serviceManifests",
+  "tasks",
+  "helpers",
+  "globals",
+  "signals",
+  "intents",
+  "actors",
+  "routines",
+  "directionalTaskMaps",
+  "actorTaskMaps",
+  "taskToRoutineMaps",
+  "taskToHelperMaps",
+  "helperToHelperMaps",
+  "taskToGlobalMaps",
+  "helperToGlobalMaps",
+  "signalToTaskMaps",
+  "intentToTaskMaps"
+];
 function readHintValue(source, key) {
   if (!source || typeof source !== "object") {
     return void 0;
@@ -131,8 +155,80 @@ function stripLocalRoutinePersistenceHints(input) {
   }
   return context;
 }
+function summarizeQueryData(queryData) {
+  if (!queryData || typeof queryData !== "object") {
+    return void 0;
+  }
+  const summary = {};
+  if (queryData.data && typeof queryData.data === "object") {
+    summary.dataKeys = Object.keys(queryData.data).sort();
+  }
+  if (queryData.filter && typeof queryData.filter === "object") {
+    summary.filterKeys = Object.keys(queryData.filter).sort();
+  }
+  if (queryData.onConflict && typeof queryData.onConflict === "object") {
+    const onConflict = queryData.onConflict;
+    summary.onConflictTarget = Array.isArray(onConflict.target) ? [...onConflict.target] : onConflict.target ?? null;
+  }
+  return Object.keys(summary).length > 0 ? summary : void 0;
+}
+function sanitizeExecutionPersistenceContext(input) {
+  const context = stripLocalRoutinePersistenceHints(input);
+  for (const key of BULKY_EXECUTION_PERSISTENCE_KEYS) {
+    const value = context[key];
+    if (value === void 0) {
+      continue;
+    }
+    const countKey = `${key}Count`;
+    if (context[countKey] === void 0) {
+      if (Array.isArray(value)) {
+        context[countKey] = value.length;
+      } else if (value && typeof value === "object") {
+        context[countKey] = Object.keys(value).length;
+      }
+    }
+    delete context[key];
+  }
+  if (context.queryData && typeof context.queryData === "object") {
+    const queryDataSummary = summarizeQueryData(context.queryData);
+    if (queryDataSummary) {
+      context.queryData = queryDataSummary;
+    } else {
+      delete context.queryData;
+    }
+  }
+  return context;
+}
+function sanitizeExecutionPersistenceResultPayload(input) {
+  const payload = input && typeof input === "object" ? { ...input } : {};
+  const resultContext = payload.resultContext && typeof payload.resultContext === "object" ? sanitizeExecutionPersistenceContext(
+    payload.resultContext
+  ) : payload.resultContext;
+  const metaResultContext = payload.metaResultContext && typeof payload.metaResultContext === "object" ? sanitizeExecutionPersistenceContext(
+    payload.metaResultContext
+  ) : payload.metaResultContext;
+  const snakeResultContext = payload.result_context && typeof payload.result_context === "object" ? sanitizeExecutionPersistenceContext(
+    payload.result_context
+  ) : payload.result_context;
+  const snakeMetaResultContext = payload.meta_result_context && typeof payload.meta_result_context === "object" ? sanitizeExecutionPersistenceContext(
+    payload.meta_result_context
+  ) : payload.meta_result_context;
+  if (resultContext !== void 0) {
+    payload.resultContext = resultContext;
+  }
+  if (metaResultContext !== void 0) {
+    payload.metaResultContext = metaResultContext;
+  }
+  if (snakeResultContext !== void 0) {
+    payload.result_context = snakeResultContext;
+  }
+  if (snakeMetaResultContext !== void 0) {
+    payload.meta_result_context = snakeMetaResultContext;
+  }
+  return payload;
+}
 function splitRoutinePersistenceContext(input) {
-  const sanitized = stripLocalRoutinePersistenceHints(input);
+  const sanitized = sanitizeExecutionPersistenceContext(input);
   return {
     context: Object.fromEntries(
       Object.entries(sanitized).filter(([key]) => !key.startsWith("__"))
@@ -321,6 +417,90 @@ function ensureDelegationContextMetadata(input) {
 
 // src/graph/definition/DeputyTask.ts
 var SERVICE_REGISTRY_TRACE_SERVICE = (process.env.CADENZA_SERVICE_REGISTRY_TRACE_SERVICE ?? "").trim();
+function deputyTaskExecutor(context, emit2, inquire, _tools, progressCallback) {
+  const task = this;
+  return new Promise((resolve, reject) => {
+    if (context.__metadata.__blockRemoteExecution) {
+      reject(new Error("Blocked remote execution"));
+      return;
+    }
+    if (context.__metadata.__skipRemoteExecution) {
+      resolve(context);
+      return;
+    }
+    const processId = (0, import_uuid2.v4)();
+    context.__metadata.__deputyExecId = processId;
+    if ((process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") && context.__remoteRoutineName === "Insert service_instance") {
+      console.log("[CADENZA_INSTANCE_DEBUG] deputy_delegation_requested", {
+        localServiceName: CadenzaService.serviceRegistry.serviceName,
+        localTaskName: context.__localTaskName ?? null,
+        remoteRoutineName: context.__remoteRoutineName ?? null,
+        targetServiceName: context.__serviceName ?? null,
+        deputyExecId: processId,
+        dataKeys: context.data && typeof context.data === "object" ? Object.keys(context.data) : [],
+        queryDataKeys: context.queryData && typeof context.queryData === "object" ? Object.keys(context.queryData) : [],
+        queryDataDataKeys: context.queryData?.data && typeof context.queryData.data === "object" ? Object.keys(context.queryData.data) : []
+      });
+    }
+    emit2("meta.deputy.delegation_requested", {
+      ...context
+    });
+    CadenzaService.createEphemeralMetaTask(
+      `On progress deputy ${task.remoteRoutineName}`,
+      (ctx) => {
+        if (typeof progressCallback === "function" && ctx.progress) {
+          progressCallback(ctx.progress * ctx.weight);
+        }
+      },
+      `Ephemeral task for deputy process ${processId}`,
+      {
+        once: false,
+        destroyCondition: (ctx) => ctx.progress === 1 || ctx.progress === void 0,
+        register: false
+      }
+    ).doOn(
+      `meta.socket_client.delegation_progress:${processId}`,
+      `meta.socket_client.delegated:${processId}`,
+      `meta.fetch.delegated:${processId}`,
+      `meta.service_registry.load_balance_failed:${processId}`
+    );
+    CadenzaService.createEphemeralMetaTask(
+      `Resolve deputy ${task.remoteRoutineName}`,
+      (responseCtx) => {
+        const mergedResponseCtx = responseCtx && typeof responseCtx === "object" ? {
+          ...context,
+          ...responseCtx
+        } : responseCtx;
+        if (responseCtx?.errored) {
+          reject(new Error(responseCtx.__error));
+        } else {
+          if (SERVICE_REGISTRY_TRACE_SERVICE.length > 0 && CadenzaService.serviceRegistry.serviceName === SERVICE_REGISTRY_TRACE_SERVICE && context.__remoteRoutineName === "Insert service_instance") {
+            console.log(
+              "[CADENZA_SERVICE_REGISTRY_TRACE] deputy_insert_service_instance_resolved",
+              {
+                localServiceName: CadenzaService.serviceRegistry.serviceName,
+                targetServiceName: context.__serviceName ?? null,
+                resolverRequestId: context.__resolverRequestId ?? null,
+                serviceInstanceId: mergedResponseCtx && typeof mergedResponseCtx === "object" ? mergedResponseCtx.__serviceInstanceId ?? mergedResponseCtx.uuid ?? mergedResponseCtx.data?.uuid ?? null : null,
+                hasResolverQueryData: mergedResponseCtx && typeof mergedResponseCtx === "object" && mergedResponseCtx.__resolverQueryData !== void 0
+              }
+            );
+          }
+          if (mergedResponseCtx && typeof mergedResponseCtx === "object") {
+            delete mergedResponseCtx.__isDeputy;
+          }
+          resolve(mergedResponseCtx);
+        }
+      },
+      `Ephemeral resolver for deputy process ${processId}`,
+      { register: false }
+    ).doOn(
+      `meta.socket_client.delegated:${processId}`,
+      `meta.fetch.delegated:${processId}`,
+      `meta.service_registry.load_balance_failed:${processId}`
+    );
+  });
+}
 var DeputyTask = class extends import_core.Task {
   /**
    * Constructs a new instance of the class with the specified parameters.
@@ -348,87 +528,9 @@ var DeputyTask = class extends import_core.Task {
    * @return {void} This constructor does not return a value.
    */
   constructor(name, remoteRoutineName, serviceName = void 0, description = "", concurrency = 0, timeout = 0, register = true, isUnique = false, isMeta = false, isSubMeta = false, isHidden = false, getTagCallback = void 0, inputSchema = void 0, validateInputContext = false, outputSchema = void 0, validateOutputContext = false, retryCount = 0, retryDelay = 0, retryDelayMax = 0, retryDelayFactor = 1) {
-    const taskFunction = (context, emit2, inquire, progressCallback) => {
-      return new Promise((resolve, reject) => {
-        if (context.__metadata.__blockRemoteExecution) {
-          reject(new Error("Blocked remote execution"));
-          return;
-        }
-        if (context.__metadata.__skipRemoteExecution) {
-          resolve(context);
-          return;
-        }
-        const processId = (0, import_uuid2.v4)();
-        context.__metadata.__deputyExecId = processId;
-        if ((process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") && context.__remoteRoutineName === "Insert service_instance") {
-          console.log("[CADENZA_INSTANCE_DEBUG] deputy_delegation_requested", {
-            localServiceName: CadenzaService.serviceRegistry.serviceName,
-            localTaskName: context.__localTaskName ?? null,
-            remoteRoutineName: context.__remoteRoutineName ?? null,
-            targetServiceName: context.__serviceName ?? null,
-            deputyExecId: processId,
-            dataKeys: context.data && typeof context.data === "object" ? Object.keys(context.data) : [],
-            queryDataKeys: context.queryData && typeof context.queryData === "object" ? Object.keys(context.queryData) : [],
-            queryDataDataKeys: context.queryData?.data && typeof context.queryData.data === "object" ? Object.keys(context.queryData.data) : []
-          });
-        }
-        emit2("meta.deputy.delegation_requested", {
-          ...context
-        });
-        CadenzaService.createEphemeralMetaTask(
-          `On progress deputy ${this.remoteRoutineName}`,
-          (ctx) => {
-            if (ctx.progress) progressCallback(ctx.progress * ctx.weight);
-          },
-          `Ephemeral task for deputy process ${processId}`,
-          {
-            once: false,
-            destroyCondition: (ctx) => ctx.progress === 1 || ctx.progress === void 0,
-            register: false
-          }
-        ).doOn(
-          `meta.socket_client.delegation_progress:${processId}`,
-          `meta.socket_client.delegated:${processId}`,
-          `meta.fetch.delegated:${processId}`,
-          `meta.service_registry.load_balance_failed:${processId}`
-        );
-        CadenzaService.createEphemeralMetaTask(
-          `Resolve deputy ${this.remoteRoutineName}`,
-          (responseCtx) => {
-            const mergedResponseCtx = responseCtx && typeof responseCtx === "object" ? {
-              ...context,
-              ...responseCtx
-            } : responseCtx;
-            if (responseCtx?.errored) {
-              reject(new Error(responseCtx.__error));
-            } else {
-              if (SERVICE_REGISTRY_TRACE_SERVICE.length > 0 && CadenzaService.serviceRegistry.serviceName === SERVICE_REGISTRY_TRACE_SERVICE && context.__remoteRoutineName === "Insert service_instance") {
-                console.log("[CADENZA_SERVICE_REGISTRY_TRACE] deputy_insert_service_instance_resolved", {
-                  localServiceName: CadenzaService.serviceRegistry.serviceName,
-                  targetServiceName: context.__serviceName ?? null,
-                  resolverRequestId: context.__resolverRequestId ?? null,
-                  serviceInstanceId: mergedResponseCtx && typeof mergedResponseCtx === "object" ? mergedResponseCtx.__serviceInstanceId ?? mergedResponseCtx.uuid ?? mergedResponseCtx.data?.uuid ?? null : null,
-                  hasResolverQueryData: mergedResponseCtx && typeof mergedResponseCtx === "object" && mergedResponseCtx.__resolverQueryData !== void 0
-                });
-              }
-              if (mergedResponseCtx && typeof mergedResponseCtx === "object") {
-                delete mergedResponseCtx.__isDeputy;
-              }
-              resolve(mergedResponseCtx);
-            }
-          },
-          `Ephemeral resolver for deputy process ${processId}`,
-          { register: false }
-        ).doOn(
-          `meta.socket_client.delegated:${processId}`,
-          `meta.fetch.delegated:${processId}`,
-          `meta.service_registry.load_balance_failed:${processId}`
-        );
-      });
-    };
     super(
       name,
-      taskFunction,
+      deputyTaskExecutor,
       description,
       concurrency,
       timeout,
@@ -460,6 +562,11 @@ var DeputyTask = class extends import_core.Task {
       communicationType: "delegation"
     });
   }
+  clone() {
+    throw new Error(
+      `DeputyTask '${this.name}' does not support clone(). Create a new named deputy task or use a flow-specific meta task that performs an inquiry instead.`
+    );
+  }
   /**
    * Executes the specified task function within the provided execution context.
    *
@@ -503,7 +610,25 @@ var DeputyTask = class extends import_core.Task {
         })
       )
     );
-    return this.taskFunction(deputyContext, emit2, inquire, progressCallback);
+    const resolvedTools = typeof CadenzaService.resolveToolsForOwner === "function" ? CadenzaService.resolveToolsForOwner(
+      this,
+      deputyContext,
+      emit2,
+      inquire,
+      progressCallback
+    ) : {
+      helpers: {},
+      globals: {}
+    };
+    const resolvedProgressCallback = typeof progressCallback === "function" ? progressCallback : () => {
+    };
+    return this.taskFunction(
+      deputyContext,
+      emit2,
+      inquire,
+      resolvedTools,
+      resolvedProgressCallback
+    );
   }
 };
 
@@ -572,6 +697,11 @@ var DatabaseTask = class extends DeputyTask {
     );
     this.queryData = queryData;
   }
+  clone() {
+    throw new Error(
+      `DatabaseTask '${this.name}' does not support clone(). Create a new named database task or use a flow-specific meta task that performs the default database inquiry instead.`
+    );
+  }
   /**
    * Executes the specified task within the given context.
    *
@@ -697,7 +827,25 @@ var DatabaseTask = class extends DeputyTask {
         sourceTaskName: rawContext.__localTaskName ?? rawContext.__metadata?.__localTaskName ?? null
       });
     }
-    return this.taskFunction(deputyContext, emit2, inquire, progressCallback);
+    const resolvedTools = typeof CadenzaService.resolveToolsForOwner === "function" ? CadenzaService.resolveToolsForOwner(
+      this,
+      deputyContext,
+      emit2,
+      inquire,
+      progressCallback
+    ) : {
+      helpers: {},
+      globals: {}
+    };
+    const resolvedProgressCallback = typeof progressCallback === "function" ? progressCallback : () => {
+    };
+    return this.taskFunction(
+      deputyContext,
+      emit2,
+      inquire,
+      resolvedTools,
+      resolvedProgressCallback
+    );
   }
 };
 
@@ -4142,6 +4290,10 @@ function normalizeServiceInstanceDescriptor(value) {
     return null;
   }
   const transports = normalizeTransportArray(raw.transports, uuid10);
+  const leaseStatusRaw = normalizeString2(raw.leaseStatus ?? raw.lease_status);
+  const leaseStatus = leaseStatusRaw === "active" || leaseStatusRaw === "non_responsive" || leaseStatusRaw === "inactive" || leaseStatusRaw === "deleted" ? leaseStatusRaw : void 0;
+  const isActive = leaseStatus === "active" ? true : leaseStatus === "non_responsive" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : Boolean(raw.isActive ?? raw.is_active ?? true);
+  const isNonResponsive = leaseStatus === "non_responsive" ? true : leaseStatus === "active" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : Boolean(raw.isNonResponsive ?? raw.is_non_responsive ?? false);
   return {
     uuid: uuid10,
     serviceName,
@@ -4152,10 +4304,16 @@ function normalizeServiceInstanceDescriptor(value) {
       )
     ),
     isPrimary: Boolean(raw.isPrimary ?? raw.is_primary ?? false),
-    isActive: Boolean(raw.isActive ?? raw.is_active ?? true),
-    isNonResponsive: Boolean(
-      raw.isNonResponsive ?? raw.is_non_responsive ?? false
-    ),
+    leaseStatus,
+    leaseExpiresAt: typeof raw.leaseExpiresAt === "string" ? raw.leaseExpiresAt : typeof raw.lease_expires_at === "string" ? raw.lease_expires_at : void 0,
+    lastLeaseRenewedAt: typeof raw.lastLeaseRenewedAt === "string" ? raw.lastLeaseRenewedAt : typeof raw.last_lease_renewed_at === "string" ? raw.last_lease_renewed_at : void 0,
+    isReady: typeof raw.isReady === "boolean" ? raw.isReady : typeof raw.is_ready === "boolean" ? raw.is_ready : void 0,
+    readinessReason: typeof raw.readinessReason === "string" ? raw.readinessReason : typeof raw.readiness_reason === "string" ? raw.readiness_reason : null,
+    lastReadyAt: typeof raw.lastReadyAt === "string" ? raw.lastReadyAt : typeof raw.last_ready_at === "string" ? raw.last_ready_at : null,
+    lastObservedTransportAt: typeof raw.lastObservedTransportAt === "string" ? raw.lastObservedTransportAt : typeof raw.last_observed_transport_at === "string" ? raw.last_observed_transport_at : null,
+    shutdownRequestedAt: typeof raw.shutdownRequestedAt === "string" ? raw.shutdownRequestedAt : typeof raw.shutdown_requested_at === "string" ? raw.shutdown_requested_at : null,
+    isActive,
+    isNonResponsive,
     isBlocked: Boolean(raw.isBlocked ?? raw.is_blocked ?? false),
     runtimeState: raw.runtimeState === "healthy" || raw.runtimeState === "degraded" || raw.runtimeState === "overloaded" || raw.runtimeState === "unavailable" ? raw.runtimeState : void 0,
     acceptingWork: typeof raw.acceptingWork === "boolean" ? raw.acceptingWork : void 0,
@@ -4608,6 +4766,61 @@ function resolveHealthMetric(input, keys) {
   }
   return void 0;
 }
+function sanitizeRuntimeMetricsHealthDetail(value) {
+  if (!value || typeof value !== "object") {
+    return void 0;
+  }
+  const input = value;
+  const sampledAt = typeof input.sampledAt === "string" && input.sampledAt.trim().length > 0 ? input.sampledAt : void 0;
+  const cpuUsage = normalizeOptionalMetric(input.cpuUsage ?? input.cpu ?? input.cpuLoad);
+  const memoryUsage = normalizeOptionalMetric(
+    input.memoryUsage ?? input.memory ?? input.memoryPressure
+  );
+  const eventLoopLag = normalizeOptionalMetric(
+    input.eventLoopLag ?? input.eventLoopLagMs
+  );
+  const rssBytes = normalizeOptionalMetric(input.rssBytes);
+  const heapUsedBytes = normalizeOptionalMetric(input.heapUsedBytes);
+  const heapTotalBytes = normalizeOptionalMetric(input.heapTotalBytes);
+  const memoryLimitBytes = normalizeOptionalMetric(input.memoryLimitBytes);
+  if (sampledAt === void 0 && cpuUsage === void 0 && memoryUsage === void 0 && eventLoopLag === void 0 && rssBytes === void 0 && heapUsedBytes === void 0 && heapTotalBytes === void 0 && memoryLimitBytes === void 0) {
+    return void 0;
+  }
+  return {
+    ...sampledAt !== void 0 ? { sampledAt } : {},
+    ...cpuUsage !== void 0 ? { cpuUsage } : {},
+    ...memoryUsage !== void 0 ? { memoryUsage } : {},
+    ...eventLoopLag !== void 0 ? { eventLoopLag } : {},
+    ...rssBytes !== void 0 ? { rssBytes } : {},
+    ...heapUsedBytes !== void 0 ? { heapUsedBytes } : {},
+    ...heapTotalBytes !== void 0 ? { heapTotalBytes } : {},
+    ...memoryLimitBytes !== void 0 ? { memoryLimitBytes } : {}
+  };
+}
+function sanitizeAuthorityRuntimeStatusHealth(health, options) {
+  const input = health && typeof health === "object" ? health : {};
+  const cpuUsage = options?.cpuUsage !== void 0 ? options.cpuUsage : normalizeOptionalMetric(input.cpuUsage ?? input.cpu ?? input.cpuLoad);
+  const memoryUsage = options?.memoryUsage !== void 0 ? options.memoryUsage : normalizeOptionalMetric(
+    input.memoryUsage ?? input.memory ?? input.memoryPressure
+  );
+  const eventLoopLag = options?.eventLoopLag !== void 0 ? options.eventLoopLag : normalizeOptionalMetric(input.eventLoopLag ?? input.eventLoopLagMs);
+  const runtimeMetrics = sanitizeRuntimeMetricsHealthDetail(input.runtimeMetrics);
+  const runtimeStatus = options?.state || options?.reportedAt || typeof options?.acceptingWork === "boolean" ? {
+    ...options?.state ? { state: options.state } : {},
+    ...typeof options?.acceptingWork === "boolean" ? { acceptingWork: options.acceptingWork } : {},
+    ...options?.reportedAt ? { reportedAt: options.reportedAt } : {}
+  } : void 0;
+  if (cpuUsage === void 0 && memoryUsage === void 0 && eventLoopLag === void 0 && !runtimeMetrics && !runtimeStatus) {
+    return void 0;
+  }
+  return {
+    ...cpuUsage !== void 0 ? { cpuUsage } : {},
+    ...memoryUsage !== void 0 ? { memoryUsage } : {},
+    ...eventLoopLag !== void 0 ? { eventLoopLag } : {},
+    ...runtimeMetrics ? { runtimeMetrics } : {},
+    ...runtimeStatus ? { runtimeStatus } : {}
+  };
+}
 function normalizeAuthorityRuntimeStatusReport(input) {
   if (!input || typeof input !== "object") {
     return null;
@@ -4636,6 +4849,17 @@ function normalizeAuthorityRuntimeStatusReport(input) {
     (protocol) => protocol === "rest" || protocol === "socket"
   ) : [];
   const transportProtocols = transportProtocolList.length > 0 ? Array.from(new Set(transportProtocolList)) : void 0;
+  const acceptingWork = Boolean(input.acceptingWork ?? input.accepting_work);
+  const cpuUsage = resolveHealthMetric(input, ["cpuUsage", "cpu", "cpuLoad"]);
+  const memoryUsage = resolveHealthMetric(input, [
+    "memoryUsage",
+    "memory",
+    "memoryPressure"
+  ]);
+  const eventLoopLag = resolveHealthMetric(input, [
+    "eventLoopLag",
+    "eventLoopLagMs"
+  ]);
   return {
     serviceName,
     serviceInstanceId,
@@ -4646,7 +4870,7 @@ function normalizeAuthorityRuntimeStatusReport(input) {
     isFrontend: typeof input.isFrontend === "boolean" ? input.isFrontend : typeof input.is_frontend === "boolean" ? input.is_frontend : void 0,
     reportedAt,
     state,
-    acceptingWork: Boolean(input.acceptingWork ?? input.accepting_work),
+    acceptingWork,
     numberOfRunningGraphs: Math.max(
       0,
       Math.trunc(
@@ -4655,22 +4879,22 @@ function normalizeAuthorityRuntimeStatusReport(input) {
         ) || 0
       )
     ),
-    cpuUsage: resolveHealthMetric(input, ["cpuUsage", "cpu", "cpuLoad"]),
-    memoryUsage: resolveHealthMetric(input, [
-      "memoryUsage",
-      "memory",
-      "memoryPressure"
-    ]),
-    eventLoopLag: resolveHealthMetric(input, [
-      "eventLoopLag",
-      "eventLoopLagMs"
-    ]),
+    cpuUsage,
+    memoryUsage,
+    eventLoopLag,
     isActive: Boolean(input.isActive ?? input.is_active ?? true),
     isNonResponsive: Boolean(
       input.isNonResponsive ?? input.is_non_responsive ?? false
     ),
     isBlocked: Boolean(input.isBlocked ?? input.is_blocked ?? false),
-    health: input.health && typeof input.health === "object" ? input.health : void 0
+    health: sanitizeAuthorityRuntimeStatusHealth(input.health, {
+      state,
+      acceptingWork,
+      reportedAt,
+      cpuUsage,
+      memoryUsage,
+      eventLoopLag
+    })
   };
 }
 function buildAuthorityRuntimeStatusSignature(report) {
@@ -4683,18 +4907,53 @@ function buildAuthorityRuntimeStatusSignature(report) {
     transportProtocols: report.transportProtocols ?? [],
     state: report.state,
     acceptingWork: report.acceptingWork,
-    numberOfRunningGraphs: report.numberOfRunningGraphs,
-    cpuUsage: report.cpuUsage ?? null,
-    memoryUsage: report.memoryUsage ?? null,
-    eventLoopLag: report.eventLoopLag ?? null,
     isActive: report.isActive,
     isNonResponsive: report.isNonResponsive,
     isBlocked: report.isBlocked,
-    isFrontend: report.isFrontend ?? null,
-    health: report.health ?? {}
+    isFrontend: report.isFrontend ?? null
   });
 }
 
+// src/registry/runtimeJitter.ts
+function normalizeKey(key) {
+  return key.trim() || "default";
+}
+function hashKeyToUnitInterval(key) {
+  const normalizedKey = normalizeKey(key);
+  let hash = 2166136261;
+  for (let index = 0; index < normalizedKey.length; index += 1) {
+    hash ^= normalizedKey.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0) / 4294967295;
+}
+function normalizeJitterRatio(value) {
+  if (!Number.isFinite(value) || value <= 0) {
+    return 0;
+  }
+  return Math.min(value, 1);
+}
+function buildDeterministicJitterOffsetMs(baseMs, ratio, key) {
+  if (!Number.isFinite(baseMs) || baseMs <= 0) {
+    return 0;
+  }
+  const normalizedRatio = normalizeJitterRatio(ratio);
+  if (normalizedRatio <= 0) {
+    return 0;
+  }
+  const maxOffsetMs = Math.round(baseMs * normalizedRatio);
+  if (maxOffsetMs <= 0) {
+    return 0;
+  }
+  return Math.round(hashKeyToUnitInterval(key) * maxOffsetMs);
+}
+function buildDeterministicJitteredDelayMs(baseMs, ratio, key) {
+  return Math.max(
+    0,
+    Math.round(baseMs) + buildDeterministicJitterOffsetMs(baseMs, ratio, key)
+  );
+}
+
 // src/registry/serviceManifestContract.ts
 var AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT = "meta-service-registry-authority-service-manifest-report";
 var AUTHORITY_SERVICE_MANIFEST_UPDATED_SIGNAL = "global.meta.cadenza_db.service_manifest_updated";
@@ -4726,11 +4985,17 @@ function normalizeServiceManifestSnapshot(input) {
     intents: normalizeArray(record.intents),
     actors: normalizeArray(record.actors),
     routines: normalizeArray(record.routines),
+    helpers: normalizeArray(record.helpers),
+    globals: normalizeArray(record.globals),
     directionalTaskMaps: normalizeArray(record.directionalTaskMaps),
     signalToTaskMaps: normalizeArray(record.signalToTaskMaps),
     intentToTaskMaps: normalizeArray(record.intentToTaskMaps),
     actorTaskMaps: normalizeArray(record.actorTaskMaps),
-    taskToRoutineMaps: normalizeArray(record.taskToRoutineMaps)
+    taskToRoutineMaps: normalizeArray(record.taskToRoutineMaps),
+    taskToHelperMaps: normalizeArray(record.taskToHelperMaps),
+    helperToHelperMaps: normalizeArray(record.helperToHelperMaps),
+    taskToGlobalMaps: normalizeArray(record.taskToGlobalMaps),
+    helperToGlobalMaps: normalizeArray(record.helperToGlobalMaps)
   };
 }
 function selectLatestServiceManifestSnapshots(snapshots) {
@@ -4994,6 +5259,27 @@ function buildRoutineDefinition(routine, serviceName) {
     is_meta: routine.isMeta === true
   };
 }
+function buildHelperDefinition(helper, serviceName) {
+  return {
+    name: helper.name,
+    version: helper.version,
+    description: helper.description,
+    service_name: serviceName,
+    is_meta: helper.isMeta === true,
+    handler_source: helper.helperFunction.toString(),
+    language: "js"
+  };
+}
+function buildGlobalDefinition(globalDefinition, serviceName) {
+  return {
+    name: globalDefinition.name,
+    version: globalDefinition.version,
+    description: globalDefinition.description,
+    service_name: serviceName,
+    is_meta: globalDefinition.isMeta === true,
+    value: sanitizeManifestValue(globalDefinition.value)
+  };
+}
 function shouldExportTask(task) {
   return task.register !== false && task.isHidden !== true && !task.isDeputy && !task.isEphemeral;
 }
@@ -5009,6 +5295,12 @@ function buildActorKey(actor) {
 function buildRoutineKey(routine) {
   return `${routine.service_name}|${routine.name}|${routine.version}`;
 }
+function buildHelperKey(helper) {
+  return `${helper.service_name}|${helper.name}|${helper.version}`;
+}
+function buildGlobalKey(globalDefinition) {
+  return `${globalDefinition.service_name}|${globalDefinition.name}|${globalDefinition.version}`;
+}
 function listManifestTasks() {
   const registryTasks = Array.from(CadenzaService.registry.tasks.values()).filter(
     (task) => Boolean(task)
@@ -5022,6 +5314,18 @@ function listManifestTasks() {
     ).values()
   );
 }
+function listManifestHelpers() {
+  const toolRuntime = CadenzaService;
+  return (toolRuntime.getAllHelpers?.() ?? []).filter(
+    (helper) => Boolean(helper && !helper.destroyed)
+  );
+}
+function listManifestGlobals() {
+  const toolRuntime = CadenzaService;
+  return (toolRuntime.getAllGlobals?.() ?? []).filter(
+    (globalDefinition) => Boolean(globalDefinition && !globalDefinition.destroyed)
+  );
+}
 function isRoutingCriticalMetaSignal(_signal) {
   return false;
 }
@@ -5037,6 +5341,8 @@ function buildServiceManifestSnapshot(params) {
     publicationLayer = "business_structural"
   } = params;
   const tasks = listManifestTasks().filter(shouldExportTask);
+  const helpers = listManifestHelpers();
+  const globals = listManifestGlobals();
   const routines = Array.from(CadenzaService.registry.routines.values()).filter((routine) => Boolean(routine)).filter(shouldExportRoutine);
   const actors = CadenzaService.getAllActors();
   const taskDefinitions = tasks.map((task) => buildTaskDefinition(task, serviceName)).sort(
@@ -5048,6 +5354,10 @@ function buildServiceManifestSnapshot(params) {
   const directionalTaskMaps = /* @__PURE__ */ new Map();
   const actorTaskMaps = /* @__PURE__ */ new Map();
   const taskToRoutineMaps = /* @__PURE__ */ new Map();
+  const helperTaskMaps = /* @__PURE__ */ new Map();
+  const helperHelperMaps = /* @__PURE__ */ new Map();
+  const taskGlobalMaps = /* @__PURE__ */ new Map();
+  const helperGlobalMaps = /* @__PURE__ */ new Map();
   const registerSignal = (signalName) => {
     const normalizedSignalName = canonicalizeSignalName(signalName);
     if (!normalizedSignalName || signalDefinitions.has(normalizedSignalName)) {
@@ -5131,6 +5441,37 @@ function buildServiceManifestSnapshot(params) {
         is_meta: actorTaskMetadata.actorKind === "meta" || task.isMeta === true
       });
     }
+    const taskTools = task;
+    for (const [alias, helperName] of taskTools.helperAliases?.entries?.() ?? []) {
+      const helper = CadenzaService.getHelper?.(helperName);
+      if (!helper) {
+        continue;
+      }
+      const key = `${task.name}|${task.version}|${alias}|${helper.name}|${helper.version}|${serviceName}`;
+      helperTaskMaps.set(key, {
+        task_name: task.name,
+        task_version: task.version,
+        service_name: serviceName,
+        alias,
+        helper_name: helper.name,
+        helper_version: helper.version
+      });
+    }
+    for (const [alias, globalName] of taskTools.globalAliases?.entries?.() ?? []) {
+      const globalDefinition = CadenzaService.getGlobal?.(globalName);
+      if (!globalDefinition) {
+        continue;
+      }
+      const key = `${task.name}|${task.version}|${alias}|${globalDefinition.name}|${globalDefinition.version}|${serviceName}`;
+      taskGlobalMaps.set(key, {
+        task_name: task.name,
+        task_version: task.version,
+        service_name: serviceName,
+        alias,
+        global_name: globalDefinition.name,
+        global_version: globalDefinition.version
+      });
+    }
   }
   const intentDefinitions = Array.from(CadenzaService.inquiryBroker.intents.values()).map((intent) => {
     const intentRecord = intent;
@@ -5162,6 +5503,44 @@ function buildServiceManifestSnapshot(params) {
   ).sort(
     (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
   );
+  const helperDefinitions = helpers.map((helper) => buildHelperDefinition(helper, serviceName)).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const globalDefinitions = globals.map((globalDefinition) => buildGlobalDefinition(globalDefinition, serviceName)).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  for (const helper of helpers) {
+    for (const [alias, dependencyHelperName] of helper.helperAliases.entries()) {
+      const dependencyHelper = CadenzaService.getHelper?.(dependencyHelperName);
+      if (!dependencyHelper) {
+        continue;
+      }
+      const key = `${helper.name}|${helper.version}|${alias}|${dependencyHelper.name}|${dependencyHelper.version}|${serviceName}`;
+      helperHelperMaps.set(key, {
+        helper_name: helper.name,
+        helper_version: helper.version,
+        service_name: serviceName,
+        alias,
+        dependency_helper_name: dependencyHelper.name,
+        dependency_helper_version: dependencyHelper.version
+      });
+    }
+    for (const [alias, globalName] of helper.globalAliases.entries()) {
+      const globalDefinition = CadenzaService.getGlobal?.(globalName);
+      if (!globalDefinition) {
+        continue;
+      }
+      const key = `${helper.name}|${helper.version}|${alias}|${globalDefinition.name}|${globalDefinition.version}|${serviceName}`;
+      helperGlobalMaps.set(key, {
+        helper_name: helper.name,
+        helper_version: helper.version,
+        service_name: serviceName,
+        alias,
+        global_name: globalDefinition.name,
+        global_version: globalDefinition.version
+      });
+    }
+  }
   for (const routine of routines) {
     for (const task of routine.tasks) {
       if (!task) {
@@ -5199,6 +5578,15 @@ function buildServiceManifestSnapshot(params) {
   const routineDefinitionsByKey = new Map(
     routineDefinitions.map((routine) => [buildRoutineKey(routine), routine])
   );
+  const helperDefinitionsByKey = new Map(
+    helperDefinitions.map((helper) => [buildHelperKey(helper), helper])
+  );
+  const globalDefinitionsByKey = new Map(
+    globalDefinitions.map((globalDefinition) => [
+      buildGlobalKey(globalDefinition),
+      globalDefinition
+    ])
+  );
   const routingTaskKeys = /* @__PURE__ */ new Set();
   const routingSignalNames = /* @__PURE__ */ new Set();
   const routingIntentNames = /* @__PURE__ */ new Set();
@@ -5516,6 +5904,112 @@ function buildServiceManifestSnapshot(params) {
   ).sort(
     (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
   );
+  const businessHelpers = helperDefinitions.filter((helper) => helper.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaHelpers = helperDefinitions.filter((helper) => helper.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessGlobals = globalDefinitions.filter((globalDefinition) => globalDefinition.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaGlobals = globalDefinitions.filter((globalDefinition) => globalDefinition.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessTaskToHelperMaps = Array.from(helperTaskMaps.values()).filter((map) => {
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    const helper = helperDefinitionsByKey.get(
+      buildHelperKey({
+        service_name: map.service_name,
+        name: map.helper_name,
+        version: map.helper_version
+      })
+    );
+    return task?.is_meta !== true && task?.is_sub_meta !== true && helper?.is_meta !== true;
+  }).sort(
+    (left, right) => `${left.task_name}:${left.alias}`.localeCompare(`${right.task_name}:${right.alias}`)
+  );
+  const localMetaTaskToHelperMaps = Array.from(helperTaskMaps.values()).filter((map) => !businessTaskToHelperMaps.includes(map)).sort(
+    (left, right) => `${left.task_name}:${left.alias}`.localeCompare(`${right.task_name}:${right.alias}`)
+  );
+  const businessHelperToHelperMaps = Array.from(helperHelperMaps.values()).filter((map) => {
+    const helper = helperDefinitionsByKey.get(
+      buildHelperKey({
+        service_name: map.service_name,
+        name: map.helper_name,
+        version: map.helper_version
+      })
+    );
+    const dependencyHelper = helperDefinitionsByKey.get(
+      buildHelperKey({
+        service_name: map.service_name,
+        name: map.dependency_helper_name,
+        version: map.dependency_helper_version
+      })
+    );
+    return helper?.is_meta !== true && dependencyHelper?.is_meta !== true;
+  }).sort(
+    (left, right) => `${left.helper_name}:${left.alias}`.localeCompare(`${right.helper_name}:${right.alias}`)
+  );
+  const localMetaHelperToHelperMaps = Array.from(helperHelperMaps.values()).filter((map) => !businessHelperToHelperMaps.includes(map)).sort(
+    (left, right) => `${left.helper_name}:${left.alias}`.localeCompare(`${right.helper_name}:${right.alias}`)
+  );
+  const businessTaskToGlobalMaps = Array.from(taskGlobalMaps.values()).filter((map) => {
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    const globalDefinition = globalDefinitionsByKey.get(
+      buildGlobalKey({
+        service_name: map.service_name,
+        name: map.global_name,
+        version: map.global_version
+      })
+    );
+    return task?.is_meta !== true && task?.is_sub_meta !== true && globalDefinition?.is_meta !== true;
+  }).sort(
+    (left, right) => `${left.task_name}:${left.alias}`.localeCompare(`${right.task_name}:${right.alias}`)
+  );
+  const localMetaTaskToGlobalMaps = Array.from(taskGlobalMaps.values()).filter((map) => !businessTaskToGlobalMaps.includes(map)).sort(
+    (left, right) => `${left.task_name}:${left.alias}`.localeCompare(`${right.task_name}:${right.alias}`)
+  );
+  const businessHelperToGlobalMaps = Array.from(helperGlobalMaps.values()).filter((map) => {
+    const helper = helperDefinitionsByKey.get(
+      buildHelperKey({
+        service_name: map.service_name,
+        name: map.helper_name,
+        version: map.helper_version
+      })
+    );
+    const globalDefinition = globalDefinitionsByKey.get(
+      buildGlobalKey({
+        service_name: map.service_name,
+        name: map.global_name,
+        version: map.global_version
+      })
+    );
+    return helper?.is_meta !== true && globalDefinition?.is_meta !== true;
+  }).sort(
+    (left, right) => `${left.helper_name}:${left.alias}`.localeCompare(`${right.helper_name}:${right.alias}`)
+  );
+  const localMetaHelperToGlobalMaps = Array.from(helperGlobalMaps.values()).filter((map) => !businessHelperToGlobalMaps.includes(map)).sort(
+    (left, right) => `${left.helper_name}:${left.alias}`.localeCompare(`${right.helper_name}:${right.alias}`)
+  );
+  const cumulativeHelpers = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessHelpers : [...businessHelpers, ...localMetaHelpers];
+  const cumulativeGlobals = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessGlobals : [...businessGlobals, ...localMetaGlobals];
+  const cumulativeTaskToHelperMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessTaskToHelperMaps : [...businessTaskToHelperMaps, ...localMetaTaskToHelperMaps];
+  const cumulativeHelperToHelperMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessHelperToHelperMaps : [...businessHelperToHelperMaps, ...localMetaHelperToHelperMaps];
+  const cumulativeTaskToGlobalMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessTaskToGlobalMaps : [...businessTaskToGlobalMaps, ...localMetaTaskToGlobalMaps];
+  const cumulativeHelperToGlobalMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessHelperToGlobalMaps : [...businessHelperToGlobalMaps, ...localMetaHelperToGlobalMaps];
   const cumulativeDirectionalTaskMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessDirectionalTaskMaps : Array.from(
     new Map(
       [...businessDirectionalTaskMaps, ...localMetaDirectionalTaskMaps].map(
@@ -5558,11 +6052,17 @@ function buildServiceManifestSnapshot(params) {
     intents: cumulativeIntents,
     actors: cumulativeActors,
     routines: cumulativeRoutines,
+    helpers: cumulativeHelpers,
+    globals: cumulativeGlobals,
     directionalTaskMaps: cumulativeDirectionalTaskMaps,
     signalToTaskMaps: publicationLayer === "routing_capability" ? publishedSignalTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedSignalTaskMaps, ...localMetaSignalTaskMaps] : [...publishedSignalTaskMaps, ...localMetaSignalTaskMaps],
     intentToTaskMaps: publicationLayer === "routing_capability" ? publishedIntentTaskMaps : publicationLayer === "local_meta_structural" ? [...publishedIntentTaskMaps, ...localMetaIntentTaskMaps] : [...publishedIntentTaskMaps, ...localMetaIntentTaskMaps],
     actorTaskMaps: cumulativeActorTaskMaps,
-    taskToRoutineMaps: cumulativeTaskToRoutineMaps
+    taskToRoutineMaps: cumulativeTaskToRoutineMaps,
+    taskToHelperMaps: cumulativeTaskToHelperMaps,
+    helperToHelperMaps: cumulativeHelperToHelperMaps,
+    taskToGlobalMaps: cumulativeTaskToGlobalMaps,
+    helperToGlobalMaps: cumulativeHelperToGlobalMaps
   };
   return {
     ...manifestBody,
@@ -5606,6 +6106,20 @@ function explodeServiceManifestSnapshots(snapshots) {
       `${right.service_name}|${right.name}|${right.version}`
     )
   );
+  const helpers = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.helpers),
+    (helper) => `${helper.service_name}|${helper.name}|${helper.version}`,
+    (left, right) => `${left.service_name}|${left.name}|${left.version}`.localeCompare(
+      `${right.service_name}|${right.name}|${right.version}`
+    )
+  );
+  const globals = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.globals),
+    (globalDefinition) => `${globalDefinition.service_name}|${globalDefinition.name}|${globalDefinition.version}`,
+    (left, right) => `${left.service_name}|${left.name}|${left.version}`.localeCompare(
+      `${right.service_name}|${right.name}|${right.version}`
+    )
+  );
   const directionalTaskMaps = dedupe(
     snapshots.flatMap((snapshot) => snapshot.directionalTaskMaps),
     (map) => `${map.predecessor_service_name}|${map.predecessor_task_name}|${map.predecessor_task_version}|${map.service_name}|${map.task_name}|${map.task_version}`,
@@ -5641,17 +6155,51 @@ function explodeServiceManifestSnapshots(snapshots) {
       `${right.routine_name}|${right.routine_version}|${right.service_name}|${right.task_name}|${right.task_version}`
     )
   );
+  const taskToHelperMaps = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.taskToHelperMaps),
+    (map) => `${map.service_name}|${map.task_name}|${map.task_version}|${map.alias}|${map.helper_name}|${map.helper_version}`,
+    (left, right) => `${left.service_name}|${left.task_name}|${left.alias}|${left.helper_name}`.localeCompare(
+      `${right.service_name}|${right.task_name}|${right.alias}|${right.helper_name}`
+    )
+  );
+  const helperToHelperMaps = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.helperToHelperMaps),
+    (map) => `${map.service_name}|${map.helper_name}|${map.helper_version}|${map.alias}|${map.dependency_helper_name}|${map.dependency_helper_version}`,
+    (left, right) => `${left.service_name}|${left.helper_name}|${left.alias}|${left.dependency_helper_name}`.localeCompare(
+      `${right.service_name}|${right.helper_name}|${right.alias}|${right.dependency_helper_name}`
+    )
+  );
+  const taskToGlobalMaps = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.taskToGlobalMaps),
+    (map) => `${map.service_name}|${map.task_name}|${map.task_version}|${map.alias}|${map.global_name}|${map.global_version}`,
+    (left, right) => `${left.service_name}|${left.task_name}|${left.alias}|${left.global_name}`.localeCompare(
+      `${right.service_name}|${right.task_name}|${right.alias}|${right.global_name}`
+    )
+  );
+  const helperToGlobalMaps = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.helperToGlobalMaps),
+    (map) => `${map.service_name}|${map.helper_name}|${map.helper_version}|${map.alias}|${map.global_name}|${map.global_version}`,
+    (left, right) => `${left.service_name}|${left.helper_name}|${left.alias}|${left.global_name}`.localeCompare(
+      `${right.service_name}|${right.helper_name}|${right.alias}|${right.global_name}`
+    )
+  );
   return {
     tasks,
     signals,
     intents,
     actors,
     routines,
+    helpers,
+    globals,
     directionalTaskMaps,
     signalToTaskMaps,
     intentToTaskMaps,
     actorTaskMaps,
-    taskToRoutineMaps
+    taskToRoutineMaps,
+    taskToHelperMaps,
+    helperToHelperMaps,
+    taskToGlobalMaps,
+    helperToGlobalMaps
   };
 }
 
@@ -5700,11 +6248,57 @@ var SERVICE_REGISTRY_TRACE_SERVICE2 = (process.env.CADENZA_SERVICE_REGISTRY_TRAC
 function shouldTraceServiceRegistry(serviceName) {
   return SERVICE_REGISTRY_TRACE_SERVICE2.length > 0 && serviceName === SERVICE_REGISTRY_TRACE_SERVICE2;
 }
-function buildServiceRegistryInsertQueryData(tableName, ctx, queryData) {
-  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
-  const getJoinedValue = (key) => {
-    for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
-      const joinedContext = joinedContexts[index];
+function normalizeLeaseStatus(value) {
+  const status = String(value ?? "").trim();
+  if (status === "active" || status === "non_responsive" || status === "inactive" || status === "deleted") {
+    return status;
+  }
+  return null;
+}
+function overlayServiceInstancesWithLeases(serviceInstances, serviceInstanceLeases) {
+  if (serviceInstanceLeases.length === 0) {
+    return serviceInstances;
+  }
+  const leasesByInstanceId = /* @__PURE__ */ new Map();
+  for (const row of serviceInstanceLeases) {
+    const serviceInstanceId = String(
+      row.service_instance_id ?? row.serviceInstanceId ?? ""
+    ).trim();
+    if (!serviceInstanceId) {
+      continue;
+    }
+    leasesByInstanceId.set(serviceInstanceId, row);
+  }
+  return serviceInstances.map((row) => {
+    const serviceInstanceId = String(row.uuid ?? "").trim();
+    const lease = serviceInstanceId ? leasesByInstanceId.get(serviceInstanceId) : void 0;
+    if (!lease) {
+      return row;
+    }
+    const leaseStatus = normalizeLeaseStatus(
+      lease.status ?? lease.lease_status ?? lease.leaseStatus
+    );
+    return {
+      ...row,
+      lease_status: leaseStatus ?? void 0,
+      is_ready: typeof lease.is_ready === "boolean" ? lease.is_ready : typeof lease.isReady === "boolean" ? lease.isReady : void 0,
+      readiness_reason: typeof lease.readiness_reason === "string" ? lease.readiness_reason : typeof lease.readinessReason === "string" ? lease.readinessReason : null,
+      lease_expires_at: typeof lease.lease_expires_at === "string" ? lease.lease_expires_at : typeof lease.leaseExpiresAt === "string" ? lease.leaseExpiresAt : null,
+      last_lease_renewed_at: typeof lease.last_lease_renewed_at === "string" ? lease.last_lease_renewed_at : typeof lease.lastLeaseRenewedAt === "string" ? lease.lastLeaseRenewedAt : null,
+      last_ready_at: typeof lease.last_ready_at === "string" ? lease.last_ready_at : typeof lease.lastReadyAt === "string" ? lease.lastReadyAt : null,
+      last_observed_transport_at: typeof lease.last_observed_transport_at === "string" ? lease.last_observed_transport_at : typeof lease.lastObservedTransportAt === "string" ? lease.lastObservedTransportAt : null,
+      shutdown_requested_at: typeof lease.shutdown_requested_at === "string" ? lease.shutdown_requested_at : typeof lease.shutdownRequestedAt === "string" ? lease.shutdownRequestedAt : null,
+      is_active: leaseStatus === "active" ? true : leaseStatus === "non_responsive" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : row.is_active,
+      is_non_responsive: leaseStatus === "non_responsive" ? true : leaseStatus === "active" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : row.is_non_responsive,
+      deleted: leaseStatus === "deleted" ? true : Boolean(row.deleted ?? false)
+    };
+  });
+}
+function buildServiceRegistryInsertQueryData(tableName, ctx, queryData) {
+  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
+  const getJoinedValue = (key) => {
+    for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+      const joinedContext = joinedContexts[index];
       if (joinedContext && typeof joinedContext === "object" && (Object.prototype.hasOwnProperty.call(joinedContext, key) || joinedContext[key] !== void 0)) {
         return joinedContext[key];
       }
@@ -5777,6 +6371,43 @@ function sanitizeAuthorityBootstrapDelegationContext(ctx) {
   }
   return sanitized;
 }
+var BOOTSTRAP_DB_OPERATION_CONTEXT_KEYS = [
+  "data",
+  "batch",
+  "transaction",
+  "onConflict",
+  "filter",
+  "fields",
+  "joins",
+  "sort",
+  "limit",
+  "offset",
+  "queryMode",
+  "aggregates",
+  "groupBy"
+];
+function isBootstrapDbOperationRoutineName(value) {
+  return /^(Insert|Update|Query|Delete)\s+/.test(String(value ?? "").trim());
+}
+function compactAuthorityBootstrapRequestBody(ctx) {
+  if (!isBootstrapDbOperationRoutineName(ctx.__remoteRoutineName)) {
+    return ctx;
+  }
+  const queryData = ctx.queryData && typeof ctx.queryData === "object" ? { ...ctx.queryData } : null;
+  if (!queryData) {
+    return ctx;
+  }
+  const compacted = {
+    ...ctx,
+    queryData
+  };
+  for (const key of BOOTSTRAP_DB_OPERATION_CONTEXT_KEYS) {
+    if (Object.prototype.hasOwnProperty.call(queryData, key)) {
+      delete compacted[key];
+    }
+  }
+  return compacted;
+}
 function cloneServiceRegistryContextValue(value) {
   if (value instanceof Date) {
     return new Date(value.getTime());
@@ -6133,6 +6764,92 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
     `Resolve service registry insert for ${tableName}`,
     (ctx, emit2) => new Promise((resolve) => {
       const resolverRequestId = (0, import_uuid3.v4)();
+      const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
+      const bootstrapAuthorityInsertSpec = !localInsertTask && CadenzaService.serviceRegistry.connectsToCadenzaDB ? getAuthorityBootstrapInsertIntentSpecForTable(tableName) : null;
+      const resolvedTargetServiceName = resolveServiceNameFromContext(ctx);
+      const selfBootstrapRetrySignal = CadenzaService.serviceRegistry.serviceName === "CadenzaDB" && resolvedTargetServiceName === "CadenzaDB" && !localInsertTask ? getSelfBootstrapRegistrationRetrySignal(tableName) : null;
+      if (selfBootstrapRetrySignal) {
+        CadenzaService.schedule(
+          selfBootstrapRetrySignal,
+          {
+            ...ctx
+          },
+          250
+        );
+        resolve(false);
+        return;
+      }
+      if (bootstrapAuthorityInsertSpec) {
+        const sanitizedContext = sanitizeServiceRegistryInsertExecutionContext(ctx);
+        const nextQueryData = buildServiceRegistryInsertQueryData(
+          tableName,
+          sanitizedContext,
+          queryData
+        );
+        const inquiryContext = ensureDelegationContextMetadata({
+          ...sanitizedContext,
+          data: nextQueryData.data !== void 0 ? nextQueryData.data : sanitizedContext.data,
+          batch: nextQueryData.batch !== void 0 ? nextQueryData.batch : sanitizedContext.batch,
+          onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
+          transaction: nextQueryData.transaction !== void 0 ? nextQueryData.transaction : sanitizedContext.transaction,
+          queryData: nextQueryData
+        });
+        inquiryContext.__metadata = {
+          ...inquiryContext.__metadata ?? {},
+          __skipRemoteExecution: inquiryContext.__metadata?.__skipRemoteExecution ?? inquiryContext.__skipRemoteExecution ?? false,
+          __blockRemoteExecution: inquiryContext.__metadata?.__blockRemoteExecution ?? inquiryContext.__blockRemoteExecution ?? false
+        };
+        CadenzaService.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
+          bootstrapAuthorityInsertSpec.intentName,
+          inquiryContext
+        );
+        void CadenzaService.inquire(
+          bootstrapAuthorityInsertSpec.intentName,
+          inquiryContext,
+          {
+            requireComplete: true,
+            timeout: bootstrapAuthorityInsertSpec.defaultTimeoutMs
+          }
+        ).then(
+          (result) => resolve(
+            resolveBootstrapAuthorityInsertResult(
+              tableName,
+              sanitizedContext,
+              nextQueryData,
+              result,
+              emit2
+            )
+          )
+        ).catch(
+          (error) => resolve(
+            resolveBootstrapAuthorityInsertResult(
+              tableName,
+              sanitizedContext,
+              nextQueryData,
+              error,
+              emit2
+            )
+          )
+        );
+        return;
+      }
+      const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+        console.log("[CADENZA_INSTANCE_DEBUG] resolve_service_registry_insert", {
+          tableName,
+          executionSignal,
+          hasLocalInsertTask: !!localInsertTask,
+          serviceName: ctx.__serviceName ?? ctx.data?.service_name ?? null,
+          serviceInstanceId: ctx.__serviceInstanceId ?? ctx.data?.uuid ?? null,
+          hasData: !!ctx.data,
+          dataKeys: ctx.data && typeof ctx.data === "object" ? Object.keys(ctx.data) : [],
+          registrationKeys: ctx.__registrationData && typeof ctx.__registrationData === "object" ? Object.keys(ctx.__registrationData) : []
+        });
+      }
+      if (localInsertTask && !wiredLocalTaskNames.has(localInsertTask.name)) {
+        wireExecutionTarget(localInsertTask, prepareLocalExecutionTask);
+        wiredLocalTaskNames.add(localInsertTask.name);
+      }
       CadenzaService.createEphemeralMetaTask(
         `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
         (resultCtx) => {
@@ -6232,95 +6949,11 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         },
         `Resolves signal-driven ${tableName} service-registry insert execution.`,
         {
-          register: false
+          register: false,
+          once: false,
+          destroyCondition: (result) => result !== false
         }
       ).doOn(executionResolvedSignal, executionFailedSignal);
-      const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
-      const bootstrapAuthorityInsertSpec = !localInsertTask && CadenzaService.serviceRegistry.connectsToCadenzaDB ? getAuthorityBootstrapInsertIntentSpecForTable(tableName) : null;
-      const resolvedTargetServiceName = resolveServiceNameFromContext(ctx);
-      const selfBootstrapRetrySignal = CadenzaService.serviceRegistry.serviceName === "CadenzaDB" && resolvedTargetServiceName === "CadenzaDB" && !localInsertTask ? getSelfBootstrapRegistrationRetrySignal(tableName) : null;
-      if (selfBootstrapRetrySignal) {
-        CadenzaService.schedule(
-          selfBootstrapRetrySignal,
-          {
-            ...ctx
-          },
-          250
-        );
-        resolve(false);
-        return;
-      }
-      if (bootstrapAuthorityInsertSpec) {
-        const sanitizedContext = sanitizeServiceRegistryInsertExecutionContext(ctx);
-        const nextQueryData = buildServiceRegistryInsertQueryData(
-          tableName,
-          sanitizedContext,
-          queryData
-        );
-        const inquiryContext = ensureDelegationContextMetadata({
-          ...sanitizedContext,
-          data: nextQueryData.data !== void 0 ? nextQueryData.data : sanitizedContext.data,
-          batch: nextQueryData.batch !== void 0 ? nextQueryData.batch : sanitizedContext.batch,
-          onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
-          transaction: nextQueryData.transaction !== void 0 ? nextQueryData.transaction : sanitizedContext.transaction,
-          queryData: nextQueryData
-        });
-        inquiryContext.__metadata = {
-          ...inquiryContext.__metadata ?? {},
-          __skipRemoteExecution: inquiryContext.__metadata?.__skipRemoteExecution ?? inquiryContext.__skipRemoteExecution ?? false,
-          __blockRemoteExecution: inquiryContext.__metadata?.__blockRemoteExecution ?? inquiryContext.__blockRemoteExecution ?? false
-        };
-        CadenzaService.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
-          bootstrapAuthorityInsertSpec.intentName,
-          inquiryContext
-        );
-        void CadenzaService.inquire(
-          bootstrapAuthorityInsertSpec.intentName,
-          inquiryContext,
-          {
-            requireComplete: true,
-            timeout: bootstrapAuthorityInsertSpec.defaultTimeoutMs
-          }
-        ).then(
-          (result) => resolve(
-            resolveBootstrapAuthorityInsertResult(
-              tableName,
-              sanitizedContext,
-              nextQueryData,
-              result,
-              emit2
-            )
-          )
-        ).catch(
-          (error) => resolve(
-            resolveBootstrapAuthorityInsertResult(
-              tableName,
-              sanitizedContext,
-              nextQueryData,
-              error,
-              emit2
-            )
-          )
-        );
-        return;
-      }
-      const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
-      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
-        console.log("[CADENZA_INSTANCE_DEBUG] resolve_service_registry_insert", {
-          tableName,
-          executionSignal,
-          hasLocalInsertTask: !!localInsertTask,
-          serviceName: ctx.__serviceName ?? ctx.data?.service_name ?? null,
-          serviceInstanceId: ctx.__serviceInstanceId ?? ctx.data?.uuid ?? null,
-          hasData: !!ctx.data,
-          dataKeys: ctx.data && typeof ctx.data === "object" ? Object.keys(ctx.data) : [],
-          registrationKeys: ctx.__registrationData && typeof ctx.__registrationData === "object" ? Object.keys(ctx.__registrationData) : []
-        });
-      }
-      if (localInsertTask && !wiredLocalTaskNames.has(localInsertTask.name)) {
-        wireExecutionTarget(localInsertTask, prepareLocalExecutionTask);
-        wiredLocalTaskNames.add(localInsertTask.name);
-      }
       emit2(executionSignal, {
         ...ctx,
         __resolverRequestId: resolverRequestId
@@ -6345,6 +6978,17 @@ function readPositiveIntegerEnv(name, fallback) {
   }
   return normalized;
 }
+function readNonNegativeFloatEnv(name, fallback) {
+  if (typeof process === "undefined") {
+    return fallback;
+  }
+  const raw = process.env?.[name];
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback;
+  }
+  return parsed;
+}
 var ServiceRegistry = class _ServiceRegistry {
   /**
    * Initializes a private constructor for managing service instances, remote signals,
@@ -6394,6 +7038,9 @@ var ServiceRegistry = class _ServiceRegistry {
       "CADENZA_RUNTIME_STATUS_REST_REFRESH_MS",
       this.runtimeMetricsSampleIntervalMs
     );
+    this.runtimeStatusLoopJitterRatio = normalizeJitterRatio(
+      readNonNegativeFloatEnv("CADENZA_RUNTIME_STATUS_JITTER_RATIO", 0.2)
+    );
     this.runtimeStatusMissThreshold = readPositiveIntegerEnv(
       "CADENZA_RUNTIME_STATUS_MISSED_HEARTBEATS",
       3
@@ -6442,6 +7089,18 @@ var ServiceRegistry = class _ServiceRegistry {
       "CADENZA_RUNTIME_STATUS_OVERLOADED_GRAPH_THRESHOLD",
       20
     );
+    this.bootstrapFullSyncRetryJitterRatio = normalizeJitterRatio(
+      readNonNegativeFloatEnv(
+        "CADENZA_BOOTSTRAP_FULL_SYNC_RETRY_JITTER_RATIO",
+        0.2
+      )
+    );
+    this.serviceCommunicationRetryJitterRatio = normalizeJitterRatio(
+      readNonNegativeFloatEnv(
+        "CADENZA_SERVICE_COMMUNICATION_RETRY_JITTER_RATIO",
+        0.2
+      )
+    );
     this.serviceName = null;
     this.serviceInstanceId = null;
     this.numberOfRunningGraphs = 0;
@@ -7420,6 +8079,12 @@ var ServiceRegistry = class _ServiceRegistry {
         const tasks = this.readArrayPayload(inquiryResult, [
           "tasks"
         ]);
+        const helpers = this.readArrayPayload(inquiryResult, [
+          "helpers"
+        ]);
+        const globals = this.readArrayPayload(inquiryResult, [
+          "globals"
+        ]);
         const signals = this.readArrayPayload(inquiryResult, [
           "signals"
         ]);
@@ -7444,6 +8109,22 @@ var ServiceRegistry = class _ServiceRegistry {
           inquiryResult,
           ["taskToRoutineMaps", "task_to_routine_maps"]
         );
+        const taskToHelperMaps = this.readArrayPayload(
+          inquiryResult,
+          ["taskToHelperMaps", "task_to_helper_maps"]
+        );
+        const helperToHelperMaps = this.readArrayPayload(
+          inquiryResult,
+          ["helperToHelperMaps", "helper_to_helper_maps"]
+        );
+        const taskToGlobalMaps = this.readArrayPayload(
+          inquiryResult,
+          ["taskToGlobalMaps", "task_to_global_maps"]
+        );
+        const helperToGlobalMaps = this.readArrayPayload(
+          inquiryResult,
+          ["helperToGlobalMaps", "helper_to_global_maps"]
+        );
         const serviceInstances = this.normalizeServiceInstancesFromSync(
           inquiryResult
         );
@@ -7477,6 +8158,8 @@ var ServiceRegistry = class _ServiceRegistry {
             serviceInstanceTransports: serviceInstanceTransports.length,
             serviceManifests: serviceManifests.length,
             tasks: tasks.length,
+            helpers: helpers.length,
+            globals: globals.length,
             signals: signals.length,
             intents: intents.length,
             actors: actors.length,
@@ -7502,6 +8185,8 @@ var ServiceRegistry = class _ServiceRegistry {
           serviceInstanceTransports,
           serviceManifests,
           tasks,
+          helpers,
+          globals,
           signals,
           intents,
           actors,
@@ -7509,6 +8194,10 @@ var ServiceRegistry = class _ServiceRegistry {
           directionalTaskMaps,
           actorTaskMaps,
           taskToRoutineMaps,
+          taskToHelperMaps,
+          helperToHelperMaps,
+          taskToGlobalMaps,
+          helperToGlobalMaps,
           __inquiryMeta: inquiryResult.__inquiryMeta
         };
       },
@@ -8128,29 +8817,51 @@ var ServiceRegistry = class _ServiceRegistry {
         this.runtimeStatusHeartbeatStarted = true;
         if (!this.runtimeMetricsSamplingStarted) {
           this.runtimeMetricsSamplingStarted = true;
+          CadenzaService.emit(META_RUNTIME_METRICS_SAMPLE_TICK_SIGNAL, {});
           CadenzaService.interval(
             META_RUNTIME_METRICS_SAMPLE_TICK_SIGNAL,
             {},
             this.runtimeMetricsSampleIntervalMs,
-            true
+            false,
+            this.buildJitteredIntervalStartDate(
+              this.runtimeMetricsSampleIntervalMs,
+              "runtime-metrics-sample"
+            )
           );
         }
+        CadenzaService.emit(META_RUNTIME_STATUS_HEARTBEAT_TICK_SIGNAL, {
+          reason: "heartbeat"
+        });
         CadenzaService.interval(
           META_RUNTIME_STATUS_HEARTBEAT_TICK_SIGNAL,
           { reason: "heartbeat" },
           this.runtimeStatusHeartbeatIntervalMs,
-          true
+          false,
+          this.buildJitteredIntervalStartDate(
+            this.runtimeStatusHeartbeatIntervalMs,
+            "runtime-status-heartbeat"
+          )
         );
         CadenzaService.interval(
           META_RUNTIME_STATUS_MONITOR_TICK_SIGNAL,
           {},
-          this.runtimeStatusHeartbeatIntervalMs
+          this.runtimeStatusHeartbeatIntervalMs,
+          false,
+          this.buildJitteredIntervalStartDate(
+            this.runtimeStatusHeartbeatIntervalMs,
+            "runtime-status-monitor"
+          )
         );
+        CadenzaService.emit(META_RUNTIME_STATUS_REST_REFRESH_TICK_SIGNAL, {});
         CadenzaService.interval(
           META_RUNTIME_STATUS_REST_REFRESH_TICK_SIGNAL,
           {},
           this.runtimeStatusRestRefreshIntervalMs,
-          true
+          false,
+          this.buildJitteredIntervalStartDate(
+            this.runtimeStatusRestRefreshIntervalMs,
+            "runtime-status-rest-refresh"
+          )
         );
         return true;
       },
@@ -9155,11 +9866,14 @@ var ServiceRegistry = class _ServiceRegistry {
   }
   collectBootstrapFullSyncPayload(ctx) {
     const serviceInstances = [];
+    const serviceInstanceLeases = [];
     const serviceInstanceTransports = [];
     const manifestSnapshots = [];
     const signalToTaskMaps = [];
     const intentToTaskMaps = [];
     const tasks = [];
+    const helpers = [];
+    const globals = [];
     const signals = [];
     const intents = [];
     const actors = [];
@@ -9167,11 +9881,18 @@ var ServiceRegistry = class _ServiceRegistry {
     const directionalTaskMaps = [];
     const actorTaskMaps = [];
     const taskToRoutineMaps = [];
+    const taskToHelperMaps = [];
+    const helperToHelperMaps = [];
+    const taskToGlobalMaps = [];
+    const helperToGlobalMaps = [];
     const seenServiceInstances = /* @__PURE__ */ new Set();
+    const seenServiceInstanceLeases = /* @__PURE__ */ new Set();
     const seenServiceInstanceTransports = /* @__PURE__ */ new Set();
     const seenSignalMaps = /* @__PURE__ */ new Set();
     const seenIntentMaps = /* @__PURE__ */ new Set();
     const seenTasks = /* @__PURE__ */ new Set();
+    const seenHelpers = /* @__PURE__ */ new Set();
+    const seenGlobals = /* @__PURE__ */ new Set();
     const seenSignals = /* @__PURE__ */ new Set();
     const seenIntents = /* @__PURE__ */ new Set();
     const seenActors = /* @__PURE__ */ new Set();
@@ -9179,6 +9900,10 @@ var ServiceRegistry = class _ServiceRegistry {
     const seenDirectionalTaskMaps = /* @__PURE__ */ new Set();
     const seenActorTaskMaps = /* @__PURE__ */ new Set();
     const seenTaskToRoutineMaps = /* @__PURE__ */ new Set();
+    const seenTaskToHelperMaps = /* @__PURE__ */ new Set();
+    const seenHelperToHelperMaps = /* @__PURE__ */ new Set();
+    const seenTaskToGlobalMaps = /* @__PURE__ */ new Set();
+    const seenHelperToGlobalMaps = /* @__PURE__ */ new Set();
     const contexts = Array.isArray(ctx.joinedContexts) ? [ctx, ...ctx.joinedContexts] : [ctx];
     const pushUnique = (rows, target, seen, keyResolver) => {
       for (const row of rows) {
@@ -9209,6 +9934,12 @@ var ServiceRegistry = class _ServiceRegistry {
         "serviceInstance",
         "service_instance"
       ]);
+      const serviceInstanceLeaseRows = readDirectArrayPayload(candidate, [
+        "serviceInstanceLeases",
+        "service_instance_leases",
+        "serviceInstanceLease",
+        "service_instance_lease"
+      ]);
       const serviceInstanceTransportRows = readDirectArrayPayload(candidate, [
         "serviceInstanceTransports",
         "service_instance_transports",
@@ -9239,6 +9970,12 @@ var ServiceRegistry = class _ServiceRegistry {
         seenServiceInstances,
         (row) => String(row.uuid ?? "").trim()
       );
+      pushUnique(
+        serviceInstanceLeaseRows,
+        serviceInstanceLeases,
+        seenServiceInstanceLeases,
+        (row) => String(row.service_instance_id ?? row.serviceInstanceId ?? "").trim()
+      );
       pushUnique(
         serviceInstanceTransportRows,
         serviceInstanceTransports,
@@ -9301,6 +10038,17 @@ var ServiceRegistry = class _ServiceRegistry {
           );
           continue;
         }
+        if (row.status !== void 0 && (row.service_instance_id !== void 0 || row.serviceInstanceId !== void 0)) {
+          pushUnique(
+            [row],
+            serviceInstanceLeases,
+            seenServiceInstanceLeases,
+            (entry) => String(
+              entry.service_instance_id ?? entry.serviceInstanceId ?? ""
+            ).trim()
+          );
+          continue;
+        }
         if (row.service_instance_id !== void 0 || row.serviceInstanceId !== void 0) {
           pushUnique(
             [row],
@@ -9329,12 +10077,16 @@ var ServiceRegistry = class _ServiceRegistry {
         }
       }
     }
+    const mergedServiceInstances = overlayServiceInstancesWithLeases(
+      serviceInstances,
+      serviceInstanceLeases
+    );
     const activeServiceInstanceIds = new Set(
-      serviceInstances.filter((row) => row.is_active === true || row.isActive === true).map((row) => String(row.uuid ?? "").trim()).filter((uuid10) => uuid10.length > 0)
+      mergedServiceInstances.filter((row) => row.is_active === true || row.isActive === true).map((row) => String(row.uuid ?? "").trim()).filter((uuid10) => uuid10.length > 0)
     );
-    const filteredServiceInstances = activeServiceInstanceIds.size > 0 ? serviceInstances.filter(
+    const filteredServiceInstances = activeServiceInstanceIds.size > 0 ? mergedServiceInstances.filter(
       (row) => activeServiceInstanceIds.has(String(row.uuid ?? "").trim())
-    ) : serviceInstances;
+    ) : mergedServiceInstances;
     const filteredServiceInstanceTransports = activeServiceInstanceIds.size > 0 ? serviceInstanceTransports.filter(
       (row) => activeServiceInstanceIds.has(
         String(row.service_instance_id ?? row.serviceInstanceId ?? "").trim()
@@ -9378,6 +10130,22 @@ var ServiceRegistry = class _ServiceRegistry {
         row.version ?? 1
       ).trim()}`
     );
+    pushUnique(
+      explodedManifest.helpers,
+      helpers,
+      seenHelpers,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(row.name ?? "").trim()}|${String(
+        row.version ?? 1
+      ).trim()}`
+    );
+    pushUnique(
+      explodedManifest.globals,
+      globals,
+      seenGlobals,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(row.name ?? "").trim()}|${String(
+        row.version ?? 1
+      ).trim()}`
+    );
     pushUnique(
       explodedManifest.signals,
       signals,
@@ -9438,6 +10206,50 @@ var ServiceRegistry = class _ServiceRegistry {
         row.task_version ?? 1
       ).trim()}`
     );
+    pushUnique(
+      explodedManifest.taskToHelperMaps,
+      taskToHelperMaps,
+      seenTaskToHelperMaps,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(row.task_name ?? "").trim()}|${String(
+        row.task_version ?? 1
+      ).trim()}|${String(row.alias ?? "").trim()}|${String(
+        row.helper_name ?? ""
+      ).trim()}|${String(row.helper_version ?? 1).trim()}`
+    );
+    pushUnique(
+      explodedManifest.helperToHelperMaps,
+      helperToHelperMaps,
+      seenHelperToHelperMaps,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(
+        row.helper_name ?? ""
+      ).trim()}|${String(row.helper_version ?? 1).trim()}|${String(
+        row.alias ?? ""
+      ).trim()}|${String(row.dependency_helper_name ?? "").trim()}|${String(
+        row.dependency_helper_version ?? 1
+      ).trim()}`
+    );
+    pushUnique(
+      explodedManifest.taskToGlobalMaps,
+      taskToGlobalMaps,
+      seenTaskToGlobalMaps,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(row.task_name ?? "").trim()}|${String(
+        row.task_version ?? 1
+      ).trim()}|${String(row.alias ?? "").trim()}|${String(
+        row.global_name ?? ""
+      ).trim()}|${String(row.global_version ?? 1).trim()}`
+    );
+    pushUnique(
+      explodedManifest.helperToGlobalMaps,
+      helperToGlobalMaps,
+      seenHelperToGlobalMaps,
+      (row) => `${String(row.service_name ?? "").trim()}|${String(
+        row.helper_name ?? ""
+      ).trim()}|${String(row.helper_version ?? 1).trim()}|${String(
+        row.alias ?? ""
+      ).trim()}|${String(row.global_name ?? "").trim()}|${String(
+        row.global_version ?? 1
+      ).trim()}`
+    );
     if (!hasExplicitSignalRoutingRows) {
       pushUnique(
         explodedManifest.signalToTaskMaps,
@@ -9464,9 +10276,12 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return {
       serviceInstances: filteredServiceInstances,
+      serviceInstanceLeases,
       serviceInstanceTransports: filteredServiceInstanceTransports,
       serviceManifests,
       tasks,
+      helpers,
+      globals,
       signals,
       intents,
       actors,
@@ -9474,6 +10289,10 @@ var ServiceRegistry = class _ServiceRegistry {
       directionalTaskMaps,
       actorTaskMaps,
       taskToRoutineMaps,
+      taskToHelperMaps,
+      helperToHelperMaps,
+      taskToGlobalMaps,
+      helperToGlobalMaps,
       signalToTaskMaps: filteredSignalToTaskMaps,
       intentToTaskMaps: filteredIntentToTaskMaps
     };
@@ -9899,35 +10718,37 @@ var ServiceRegistry = class _ServiceRegistry {
         ...context,
         __error: "Authority bootstrap route is not established yet. Waiting for authority handshake.",
         errored: true
-      };
-    }
-    const controller = typeof AbortController === "function" ? new AbortController() : null;
-    const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
-    try {
-      const sanitizedContext = sanitizeAuthorityBootstrapDelegationContext(context);
-      const requestBody = stripDelegationRequestSnapshot(
-        ensureDelegationContextMetadata(
-          attachDelegationRequestSnapshot({
-            ...sanitizedContext,
-            __remoteRoutineName: remoteRoutineName,
-            __serviceName: "CadenzaDB",
-            __localServiceName: this.serviceName,
-            __timeout: timeoutMs,
-            __syncing: true,
-            __transportOrigin: target.origin,
-            __transportProtocol: "rest",
-            __transportProtocols: ["rest"],
-            __routeKey: target.routeKey,
-            routeKey: target.routeKey,
-            __fetchId: target.fetchId,
-            fetchId: target.fetchId,
-            __metadata: {
-              ...sanitizedContext.__metadata && typeof sanitizedContext.__metadata === "object" ? sanitizedContext.__metadata : {},
+      };
+    }
+    const controller = typeof AbortController === "function" ? new AbortController() : null;
+    const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
+    try {
+      const sanitizedContext = sanitizeAuthorityBootstrapDelegationContext(context);
+      const requestBody = compactAuthorityBootstrapRequestBody(
+        stripDelegationRequestSnapshot(
+          ensureDelegationContextMetadata(
+            attachDelegationRequestSnapshot({
+              ...sanitizedContext,
+              __remoteRoutineName: remoteRoutineName,
+              __serviceName: "CadenzaDB",
+              __localServiceName: this.serviceName,
               __timeout: timeoutMs,
               __syncing: true,
-              __authorityBootstrapChannel: true
-            }
-          })
+              __transportOrigin: target.origin,
+              __transportProtocol: "rest",
+              __transportProtocols: ["rest"],
+              __routeKey: target.routeKey,
+              routeKey: target.routeKey,
+              __fetchId: target.fetchId,
+              fetchId: target.fetchId,
+              __metadata: {
+                ...sanitizedContext.__metadata && typeof sanitizedContext.__metadata === "object" ? sanitizedContext.__metadata : {},
+                __timeout: timeoutMs,
+                __syncing: true,
+                __authorityBootstrapChannel: true
+              }
+            })
+          )
         )
       );
       const response = await globalThis.fetch(`${target.origin}/delegation`, {
@@ -10082,12 +10903,14 @@ var ServiceRegistry = class _ServiceRegistry {
         };
         const [
           serviceInstances,
+          serviceInstanceLeases,
           serviceInstanceTransports,
           serviceManifests,
           signalToTaskMaps,
           intentToTaskMaps
         ] = await Promise.all([
           DatabaseController.instance.queryAuthorityTableRows("service_instance"),
+          queryOptionalAuthorityRoutingRows("service_instance_lease"),
           DatabaseController.instance.queryAuthorityTableRows(
             "service_instance_transport"
           ),
@@ -10100,6 +10923,7 @@ var ServiceRegistry = class _ServiceRegistry {
           __syncing: true,
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
+            serviceInstanceLeases,
             serviceInstanceTransports,
             serviceManifests,
             signalToTaskMaps,
@@ -10132,9 +10956,14 @@ var ServiceRegistry = class _ServiceRegistry {
           return false;
         }
         const scheduleRetry = (reason, error) => {
-          const delayMs = SERVICE_COMMUNICATION_PERSIST_RETRY_DELAYS_MS[descriptor.retryAttempt];
+          const baseDelayMs = SERVICE_COMMUNICATION_PERSIST_RETRY_DELAYS_MS[descriptor.retryAttempt];
           const nextAttempt = descriptor.retryAttempt + 1;
-          if (delayMs !== void 0) {
+          if (baseDelayMs !== void 0) {
+            const delayMs = buildDeterministicJitteredDelayMs(
+              baseDelayMs,
+              this.serviceCommunicationRetryJitterRatio,
+              `${descriptor.serviceInstanceId}:${descriptor.communicationType}:${descriptor.retryAttempt}`
+            );
             CadenzaService.schedule(
               retrySignal,
               buildServiceCommunicationRetryContext({
@@ -10282,6 +11111,31 @@ var ServiceRegistry = class _ServiceRegistry {
       })
     );
   }
+  buildDeterministicInstanceJitterKey(scope) {
+    const serviceName = String(this.serviceName ?? "").trim() || "unknown-service";
+    const serviceInstanceId = String(this.serviceInstanceId ?? "").trim() || "pending-instance";
+    return `${serviceName}:${serviceInstanceId}:${scope}`;
+  }
+  buildJitteredIntervalStartDate(intervalMs, scope) {
+    const jitterOffsetMs = buildDeterministicJitterOffsetMs(
+      intervalMs,
+      this.runtimeStatusLoopJitterRatio,
+      this.buildDeterministicInstanceJitterKey(scope)
+    );
+    if (jitterOffsetMs <= 0) {
+      return void 0;
+    }
+    return new Date(Date.now() + intervalMs + jitterOffsetMs);
+  }
+  buildJitteredBootstrapRetryDelayMs(baseDelayMs, attempt) {
+    return buildDeterministicJitteredDelayMs(
+      baseDelayMs,
+      this.bootstrapFullSyncRetryJitterRatio,
+      this.buildDeterministicInstanceJitterKey(
+        `bootstrap-full-sync-retry-${attempt}`
+      )
+    );
+  }
   ensureAuthorityBootstrapSignalTransmissions() {
     if (this.serviceName !== "CadenzaDB") {
       return false;
@@ -10359,8 +11213,11 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     const retryGeneration = this.bootstrapFullSyncRetryGeneration;
     const retryReason = this.bootstrapFullSyncRetryReason ?? "service_registry_bootstrap_retry";
-    const delayMs = EARLY_FULL_SYNC_DELAYS_MS[this.bootstrapFullSyncRetryIndex];
     const attempt = this.bootstrapFullSyncRetryIndex + 1;
+    const delayMs = this.buildJitteredBootstrapRetryDelayMs(
+      EARLY_FULL_SYNC_DELAYS_MS[this.bootstrapFullSyncRetryIndex],
+      attempt
+    );
     this.bootstrapFullSyncRetryIndex += 1;
     this.bootstrapFullSyncRetryTimer = setTimeout(() => {
       this.bootstrapFullSyncRetryTimer = null;
@@ -12263,6 +13120,18 @@ var ServiceRegistry = class _ServiceRegistry {
       isNonResponsive,
       isBlocked
     );
+    const cpuUsage = this.readRuntimeStatusMetric(ctx, "cpuUsage", "cpu", "cpuLoad");
+    const memoryUsage = this.readRuntimeStatusMetric(
+      ctx,
+      "memoryUsage",
+      "memory",
+      "memoryPressure"
+    );
+    const eventLoopLag = this.readRuntimeStatusMetric(
+      ctx,
+      "eventLoopLag",
+      "eventLoopLagMs"
+    );
     return {
       serviceName,
       serviceInstanceId,
@@ -12275,22 +13144,20 @@ var ServiceRegistry = class _ServiceRegistry {
       state: ctx.state === "healthy" || ctx.state === "degraded" || ctx.state === "overloaded" || ctx.state === "unavailable" ? ctx.state : resolved.state,
       acceptingWork: typeof ctx.acceptingWork === "boolean" ? ctx.acceptingWork : resolved.acceptingWork,
       numberOfRunningGraphs,
-      cpuUsage: this.readRuntimeStatusMetric(ctx, "cpuUsage", "cpu", "cpuLoad"),
-      memoryUsage: this.readRuntimeStatusMetric(
-        ctx,
-        "memoryUsage",
-        "memory",
-        "memoryPressure"
-      ),
-      eventLoopLag: this.readRuntimeStatusMetric(
-        ctx,
-        "eventLoopLag",
-        "eventLoopLagMs"
-      ),
+      cpuUsage,
+      memoryUsage,
+      eventLoopLag,
       isActive,
       isNonResponsive,
       isBlocked,
-      health: ctx.health ?? ctx.__health ?? {}
+      health: sanitizeAuthorityRuntimeStatusHealth(ctx.health ?? ctx.__health, {
+        state: ctx.state === "healthy" || ctx.state === "degraded" || ctx.state === "overloaded" || ctx.state === "unavailable" ? ctx.state : resolved.state,
+        acceptingWork: typeof ctx.acceptingWork === "boolean" ? ctx.acceptingWork : resolved.acceptingWork,
+        reportedAt: ctx.reportedAt ?? (typeof ctx.__reportedAt === "string" ? ctx.__reportedAt : void 0) ?? (/* @__PURE__ */ new Date()).toISOString(),
+        cpuUsage,
+        memoryUsage,
+        eventLoopLag
+      })
     };
   }
   applyRuntimeStatusReport(report) {
@@ -12331,12 +13198,14 @@ var ServiceRegistry = class _ServiceRegistry {
       instance.isFrontend = report.isFrontend;
     }
     instance.numberOfRunningGraphs = report.numberOfRunningGraphs;
-    const runtimeMetricsHealth = {
+    const runtimeStatusHealth = sanitizeAuthorityRuntimeStatusHealth(report.health, {
+      state: report.state,
+      acceptingWork: report.acceptingWork,
+      reportedAt: report.reportedAt,
       cpuUsage: report.cpuUsage ?? null,
       memoryUsage: report.memoryUsage ?? null,
-      eventLoopLag: report.eventLoopLag ?? null,
-      runtimeMetrics: report.health?.runtimeMetrics && typeof report.health.runtimeMetrics === "object" ? report.health.runtimeMetrics : void 0
-    };
+      eventLoopLag: report.eventLoopLag ?? null
+    });
     instance.isActive = report.isActive;
     instance.isNonResponsive = report.isNonResponsive;
     instance.isBlocked = report.isBlocked;
@@ -12345,13 +13214,7 @@ var ServiceRegistry = class _ServiceRegistry {
     instance.reportedAt = report.reportedAt;
     instance.health = {
       ...instance.health ?? {},
-      ...report.health ?? {},
-      ...runtimeMetricsHealth,
-      runtimeStatus: {
-        state: report.state,
-        acceptingWork: report.acceptingWork,
-        reportedAt: report.reportedAt
-      }
+      ...runtimeStatusHealth ?? {}
     };
     this.lastHeartbeatAtByInstance.set(report.serviceInstanceId, Date.now());
     this.missedHeartbeatsByInstance.set(report.serviceInstanceId, 0);
@@ -12523,15 +13386,20 @@ var ServiceRegistry = class _ServiceRegistry {
       isActive: snapshot.isActive,
       isNonResponsive: snapshot.isNonResponsive,
       isBlocked: snapshot.isBlocked,
-      health: {
-        ...localInstance.health ?? {},
-        ...this.buildRuntimeMetricsHealthPayload(runtimeMetricsSnapshot) ?? {},
-        runtimeStatus: {
+      health: sanitizeAuthorityRuntimeStatusHealth(
+        {
+          ...localInstance.health ?? {},
+          ...this.buildRuntimeMetricsHealthPayload(runtimeMetricsSnapshot) ?? {}
+        },
+        {
           state: snapshot.state,
           acceptingWork: snapshot.acceptingWork,
-          reportedAt
+          reportedAt,
+          cpuUsage: runtimeMetricsSnapshot?.cpuUsage ?? null,
+          memoryUsage: runtimeMetricsSnapshot?.memoryUsage ?? null,
+          eventLoopLag: runtimeMetricsSnapshot?.eventLoopLag ?? null
         }
-      }
+      )
     };
     this.applyRuntimeStatusReport(report);
     return detailLevel === "full" ? report : this.stripRuntimeStatusReportForPeer(report);
@@ -12885,6 +13753,32 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!instancePersisted) {
       return false;
     }
+    await this.delegateAuthorityLifecycleUpdate(
+      "Update service_instance_lease",
+      {
+        reason,
+        graceful: true,
+        data: {
+          status: "inactive",
+          is_ready: false,
+          readiness_reason: "graceful_shutdown",
+          lease_expires_at: reportedAt,
+          last_lease_renewed_at: reportedAt,
+          last_ready_at: null,
+          last_observed_transport_at: reportedAt,
+          shutdown_requested_at: reportedAt,
+          deleted: false,
+          modified: reportedAt
+        },
+        queryData: {
+          filter: {
+            service_instance_id: localInstance.uuid
+          }
+        },
+        __serviceInstanceId: localInstance.uuid
+      },
+      Math.max(1e3, timeoutMs)
+    );
     for (const transport of localInstance.transports) {
       if (!isPersistedUuid(transport.uuid)) {
         continue;
@@ -13036,6 +13930,7 @@ var ServiceRegistry = class _ServiceRegistry {
     };
   }
   reset() {
+    this.clearBootstrapFullSyncRetryTimer();
     this.instances.clear();
     this.deputies.clear();
     this.remoteSignals.clear();
@@ -13059,6 +13954,23 @@ var ServiceRegistry = class _ServiceRegistry {
     this.lastRuntimeStatusSnapshot = null;
     this.isFrontend = false;
     this.localInstanceSeed = null;
+    this.bootstrapFullSyncRetryIndex = 0;
+    this.bootstrapFullSyncRetryGeneration = 0;
+    this.bootstrapFullSyncSatisfied = false;
+    this.bootstrapFullSyncRetryReason = null;
+    this.knownGlobalSignalMaps.clear();
+    this.authorityBootstrapRoute = {
+      origin: null,
+      role: "internal",
+      routeKey: null,
+      fetchId: null,
+      serviceInstanceId: null,
+      serviceTransportId: null,
+      handshakeEstablished: false
+    };
+    this.authorityBootstrapHandshakeInFlight = false;
+    this.authorityFullSyncResponderTask = null;
+    this.authorityServiceCommunicationPersistenceTask = null;
   }
 };
 
@@ -13167,7 +14079,25 @@ var SignalTransmissionTask = class extends import_core3.Task {
         ...ctx
       })
     );
-    return this.taskFunction(deputyContext, emit2, inquire, progressCallback);
+    const resolvedTools = typeof CadenzaService.resolveToolsForOwner === "function" ? CadenzaService.resolveToolsForOwner(
+      this,
+      deputyContext,
+      emit2,
+      inquire,
+      progressCallback
+    ) : {
+      helpers: {},
+      globals: {}
+    };
+    const resolvedProgressCallback = typeof progressCallback === "function" ? progressCallback : () => {
+    };
+    return this.taskFunction(
+      deputyContext,
+      emit2,
+      inquire,
+      resolvedTools,
+      resolvedProgressCallback
+    );
   }
 };
 
@@ -13496,16 +14426,16 @@ var RestController = class _RestController {
                 };
                 CadenzaService.createEphemeralMetaTask(
                   "Resolve delegation",
-                  (endCtx) => resolveDelegation(endCtx, "success"),
+                  (endCtx) => resolveDelegation(
+                    endCtx,
+                    endCtx?.errored || endCtx?.failed ? "error" : "success"
+                  ),
                   "Resolves a delegation request",
                   { register: false }
-                ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.rest.delegation_resolved:${deputyExecId}`);
-                CadenzaService.createEphemeralMetaTask(
-                  "Resolve delegation target lookup failure",
-                  (endCtx) => resolveDelegation(endCtx, "error"),
-                  "Resolves delegation requests that cannot find a local task or routine",
-                  { register: false }
-                ).doOn(targetNotFoundSignal);
+                ).doOn(
+                  `meta.node.graph_completed:${deputyExecId}`,
+                  targetNotFoundSignal
+                ).emits(`meta.rest.delegation_resolved:${deputyExecId}`);
                 if (!CadenzaService.get(remoteRoutineName) && !CadenzaService.registry.routines.get(remoteRoutineName)) {
                   CadenzaService.emit(targetNotFoundSignal, {
                     ...ctx2,
@@ -16496,7 +17426,7 @@ var SignalController = class _SignalController {
         }
         const traceContext = { ...ctx };
         delete traceContext.__traceCreatedBySignalBroker;
-        const sanitizedTraceContext = stripLocalRoutinePersistenceHints(traceContext);
+        const sanitizedTraceContext = sanitizeExecutionPersistenceContext(traceContext);
         const routineMetadata = resolveRoutinePersistenceMetadata(traceContext);
         const { context: routineContext, metaContext: routineMetaContext } = splitRoutinePersistenceContext(traceContext);
         const traceCreatedBySignalBroker = ctx.__traceCreatedBySignalBroker === true || signalEmission.__traceCreatedBySignalBroker === true;
@@ -17178,6 +18108,16 @@ function buildActorRegistrationData(actor) {
     version: 1
   };
 }
+function sanitizePersistedTaskSourceFields(task, data) {
+  if (!task.isMeta && !task.isDeputy) {
+    return data;
+  }
+  return {
+    ...data,
+    function_string: "",
+    tag_id_getter: null
+  };
+}
 function resolveSyncServiceName(task) {
   const ownerServiceName = typeof task?.ownerServiceName === "string" ? task.ownerServiceName.trim() : "";
   const taskServiceName = typeof task?.serviceName === "string" ? task.serviceName.trim() : "";
@@ -18295,40 +19235,41 @@ var GraphSyncController = class _GraphSyncController {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
           this.tasksSynced = false;
+          const taskRegistrationData = sanitizePersistedTaskSourceFields(task, {
+            name: task.name,
+            version: task.version,
+            description: task.description,
+            function_string: __functionString,
+            tag_id_getter: __getTagCallback,
+            layer_index: task.layerIndex,
+            concurrency: task.concurrency,
+            timeout: task.timeout,
+            is_unique: task.isUnique,
+            is_signal: task.isSignal,
+            is_throttled: task.isThrottled,
+            is_debounce: task.isDebounce,
+            is_ephemeral: task.isEphemeral,
+            is_meta: task.isMeta,
+            is_sub_meta: task.isSubMeta,
+            is_hidden: task.isHidden,
+            validate_input_context: task.validateInputContext,
+            validate_output_context: task.validateOutputContext,
+            retry_count: task.retryCount,
+            retry_delay: task.retryDelay,
+            retry_delay_max: task.retryDelayMax,
+            retry_delay_factor: task.retryDelayFactor,
+            service_name: serviceName2,
+            signals: {
+              emits: Array.from(task.emitsSignals),
+              signalsToEmitAfter: Array.from(task.signalsToEmitAfter),
+              signalsToEmitOnFail: Array.from(task.signalsToEmitOnFail),
+              observed: Array.from(task.observedSignals)
+            },
+            intents: Array.from(task.handlesIntents)
+          });
           yield {
             __syncing: ctx.__syncing,
-            data: {
-              name: task.name,
-              version: task.version,
-              description: task.description,
-              function_string: __functionString,
-              tag_id_getter: __getTagCallback,
-              layer_index: task.layerIndex,
-              concurrency: task.concurrency,
-              timeout: task.timeout,
-              is_unique: task.isUnique,
-              is_signal: task.isSignal,
-              is_throttled: task.isThrottled,
-              is_debounce: task.isDebounce,
-              is_ephemeral: task.isEphemeral,
-              is_meta: task.isMeta,
-              is_sub_meta: task.isSubMeta,
-              is_hidden: task.isHidden,
-              validate_input_context: task.validateInputContext,
-              validate_output_context: task.validateOutputContext,
-              retry_count: task.retryCount,
-              retry_delay: task.retryDelay,
-              retry_delay_max: task.retryDelayMax,
-              retry_delay_factor: task.retryDelayFactor,
-              service_name: serviceName2,
-              signals: {
-                emits: Array.from(task.emitsSignals),
-                signalsToEmitAfter: Array.from(task.signalsToEmitAfter),
-                signalsToEmitOnFail: Array.from(task.signalsToEmitOnFail),
-                observed: Array.from(task.observedSignals)
-              },
-              intents: Array.from(task.handlesIntents)
-            },
+            data: taskRegistrationData,
             __taskName: task.name
           };
         }
@@ -19487,13 +20428,50 @@ var GraphSyncController = class _GraphSyncController {
       startActorPrimitiveSyncTask,
       startRoutinePrimitiveSyncTask
     );
-    const getAllTasksForSyncTask = CadenzaService.registry.getAllTasks.clone();
+    const getAllTasksForSyncTask = CadenzaService.createMetaTask(
+      "Get all tasks for sync",
+      (ctx) => ({
+        ...ctx,
+        tasks: Array.from(CadenzaService.registry.tasks.values())
+      }),
+      "Collects local tasks for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startTaskPrimitiveSyncTask.then(
       getAllTasksForSyncTask,
       gatherTaskRegistrationTask
     );
     getAllTasksForSyncTask.then(this.splitTasksForRegistration);
-    const getSignalsForSyncTask = CadenzaService.signalBroker.getSignalsTask.clone();
+    const getSignalsForSyncTask = CadenzaService.createMetaTask(
+      "Get signals for sync",
+      (ctx) => {
+        const uniqueSignals = Array.from(
+          /* @__PURE__ */ new Set([
+            ...CadenzaService.signalBroker.signalObservers.keys(),
+            ...CadenzaService.signalBroker.emittedSignalsRegistry
+          ])
+        ).filter((signal) => !signal.includes(":"));
+        const processedSignals = uniqueSignals.map((signal) => ({
+          signal,
+          data: {
+            registered: CadenzaService.signalBroker.signalObservers.get(signal)?.registered ?? false,
+            metadata: CadenzaService.signalBroker.getSignalMetadata(signal) ?? null
+          }
+        }));
+        return {
+          ...ctx,
+          signals: processedSignals
+        };
+      },
+      "Collects local signals for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startSignalPrimitiveSyncTask.then(
       getSignalsForSyncTask,
       gatherSignalRegistrationTask
@@ -19535,40 +20513,110 @@ var GraphSyncController = class _GraphSyncController {
       gatherActorRegistrationTask
     );
     getAllActorsForSyncTask.then(this.splitActorsForRegistration);
-    const getAllRoutinesForSyncTask = CadenzaService.registry.getAllRoutines.clone();
+    const getAllRoutinesForSyncTask = CadenzaService.createMetaTask(
+      "Get all routines for sync",
+      (ctx) => ({
+        ...ctx,
+        routines: Array.from(CadenzaService.registry.routines.values())
+      }),
+      "Collects local routines for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startRoutinePrimitiveSyncTask.then(
       getAllRoutinesForSyncTask,
       gatherRoutineRegistrationTask
     );
     getAllRoutinesForSyncTask.then(this.splitRoutinesTask);
-    const iterateTasksForDirectionalTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    const iterateTasksForDirectionalTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Iterate tasks for directional task map sync",
+      function* (ctx) {
+        for (const task of CadenzaService.registry.tasks.values()) {
+          yield { ...ctx, task };
+        }
+      },
+      "Iterates local tasks for directional task-map sync.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startDirectionalTaskMapSyncTask.then(
       iterateTasksForDirectionalTaskMapSyncTask,
       gatherDirectionalTaskMapRegistrationTask
     );
     iterateTasksForDirectionalTaskMapSyncTask.then(this.registerTaskMapTask);
     recordTaskMapRegistrationTask.then(gatherDirectionalTaskMapRegistrationTask);
-    const iterateTasksForSignalTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    const iterateTasksForSignalTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Iterate tasks for signal task map sync",
+      function* (ctx) {
+        for (const task of CadenzaService.registry.tasks.values()) {
+          yield { ...ctx, task };
+        }
+      },
+      "Iterates local tasks for signal-to-task map sync.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startSignalTaskMapSyncTask.then(
       iterateTasksForSignalTaskMapSyncTask,
       gatherSignalTaskMapRegistrationTask
     );
     iterateTasksForSignalTaskMapSyncTask.then(this.registerSignalToTaskMapTask);
     this.registerSignalToTaskMapTask.then(gatherSignalTaskMapRegistrationTask);
-    const iterateTasksForIntentTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    const iterateTasksForIntentTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Iterate tasks for intent task map sync",
+      function* (ctx) {
+        for (const task of CadenzaService.registry.tasks.values()) {
+          yield { ...ctx, task };
+        }
+      },
+      "Iterates local tasks for intent-to-task map sync.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startIntentTaskMapSyncTask.then(
       iterateTasksForIntentTaskMapSyncTask,
       gatherIntentTaskMapRegistrationTask
     );
     iterateTasksForIntentTaskMapSyncTask.then(this.registerIntentToTaskMapTask);
     this.registerIntentToTaskMapTask.then(gatherIntentTaskMapRegistrationTask);
-    const iterateTasksForActorTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    const iterateTasksForActorTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Iterate tasks for actor task map sync",
+      function* (ctx) {
+        for (const task of CadenzaService.registry.tasks.values()) {
+          yield { ...ctx, task };
+        }
+      },
+      "Iterates local tasks for actor-to-task map sync.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startActorTaskMapSyncTask.then(
       iterateTasksForActorTaskMapSyncTask,
       gatherActorTaskMapRegistrationTask
     );
     iterateTasksForActorTaskMapSyncTask.then(this.registerActorTaskMapTask);
-    const getAllRoutinesForTaskMapSyncTask = CadenzaService.registry.getAllRoutines.clone();
+    const getAllRoutinesForTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Get all routines for task map sync",
+      (ctx) => ({
+        ...ctx,
+        routines: Array.from(CadenzaService.registry.routines.values())
+      }),
+      "Collects local routines for routine-to-task map sync.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     startRoutineTaskMapSyncTask.then(
       getAllRoutinesForTaskMapSyncTask,
       gatherRoutineTaskMapRegistrationTask
@@ -19644,11 +20692,37 @@ function resolveTaskByName(name) {
   const taskName = String(name ?? "");
   return taskName ? CadenzaService.get(taskName) : void 0;
 }
+function resolveHelperFromMetadataContext(ctx) {
+  const toolRuntime = CadenzaService;
+  const helperName = String(
+    ctx?.helperName ?? ctx?.data?.helperName ?? ctx?.data?.helper_name ?? ctx?.filter?.helperName ?? ctx?.filter?.helper_name ?? ""
+  );
+  return helperName ? toolRuntime.getHelper?.(helperName) : void 0;
+}
+function resolveGlobalFromMetadataContext(ctx) {
+  const toolRuntime = CadenzaService;
+  const globalName = String(
+    ctx?.globalName ?? ctx?.data?.globalName ?? ctx?.data?.global_name ?? ctx?.filter?.globalName ?? ctx?.filter?.global_name ?? ""
+  );
+  return globalName ? toolRuntime.getGlobal?.(globalName) : void 0;
+}
 function resolvePredecessorTaskFromMetadataContext(ctx) {
   return resolveTaskByName(
     ctx?.predecessorTaskName ?? ctx?.data?.predecessorTaskName ?? ctx?.data?.predecessor_task_name ?? ctx?.filter?.predecessorTaskName ?? ctx?.filter?.predecessor_task_name
   );
 }
+function sanitizePersistedTaskSourceFields2(task, data) {
+  if (!task?.isMeta && !task?.isDeputy) {
+    return data;
+  }
+  return {
+    ...data,
+    functionString: "",
+    function_string: "",
+    tagIdGetter: null,
+    tag_id_getter: null
+  };
+}
 function shouldSkipDirectTaskMetadata(task) {
   return !task || !task.register || task.isHidden || task.isDeputy;
 }
@@ -19726,6 +20800,9 @@ function shouldPersistBusinessInquiryCompletion(ctx) {
   const inquiryName = String(ctx?.data?.metadata?.inquiryMeta?.inquiry ?? "");
   return inquiryName.length > 0 && !isMetaIntentName(inquiryName);
 }
+function shouldPersistExecutionTrace(ctx) {
+  return ctx?.data?.isMeta !== true && ctx?.data?.is_meta !== true;
+}
 function shouldPersistRoutineExecution(ctx) {
   if (ctx?.data?.isMeta === true || ctx?.data?.is_meta === true) {
     return false;
@@ -19789,10 +20866,10 @@ var GraphMetadataController = class _GraphMetadataController {
         task.registrationRequested = true;
       }
       return buildDatabaseTriggerContext(
-        {
+        sanitizePersistedTaskSourceFields2(task, {
           ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName
-        },
+        }),
         void 0,
         { onConflict },
         { onConflict }
@@ -19895,6 +20972,88 @@ var GraphMetadataController = class _GraphMetadataController {
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.task.intent_associated").emits("global.meta.graph_metadata.task_intent_associated");
+    const buildHelperMetadataContext = (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const helper = resolveHelperFromMetadataContext(ctx);
+      if (!helper) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    };
+    createLocalGraphMetadataTask("Handle helper creation", buildHelperMetadataContext).doOn("meta.helper.created").emits("global.meta.graph_metadata.helper_created");
+    createLocalGraphMetadataTask("Handle helper update", buildHelperMetadataContext).doOn("meta.helper.updated").emits("global.meta.graph_metadata.helper_updated");
+    const buildGlobalMetadataContext = (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const globalDefinition = resolveGlobalFromMetadataContext(ctx);
+      if (!globalDefinition) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    };
+    createLocalGraphMetadataTask("Handle global creation", buildGlobalMetadataContext).doOn("meta.global.created").emits("global.meta.graph_metadata.global_created");
+    createLocalGraphMetadataTask("Handle global update", buildGlobalMetadataContext).doOn("meta.global.updated").emits("global.meta.graph_metadata.global_updated");
+    createLocalGraphMetadataTask("Handle task helper association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.task.helper_associated").emits("global.meta.graph_metadata.task_helper_associated");
+    createLocalGraphMetadataTask("Handle helper helper association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const helper = resolveHelperFromMetadataContext(ctx);
+      if (!helper) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.helper.helper_associated").emits("global.meta.graph_metadata.helper_helper_associated");
+    createLocalGraphMetadataTask("Handle task global association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.task.global_associated").emits("global.meta.graph_metadata.task_global_associated");
+    createLocalGraphMetadataTask("Handle helper global association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const helper = resolveHelperFromMetadataContext(ctx);
+      if (!helper) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.helper.global_associated").emits("global.meta.graph_metadata.helper_global_associated");
     createLocalGraphMetadataTask("Handle task unsubscribing signal", (ctx) => {
       if (!shouldEmitDirectPrimitiveMetadata()) {
         return false;
@@ -19962,6 +21121,9 @@ var GraphMetadataController = class _GraphMetadataController {
       });
     }).doOn("meta.routine.task_added").emits("global.meta.graph_metadata.task_added_to_routine");
     createLocalGraphMetadataTask("Handle new trace", (ctx) => {
+      if (!shouldPersistExecutionTrace(ctx)) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         service_name: CadenzaService.serviceRegistry.serviceName,
@@ -19975,10 +21137,10 @@ var GraphMetadataController = class _GraphMetadataController {
           return false;
         }
         const routineData = ctx.data ?? {};
-        const sanitizedRoutineContext = stripLocalRoutinePersistenceHints(
+        const sanitizedRoutineContext = sanitizeExecutionPersistenceContext(
           routineData.context ?? {}
         );
-        const sanitizedRoutineMetaContext = stripLocalRoutinePersistenceHints(
+        const sanitizedRoutineMetaContext = sanitizeExecutionPersistenceContext(
           routineData.metaContext ?? {}
         );
         const routineExecutionRow = {
@@ -20113,12 +21275,13 @@ var GraphMetadataController = class _GraphMetadataController {
     createLocalGraphMetadataTask(
       "Handle routine execution ended",
       (ctx) => {
+        const sanitizedData = sanitizeExecutionPersistenceResultPayload({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: resolveExecutionObservabilityServiceInstanceId2()
+        });
         return buildDatabaseTriggerContext(
-          {
-            ...ctx.data,
-            serviceName: CadenzaService.serviceRegistry.serviceName,
-            serviceInstanceId: resolveExecutionObservabilityServiceInstanceId2()
-          },
+          sanitizedData,
           ctx.filter ?? void 0
         );
       },
@@ -20132,10 +21295,10 @@ var GraphMetadataController = class _GraphMetadataController {
           return false;
         }
         const taskExecutionData = ctx.data ?? {};
-        const sanitizedTaskContext = stripLocalRoutinePersistenceHints(
+        const sanitizedTaskContext = sanitizeExecutionPersistenceContext(
           taskExecutionData.context ?? {}
         );
-        const sanitizedTaskMetaContext = stripLocalRoutinePersistenceHints(
+        const sanitizedTaskMetaContext = sanitizeExecutionPersistenceContext(
           taskExecutionData.metaContext ?? {}
         );
         const routineMetadata = resolveRoutinePersistenceMetadata(
@@ -20368,12 +21531,13 @@ var GraphMetadataController = class _GraphMetadataController {
         if (!shouldPersistTaskExecutionMetadata(ctx)) {
           return false;
         }
+        const sanitizedData = sanitizeExecutionPersistenceResultPayload({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: resolveExecutionObservabilityServiceInstanceId2()
+        });
         return buildDatabaseTriggerContext(
-          {
-            ...ctx.data,
-            serviceName: CadenzaService.serviceRegistry.serviceName,
-            serviceInstanceId: resolveExecutionObservabilityServiceInstanceId2()
-          },
+          sanitizedData,
           ctx.filter ?? void 0
         );
       },
@@ -21458,9 +22622,17 @@ var CadenzaService = class {
       "meta.task.relationship_added",
       "meta.task.relationship_removed",
       "meta.task.intent_associated",
+      "meta.task.helper_associated",
+      "meta.task.global_associated",
       "meta.task.observed_signal",
       "meta.task.attached_signal",
       "meta.task.detached_signal",
+      "meta.helper.created",
+      "meta.helper.updated",
+      "meta.global.created",
+      "meta.global.updated",
+      "meta.helper.helper_associated",
+      "meta.helper.global_associated",
       "meta.actor.created",
       "meta.actor.task_associated",
       "meta.fetch.handshake_complete",