@cadenza.io/service 2.20.0 → 2.21.0

package/dist/browser/index.js

@@ -39,15 +39,15 @@ __export(src_exports, {
   AUTHORITY_SERVICE_INSTANCE_TRANSPORT_REGISTER_TASK_NAME: () => AUTHORITY_SERVICE_INSTANCE_TRANSPORT_REGISTER_TASK_NAME,
   AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT: () => AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
   AUTHORITY_SERVICE_MANIFEST_UPDATED_SIGNAL: () => AUTHORITY_SERVICE_MANIFEST_UPDATED_SIGNAL,
-  Actor: () => import_core6.Actor,
+  Actor: () => import_core7.Actor,
   DatabaseController: () => DatabaseController,
   DatabaseTask: () => DatabaseTask,
-  DebounceTask: () => import_core6.DebounceTask,
+  DebounceTask: () => import_core7.DebounceTask,
   DeputyTask: () => DeputyTask,
   EXECUTION_PERSISTENCE_BUNDLE_SIGNAL: () => EXECUTION_PERSISTENCE_BUNDLE_SIGNAL,
-  EphemeralTask: () => import_core6.EphemeralTask,
+  EphemeralTask: () => import_core7.EphemeralTask,
   GraphMetadataController: () => GraphMetadataController,
-  GraphRoutine: () => import_core6.GraphRoutine,
+  GraphRoutine: () => import_core7.GraphRoutine,
   RUNTIME_STATUS_AUTHORITY_SYNC_REQUESTED_SIGNAL: () => RUNTIME_STATUS_AUTHORITY_SYNC_REQUESTED_SIGNAL,
   RUNTIME_VALIDATION_INTENTS: () => RUNTIME_VALIDATION_INTENTS,
   RUNTIME_VALIDATION_SIGNALS: () => RUNTIME_VALIDATION_SIGNALS,
@@ -56,7 +56,7 @@ __export(src_exports, {
   SignalController: () => SignalController,
   SignalTransmissionTask: () => SignalTransmissionTask,
   SocketController: () => SocketController,
-  Task: () => import_core6.Task,
+  Task: () => import_core7.Task,
   buildAuthorityRuntimeStatusSignature: () => buildAuthorityRuntimeStatusSignature,
   buildExecutionPersistenceDependency: () => buildExecutionPersistenceDependency,
   buildExecutionPersistenceEnsureEvent: () => buildExecutionPersistenceEnsureEvent,
@@ -87,7 +87,7 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/Cadenza.ts
-var import_core5 = __toESM(require("@cadenza.io/core"));
+var import_core6 = __toESM(require("@cadenza.io/core"));
 
 // src/graph/definition/DeputyTask.ts
 var import_uuid2 = require("uuid");
@@ -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("__"))
@@ -163,14 +259,55 @@ var ROOT_METADATA_PASSTHROUGH_KEYS = [
   "__inquirySourceRoutineExecutionId"
 ];
 var DELEGATION_REQUEST_SNAPSHOT_KEY = "__delegationRequestContext";
+var DELEGATION_FAILURE_CONTEXT_KEYS = [
+  "__remoteRoutineName",
+  "__serviceName",
+  "__timeout",
+  "__localTaskName",
+  "__localTaskVersion",
+  "__localServiceName",
+  "__localRoutineExecId",
+  "__previousTaskExecutionId",
+  "__fetchId",
+  "fetchId",
+  "__routeKey",
+  "routeKey",
+  "__instance",
+  "__transportId",
+  "__transportOrigin",
+  "__transportProtocols",
+  "__transportProtocol",
+  "__retries",
+  "__triedInstances",
+  "__delegationRequestContext",
+  "__metadata",
+  "serviceName",
+  "serviceInstanceId",
+  "serviceTransportId",
+  "serviceOrigin",
+  "transportProtocols",
+  "transportProtocol"
+];
+function isPlainObject(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
 function cloneDelegationValue(value) {
+  if (value instanceof Date) {
+    return new Date(value.getTime());
+  }
   if (Array.isArray(value)) {
-    return value.map(
-      (item) => item && typeof item === "object" ? { ...item } : item
-    );
+    return value.map((item) => cloneDelegationValue(item));
   }
-  if (value && typeof value === "object") {
-    return { ...value };
+  if (isPlainObject(value)) {
+    const clone = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      clone[key] = cloneDelegationValue(nestedValue);
+    }
+    return clone;
   }
   return value;
 }
@@ -206,9 +343,9 @@ function attachDelegationRequestSnapshot(input) {
 function restoreDelegationRequestSnapshot(input) {
   const context = input && typeof input === "object" ? { ...input } : {};
   const mutableContext = context;
-  const snapshotCandidate = mutableContext[DELEGATION_REQUEST_SNAPSHOT_KEY];
+  const snapshotCandidate = mutableContext[DELEGATION_REQUEST_SNAPSHOT_KEY] ?? (mutableContext.__metadata && typeof mutableContext.__metadata === "object" ? mutableContext.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY] : void 0);
   const snapshot = snapshotCandidate && typeof snapshotCandidate === "object" ? snapshotCandidate : null;
-  const looksLikeDelegationResult = mutableContext.__status !== void 0 || mutableContext.__success !== void 0 || mutableContext.rowCount !== void 0 || mutableContext.__nextNodes !== void 0 || mutableContext.__isDeputy === true;
+  const looksLikeDelegationResult = mutableContext.__status !== void 0 || mutableContext.__success !== void 0 || mutableContext.rowCount !== void 0 || mutableContext.__nextNodes !== void 0 || mutableContext.__isDeputy === true || mutableContext.errored === true || mutableContext.failed === true || mutableContext.timedOut === true || mutableContext.__error !== void 0 || mutableContext.error !== void 0 || mutableContext.__inquiryMeta !== void 0;
   if (!snapshot || !looksLikeDelegationResult) {
     return context;
   }
@@ -229,6 +366,26 @@ function stripDelegationRequestSnapshot(input) {
   delete context[DELEGATION_REQUEST_SNAPSHOT_KEY];
   return context;
 }
+function buildDelegationFailureContext(signalName, input, error) {
+  const source = input && typeof input === "object" ? { ...input } : {};
+  const slimContext = {};
+  for (const key of DELEGATION_FAILURE_CONTEXT_KEYS) {
+    if (source[key] !== void 0) {
+      slimContext[key] = cloneDelegationValue(source[key]);
+    }
+  }
+  if (slimContext[DELEGATION_REQUEST_SNAPSHOT_KEY] === void 0 && source.__metadata && typeof source.__metadata === "object" && source.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY] !== void 0) {
+    slimContext[DELEGATION_REQUEST_SNAPSHOT_KEY] = cloneDelegationValue(
+      source.__metadata[DELEGATION_REQUEST_SNAPSHOT_KEY]
+    );
+  }
+  return {
+    __signalName: signalName,
+    __error: error instanceof Error ? error.message : String(error ?? "Unknown error"),
+    errored: true,
+    ...slimContext
+  };
+}
 function stripTransportSelectionRoutingContext(input) {
   const context = stripLocalRoutinePersistenceHints(
     input && typeof input === "object" ? { ...input } : {}
@@ -260,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.
@@ -287,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,
@@ -399,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.
    *
@@ -442,12 +610,32 @@ 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
+    );
   }
 };
 
 // src/graph/definition/DatabaseTask.ts
 var ACTOR_SESSION_TRACE_ENABLED = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+var actorSessionEmptyDelegationLogCount = 0;
+var ACTOR_SESSION_EMPTY_DELEGATION_LOG_LIMIT = 40;
 var INSTANCE_TRACE_ENABLED = process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true";
 var EXECUTION_OBSERVABILITY_INSERT_ROUTINES = /* @__PURE__ */ new Set([
   "Insert execution_trace",
@@ -509,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.
    *
@@ -549,15 +742,16 @@ var DatabaseTask = class extends DeputyTask {
     }
     delete ctx.__metadata;
     const isResolverExecution = typeof ctx.__resolverRequestId === "string" && ctx.__resolverRequestId.length > 0;
-    const dynamicQueryData = isResolverExecution ? {} : ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : ctx.queryData ?? {};
+    const resolverQueryData = ctx.__resolverQueryData && typeof ctx.__resolverQueryData === "object" ? ctx.__resolverQueryData : null;
+    const dynamicQueryData = resolverQueryData ?? (ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {});
     delete ctx.queryData;
     const nextQueryData = {
       ...this.queryData,
-      data: {
-        ...ctx.data
-      },
       ...dynamicQueryData
     };
+    if (dynamicQueryData.data === void 0 && ctx.data !== void 0) {
+      nextQueryData.data = ctx.data && typeof ctx.data === "object" && !Array.isArray(ctx.data) ? { ...ctx.data } : ctx.data;
+    }
     const deputyContext = attachDelegationRequestSnapshot(
       stripDelegationRequestSnapshot(
         hoistDelegationMetadataFields({
@@ -617,7 +811,41 @@ var DatabaseTask = class extends DeputyTask {
         rootKeys: Object.keys(rawContext)
       });
     }
-    return this.taskFunction(deputyContext, emit2, inquire, progressCallback);
+    if (this.remoteRoutineName === "Insert actor_session_state" && deputyContext.data === void 0 && deputyContext.queryData === void 0 && actorSessionEmptyDelegationLogCount < ACTOR_SESSION_EMPTY_DELEGATION_LOG_LIMIT) {
+      actorSessionEmptyDelegationLogCount += 1;
+      console.warn("[CADENZA_ACTOR_SESSION_EMPTY_DELEGATION]", {
+        localServiceName: CadenzaService.serviceRegistry.serviceName,
+        localTaskName: this.name,
+        remoteRoutineName: this.remoteRoutineName,
+        hadSnapshotBeforeRestore: initialFullContext.__delegationRequestContext !== void 0 || initialFullContext.__metadata?.__delegationRequestContext !== void 0,
+        restoredRootKeys: Object.keys(rawContext),
+        deputyRootKeys: Object.keys(deputyContext),
+        signalName: rawContext.__signalName ?? rawContext.__metadata?.__signalName ?? null,
+        inquiryName: rawContext.__inquiryName ?? rawContext.__metadata?.__inquiryName ?? null,
+        sourceServiceName: rawContext.__localServiceName ?? rawContext.__metadata?.__localServiceName ?? null,
+        sourceRoutineName: rawContext.__routineName ?? rawContext.__metadata?.__routineName ?? null,
+        sourceTaskName: rawContext.__localTaskName ?? rawContext.__metadata?.__localTaskName ?? null
+      });
+    }
+    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
+    );
   }
 };
 
@@ -656,14 +884,14 @@ var META_INTENT_PREFIX = "meta-";
 var META_RUNTIME_TRANSPORT_DIAGNOSTICS_INTENT = "meta-runtime-transport-diagnostics";
 var META_RUNTIME_STATUS_INTENT = "meta-runtime-status";
 var META_READINESS_INTENT = "meta-readiness";
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
 }
 function deepMergeDeterministic(left, right) {
   if (Array.isArray(left) && Array.isArray(right)) {
     return [...left, ...right];
   }
-  if (isPlainObject(left) && isPlainObject(right)) {
+  if (isPlainObject2(left) && isPlainObject2(right)) {
     const merged = { ...left };
     const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])).sort();
     for (const key of keys) {
@@ -907,6 +1135,10 @@ function normalizeServiceInstanceDescriptor(value) {
     return null;
   }
   const transports = normalizeTransportArray(raw.transports, uuid9);
+  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: uuid9,
     serviceName,
@@ -917,10 +1149,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,
@@ -1373,6 +1611,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;
@@ -1401,6 +1694,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,
@@ -1411,7 +1715,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(
@@ -1420,22 +1724,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) {
@@ -1448,18 +1752,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";
@@ -1485,16 +1824,23 @@ function normalizeServiceManifestSnapshot(input) {
     revision,
     manifestHash,
     publishedAt,
+    publicationLayer: record.publicationLayer === "routing_capability" || record.publicationLayer === "business_structural" || record.publicationLayer === "local_meta_structural" ? record.publicationLayer : "business_structural",
     tasks: normalizeArray(record.tasks),
     signals: normalizeArray(record.signals),
     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) {
@@ -1614,6 +1960,7 @@ function decomposeSignalName(signalName) {
 }
 
 // src/registry/serviceManifest.ts
+var import_core2 = __toESM(require("@cadenza.io/core"));
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -1757,15 +2104,90 @@ 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.isDeputy && !task.isEphemeral;
+  return task.register !== false && task.isHidden !== true && !task.isDeputy && !task.isEphemeral;
 }
 function shouldExportRoutine(routine) {
   return Boolean(String(routine?.name ?? "").trim());
 }
+function buildTaskKey(task) {
+  return `${task.service_name}|${task.name}|${task.version}`;
+}
+function buildActorKey(actor) {
+  return `${actor.service_name}|${actor.name}|${actor.version}`;
+}
+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)
+  );
+  const cachedTasks = Array.from(
+    import_core2.default.taskCache?.values?.() ?? []
+  ).filter((task) => Boolean(task));
+  return Array.from(
+    new Map(
+      [...registryTasks, ...cachedTasks].map((task) => [task.name, task])
+    ).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;
+}
+function isRoutingCriticalMetaIntent(_intent) {
+  return false;
+}
 function buildServiceManifestSnapshot(params) {
-  const { serviceName, serviceInstanceId, revision, publishedAt } = params;
-  const tasks = Array.from(CadenzaService.registry.tasks.values()).filter((task) => Boolean(task)).filter(shouldExportTask);
+  const {
+    serviceName,
+    serviceInstanceId,
+    revision,
+    publishedAt,
+    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(
@@ -1777,6 +2199,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)) {
@@ -1860,6 +2286,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;
@@ -1891,6 +2348,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) {
@@ -1913,59 +2408,524 @@ function buildServiceManifestSnapshot(params) {
       }
     }
   }
-  const manifestBody = {
-    serviceName,
-    serviceInstanceId,
-    tasks: taskDefinitions,
-    signals: Array.from(signalDefinitions.values()).sort(
-      (left, right) => left.name.localeCompare(right.name)
-    ),
-    intents: intentDefinitions,
-    actors: actorDefinitions,
-    routines: routineDefinitions,
-    directionalTaskMaps: Array.from(directionalTaskMaps.values()).sort(
-      (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
-        `${right.predecessor_task_name}:${right.task_name}`
-      )
-    ),
-    signalToTaskMaps: Array.from(signalTaskMaps.values()).sort(
-      (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
-        `${right.signal_name}:${right.task_name}`
-      )
-    ),
-    intentToTaskMaps: Array.from(intentTaskMaps.values()).sort(
-      (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
-        `${right.intent_name}:${right.task_name}`
-      )
-    ),
-    actorTaskMaps: Array.from(actorTaskMaps.values()).sort(
-      (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
-        `${right.actor_name}:${right.task_name}`
-      )
-    ),
-    taskToRoutineMaps: Array.from(taskToRoutineMaps.values()).sort(
-      (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
-        `${right.routine_name}:${right.task_name}`
-      )
-    )
-  };
-  return {
-    ...manifestBody,
-    revision,
-    manifestHash: hashManifest(manifestBody),
-    publishedAt
-  };
-}
-function explodeServiceManifestSnapshots(snapshots) {
-  const dedupe = (items, keyOf, sortOf) => Array.from(
-    new Map(items.map((item) => [keyOf(item), item])).values()
-  ).sort(sortOf);
-  const tasks = dedupe(
-    snapshots.flatMap((snapshot) => snapshot.tasks),
-    (task) => `${task.service_name}|${task.name}|${task.version}`,
-    (left, right) => `${left.service_name}|${left.name}|${left.version}`.localeCompare(
-      `${right.service_name}|${right.name}|${right.version}`
-    )
+  const taskDefinitionsByKey = new Map(
+    taskDefinitions.map((task) => [buildTaskKey(task), task])
+  );
+  const signalDefinitionsByName = new Map(
+    Array.from(signalDefinitions.values()).map((signal) => [signal.name, signal])
+  );
+  const intentDefinitionsByName = new Map(
+    intentDefinitions.map((intent) => [intent.name, intent])
+  );
+  const actorDefinitionsByKey = new Map(
+    actorDefinitions.map((actor) => [buildActorKey(actor), actor])
+  );
+  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();
+  const publishedSignalTaskMaps = Array.from(signalTaskMaps.values()).filter((map) => {
+    const signal = signalDefinitionsByName.get(map.signal_name);
+    return signal?.is_meta !== true || (signal ? isRoutingCriticalMetaSignal(signal) : false);
+  }).sort(
+    (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
+      `${right.signal_name}:${right.task_name}`
+    )
+  );
+  const publishedIntentTaskMaps = Array.from(intentTaskMaps.values()).filter((map) => {
+    const intent = intentDefinitionsByName.get(map.intent_name);
+    return intent?.is_meta !== true || (intent ? isRoutingCriticalMetaIntent(intent) : false);
+  }).sort(
+    (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
+      `${right.intent_name}:${right.task_name}`
+    )
+  );
+  const localMetaSignalTaskMaps = Array.from(signalTaskMaps.values()).filter((map) => !publishedSignalTaskMaps.includes(map)).sort(
+    (left, right) => `${left.signal_name}:${left.task_name}`.localeCompare(
+      `${right.signal_name}:${right.task_name}`
+    )
+  );
+  const localMetaIntentTaskMaps = Array.from(intentTaskMaps.values()).filter((map) => !publishedIntentTaskMaps.includes(map)).sort(
+    (left, right) => `${left.intent_name}:${left.task_name}`.localeCompare(
+      `${right.intent_name}:${right.task_name}`
+    )
+  );
+  for (const map of publishedSignalTaskMaps) {
+    routingTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    routingSignalNames.add(map.signal_name);
+  }
+  for (const map of publishedIntentTaskMaps) {
+    routingTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    routingIntentNames.add(map.intent_name);
+  }
+  const routingTasks = Array.from(routingTaskKeys).map((key) => taskDefinitionsByKey.get(key) ?? null).filter((task) => task !== null).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const routingSignals = Array.from(routingSignalNames).map((name) => signalDefinitionsByName.get(name) ?? null).filter((signal) => signal !== null).sort((left, right) => left.name.localeCompare(right.name));
+  const routingIntents = Array.from(routingIntentNames).map((name) => intentDefinitionsByName.get(name) ?? null).filter((intent) => intent !== null).sort((left, right) => left.name.localeCompare(right.name));
+  const businessTasks = taskDefinitions.filter((task) => task.is_meta !== true && task.is_sub_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessSignals = Array.from(signalDefinitions.values()).filter((signal) => signal.is_meta !== true).sort((left, right) => left.name.localeCompare(right.name));
+  const businessIntents = intentDefinitions.filter((intent) => intent.is_meta !== true).sort((left, right) => left.name.localeCompare(right.name));
+  const businessActors = actorDefinitions.filter((actor) => actor.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessRoutines = routineDefinitions.filter((routine) => routine.is_meta !== true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessDirectionalTaskMaps = Array.from(directionalTaskMaps.values()).filter((map) => {
+    const predecessor = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.predecessor_service_name,
+        name: map.predecessor_task_name,
+        version: map.predecessor_task_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return predecessor?.is_meta !== true && predecessor?.is_sub_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
+      `${right.predecessor_task_name}:${right.task_name}`
+    )
+  );
+  const businessActorTaskMaps = Array.from(actorTaskMaps.values()).filter((map) => {
+    const actor = actorDefinitionsByKey.get(
+      buildActorKey({
+        service_name: map.service_name,
+        name: map.actor_name,
+        version: map.actor_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return actor?.is_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
+      `${right.actor_name}:${right.task_name}`
+    )
+  );
+  const businessTaskToRoutineMaps = Array.from(taskToRoutineMaps.values()).filter((map) => {
+    const routine = routineDefinitionsByKey.get(
+      buildRoutineKey({
+        service_name: map.service_name,
+        name: map.routine_name,
+        version: map.routine_version
+      })
+    );
+    const task = taskDefinitionsByKey.get(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+    return routine?.is_meta !== true && task?.is_meta !== true && task?.is_sub_meta !== true;
+  }).sort(
+    (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
+      `${right.routine_name}:${right.task_name}`
+    )
+  );
+  const localMetaTasks = taskDefinitions.filter((task) => task.is_meta === true || task.is_sub_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaSignals = Array.from(signalDefinitions.values()).filter((signal) => signal.is_meta === true).sort((left, right) => left.name.localeCompare(right.name));
+  const localMetaIntents = intentDefinitions.filter((intent) => intent.is_meta === true).sort((left, right) => left.name.localeCompare(right.name));
+  const localMetaActors = actorDefinitions.filter((actor) => actor.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaRoutines = routineDefinitions.filter((routine) => routine.is_meta === true).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const localMetaDirectionalTaskMaps = Array.from(directionalTaskMaps.values()).filter((map) => !businessDirectionalTaskMaps.includes(map)).sort(
+    (left, right) => `${left.predecessor_task_name}:${left.task_name}`.localeCompare(
+      `${right.predecessor_task_name}:${right.task_name}`
+    )
+  );
+  const localMetaActorTaskMaps = Array.from(actorTaskMaps.values()).filter((map) => !businessActorTaskMaps.includes(map)).sort(
+    (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
+      `${right.actor_name}:${right.task_name}`
+    )
+  );
+  const localMetaTaskToRoutineMaps = Array.from(taskToRoutineMaps.values()).filter((map) => !businessTaskToRoutineMaps.includes(map)).sort(
+    (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
+      `${right.routine_name}:${right.task_name}`
+    )
+  );
+  const businessLocalMetaTaskKeys = /* @__PURE__ */ new Set();
+  const businessLocalMetaSignalNames = /* @__PURE__ */ new Set();
+  const businessLocalMetaIntentNames = /* @__PURE__ */ new Set();
+  const businessLocalMetaActorKeys = /* @__PURE__ */ new Set();
+  const businessLocalMetaRoutineKeys = /* @__PURE__ */ new Set();
+  for (const map of localMetaSignalTaskMaps) {
+    businessLocalMetaSignalNames.add(map.signal_name);
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaIntentTaskMaps) {
+    businessLocalMetaIntentNames.add(map.intent_name);
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaActorTaskMaps) {
+    businessLocalMetaActorKeys.add(
+      buildActorKey({
+        service_name: map.service_name,
+        name: map.actor_name,
+        version: map.actor_version
+      })
+    );
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  for (const map of localMetaTaskToRoutineMaps) {
+    businessLocalMetaRoutineKeys.add(
+      buildRoutineKey({
+        service_name: map.service_name,
+        name: map.routine_name,
+        version: map.routine_version
+      })
+    );
+    businessLocalMetaTaskKeys.add(
+      buildTaskKey({
+        service_name: map.service_name,
+        name: map.task_name,
+        version: map.task_version
+      })
+    );
+  }
+  const businessLocalMetaTasks = Array.from(businessLocalMetaTaskKeys).map((key) => taskDefinitionsByKey.get(key) ?? null).filter(
+    (task) => task !== null && (task.is_meta === true || task.is_sub_meta === true)
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessLocalMetaSignals = Array.from(businessLocalMetaSignalNames).map((name) => signalDefinitionsByName.get(name) ?? null).filter(
+    (signal) => signal !== null && signal.is_meta === true
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const businessLocalMetaIntents = Array.from(businessLocalMetaIntentNames).map((name) => intentDefinitionsByName.get(name) ?? null).filter(
+    (intent) => intent !== null && intent.is_meta === true
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const businessLocalMetaActors = Array.from(businessLocalMetaActorKeys).map((key) => actorDefinitionsByKey.get(key) ?? null).filter(
+    (actor) => actor !== null && actor.is_meta === true
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const businessLocalMetaRoutines = Array.from(businessLocalMetaRoutineKeys).map((key) => routineDefinitionsByKey.get(key) ?? null).filter(
+    (routine) => routine !== null && routine.is_meta === true
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeTasks = publicationLayer === "routing_capability" ? routingTasks : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingTasks, ...businessTasks, ...businessLocalMetaTasks].map((task) => [
+        buildTaskKey(task),
+        task
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...routingTasks, ...businessTasks, ...localMetaTasks].map((task) => [
+        buildTaskKey(task),
+        task
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeSignals = publicationLayer === "routing_capability" ? routingSignals : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingSignals, ...businessSignals, ...businessLocalMetaSignals].map(
+        (signal) => [signal.name, signal]
+      )
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name)) : Array.from(
+    new Map(
+      [...routingSignals, ...businessSignals, ...localMetaSignals].map((signal) => [
+        signal.name,
+        signal
+      ])
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const cumulativeIntents = publicationLayer === "routing_capability" ? routingIntents : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...routingIntents, ...businessIntents, ...businessLocalMetaIntents].map(
+        (intent) => [intent.name, intent]
+      )
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name)) : Array.from(
+    new Map(
+      [...routingIntents, ...businessIntents, ...localMetaIntents].map((intent) => [
+        intent.name,
+        intent
+      ])
+    ).values()
+  ).sort((left, right) => left.name.localeCompare(right.name));
+  const cumulativeActors = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessActors, ...businessLocalMetaActors].map((actor) => [
+        buildActorKey(actor),
+        actor
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...businessActors, ...localMetaActors].map((actor) => [
+        buildActorKey(actor),
+        actor
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  );
+  const cumulativeRoutines = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessRoutines, ...businessLocalMetaRoutines].map((routine) => [
+        buildRoutineKey(routine),
+        routine
+      ])
+    ).values()
+  ).sort(
+    (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
+  ) : Array.from(
+    new Map(
+      [...businessRoutines, ...localMetaRoutines].map((routine) => [
+        buildRoutineKey(routine),
+        routine
+      ])
+    ).values()
+  ).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(
+        (map) => [
+          `${map.predecessor_service_name}|${map.predecessor_task_name}|${map.predecessor_task_version}|${map.service_name}|${map.task_name}|${map.task_version}`,
+          map
+        ]
+      )
+    ).values()
+  );
+  const cumulativeActorTaskMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? Array.from(
+    new Map(
+      [...businessActorTaskMaps, ...localMetaActorTaskMaps].map((map) => [
+        `${map.service_name}|${map.actor_name}|${map.actor_version}|${map.task_name}|${map.task_version}|${map.mode}`,
+        map
+      ])
+    ).values()
+  ) : Array.from(
+    new Map(
+      [...businessActorTaskMaps, ...localMetaActorTaskMaps].map((map) => [
+        `${map.service_name}|${map.actor_name}|${map.actor_version}|${map.task_name}|${map.task_version}|${map.mode}`,
+        map
+      ])
+    ).values()
+  );
+  const cumulativeTaskToRoutineMaps = publicationLayer === "routing_capability" ? [] : publicationLayer === "business_structural" ? businessTaskToRoutineMaps : Array.from(
+    new Map(
+      [...businessTaskToRoutineMaps, ...localMetaTaskToRoutineMaps].map((map) => [
+        `${map.service_name}|${map.task_name}|${map.task_version}|${map.routine_name}|${map.routine_version}`,
+        map
+      ])
+    ).values()
+  );
+  const manifestBody = {
+    serviceName,
+    serviceInstanceId,
+    publicationLayer,
+    tasks: cumulativeTasks,
+    signals: cumulativeSignals,
+    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,
+    taskToHelperMaps: cumulativeTaskToHelperMaps,
+    helperToHelperMaps: cumulativeHelperToHelperMaps,
+    taskToGlobalMaps: cumulativeTaskToGlobalMaps,
+    helperToGlobalMaps: cumulativeHelperToGlobalMaps
+  };
+  return {
+    ...manifestBody,
+    revision,
+    manifestHash: hashManifest(manifestBody),
+    publishedAt
+  };
+}
+function explodeServiceManifestSnapshots(snapshots) {
+  const dedupe = (items, keyOf, sortOf) => Array.from(
+    new Map(items.map((item) => [keyOf(item), item])).values()
+  ).sort(sortOf);
+  const tasks = dedupe(
+    snapshots.flatMap((snapshot) => snapshot.tasks),
+    (task) => `${task.service_name}|${task.name}|${task.version}`,
+    (left, right) => `${left.service_name}|${left.name}|${left.version}`.localeCompare(
+      `${right.service_name}|${right.name}|${right.version}`
+    )
   );
   const signals = dedupe(
     snapshots.flatMap((snapshot) => snapshot.signals),
@@ -1991,6 +2951,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}`,
@@ -2026,17 +3000,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
   };
 }
 
@@ -2085,7 +3093,53 @@ 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(ctx, queryData) {
+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) {
@@ -2103,7 +3157,8 @@ function buildServiceRegistryInsertQueryData(ctx, queryData) {
   if (!Object.prototype.hasOwnProperty.call(queryData, "onConflict")) {
     delete nextQueryData.onConflict;
   }
-  const resolvedData = Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data");
+  const preferRegistrationData = tableName === "service" || tableName === "service_instance" || tableName === "service_instance_transport";
+  const resolvedData = preferRegistrationData ? registrationData ?? (Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data")) : Object.prototype.hasOwnProperty.call(ctx, "data") || ctx.data !== void 0 ? ctx.data : getJoinedValue("data");
   const resolvedBatch = Object.prototype.hasOwnProperty.call(ctx, "batch") || ctx.batch !== void 0 ? ctx.batch : getJoinedValue("batch");
   const nextData = resolvedData !== void 0 ? resolvedData && typeof resolvedData === "object" ? { ...resolvedData } : resolvedData : registrationData && typeof registrationData === "object" && !Array.isArray(registrationData) ? { ...registrationData } : registrationData;
   if (nextData !== void 0) {
@@ -2130,8 +3185,151 @@ function sanitizeServiceRegistryInsertExecutionContext(ctx) {
   delete sanitized.returnedValue;
   delete sanitized.queryData;
   delete sanitized.onConflict;
+  delete sanitized.task;
+  delete sanitized.routine;
+  delete sanitized.httpServer;
+  delete sanitized.service;
+  delete sanitized.serviceInstance;
+  delete sanitized.joinedContexts;
+  delete sanitized.__declaredTransports;
+  delete sanitized.__resolverOriginalContext;
+  delete sanitized.__resolverQueryData;
   return sanitized;
 }
+function sanitizeAuthorityBootstrapDelegationContext(ctx) {
+  const sanitized = stripDelegationRequestSnapshot({
+    ...ctx
+  });
+  delete sanitized.__resolverOriginalContext;
+  delete sanitized.__resolverQueryData;
+  delete sanitized.joinedContexts;
+  delete sanitized.httpServer;
+  delete sanitized.service;
+  delete sanitized.serviceInstance;
+  delete sanitized.task;
+  delete sanitized.routine;
+  delete sanitized.__declaredTransports;
+  const queryData = sanitized.queryData && typeof sanitized.queryData === "object" ? { ...sanitized.queryData } : null;
+  if (queryData) {
+    delete queryData.joinedContexts;
+    sanitized.queryData = queryData;
+  }
+  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());
+  }
+  if (Array.isArray(value)) {
+    return value.map(
+      (entry) => cloneServiceRegistryContextValue(entry)
+    );
+  }
+  if (value && typeof value === "object") {
+    const clone = {};
+    for (const [key, nestedValue] of Object.entries(value)) {
+      clone[key] = cloneServiceRegistryContextValue(nestedValue);
+    }
+    return clone;
+  }
+  return value;
+}
+function buildServiceRegistryResolverOriginalContext(tableName, ctx, queryData) {
+  const originalContext = {};
+  for (const key of [
+    "__serviceName",
+    "serviceName",
+    "__serviceInstanceId",
+    "serviceInstanceId",
+    "__registrationData",
+    "__reason",
+    "__syncing",
+    "__syncSourceServiceName",
+    "__preferredTransportProtocol",
+    "__networkMode",
+    "__securityProfile",
+    "__loadBalance",
+    "__cadenzaDBConnect",
+    "__isFrontend",
+    "__isDatabase",
+    "__retryCount",
+    "__retries",
+    "__triedInstances"
+  ]) {
+    if (ctx[key] !== void 0) {
+      originalContext[key] = cloneServiceRegistryContextValue(ctx[key]);
+    }
+  }
+  if (queryData.data !== void 0) {
+    originalContext.data = cloneServiceRegistryContextValue(queryData.data);
+  }
+  if (queryData.batch !== void 0) {
+    originalContext.batch = cloneServiceRegistryContextValue(queryData.batch);
+  }
+  if (Object.prototype.hasOwnProperty.call(queryData, "onConflict")) {
+    originalContext.queryData = {
+      data: queryData.data !== void 0 ? cloneServiceRegistryContextValue(queryData.data) : void 0,
+      batch: queryData.batch !== void 0 ? cloneServiceRegistryContextValue(queryData.batch) : void 0,
+      onConflict: cloneServiceRegistryContextValue(queryData.onConflict)
+    };
+  } else if (queryData.data !== void 0 || queryData.batch !== void 0) {
+    originalContext.queryData = {
+      data: queryData.data !== void 0 ? cloneServiceRegistryContextValue(queryData.data) : void 0,
+      batch: queryData.batch !== void 0 ? cloneServiceRegistryContextValue(queryData.batch) : void 0
+    };
+  }
+  if (tableName === "service_instance") {
+    for (const key of [
+      "__transportData",
+      "transportData",
+      "__useSocket",
+      "__retryCount",
+      "__isFrontend"
+    ]) {
+      if (ctx[key] !== void 0) {
+        originalContext[key] = cloneServiceRegistryContextValue(ctx[key]);
+      }
+    }
+  }
+  return originalContext;
+}
 function clearTransientRoutingErrorState(context) {
   delete context.errored;
   delete context.failed;
@@ -2187,7 +3385,8 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   delete result.__resolverOriginalContext;
   delete result.__resolverQueryData;
   const normalizedQueryData = result.queryData && typeof result.queryData === "object" ? { ...result.queryData } : { ...queryData };
-  const resolvedData = result.data ?? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData;
+  const preferRequestedData = tableName === "service" || tableName === "service_instance" || tableName === "service_instance_transport";
+  const resolvedData = preferRequestedData ? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData ?? result.data : result.data ?? normalizedQueryData.data ?? queryData.data ?? ctx.data ?? ctx.__registrationData;
   if (resolvedData !== void 0 && result.data === void 0) {
     result.data = resolvedData;
   }
@@ -2217,6 +3416,7 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
     ).trim();
     if (resolvedServiceName) {
       result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
     }
   }
   const resolvedLocalServiceInstanceId = String(
@@ -2225,6 +3425,18 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   if (resolvedLocalServiceInstanceId) {
     result.__serviceInstanceId = resolvedLocalServiceInstanceId;
   }
+  if (tableName === "service_instance") {
+    const resolvedServiceName = String(
+      ctx.__serviceName ?? resolveServiceNameFromContext(ctx) ?? resolvedData?.service_name ?? resolvedData?.serviceName ?? ""
+    ).trim();
+    if (resolvedServiceName) {
+      result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
+    }
+    if (resolvedLocalServiceInstanceId) {
+      result.serviceInstanceId = resolvedLocalServiceInstanceId;
+    }
+  }
   if (tableName === "service_instance" || tableName === "service_instance_transport") {
     const resolvedUuid = String(
       result.uuid ?? resolvedData?.uuid ?? ctx.__serviceInstanceId ?? ""
@@ -2324,9 +3536,15 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         ctx
       );
       const nextQueryData = buildServiceRegistryInsertQueryData(
+        tableName,
         sanitizedContext,
         queryData
       );
+      const resolverOriginalContext = buildServiceRegistryResolverOriginalContext(
+        tableName,
+        sanitizedContext,
+        nextQueryData
+      );
       const delegationContext = ensureDelegationContextMetadata({
         ...sanitizedContext,
         data: nextQueryData.data !== void 0 ? nextQueryData.data : sanitizedContext.data,
@@ -2339,9 +3557,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       delegationContext.__metadata.__blockRemoteExecution = delegationContext.__metadata.__blockRemoteExecution ?? delegationContext.__blockRemoteExecution ?? false;
       const nextContext = {
         ...delegationContext,
-        __resolverOriginalContext: {
-          ...sanitizedContext
-        },
+        __resolverOriginalContext: resolverOriginalContext,
         __resolverQueryData: nextQueryData
       };
       if (tableName === "service_instance_transport" && shouldTraceServiceRegistry(
@@ -2393,6 +3609,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) => {
@@ -2451,135 +3753,52 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
               ) || CadenzaService.serviceRegistry.serviceName,
               uuid: normalizedResult.uuid ?? normalizedResult.data?.uuid ?? null,
               errored: normalizedResult.errored === true,
-              error: normalizedResult.__error ?? null,
-              data: normalizedResult.data ?? normalizedResult.queryData?.data ?? null
-            });
-          }
-          if (normalizedResult && typeof normalizedResult === "object" && tableName === "service_instance") {
-            const traceServiceName = resolveServiceNameFromContext(
-              resultCtx.__resolverOriginalContext ?? resultCtx
-            ) || CadenzaService.serviceRegistry.serviceName;
-            if (shouldTraceServiceRegistry(traceServiceName)) {
-              console.log("[CADENZA_SERVICE_REGISTRY_TRACE] service_instance_insert_resolved", {
-                localServiceName: CadenzaService.serviceRegistry.serviceName,
-                serviceName: traceServiceName,
-                serviceInstanceId: normalizedResult.__serviceInstanceId ?? normalizedResult.uuid ?? normalizedResult.data?.uuid ?? null,
-                hasTransportData: Array.isArray(normalizedResult.__transportData) || Array.isArray(normalizedResult.transportData),
-                transportCount: Array.isArray(
-                  normalizedResult.__transportData
-                ) ? normalizedResult.__transportData.length : Array.isArray(normalizedResult.transportData) ? normalizedResult.transportData.length : 0,
-                errored: normalizedResult.errored === true,
-                error: normalizedResult.__error ?? null
-              });
-            }
-            emit2(
-              META_SERVICE_INSTANCE_INSERT_RESOLVED_SIGNAL,
-              normalizedResult
-            );
-          }
-          if (!normalizedResult || typeof normalizedResult !== "object") {
-            resolve(normalizedResult);
-            return normalizedResult;
-          }
-          const resolvedResult = {
-            ...normalizedResult
-          };
-          delete resolvedResult.__resolverRequestId;
-          delete resolvedResult.__resolverOriginalContext;
-          delete resolvedResult.__resolverQueryData;
-          resolve(resolvedResult);
-          return resolvedResult;
-        },
-        `Resolves signal-driven ${tableName} service-registry insert execution.`,
-        {
-          register: 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(
-          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
+              error: normalizedResult.__error ?? null,
+              data: normalizedResult.data ?? normalizedResult.queryData?.data ?? null
+            });
           }
-        ).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);
-      }
+          if (normalizedResult && typeof normalizedResult === "object" && tableName === "service_instance") {
+            const traceServiceName = resolveServiceNameFromContext(
+              resultCtx.__resolverOriginalContext ?? resultCtx
+            ) || CadenzaService.serviceRegistry.serviceName;
+            if (shouldTraceServiceRegistry(traceServiceName)) {
+              console.log("[CADENZA_SERVICE_REGISTRY_TRACE] service_instance_insert_resolved", {
+                localServiceName: CadenzaService.serviceRegistry.serviceName,
+                serviceName: traceServiceName,
+                serviceInstanceId: normalizedResult.__serviceInstanceId ?? normalizedResult.uuid ?? normalizedResult.data?.uuid ?? null,
+                hasTransportData: Array.isArray(normalizedResult.__transportData) || Array.isArray(normalizedResult.transportData),
+                transportCount: Array.isArray(
+                  normalizedResult.__transportData
+                ) ? normalizedResult.__transportData.length : Array.isArray(normalizedResult.transportData) ? normalizedResult.transportData.length : 0,
+                errored: normalizedResult.errored === true,
+                error: normalizedResult.__error ?? null
+              });
+            }
+            emit2(
+              META_SERVICE_INSTANCE_INSERT_RESOLVED_SIGNAL,
+              normalizedResult
+            );
+          }
+          if (!normalizedResult || typeof normalizedResult !== "object") {
+            resolve(normalizedResult);
+            return normalizedResult;
+          }
+          const resolvedResult = {
+            ...normalizedResult
+          };
+          delete resolvedResult.__resolverRequestId;
+          delete resolvedResult.__resolverOriginalContext;
+          delete resolvedResult.__resolverQueryData;
+          resolve(resolvedResult);
+          return resolvedResult;
+        },
+        `Resolves signal-driven ${tableName} service-registry insert execution.`,
+        {
+          register: false,
+          once: false,
+          destroyCondition: (result) => result !== false
+        }
+      ).doOn(executionResolvedSignal, executionFailedSignal);
       emit2(executionSignal, {
         ...ctx,
         __resolverRequestId: resolverRequestId
@@ -2604,6 +3823,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,
@@ -2653,6 +3883,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
@@ -2701,6 +3934,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;
@@ -2947,6 +4192,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
         if (uuid9 === this.serviceInstanceId) return;
+        if (serviceName === this.serviceName) {
+          return false;
+        }
         if (deleted) {
           const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid9);
           const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid9) ?? -1;
@@ -3033,9 +4281,6 @@ var ServiceRegistry = class _ServiceRegistry {
             emit2
           );
         }
-        if (this.serviceName === serviceName) {
-          return false;
-        }
         if (trackedInstance?.isFrontend) {
           return true;
         }
@@ -3089,6 +4334,9 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!ownerInstance) {
           return false;
         }
+        if (ownerInstance.serviceName === this.serviceName && ownerInstance.uuid !== this.serviceInstanceId) {
+          return false;
+        }
         if (transport.deleted) {
           this.clearTransportFailureState(ownerInstance.uuid, transport.uuid);
           const transportKey = this.buildTransportRouteKey(
@@ -3676,6 +4924,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"
         ]);
@@ -3700,6 +4954,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
         );
@@ -3733,6 +5003,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,
@@ -3758,6 +5030,8 @@ var ServiceRegistry = class _ServiceRegistry {
           serviceInstanceTransports,
           serviceManifests,
           tasks,
+          helpers,
+          globals,
           signals,
           intents,
           actors,
@@ -3765,6 +5039,10 @@ var ServiceRegistry = class _ServiceRegistry {
           directionalTaskMaps,
           actorTaskMaps,
           taskToRoutineMaps,
+          taskToHelperMaps,
+          helperToHelperMaps,
+          taskToGlobalMaps,
+          helperToGlobalMaps,
           __inquiryMeta: inquiryResult.__inquiryMeta
         };
       },
@@ -4384,29 +5662,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;
       },
@@ -5411,11 +6711,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 = [];
@@ -5423,11 +6726,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();
@@ -5435,6 +6745,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) {
@@ -5465,6 +6779,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",
@@ -5495,6 +6815,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,
@@ -5515,6 +6841,8 @@ var ServiceRegistry = class _ServiceRegistry {
         seenSignalMaps,
         (row) => `${String(row.service_name ?? row.serviceName ?? "").trim()}|${String(
           row.signal_name ?? row.signalName ?? ""
+        ).trim()}|${String(row.task_name ?? row.taskName ?? "").trim()}|${String(
+          row.task_version ?? row.taskVersion ?? 1
         ).trim()}`
       );
       pushUnique(
@@ -5549,10 +6877,23 @@ var ServiceRegistry = class _ServiceRegistry {
             seenSignalMaps,
             (entry) => `${String(entry.service_name ?? entry.serviceName ?? "").trim()}|${String(
               entry.signal_name ?? entry.signalName ?? ""
+            ).trim()}|${String(entry.task_name ?? entry.taskName ?? "").trim()}|${String(
+              entry.task_version ?? entry.taskVersion ?? 1
             ).trim()}`
           );
           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],
@@ -5581,9 +6922,40 @@ var ServiceRegistry = class _ServiceRegistry {
         }
       }
     }
-    const hasExplicitSignalRoutingRows = signalToTaskMaps.length > 0;
-    const hasExplicitIntentRoutingRows = intentToTaskMaps.length > 0;
-    const latestManifestSnapshots = selectLatestServiceManifestSnapshots(manifestSnapshots);
+    const mergedServiceInstances = overlayServiceInstancesWithLeases(
+      serviceInstances,
+      serviceInstanceLeases
+    );
+    const activeServiceInstanceIds = new Set(
+      mergedServiceInstances.filter((row) => row.is_active === true || row.isActive === true).map((row) => String(row.uuid ?? "").trim()).filter((uuid9) => uuid9.length > 0)
+    );
+    const filteredServiceInstances = activeServiceInstanceIds.size > 0 ? mergedServiceInstances.filter(
+      (row) => activeServiceInstanceIds.has(String(row.uuid ?? "").trim())
+    ) : mergedServiceInstances;
+    const filteredServiceInstanceTransports = activeServiceInstanceIds.size > 0 ? serviceInstanceTransports.filter(
+      (row) => activeServiceInstanceIds.has(
+        String(row.service_instance_id ?? row.serviceInstanceId ?? "").trim()
+      )
+    ) : serviceInstanceTransports;
+    const filteredManifestSnapshots = activeServiceInstanceIds.size > 0 ? manifestSnapshots.filter(
+      (snapshot) => activeServiceInstanceIds.has(snapshot.serviceInstanceId)
+    ) : manifestSnapshots;
+    const activeServiceNames = new Set(
+      filteredServiceInstances.map((row) => String(row.service_name ?? row.serviceName ?? "").trim()).filter((serviceName) => serviceName.length > 0)
+    );
+    const filteredSignalToTaskMaps = activeServiceNames.size > 0 ? signalToTaskMaps.filter(
+      (row) => activeServiceNames.has(
+        String(row.service_name ?? row.serviceName ?? "").trim()
+      )
+    ) : signalToTaskMaps;
+    const filteredIntentToTaskMaps = activeServiceNames.size > 0 ? intentToTaskMaps.filter(
+      (row) => activeServiceNames.has(
+        String(row.service_name ?? row.serviceName ?? "").trim()
+      )
+    ) : intentToTaskMaps;
+    const hasExplicitSignalRoutingRows = filteredSignalToTaskMaps.length > 0;
+    const hasExplicitIntentRoutingRows = filteredIntentToTaskMaps.length > 0;
+    const latestManifestSnapshots = selectLatestServiceManifestSnapshots(filteredManifestSnapshots);
     const explodedManifest = explodeServiceManifestSnapshots(
       latestManifestSnapshots
     );
@@ -5603,6 +6975,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,
@@ -5663,10 +7051,54 @@ 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,
-        signalToTaskMaps,
+        filteredSignalToTaskMaps,
         seenSignalMaps,
         (row) => `${String(row.signal_name ?? "").trim()}|${String(
           row.service_name ?? ""
@@ -5678,7 +7110,7 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!hasExplicitIntentRoutingRows) {
       pushUnique(
         explodedManifest.intentToTaskMaps,
-        intentToTaskMaps,
+        filteredIntentToTaskMaps,
         seenIntentMaps,
         (row) => `${String(row.intent_name ?? "").trim()}|${String(
           row.service_name ?? ""
@@ -5688,10 +7120,13 @@ var ServiceRegistry = class _ServiceRegistry {
       );
     }
     return {
-      serviceInstances,
-      serviceInstanceTransports,
+      serviceInstances: filteredServiceInstances,
+      serviceInstanceLeases,
+      serviceInstanceTransports: filteredServiceInstanceTransports,
       serviceManifests,
       tasks,
+      helpers,
+      globals,
       signals,
       intents,
       actors,
@@ -5699,8 +7134,12 @@ var ServiceRegistry = class _ServiceRegistry {
       directionalTaskMaps,
       actorTaskMaps,
       taskToRoutineMaps,
-      signalToTaskMaps,
-      intentToTaskMaps
+      taskToHelperMaps,
+      helperToHelperMaps,
+      taskToGlobalMaps,
+      helperToGlobalMaps,
+      signalToTaskMaps: filteredSignalToTaskMaps,
+      intentToTaskMaps: filteredIntentToTaskMaps
     };
   }
   buildRemoteIntentDeputyKey(map) {
@@ -6129,29 +7568,32 @@ var ServiceRegistry = class _ServiceRegistry {
     const controller = typeof AbortController === "function" ? new AbortController() : null;
     const timeoutId = controller ? setTimeout(() => controller.abort(), timeoutMs) : null;
     try {
-      const requestBody = stripDelegationRequestSnapshot(
-        ensureDelegationContextMetadata(
-          attachDelegationRequestSnapshot({
-            ...context,
-            __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: {
-              ...context.__metadata && typeof context.__metadata === "object" ? context.__metadata : {},
+      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`, {
@@ -6164,22 +7606,22 @@ var ServiceRegistry = class _ServiceRegistry {
       });
       if ("ok" in response && response.ok === false) {
         return {
-          ...context,
+          ...sanitizedContext,
           __error: `Bootstrap authority delegation failed with HTTP ${response.status}`,
           errored: true
         };
       }
       const payload = typeof response.json === "function" ? await response.json() : response;
       return payload && typeof payload === "object" ? {
-        ...context,
+        ...sanitizedContext,
         ...payload
       } : {
-        ...context,
+        ...sanitizedContext,
         returnedValue: payload
       };
     } catch (error) {
       return {
-        ...context,
+        ...sanitizeAuthorityBootstrapDelegationContext(context),
         __error: error instanceof Error ? error.message : String(error),
         errored: true
       };
@@ -6306,12 +7748,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"
           ),
@@ -6324,6 +7768,7 @@ var ServiceRegistry = class _ServiceRegistry {
           __syncing: true,
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
+            serviceInstanceLeases,
             serviceInstanceTransports,
             serviceManifests,
             signalToTaskMaps,
@@ -6356,9 +7801,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({
@@ -6506,6 +7956,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;
@@ -6583,8 +8058,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;
@@ -8487,6 +9965,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,
@@ -8499,22 +9989,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) {
@@ -8555,12 +10043,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;
@@ -8569,13 +10059,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);
@@ -8747,15 +10231,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);
@@ -9109,6 +10598,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;
@@ -9260,6 +10775,7 @@ var ServiceRegistry = class _ServiceRegistry {
     };
   }
   reset() {
+    this.clearBootstrapFullSyncRetryTimer();
     this.instances.clear();
     this.deputies.clear();
     this.remoteSignals.clear();
@@ -9283,13 +10799,30 @@ 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;
   }
 };
 
 // src/graph/definition/SignalTransmissionTask.ts
-var import_core2 = require("@cadenza.io/core");
+var import_core3 = require("@cadenza.io/core");
 var import_uuid4 = require("uuid");
-var SignalTransmissionTask = class extends import_core2.Task {
+var SignalTransmissionTask = class extends import_core3.Task {
   /**
    * Constructs a new instance of the class and initializes it with the provided parameters.
    *
@@ -9391,7 +10924,25 @@ var SignalTransmissionTask = class extends import_core2.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
+    );
   }
 };
 
@@ -11197,8 +12748,8 @@ var SocketController = class _SocketController {
               }
               const routedDelegateCtx = stripTransportSelectionRoutingContext(delegateCtx);
               const normalizedDelegateCtx = ensureDelegationContextMetadata(
-                attachDelegationRequestSnapshot(
-                  stripDelegationRequestSnapshot(routedDelegateCtx)
+                restoreDelegationRequestSnapshot(
+                  attachDelegationRequestSnapshot(routedDelegateCtx)
                 )
               );
               delete normalizedDelegateCtx.__isSubMeta;
@@ -11271,13 +12822,11 @@ var SocketController = class _SocketController {
                 return resolvedResultContext;
               } catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                const failedContext = {
-                  __signalName: "meta.socket_client.delegate_failed",
-                  errored: true,
-                  __error: message,
-                  ...normalizedDelegateCtx,
-                  ...normalizedDelegateCtx.__metadata
-                };
+                const failedContext = buildDelegationFailureContext(
+                  "meta.socket_client.delegate_failed",
+                  normalizedDelegateCtx,
+                  error
+                );
                 if (deputyExecId) {
                   emitter(`meta.socket_client.delegated:${deputyExecId}`, {
                     ...failedContext,
@@ -11964,7 +13513,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;
@@ -12282,10 +13831,55 @@ var RuntimeValidationController = class _RuntimeValidationController {
 };
 
 // src/graph/controllers/registerActorSessionPersistence.ts
-var import_core3 = require("@cadenza.io/core");
+var import_core4 = require("@cadenza.io/core");
 var ACTOR_SESSION_STATE_PERSIST_CONCURRENCY = 20;
 var META_ACTOR_SESSION_STATE_HYDRATE_INTENT = "meta-actor-session-state-hydrate";
 var ACTOR_SESSION_TRACE_ENABLED2 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+function findNestedContextValue(ctx, key) {
+  if (!ctx || typeof ctx !== "object") {
+    return void 0;
+  }
+  if (Object.prototype.hasOwnProperty.call(ctx, key) || ctx[key] !== void 0) {
+    return ctx[key];
+  }
+  const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
+  for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+    const nested = joinedContexts[index];
+    if (!nested || typeof nested !== "object") {
+      continue;
+    }
+    const nestedValue = findNestedContextValue(nested, key);
+    if (nestedValue !== void 0) {
+      return nestedValue;
+    }
+  }
+  return void 0;
+}
+function resolveActorSessionStateRow(ctx) {
+  const singular = findNestedContextValue(ctx, "actorSessionState");
+  if (singular && typeof singular === "object" && !Array.isArray(singular)) {
+    return singular;
+  }
+  const plural = findNestedContextValue(ctx, "actorSessionStates");
+  if (Array.isArray(plural)) {
+    const first = plural.find(
+      (entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+    );
+    if (first) {
+      return first;
+    }
+  }
+  const rows = findNestedContextValue(ctx, "rows");
+  if (Array.isArray(rows)) {
+    const first = rows.find(
+      (entry) => entry && typeof entry === "object" && !Array.isArray(entry)
+    );
+    if (first) {
+      return first;
+    }
+  }
+  return null;
+}
 function shouldAssumeSuccessfulActorSessionRowCount(ctx) {
   return ctx.__success === true && ctx.rowCount === void 0 && ctx.__status === "success" && ctx.__serviceName === "CadenzaDB" && ctx.__localTaskName === "Insert actor_session_state in CadenzaDB";
 }
@@ -12358,7 +13952,7 @@ function registerActorSessionPersistenceTasks() {
           )
         );
       }
-      const row = ctx.actorSessionState && typeof ctx.actorSessionState === "object" && !Array.isArray(ctx.actorSessionState) ? ctx.actorSessionState : null;
+      const row = resolveActorSessionStateRow(ctx);
       if (!row) {
         return {
           __success: true,
@@ -12536,11 +14130,11 @@ function registerActorSessionPersistenceTasks() {
     },
     "Validates and prepares actor_session_state payload for strict write-through persistence.",
     localActorSessionTaskOptions
-  ).then(insertAndValidateActorSessionStateTask).respondsTo(import_core3.META_ACTOR_SESSION_STATE_PERSIST_INTENT);
+  ).then(insertAndValidateActorSessionStateTask).respondsTo(import_core4.META_ACTOR_SESSION_STATE_PERSIST_INTENT);
 }
 
 // src/graph/controllers/GraphSyncController.ts
-var import_core4 = require("@cadenza.io/core");
+var import_core5 = require("@cadenza.io/core");
 var import_uuid6 = require("uuid");
 var ACTOR_TASK_METADATA2 = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata2(taskFunction) {
@@ -12601,6 +14195,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() : "";
@@ -12624,7 +14228,7 @@ function buildIntentRegistryData(intent) {
   };
 }
 function isLocalOnlySyncIntent(intentName) {
-  return intentName === import_core4.META_ACTOR_SESSION_STATE_PERSIST_INTENT;
+  return intentName === import_core5.META_ACTOR_SESSION_STATE_PERSIST_INTENT;
 }
 function getJoinedContextValue(ctx, key) {
   const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
@@ -12763,16 +14367,20 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ctx,
         queryData
       );
-      if ((tableName === "signal_registry" || tableName === "directional_task_graph_map") && originalQueryData.data && typeof originalQueryData.data === "object" && !Array.isArray(originalQueryData.data) && Object.keys(originalQueryData.data).length === 0) {
-        console.warn(
-          "[CADENZA_SYNC_EMPTY_INSERT]",
-          {
-            tableName,
-            queryData: originalQueryData,
-            ctx,
-            joinedContexts: Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : []
-          }
-        );
+      const hasEmptyObjectData = originalQueryData.data && typeof originalQueryData.data === "object" && !Array.isArray(originalQueryData.data) && Object.keys(originalQueryData.data).length === 0;
+      const hasMissingData = originalQueryData.data === void 0;
+      if ((tableName === "task" || tableName === "signal_registry" || tableName === "directional_task_graph_map") && (hasEmptyObjectData || hasMissingData)) {
+        console.warn("[CADENZA_SYNC_EMPTY_INSERT]", {
+          tableName,
+          hasMissingData,
+          hasEmptyObjectData,
+          taskName: typeof ctx.__taskName === "string" ? ctx.__taskName : void 0,
+          reason: typeof ctx.__reason === "string" ? ctx.__reason : void 0,
+          syncSourceServiceName: typeof ctx.__syncSourceServiceName === "string" ? ctx.__syncSourceServiceName : void 0,
+          queryData: originalQueryData,
+          ctx,
+          joinedContexts: Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : []
+        });
       }
       return buildSyncExecutionEnvelope(
         ctx,
@@ -12863,7 +14471,7 @@ function isBootstrapLocalOnlyActorName(actorName) {
   return BOOTSTRAP_LOCAL_ONLY_ACTOR_NAMES.has(actorName);
 }
 function isBootstrapLocalOnlySignal(signalName) {
-  return signalName.startsWith("meta.") || signalName === "meta.service_registry.insert_execution_requested" || signalName === "meta.service_registry.routeable_transport_missing" || signalName === "meta.signal_broker.added" || signalName === "meta.rest.handshake" || signalName === "meta.rest.delegation_target_not_found" || signalName === "meta.socket.handshake" || signalName === "meta.socket.delegation_target_not_found" || signalName === "meta.fetch.handshake_complete" || signalName === "sub_meta.signal_broker.new_trace" || signalName.startsWith("meta.task.") || signalName.startsWith("meta.sync_controller.") || isLocalServiceReadySignal(signalName);
+  return signalName.startsWith("meta.") || signalName.startsWith("global.meta.") || signalName === "meta.service_registry.insert_execution_requested" || signalName === "meta.service_registry.routeable_transport_missing" || signalName === "meta.signal_broker.added" || signalName === "meta.rest.handshake" || signalName === "meta.rest.delegation_target_not_found" || signalName === "meta.socket.handshake" || signalName === "meta.socket.delegation_target_not_found" || signalName === "meta.fetch.handshake_complete" || signalName === "sub_meta.signal_broker.new_trace" || signalName.startsWith("meta.task.") || signalName.startsWith("meta.sync_controller.") || isLocalServiceReadySignal(signalName);
 }
 function hasNonZeroPending(summary) {
   return Object.values(summary).some((value) => Number(value) > 0);
@@ -13091,6 +14699,12 @@ function resolveLocalRoutineFromSyncContext(ctx) {
   );
   return routineName ? CadenzaService.getRoutine(routineName) : void 0;
 }
+function shouldTrackDirectionalTaskMapForBootstrap(predecessorTask, nextTask) {
+  if (!predecessorTask || !nextTask) {
+    return false;
+  }
+  return predecessorTask.isMeta !== true && predecessorTask.isSubMeta !== true && nextTask.isMeta !== true && nextTask.isSubMeta !== true;
+}
 function resolveSignalNameFromSyncContext(ctx) {
   const candidateSignalNames = [
     ctx.signalName,
@@ -13708,40 +15322,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
           };
         }
@@ -14167,7 +15782,7 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const t of task.nextTasks) {
-          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered) {
+          if (task.taskMapRegistration.has(t.name) || t.hidden || !t.register || !t.registered || !shouldTrackDirectionalTaskMapForBootstrap(task, t)) {
             continue;
           }
           const serviceName2 = resolveSyncServiceName(t);
@@ -14235,7 +15850,7 @@ var GraphSyncController = class _GraphSyncController {
         return false;
       }
       for (const nextTask of task.nextTasks) {
-        if (task.taskMapRegistration.has(nextTask.name) || nextTask.isHidden || !nextTask.register || !nextTask.registered) {
+        if (task.taskMapRegistration.has(nextTask.name) || nextTask.isHidden || !nextTask.register || !nextTask.registered || !shouldTrackDirectionalTaskMapForBootstrap(task, nextTask)) {
           continue;
         }
         if (resolveSyncServiceName(nextTask)) {
@@ -14900,13 +16515,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
@@ -14948,40 +16600,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
@@ -15057,11 +16779,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;
 }
@@ -15139,6 +16887,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;
@@ -15202,10 +16953,10 @@ var GraphMetadataController = class _GraphMetadataController {
         task.registrationRequested = true;
       }
       return buildDatabaseTriggerContext(
-        {
+        sanitizePersistedTaskSourceFields2(task, {
           ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName
-        },
+        }),
         void 0,
         { onConflict },
         { onConflict }
@@ -15308,6 +17059,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;
@@ -15375,6 +17208,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,
@@ -15388,10 +17224,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 = {
@@ -15526,12 +17362,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
         );
       },
@@ -15545,10 +17382,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(
@@ -15781,12 +17618,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
         );
       },
@@ -16553,6 +18391,15 @@ var DEFAULT_DEPUTY_TASK_CONCURRENCY = 50;
 var DEFAULT_DEPUTY_TASK_TIMEOUT_MS = 12e4;
 var DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY = 50;
 var DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS = 12e4;
+var SERVICE_MANIFEST_PUBLICATION_ORDER = [
+  "routing_capability",
+  "business_structural",
+  "local_meta_structural"
+];
+function getServiceManifestPublicationLayerRank(layer) {
+  const index = SERVICE_MANIFEST_PUBLICATION_ORDER.indexOf(layer);
+  return index >= 0 ? index : SERVICE_MANIFEST_PUBLICATION_ORDER.length - 1;
+}
 var CadenzaService = class {
   static unregisterGracefulShutdownHandlers() {
     for (const cleanup of this.shutdownHandlerCleanup) {
@@ -16679,7 +18526,15 @@ var CadenzaService = class {
     this.replayRegisteredTaskSignalObservations();
     this.replayRegisteredTaskIntentAssociations();
   }
-  static requestServiceManifestPublication(reason, immediate = false) {
+  static normalizeServiceManifestPublicationLayer(value, fallback = "business_structural") {
+    return value === "routing_capability" || value === "business_structural" || value === "local_meta_structural" ? value : fallback;
+  }
+  static mergeServiceManifestPublicationRequest(reason, targetLayer) {
+    this.serviceManifestPublicationPendingReason = reason;
+    const currentTargetLayer = this.serviceManifestPublicationPendingLayer ?? "routing_capability";
+    this.serviceManifestPublicationPendingLayer = getServiceManifestPublicationLayerRank(targetLayer) >= getServiceManifestPublicationLayerRank(currentTargetLayer) ? targetLayer : currentTargetLayer;
+  }
+  static requestServiceManifestPublication(reason, immediate = false, targetLayer = "business_structural") {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
@@ -16687,7 +18542,8 @@ var CadenzaService = class {
     const payload = {
       __reason: reason,
       __serviceName: this.serviceRegistry.serviceName,
-      __serviceInstanceId: this.serviceRegistry.serviceInstanceId
+      __serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+      __publicationLayer: targetLayer
     };
     if (immediate) {
       this.emit(signalName, payload);
@@ -16695,32 +18551,53 @@ var CadenzaService = class {
     }
     this.debounce(signalName, payload, 100);
   }
-  static scheduleServiceManifestPublicationRetry(reason) {
+  static scheduleServiceManifestPublicationRetry(reason, targetLayer = "business_structural") {
     if (!this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return;
     }
     setTimeout(() => {
-      this.requestServiceManifestPublication(reason, false);
+      this.requestServiceManifestPublication(reason, false, targetLayer);
     }, 1e3);
   }
-  static async publishServiceManifestIfNeeded(reason) {
+  static async publishServiceManifestIfNeeded(reason, targetLayer = "business_structural") {
     if (!this.serviceRegistry.connectsToCadenzaDB || !this.serviceRegistry.serviceName || !this.serviceRegistry.serviceInstanceId) {
       return false;
     }
     const publishReason = typeof reason === "string" && reason.trim().length > 0 ? reason.trim() : "service_manifest_publish";
+    const publishTargetLayer = this.normalizeServiceManifestPublicationLayer(
+      targetLayer
+    );
     if (this.serviceManifestPublicationInFlight) {
-      this.serviceManifestPublicationPendingReason = publishReason;
+      this.mergeServiceManifestPublicationRequest(
+        publishReason,
+        publishTargetLayer
+      );
       return false;
     }
-    const snapshot = buildServiceManifestSnapshot({
-      serviceName: this.serviceRegistry.serviceName,
-      serviceInstanceId: this.serviceRegistry.serviceInstanceId,
-      revision: this.serviceManifestRevision + 1,
-      publishedAt: (/* @__PURE__ */ new Date()).toISOString()
+    const publicationPlan = SERVICE_MANIFEST_PUBLICATION_ORDER.filter(
+      (layer) => getServiceManifestPublicationLayerRank(layer) <= getServiceManifestPublicationLayerRank(publishTargetLayer)
+    ).map((layer) => {
+      const snapshot2 = buildServiceManifestSnapshot({
+        serviceName: this.serviceRegistry.serviceName,
+        serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+        revision: this.serviceManifestRevision + 1,
+        publishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        publicationLayer: layer
+      });
+      return {
+        layer,
+        snapshot: snapshot2,
+        changed: this.lastPublishedServiceManifestHashes[layer] !== snapshot2.manifestHash
+      };
     });
-    if (this.lastPublishedServiceManifestHash && this.lastPublishedServiceManifestHash === snapshot.manifestHash) {
+    const nextPublication = publicationPlan.find((entry) => entry.changed);
+    if (!nextPublication) {
       return false;
     }
+    const { layer: publicationLayer, snapshot } = nextPublication;
+    const hasPendingFollowupLayer = publicationPlan.some(
+      (entry) => entry.changed && getServiceManifestPublicationLayerRank(entry.layer) > getServiceManifestPublicationLayerRank(publicationLayer)
+    );
     this.serviceManifestPublicationInFlight = true;
     try {
       this.serviceRegistry.ensureBootstrapAuthorityControlPlaneForInquiry(
@@ -16728,7 +18605,10 @@ var CadenzaService = class {
         snapshot
       );
       if (!this.serviceRegistry.hasAuthorityBootstrapHandshakeEstablished()) {
-        this.scheduleServiceManifestPublicationRetry(publishReason);
+        this.scheduleServiceManifestPublicationRetry(
+          publishReason,
+          publishTargetLayer
+        );
         return false;
       }
       await this.inquire(AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT, snapshot, {
@@ -16736,32 +18616,48 @@ var CadenzaService = class {
         requireComplete: true
       });
       this.serviceManifestRevision = snapshot.revision;
-      this.lastPublishedServiceManifestHash = snapshot.manifestHash;
+      this.lastPublishedServiceManifestHashes[publicationLayer] = snapshot.manifestHash;
+      if (hasPendingFollowupLayer) {
+        this.mergeServiceManifestPublicationRequest(
+          publishReason,
+          publishTargetLayer
+        );
+      }
       return {
         serviceManifest: snapshot,
-        published: true
+        published: true,
+        publicationLayer
       };
     } catch (error) {
       this.log("Service manifest publication failed. Scheduling retry.", {
         serviceName: this.serviceRegistry.serviceName,
         serviceInstanceId: this.serviceRegistry.serviceInstanceId,
         reason: publishReason,
+        publicationLayer,
         error: resolveInquiryFailureError(
           AUTHORITY_SERVICE_MANIFEST_REPORT_INTENT,
           error
         ),
         inquiryMeta: error && typeof error === "object" && "__inquiryMeta" in error ? error.__inquiryMeta : null
       });
-      this.scheduleServiceManifestPublicationRetry(publishReason);
+      this.scheduleServiceManifestPublicationRetry(
+        publishReason,
+        publishTargetLayer
+      );
       return false;
     } finally {
       this.serviceManifestPublicationInFlight = false;
-      if (this.serviceManifestPublicationPendingReason) {
+      if (this.serviceManifestPublicationPendingReason && this.serviceManifestPublicationPendingLayer) {
         const pendingReason = this.serviceManifestPublicationPendingReason;
+        const pendingLayer = this.serviceManifestPublicationPendingLayer;
         this.serviceManifestPublicationPendingReason = null;
+        this.serviceManifestPublicationPendingLayer = null;
         this.debounce(
           "meta.service_manifest.publish_requested",
-          { __reason: pendingReason },
+          {
+            __reason: pendingReason,
+            __publicationLayer: pendingLayer
+          },
           100
         );
       }
@@ -16774,9 +18670,13 @@ var CadenzaService = class {
     this.createMetaTask(
       "Publish service manifest",
       async (ctx) => this.publishServiceManifestIfNeeded(
-        typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason.trim() : "service_manifest_publish"
+        typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason.trim() : "service_manifest_publish",
+        this.normalizeServiceManifestPublicationLayer(
+          ctx.__publicationLayer,
+          "business_structural"
+        )
       ),
-      "Publishes a full static manifest snapshot to authority when the manifest hash changes.",
+      "Publishes staged static manifest snapshots to authority when the manifest hash changes.",
       {
         register: false,
         isHidden: true
@@ -16786,13 +18686,18 @@ var CadenzaService = class {
       "Request manifest publication after structural change",
       (ctx) => {
         const reason = typeof ctx.signal === "string" && ctx.signal.trim().length > 0 ? ctx.signal : typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0 ? ctx.__reason : "manifest_structural_update";
+        const targetLayer = reason === "meta.service_registry.instance_inserted" ? "business_structural" : this.normalizeServiceManifestPublicationLayer(
+          ctx.__publicationLayer,
+          "business_structural"
+        );
         this.requestServiceManifestPublication(
           reason,
-          reason === "meta.service_registry.instance_inserted"
+          reason === "meta.service_registry.instance_inserted",
+          targetLayer
         );
         return true;
       },
-      "Requests a manifest publication when a static service primitive changes.",
+      "Requests staged manifest publication when a static service primitive changes.",
       {
         register: false,
         isHidden: true
@@ -16804,9 +18709,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",
@@ -16835,19 +18748,19 @@ var CadenzaService = class {
   static bootstrap() {
     if (this.isBootstrapped) return;
     this.isBootstrapped = true;
-    import_core5.default.bootstrap();
-    import_core5.default.setRuntimeInquiryDelegate(
+    import_core6.default.bootstrap();
+    import_core6.default.setRuntimeInquiryDelegate(
       (inquiry, context, options) => this.inquire(
         inquiry,
         context,
         options ?? {}
       )
     );
-    this.signalBroker = import_core5.default.signalBroker;
-    this.inquiryBroker = import_core5.default.inquiryBroker;
-    this.runner = import_core5.default.runner;
-    this.metaRunner = import_core5.default.metaRunner;
-    this.registry = import_core5.default.registry;
+    this.signalBroker = import_core6.default.signalBroker;
+    this.inquiryBroker = import_core6.default.inquiryBroker;
+    this.runner = import_core6.default.runner;
+    this.metaRunner = import_core6.default.metaRunner;
+    this.registry = import_core6.default.registry;
     this.serviceRegistry = ServiceRegistry.instance;
     RestController.instance;
     SocketController.instance;
@@ -16881,8 +18794,8 @@ var CadenzaService = class {
       return;
     }
     this.frontendSyncScheduled = true;
-    import_core5.default.interval("meta.sync_requested", { __syncing: false }, 18e4);
-    import_core5.default.schedule("meta.sync_requested", { __syncing: false }, 250);
+    import_core6.default.interval("meta.sync_requested", { __syncing: false }, 18e4);
+    import_core6.default.schedule("meta.sync_requested", { __syncing: false }, 250);
   }
   static normalizeDeclaredTransports(transports, serviceId, useSocket) {
     return (transports ?? []).map((transport) => normalizeServiceTransportConfig(transport)).filter(
@@ -16940,7 +18853,7 @@ var CadenzaService = class {
    * @return {void} Does not return any value.
    */
   static validateName(name) {
-    import_core5.default.validateName(name);
+    import_core6.default.validateName(name);
   }
   /**
    * Gets the current run strategy from the Cadenza configuration.
@@ -16948,7 +18861,7 @@ var CadenzaService = class {
    * @return {Function} The run strategy function defined in the Cadenza configuration.
    */
   static get runStrategy() {
-    return import_core5.default.runStrategy;
+    return import_core6.default.runStrategy;
   }
   /**
    * Sets the mode for the Cadenza application.
@@ -16957,7 +18870,7 @@ var CadenzaService = class {
    * @return {void} This method does not return a value.
    */
   static setMode(mode) {
-    import_core5.default.setMode(mode);
+    import_core6.default.setMode(mode);
   }
   static hasCompletedBootstrapSync() {
     return !this.serviceCreated || this.bootstrapSyncCompleted;
@@ -17000,16 +18913,16 @@ var CadenzaService = class {
    * ```
    */
   static emit(signal, data = {}, options = {}) {
-    import_core5.default.emit(signal, data, options);
+    import_core6.default.emit(signal, data, options);
   }
   static debounce(signal, context = {}, delayMs = 500) {
-    import_core5.default.debounce(signal, context, delayMs);
+    import_core6.default.debounce(signal, context, delayMs);
   }
   static schedule(signal, context, timeoutMs, exactDateTime) {
-    import_core5.default.schedule(signal, context, timeoutMs, exactDateTime);
+    import_core6.default.schedule(signal, context, timeoutMs, exactDateTime);
   }
   static interval(signal, context, intervalMs, leading = false, startDateTime) {
-    import_core5.default.interval(signal, context, intervalMs, leading, startDateTime);
+    import_core6.default.interval(signal, context, intervalMs, leading, startDateTime);
   }
   static defineIntent(intent) {
     this.inquiryBroker?.addIntent(intent);
@@ -17017,35 +18930,35 @@ var CadenzaService = class {
   }
   static getRuntimeValidationPolicy() {
     this.bootstrap();
-    return import_core5.default.getRuntimeValidationPolicy();
+    return import_core6.default.getRuntimeValidationPolicy();
   }
   static setRuntimeValidationPolicy(policy = {}) {
     this.bootstrap();
-    return import_core5.default.setRuntimeValidationPolicy(policy);
+    return import_core6.default.setRuntimeValidationPolicy(policy);
   }
   static replaceRuntimeValidationPolicy(policy = {}) {
     this.bootstrap();
-    return import_core5.default.replaceRuntimeValidationPolicy(policy);
+    return import_core6.default.replaceRuntimeValidationPolicy(policy);
   }
   static clearRuntimeValidationPolicy() {
     this.bootstrap();
-    import_core5.default.clearRuntimeValidationPolicy();
+    import_core6.default.clearRuntimeValidationPolicy();
   }
   static getRuntimeValidationScopes() {
     this.bootstrap();
-    return import_core5.default.getRuntimeValidationScopes();
+    return import_core6.default.getRuntimeValidationScopes();
   }
   static upsertRuntimeValidationScope(scope) {
     this.bootstrap();
-    return import_core5.default.upsertRuntimeValidationScope(scope);
+    return import_core6.default.upsertRuntimeValidationScope(scope);
   }
   static removeRuntimeValidationScope(id) {
     this.bootstrap();
-    import_core5.default.removeRuntimeValidationScope(id);
+    import_core6.default.removeRuntimeValidationScope(id);
   }
   static clearRuntimeValidationScopes() {
     this.bootstrap();
-    import_core5.default.clearRuntimeValidationScopes();
+    import_core6.default.clearRuntimeValidationScopes();
   }
   static getInquiryResponderDescriptor(task) {
     return this.serviceRegistry.getInquiryResponderDescriptor(task);
@@ -17407,7 +19320,7 @@ var CadenzaService = class {
     });
   }
   static get(taskName) {
-    return import_core5.default.get(taskName);
+    return import_core6.default.get(taskName);
   }
   static getLocalCadenzaDBTask(tableName, operation) {
     const generatedTaskName = this.buildGeneratedLocalCadenzaDBTaskName(
@@ -17418,7 +19331,7 @@ var CadenzaService = class {
       tableName,
       operation
     );
-    return import_core5.default.get(generatedTaskName) ?? import_core5.default.get(legacyTaskName);
+    return import_core6.default.get(generatedTaskName) ?? import_core6.default.get(legacyTaskName);
   }
   static getLocalCadenzaDBInsertTask(tableName) {
     return this.getLocalCadenzaDBTask(tableName, "insert");
@@ -17427,15 +19340,15 @@ var CadenzaService = class {
     return this.getLocalCadenzaDBTask(tableName, "query");
   }
   static getActor(actorName) {
-    const cadenzaWithActors = import_core5.default;
+    const cadenzaWithActors = import_core6.default;
     return cadenzaWithActors.getActor?.(actorName);
   }
   static getAllActors() {
-    const cadenzaWithActors = import_core5.default;
+    const cadenzaWithActors = import_core6.default;
     return cadenzaWithActors.getAllActors?.() ?? [];
   }
   static getRoutine(routineName) {
-    return import_core5.default.getRoutine(routineName);
+    return import_core6.default.getRoutine(routineName);
   }
   /**
    * Creates a new DeputyTask instance based on the provided routine name, service name, and options.
@@ -18047,10 +19960,28 @@ var CadenzaService = class {
       __isFrontend: isFrontend,
       __declaredTransports: declaredTransports
     };
+    let bootstrapServiceCreationRequested = false;
     if (options.cadenzaDB?.connect) {
-      this.createEphemeralMetaTask("Create service", async (context, emit2) => {
-        emit2("meta.create_service_requested", initContext);
-      }).doOn("meta.fetch.handshake_complete");
+      this.createMetaTask(
+        "Create service",
+        async (context, emit2) => {
+          const handshakeServiceName = String(context?.serviceName ?? "").trim();
+          if (handshakeServiceName !== "CadenzaDB") {
+            return false;
+          }
+          if (bootstrapServiceCreationRequested) {
+            return false;
+          }
+          bootstrapServiceCreationRequested = true;
+          emit2("meta.create_service_requested", initContext);
+          return true;
+        },
+        "Requests local service creation only once after the initial authority bootstrap handshake completes.",
+        {
+          register: false,
+          isHidden: true
+        }
+      ).doOn("meta.fetch.handshake_complete");
     } else {
       this.emit("meta.create_service_requested", initContext);
       this.createMetaTask("Create signal transmission for sync", (ctx, emit2) => {
@@ -18063,10 +19994,33 @@ var CadenzaService = class {
         );
       }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
+    let serviceSetupCompletedHandled = false;
     this.createMetaTask("Handle service setup completion", (ctx, emit2) => {
+      if (serviceSetupCompletedHandled) {
+        return false;
+      }
+      const insertedServiceInstanceId = String(
+        ctx?.serviceInstanceId ?? ctx?.service_instance_id ?? ctx?.serviceInstance?.uuid ?? ctx?.serviceInstance?.serviceInstanceId ?? ""
+      ).trim();
+      const insertedServiceName = String(
+        ctx?.serviceName ?? ctx?.service_name ?? ctx?.serviceInstance?.serviceName ?? ctx?.serviceInstance?.service_name ?? ""
+      ).trim();
+      if (!insertedServiceInstanceId && !insertedServiceName) {
+        return false;
+      }
+      if (insertedServiceInstanceId && insertedServiceInstanceId !== serviceId) {
+        return false;
+      }
+      if (!insertedServiceInstanceId && insertedServiceName && insertedServiceName !== serviceName) {
+        return false;
+      }
+      serviceSetupCompletedHandled = true;
       if (options.cadenzaDB?.connect) {
         this.serviceRegistry.bootstrapFullSync(emit2, ctx, "service_setup_completed");
-        void this.publishServiceManifestIfNeeded("service_setup_completed");
+        void this.publishServiceManifestIfNeeded(
+          "service_setup_completed",
+          "business_structural"
+        );
       }
       if (isFrontend) {
         registerActorSessionPersistenceTasks();
@@ -18076,7 +20030,7 @@ var CadenzaService = class {
       return true;
     }).doOn("meta.service_registry.instance_inserted");
     if (!options.cadenzaDB?.connect) {
-      import_core5.default.schedule(
+      import_core6.default.schedule(
         "meta.service_registry.instance_registration_requested",
         {
           data: {
@@ -18121,7 +20075,11 @@ var CadenzaService = class {
       );
     }
     this.serviceCreated = true;
-    this.requestServiceManifestPublication("service_created", true);
+    this.requestServiceManifestPublication(
+      "service_created",
+      true,
+      "routing_capability"
+    );
   }
   /**
    * Creates a Cadenza metadata service with the specified name, description, and options.
@@ -18382,7 +20340,7 @@ var CadenzaService = class {
   }
   static createActor(spec, options = {}) {
     this.bootstrap();
-    return import_core5.default.createActor(
+    return import_core6.default.createActor(
       spec,
       this.withActorSessionHydration(
         spec,
@@ -18392,7 +20350,7 @@ var CadenzaService = class {
   }
   static createActorFromDefinition(definition, options = {}) {
     this.bootstrap();
-    return import_core5.default.createActorFromDefinition(
+    return import_core6.default.createActorFromDefinition(
       definition,
       this.withActorSessionHydration(
         {
@@ -18430,7 +20388,7 @@ var CadenzaService = class {
       ...options,
       hydrateDurableState: async (actorKey) => {
         registerActorSessionPersistenceTasks();
-        const response = await import_core5.default.inquire(
+        const response = await import_core6.default.inquire(
           META_ACTOR_SESSION_STATE_HYDRATE_INTENT,
           {
             actor_name: actorName,
@@ -18533,7 +20491,7 @@ var CadenzaService = class {
    */
   static createTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createTask(name, func, description, options);
+    return import_core6.default.createTask(name, func, description, options);
   }
   /**
    * Creates a meta task with the specified name, functionality, description, and options.
@@ -18549,7 +20507,7 @@ var CadenzaService = class {
    */
   static createMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createMetaTask(name, func, description, options);
+    return import_core6.default.createMetaTask(name, func, description, options);
   }
   /**
    * Creates a unique task by wrapping the provided task function with a uniqueness constraint.
@@ -18599,7 +20557,7 @@ var CadenzaService = class {
    */
   static createUniqueTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createUniqueTask(name, func, description, options);
+    return import_core6.default.createUniqueTask(name, func, description, options);
   }
   /**
    * Creates a unique meta task with the specified name, function, description, and options.
@@ -18613,7 +20571,7 @@ var CadenzaService = class {
    */
   static createUniqueMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createUniqueMetaTask(name, func, description, options);
+    return import_core6.default.createUniqueMetaTask(name, func, description, options);
   }
   /**
    * Creates a throttled task with a concurrency limit of 1, ensuring that only one instance of the task can run at a time for a specific throttle tag.
@@ -18646,7 +20604,7 @@ var CadenzaService = class {
    */
   static createThrottledTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createThrottledTask(
+    return import_core6.default.createThrottledTask(
       name,
       func,
       throttledIdGetter,
@@ -18667,7 +20625,7 @@ var CadenzaService = class {
    */
   static createThrottledMetaTask(name, func, throttledIdGetter = () => "default", description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createThrottledMetaTask(
+    return import_core6.default.createThrottledMetaTask(
       name,
       func,
       throttledIdGetter,
@@ -18710,7 +20668,7 @@ var CadenzaService = class {
    */
   static createDebounceTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core5.default.createDebounceTask(
+    return import_core6.default.createDebounceTask(
       name,
       func,
       description,
@@ -18731,7 +20689,7 @@ var CadenzaService = class {
    */
   static createDebounceMetaTask(name, func, description, debounceTime = 1e3, options = {}) {
     this.bootstrap();
-    return import_core5.default.createDebounceMetaTask(
+    return import_core6.default.createDebounceMetaTask(
       name,
       func,
       description,
@@ -18801,7 +20759,7 @@ var CadenzaService = class {
    */
   static createEphemeralTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createEphemeralTask(name, func, description, options);
+    return import_core6.default.createEphemeralTask(name, func, description, options);
   }
   /**
    * Creates an ephemeral meta-task with the specified name, function, description, and options.
@@ -18815,7 +20773,7 @@ var CadenzaService = class {
    */
   static createEphemeralMetaTask(name, func, description, options = {}) {
     this.bootstrap();
-    return import_core5.default.createEphemeralMetaTask(name, func, description, options);
+    return import_core6.default.createEphemeralMetaTask(name, func, description, options);
   }
   /**
    * Creates a new routine with the specified name, tasks, and an optional description.
@@ -18847,7 +20805,7 @@ var CadenzaService = class {
    */
   static createRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core5.default.createRoutine(name, tasks, description);
+    return import_core6.default.createRoutine(name, tasks, description);
   }
   /**
    * Creates a meta routine with a given name, tasks, and optional description.
@@ -18862,10 +20820,10 @@ var CadenzaService = class {
    */
   static createMetaRoutine(name, tasks, description = "") {
     this.bootstrap();
-    return import_core5.default.createMetaRoutine(name, tasks, description);
+    return import_core6.default.createMetaRoutine(name, tasks, description);
   }
   static reset() {
-    import_core5.default.reset();
+    import_core6.default.reset();
     this.serviceRegistry?.reset();
     this.unregisterGracefulShutdownHandlers();
     this.isBootstrapped = false;
@@ -18877,6 +20835,11 @@ var CadenzaService = class {
     this.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
     this.hydratedInquiryResults = /* @__PURE__ */ new Map();
     this.frontendSyncScheduled = false;
+    this.serviceManifestRevision = 0;
+    this.lastPublishedServiceManifestHashes = {};
+    this.serviceManifestPublicationInFlight = false;
+    this.serviceManifestPublicationPendingReason = null;
+    this.serviceManifestPublicationPendingLayer = null;
     resetBrowserRuntimeActorHandles();
   }
 };
@@ -18890,15 +20853,16 @@ CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
 CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();
 CadenzaService.frontendSyncScheduled = false;
 CadenzaService.serviceManifestRevision = 0;
-CadenzaService.lastPublishedServiceManifestHash = null;
+CadenzaService.lastPublishedServiceManifestHashes = {};
 CadenzaService.serviceManifestPublicationInFlight = false;
 CadenzaService.serviceManifestPublicationPendingReason = null;
+CadenzaService.serviceManifestPublicationPendingLayer = null;
 CadenzaService.shutdownHandlersRegistered = false;
 CadenzaService.shutdownInFlight = false;
 CadenzaService.shutdownHandlerCleanup = [];
 
 // src/index.ts
-var import_core6 = require("@cadenza.io/core");
+var import_core7 = require("@cadenza.io/core");
 
 // src/ssr/createSSRInquiryBridge.ts
 var import_uuid8 = require("uuid");
@@ -18920,6 +20884,17 @@ function normalizeArrayResponse(value, keys) {
   if (Array.isArray(value?.data)) {
     return value.data;
   }
+  const joinedContexts = Array.isArray(value?.joinedContexts) ? value.joinedContexts : [];
+  for (let index = joinedContexts.length - 1; index >= 0; index -= 1) {
+    const nested = joinedContexts[index];
+    if (!nested || typeof nested !== "object") {
+      continue;
+    }
+    const rows = normalizeArrayResponse(nested, keys);
+    if (rows.length > 0) {
+      return rows;
+    }
+  }
   return [];
 }
 function buildQueryResponseKeys(tableName) {