@cadenza.io/service 2.20.0 → 2.21.0

package/dist/index.mjs

@@ -21,6 +21,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;
@@ -47,8 +71,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("__"))
@@ -79,14 +175,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;
 }
@@ -122,9 +259,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;
   }
@@ -145,6 +282,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 } : {}
@@ -176,6 +333,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 = uuid2();
+    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 Task {
   /**
    * Constructs a new instance of the class with the specified parameters.
@@ -203,87 +444,9 @@ var DeputyTask = class extends 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 = uuid2();
-        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,
@@ -315,6 +478,11 @@ var DeputyTask = class extends 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.
    *
@@ -358,12 +526,32 @@ var DeputyTask = class extends 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",
@@ -425,6 +613,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.
    *
@@ -465,15 +658,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({
@@ -533,7 +727,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
+    );
   }
 };
 
@@ -578,6 +806,26 @@ var AUTHORITY_SYNC_DEBUG_TASK_NAMES = /* @__PURE__ */ new Set([
 ]);
 var AUTHORITY_SYNC_DEBUG_ROUTINE_NAMES = /* @__PURE__ */ new Set(["Sync services"]);
 var INTENT_MAP_DEBUG_ENABLED = process.env.CADENZA_INTENT_MAP_DEBUG === "1" || process.env.CADENZA_INTENT_MAP_DEBUG === "true";
+function normalizeQueryResultValue(value) {
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+  if (Array.isArray(value)) {
+    return value.map((entry) => normalizeQueryResultValue(entry));
+  }
+  if (value && typeof value === "object") {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype === Object.prototype || prototype === null) {
+      return Object.fromEntries(
+        Object.entries(value).map(([key, nestedValue]) => [
+          key,
+          normalizeQueryResultValue(nestedValue)
+        ])
+      );
+    }
+  }
+  return value;
+}
 var POSTGRES_SETUP_DEBUG_ENABLED = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
 var ACTOR_SESSION_TRACE_ENABLED2 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
 var ACTOR_SESSION_TRACE_LIMIT = 20;
@@ -875,14 +1123,14 @@ function errorMessage(error) {
   }
   return String(error);
 }
-function isPlainObject(value) {
+function isPlainObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function stableStringify(value) {
   if (Array.isArray(value)) {
     return `[${value.map((item) => stableStringify(item)).join(",")}]`;
   }
-  if (isPlainObject(value)) {
+  if (isPlainObject2(value)) {
     return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(value[key])}`).join(",")}}`;
   }
   return JSON.stringify(value);
@@ -998,7 +1246,23 @@ function resolveGeneratedTaskTag(tableName, actorToken, context, operation) {
   if (operation === "insert") {
     return `insert:${actorToken}:${tableName}`;
   }
-  return context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default";
+  const traceScopedTag = context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? context?.__metadata?.__deputyExecId ?? context?.__deputyExecId ?? context?.__metadata?.__inquiryId ?? context?.__inquiryId ?? context?.__metadata?.__routineExecId ?? context?.__routineExecId ?? context?.__metadata?.__localRoutineExecId ?? context?.__localRoutineExecId;
+  if (typeof traceScopedTag === "string" && traceScopedTag.length > 0) {
+    return traceScopedTag;
+  }
+  const queryScope = {
+    queryData: context?.queryData,
+    filter: context?.filter,
+    fields: context?.fields,
+    joins: context?.joins,
+    sort: context?.sort,
+    limit: context?.limit,
+    offset: context?.offset,
+    queryMode: context?.queryMode,
+    aggregates: context?.aggregates,
+    groupBy: context?.groupBy
+  };
+  return `read:${actorToken}:${tableName}:${stableStringify(queryScope)}`;
 }
 function resolveExecutionObservabilitySafetyPolicyForTable(basePolicy, tableName) {
   if (!EXECUTION_OBSERVABILITY_TABLES.has(tableName)) {
@@ -1080,6 +1344,44 @@ function mergeTriggerQueryData(context, triggerQueryData) {
     ...triggerQueryData
   };
 }
+function isNonEmptyPlainObject(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && Object.keys(value).length > 0;
+}
+function isMissingInsertData(data) {
+  return !data || Array.isArray(data) && data.length === 0 || typeof data === "object" && !Array.isArray(data) && Object.keys(data).length === 0;
+}
+function resolveActorSessionDelegationSnapshot(context) {
+  const direct = context.__delegationRequestContext && typeof context.__delegationRequestContext === "object" ? context.__delegationRequestContext : null;
+  if (direct) {
+    return direct;
+  }
+  const metadata = context.__metadata && typeof context.__metadata === "object" ? context.__metadata : null;
+  const nested = metadata?.__delegationRequestContext && typeof metadata.__delegationRequestContext === "object" ? metadata.__delegationRequestContext : null;
+  return nested;
+}
+function recoverActorSessionInsertPayload(context, payload) {
+  if (!isMissingInsertData(payload.data)) {
+    return payload;
+  }
+  const snapshot = resolveActorSessionDelegationSnapshot(context);
+  if (!snapshot) {
+    return payload;
+  }
+  const snapshotQueryData = snapshot.queryData && typeof snapshot.queryData === "object" ? { ...snapshot.queryData } : {};
+  const snapshotData = isNonEmptyPlainObject(snapshotQueryData.data) ? snapshotQueryData.data : isNonEmptyPlainObject(snapshot.data) ? snapshot.data : null;
+  if (!snapshotData) {
+    return payload;
+  }
+  const recoveredPayload = {
+    ...snapshotQueryData,
+    ...payload,
+    data: snapshotData
+  };
+  if (recoveredPayload.onConflict === void 0 && snapshotQueryData.onConflict) {
+    recoveredPayload.onConflict = snapshotQueryData.onConflict;
+  }
+  return recoveredPayload;
+}
 function resolveOperationPayload(context) {
   const queryData = typeof context.queryData === "object" && context.queryData ? context.queryData : {};
   return mergeTriggerQueryData(context, queryData);
@@ -1807,6 +2109,23 @@ var DatabaseController = class _DatabaseController {
   async insertFunction(registration, tableName, context) {
     const { data, transaction = true, fields = [], onConflict } = context;
     if (!data || Array.isArray(data) && data.length === 0) {
+      if (tableName === "actor_session_state") {
+        const rawContext = context;
+        const rawMetadata = rawContext.__metadata && typeof rawContext.__metadata === "object" ? rawContext.__metadata : void 0;
+        console.warn("[CADENZA_ACTOR_SESSION_EMPTY_INSERT]", {
+          tableName,
+          contextKeys: Object.keys(context ?? {}),
+          queryDataKeys: [],
+          hasDelegationSnapshot: rawContext.__delegationRequestContext !== void 0 || rawMetadata?.__delegationRequestContext !== void 0,
+          localTaskName: typeof rawContext.__localTaskName === "string" ? rawContext.__localTaskName : void 0,
+          remoteRoutineName: typeof rawContext.__remoteRoutineName === "string" ? rawContext.__remoteRoutineName : void 0,
+          serviceName: typeof rawContext.__serviceName === "string" ? rawContext.__serviceName : void 0,
+          actorName: typeof rawContext.actor_name === "string" ? rawContext.actor_name : void 0,
+          actorKey: typeof rawContext.actor_key === "string" ? rawContext.actor_key : void 0,
+          durableVersion: rawContext.durable_version,
+          metadata: rawMetadata
+        });
+      }
       return {
         rowCount: 0,
         errored: true,
@@ -2876,9 +3195,18 @@ var DatabaseController = class _DatabaseController {
             }
           }
         }
-        const operationPayload = resolveOperationPayload(context);
+        const initialOperationPayload = resolveOperationPayload(context);
+        let operationPayload = initialOperationPayload;
+        if (tableName === "actor_session_state" && op === "insert") {
+          operationPayload = recoverActorSessionInsertPayload(
+            context,
+            operationPayload
+          );
+        }
         const actorSessionInsertData = operationPayload.data;
-        const actorSessionInsertMissingData = !actorSessionInsertData || Array.isArray(actorSessionInsertData) && actorSessionInsertData.length === 0 || typeof actorSessionInsertData === "object" && !Array.isArray(actorSessionInsertData) && Object.keys(actorSessionInsertData).length === 0;
+        const actorSessionInsertMissingData = isMissingInsertData(
+          actorSessionInsertData
+        );
         if (tableName === "actor_session_state" && op === "insert" && actorSessionInsertMissingData) {
           logActorSessionTrace("empty_insert_payload", {
             taskName,
@@ -2894,7 +3222,10 @@ var DatabaseController = class _DatabaseController {
             payloadDataType: actorSessionInsertData === null ? "null" : Array.isArray(actorSessionInsertData) ? "array" : typeof actorSessionInsertData,
             payloadDataKeys: actorSessionInsertData && typeof actorSessionInsertData === "object" && !Array.isArray(actorSessionInsertData) ? Object.keys(actorSessionInsertData) : [],
             queryDataKeys: context.queryData && typeof context.queryData === "object" && !Array.isArray(context.queryData) ? Object.keys(context.queryData) : [],
-            rootKeys: Object.keys(context ?? {}).slice(0, 24)
+            rootKeys: Object.keys(context ?? {}).slice(0, 24),
+            initialPayloadMissingData: isMissingInsertData(
+              initialOperationPayload.data
+            )
           });
         }
         const shouldDebugAuthoritySync = shouldDebugAuthoritySyncPayload(
@@ -3189,7 +3520,7 @@ var DatabaseController = class _DatabaseController {
     return rows.map((row) => {
       const camelCasedRow = {};
       for (const [key, value] of Object.entries(row)) {
-        camelCasedRow[camelCase(key)] = value;
+        camelCasedRow[camelCase(key)] = normalizeQueryResultValue(value);
       }
       return camelCasedRow;
     });
@@ -3624,14 +3955,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 isPlainObject2(value) {
+function isPlainObject3(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 (isPlainObject2(left) && isPlainObject2(right)) {
+  if (isPlainObject3(left) && isPlainObject3(right)) {
     const merged = { ...left };
     const keys = Array.from(/* @__PURE__ */ new Set([...Object.keys(left), ...Object.keys(right)])).sort();
     for (const key of keys) {
@@ -3875,6 +4206,10 @@ function normalizeServiceInstanceDescriptor(value) {
     return null;
   }
   const transports = normalizeTransportArray(raw.transports, uuid10);
+  const leaseStatusRaw = normalizeString2(raw.leaseStatus ?? raw.lease_status);
+  const leaseStatus = leaseStatusRaw === "active" || leaseStatusRaw === "non_responsive" || leaseStatusRaw === "inactive" || leaseStatusRaw === "deleted" ? leaseStatusRaw : void 0;
+  const isActive = leaseStatus === "active" ? true : leaseStatus === "non_responsive" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : Boolean(raw.isActive ?? raw.is_active ?? true);
+  const isNonResponsive = leaseStatus === "non_responsive" ? true : leaseStatus === "active" || leaseStatus === "inactive" || leaseStatus === "deleted" ? false : Boolean(raw.isNonResponsive ?? raw.is_non_responsive ?? false);
   return {
     uuid: uuid10,
     serviceName,
@@ -3885,10 +4220,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,
@@ -4341,6 +4682,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;
@@ -4369,6 +4765,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,
@@ -4379,7 +4786,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(
@@ -4388,22 +4795,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) {
@@ -4416,18 +4823,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";
@@ -4453,16 +4895,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) {
@@ -4582,6 +5031,7 @@ function decomposeSignalName(signalName) {
 }
 
 // src/registry/serviceManifest.ts
+import CoreCadenza from "@cadenza.io/core";
 var ACTOR_TASK_METADATA = /* @__PURE__ */ Symbol.for("@cadenza.io/core/actor-task-meta");
 function getActorTaskRuntimeMetadata(taskFunction) {
   if (typeof taskFunction !== "function") {
@@ -4725,15 +5175,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(
+    CoreCadenza.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(
@@ -4745,6 +5270,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)) {
@@ -4828,6 +5357,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;
@@ -4859,18 +5419,56 @@ function buildServiceManifestSnapshot(params) {
   ).sort(
     (left, right) => `${left.name}:${left.version}`.localeCompare(`${right.name}:${right.version}`)
   );
-  for (const routine of routines) {
-    for (const task of routine.tasks) {
-      if (!task) {
+  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 iterator = task.getIterator();
-      while (iterator.hasNext()) {
-        const nextTask = iterator.next();
-        if (!nextTask || !shouldExportTask(nextTask)) {
-          continue;
-        }
-        const key = `${routine.name}|${routine.version}|${nextTask.name}|${nextTask.version}|${serviceName}`;
+      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) {
+        continue;
+      }
+      const iterator = task.getIterator();
+      while (iterator.hasNext()) {
+        const nextTask = iterator.next();
+        if (!nextTask || !shouldExportTask(nextTask)) {
+          continue;
+        }
+        const key = `${routine.name}|${routine.version}|${nextTask.name}|${nextTask.version}|${serviceName}`;
         taskToRoutineMaps.set(key, {
           task_name: nextTask.name,
           task_version: nextTask.version,
@@ -4881,41 +5479,506 @@ 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}`
+  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]
       )
-    ),
-    actorTaskMaps: Array.from(actorTaskMaps.values()).sort(
-      (left, right) => `${left.actor_name}:${left.task_name}`.localeCompare(
-        `${right.actor_name}:${right.task_name}`
+    ).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]
       )
-    ),
-    taskToRoutineMaps: Array.from(taskToRoutineMaps.values()).sort(
-      (left, right) => `${left.routine_name}:${left.task_name}`.localeCompare(
-        `${right.routine_name}:${right.task_name}`
+    ).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,
@@ -4959,6 +6022,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}`,
@@ -4994,17 +6071,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
   };
 }
 
@@ -5053,7 +6164,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) {
@@ -5071,7 +6228,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) {
@@ -5098,8 +6256,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;
@@ -5155,7 +6456,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;
   }
@@ -5185,6 +6487,7 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
     ).trim();
     if (resolvedServiceName) {
       result.__serviceName = resolvedServiceName;
+      result.serviceName = resolvedServiceName;
     }
   }
   const resolvedLocalServiceInstanceId = String(
@@ -5193,6 +6496,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 ?? ""
@@ -5292,9 +6607,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,
@@ -5307,9 +6628,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(
@@ -5361,108 +6680,6 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
     `Resolve service registry insert for ${tableName}`,
     (ctx, emit2) => new Promise((resolve) => {
       const resolverRequestId = uuid3();
-      CadenzaService.createEphemeralMetaTask(
-        `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
-        (resultCtx) => {
-          if (tableName === "service_instance" && shouldTraceServiceRegistry(
-            resolveServiceNameFromContext(
-              resultCtx.__resolverOriginalContext ?? resultCtx ?? ctx
-            ) || CadenzaService.serviceRegistry.serviceName
-          )) {
-            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] resolver_service_instance_signal", {
-              localServiceName: CadenzaService.serviceRegistry.serviceName,
-              resolverRequestId,
-              incomingResolverRequestId: resultCtx.__resolverRequestId ?? null,
-              keys: resultCtx && typeof resultCtx === "object" ? Object.keys(resultCtx) : []
-            });
-          }
-          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_signal", {
-              tableName,
-              resolverRequestId,
-              incomingResolverRequestId: resultCtx.__resolverRequestId ?? null,
-              errored: resultCtx.errored === true,
-              error: resultCtx.__error ?? null,
-              keys: resultCtx && typeof resultCtx === "object" ? Object.keys(resultCtx) : []
-            });
-          }
-          if (resultCtx.__resolverRequestId !== resolverRequestId) {
-            return false;
-          }
-          const normalizedResult = normalizeServiceRegistryInsertResult(
-            tableName,
-            resultCtx.__resolverOriginalContext ?? ctx,
-            resultCtx.__resolverQueryData ?? resultCtx.queryData ?? ctx.queryData ?? {},
-            resultCtx
-          );
-          if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
-            console.log("[CADENZA_INSTANCE_DEBUG] finalize_service_registry_insert", {
-              tableName,
-              hasNormalized: !!normalizedResult,
-              normalizedKeys: normalizedResult && typeof normalizedResult === "object" ? Object.keys(normalizedResult) : [],
-              uuid: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.uuid ?? normalizedResult.data?.uuid ?? normalizedResult.queryData?.data?.uuid ?? null : null,
-              serviceName: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__serviceName ?? normalizedResult.data?.service_name ?? normalizedResult.queryData?.data?.service_name ?? null : null,
-              errored: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.errored === true : false,
-              error: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__error ?? null : null,
-              inquiryMeta: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__inquiryMeta ?? null : null
-            });
-          }
-          if (normalizedResult && typeof normalizedResult === "object" && tableName === "service_instance_transport" && shouldTraceServiceRegistry(
-            resolveServiceNameFromContext(
-              resultCtx.__resolverOriginalContext ?? resultCtx
-            ) || CadenzaService.serviceRegistry.serviceName
-          )) {
-            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] finalize_transport_insert_execution", {
-              localServiceName: CadenzaService.serviceRegistry.serviceName,
-              serviceName: resolveServiceNameFromContext(
-                resultCtx.__resolverOriginalContext ?? resultCtx
-              ) || 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);
@@ -5481,6 +6698,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       if (bootstrapAuthorityInsertSpec) {
         const sanitizedContext = sanitizeServiceRegistryInsertExecutionContext(ctx);
         const nextQueryData = buildServiceRegistryInsertQueryData(
+          tableName,
           sanitizedContext,
           queryData
         );
@@ -5548,6 +6766,110 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         wireExecutionTarget(localInsertTask, prepareLocalExecutionTask);
         wiredLocalTaskNames.add(localInsertTask.name);
       }
+      CadenzaService.createEphemeralMetaTask(
+        `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
+        (resultCtx) => {
+          if (tableName === "service_instance" && shouldTraceServiceRegistry(
+            resolveServiceNameFromContext(
+              resultCtx.__resolverOriginalContext ?? resultCtx ?? ctx
+            ) || CadenzaService.serviceRegistry.serviceName
+          )) {
+            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] resolver_service_instance_signal", {
+              localServiceName: CadenzaService.serviceRegistry.serviceName,
+              resolverRequestId,
+              incomingResolverRequestId: resultCtx.__resolverRequestId ?? null,
+              keys: resultCtx && typeof resultCtx === "object" ? Object.keys(resultCtx) : []
+            });
+          }
+          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_signal", {
+              tableName,
+              resolverRequestId,
+              incomingResolverRequestId: resultCtx.__resolverRequestId ?? null,
+              errored: resultCtx.errored === true,
+              error: resultCtx.__error ?? null,
+              keys: resultCtx && typeof resultCtx === "object" ? Object.keys(resultCtx) : []
+            });
+          }
+          if (resultCtx.__resolverRequestId !== resolverRequestId) {
+            return false;
+          }
+          const normalizedResult = normalizeServiceRegistryInsertResult(
+            tableName,
+            resultCtx.__resolverOriginalContext ?? ctx,
+            resultCtx.__resolverQueryData ?? resultCtx.queryData ?? ctx.queryData ?? {},
+            resultCtx
+          );
+          if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+            console.log("[CADENZA_INSTANCE_DEBUG] finalize_service_registry_insert", {
+              tableName,
+              hasNormalized: !!normalizedResult,
+              normalizedKeys: normalizedResult && typeof normalizedResult === "object" ? Object.keys(normalizedResult) : [],
+              uuid: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.uuid ?? normalizedResult.data?.uuid ?? normalizedResult.queryData?.data?.uuid ?? null : null,
+              serviceName: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__serviceName ?? normalizedResult.data?.service_name ?? normalizedResult.queryData?.data?.service_name ?? null : null,
+              errored: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.errored === true : false,
+              error: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__error ?? null : null,
+              inquiryMeta: normalizedResult && typeof normalizedResult === "object" ? normalizedResult.__inquiryMeta ?? null : null
+            });
+          }
+          if (normalizedResult && typeof normalizedResult === "object" && tableName === "service_instance_transport" && shouldTraceServiceRegistry(
+            resolveServiceNameFromContext(
+              resultCtx.__resolverOriginalContext ?? resultCtx
+            ) || CadenzaService.serviceRegistry.serviceName
+          )) {
+            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] finalize_transport_insert_execution", {
+              localServiceName: CadenzaService.serviceRegistry.serviceName,
+              serviceName: resolveServiceNameFromContext(
+                resultCtx.__resolverOriginalContext ?? resultCtx
+              ) || 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,
+          once: false,
+          destroyCondition: (result) => result !== false
+        }
+      ).doOn(executionResolvedSignal, executionFailedSignal);
       emit2(executionSignal, {
         ...ctx,
         __resolverRequestId: resolverRequestId
@@ -5572,6 +6894,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,
@@ -5621,6 +6954,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
@@ -5669,6 +7005,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;
@@ -5915,6 +7263,9 @@ var ServiceRegistry = class _ServiceRegistry {
           ctx.deleted ?? ctx.serviceInstance?.deleted ?? ctx.data?.deleted
         );
         if (uuid10 === this.serviceInstanceId) return;
+        if (serviceName === this.serviceName) {
+          return false;
+        }
         if (deleted) {
           const existingInstance = this.instances.get(serviceName)?.find((instance) => instance.uuid === uuid10);
           const indexToDelete = this.instances.get(serviceName)?.findIndex((i) => i.uuid === uuid10) ?? -1;
@@ -6001,9 +7352,6 @@ var ServiceRegistry = class _ServiceRegistry {
             emit2
           );
         }
-        if (this.serviceName === serviceName) {
-          return false;
-        }
         if (trackedInstance?.isFrontend) {
           return true;
         }
@@ -6057,6 +7405,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(
@@ -6644,6 +7995,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"
         ]);
@@ -6668,6 +8025,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
         );
@@ -6701,6 +8074,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,
@@ -6726,6 +8101,8 @@ var ServiceRegistry = class _ServiceRegistry {
           serviceInstanceTransports,
           serviceManifests,
           tasks,
+          helpers,
+          globals,
           signals,
           intents,
           actors,
@@ -6733,6 +8110,10 @@ var ServiceRegistry = class _ServiceRegistry {
           directionalTaskMaps,
           actorTaskMaps,
           taskToRoutineMaps,
+          taskToHelperMaps,
+          helperToHelperMaps,
+          taskToGlobalMaps,
+          helperToGlobalMaps,
           __inquiryMeta: inquiryResult.__inquiryMeta
         };
       },
@@ -7352,29 +8733,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;
       },
@@ -8379,11 +9782,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 = [];
@@ -8391,11 +9797,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();
@@ -8403,6 +9816,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) {
@@ -8433,6 +9850,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",
@@ -8463,6 +9886,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,
@@ -8483,6 +9912,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(
@@ -8517,10 +9948,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],
@@ -8549,9 +9993,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((uuid10) => uuid10.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
     );
@@ -8571,6 +10046,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,
@@ -8631,10 +10122,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 ?? ""
@@ -8646,7 +10181,7 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!hasExplicitIntentRoutingRows) {
       pushUnique(
         explodedManifest.intentToTaskMaps,
-        intentToTaskMaps,
+        filteredIntentToTaskMaps,
         seenIntentMaps,
         (row) => `${String(row.intent_name ?? "").trim()}|${String(
           row.service_name ?? ""
@@ -8656,10 +10191,13 @@ var ServiceRegistry = class _ServiceRegistry {
       );
     }
     return {
-      serviceInstances,
-      serviceInstanceTransports,
+      serviceInstances: filteredServiceInstances,
+      serviceInstanceLeases,
+      serviceInstanceTransports: filteredServiceInstanceTransports,
       serviceManifests,
       tasks,
+      helpers,
+      globals,
       signals,
       intents,
       actors,
@@ -8667,8 +10205,12 @@ var ServiceRegistry = class _ServiceRegistry {
       directionalTaskMaps,
       actorTaskMaps,
       taskToRoutineMaps,
-      signalToTaskMaps,
-      intentToTaskMaps
+      taskToHelperMaps,
+      helperToHelperMaps,
+      taskToGlobalMaps,
+      helperToGlobalMaps,
+      signalToTaskMaps: filteredSignalToTaskMaps,
+      intentToTaskMaps: filteredIntentToTaskMaps
     };
   }
   buildRemoteIntentDeputyKey(map) {
@@ -9097,29 +10639,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`, {
@@ -9132,22 +10677,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
       };
@@ -9274,12 +10819,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"
           ),
@@ -9292,6 +10839,7 @@ var ServiceRegistry = class _ServiceRegistry {
           __syncing: true,
           ...this.collectBootstrapFullSyncPayload({
             serviceInstances,
+            serviceInstanceLeases,
             serviceInstanceTransports,
             serviceManifests,
             signalToTaskMaps,
@@ -9324,9 +10872,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({
@@ -9474,6 +11027,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;
@@ -9551,8 +11129,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;
@@ -11455,6 +13036,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,
@@ -11467,22 +13060,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) {
@@ -11523,12 +13114,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;
@@ -11537,13 +13130,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);
@@ -11715,15 +13302,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);
@@ -12077,6 +13669,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;
@@ -12228,6 +13846,7 @@ var ServiceRegistry = class _ServiceRegistry {
     };
   }
   reset() {
+    this.clearBootstrapFullSyncRetryTimer();
     this.instances.clear();
     this.deputies.clear();
     this.remoteSignals.clear();
@@ -12251,6 +13870,23 @@ var ServiceRegistry = class _ServiceRegistry {
     this.lastRuntimeStatusSnapshot = null;
     this.isFrontend = false;
     this.localInstanceSeed = null;
+    this.bootstrapFullSyncRetryIndex = 0;
+    this.bootstrapFullSyncRetryGeneration = 0;
+    this.bootstrapFullSyncSatisfied = false;
+    this.bootstrapFullSyncRetryReason = null;
+    this.knownGlobalSignalMaps.clear();
+    this.authorityBootstrapRoute = {
+      origin: null,
+      role: "internal",
+      routeKey: null,
+      fetchId: null,
+      serviceInstanceId: null,
+      serviceTransportId: null,
+      handshakeEstablished: false
+    };
+    this.authorityBootstrapHandshakeInFlight = false;
+    this.authorityFullSyncResponderTask = null;
+    this.authorityServiceCommunicationPersistenceTask = null;
   }
 };
 
@@ -12359,7 +13995,25 @@ var SignalTransmissionTask = class extends Task2 {
         ...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
+    );
   }
 };
 
@@ -12384,6 +14038,41 @@ var TRACED_INQUIRY_METADATA_SIGNALS = /* @__PURE__ */ new Set([
   "global.meta.graph_metadata.inquiry_updated"
 ]);
 var ACTOR_SESSION_TRACE_ENABLED3 = process.env.CADENZA_ACTOR_SESSION_TRACE === "1" || process.env.CADENZA_ACTOR_SESSION_TRACE === "true";
+function summarizeRequestBodyForLogging(body) {
+  if (typeof body !== "string") {
+    return body;
+  }
+  const summary = {
+    bodyLength: body.length
+  };
+  try {
+    const parsed = JSON.parse(body);
+    const queryData = parsed.queryData && typeof parsed.queryData === "object" ? parsed.queryData : null;
+    const queryDataData = queryData?.data && typeof queryData.data === "object" ? queryData.data : null;
+    const data = parsed.data && typeof parsed.data === "object" ? parsed.data : null;
+    summary.rootKeys = Object.keys(parsed).slice(0, 24);
+    summary.remoteRoutineName = typeof parsed.__remoteRoutineName === "string" ? parsed.__remoteRoutineName : null;
+    summary.serviceName = typeof parsed.__serviceName === "string" ? parsed.__serviceName : null;
+    summary.authorityBootstrapChannel = parsed.__authorityBootstrapChannel === true || parsed.__metadata?.__authorityBootstrapChannel === true;
+    summary.hasData = data !== null;
+    summary.dataKeys = data ? Object.keys(data).slice(0, 24) : [];
+    summary.hasQueryData = queryData !== null;
+    summary.queryDataKeys = queryData ? Object.keys(queryData).slice(0, 24) : [];
+    summary.queryDataDataKeys = queryDataData ? Object.keys(queryDataData).slice(0, 24) : [];
+  } catch {
+    summary.preview = body.slice(0, 240);
+  }
+  return summary;
+}
+function summarizeRequestInitForLogging(requestInit) {
+  if (!requestInit || typeof requestInit !== "object") {
+    return requestInit;
+  }
+  return {
+    ...requestInit,
+    body: summarizeRequestBodyForLogging(requestInit.body)
+  };
+}
 var RestController = class _RestController {
   /**
    * Constructor for initializing the REST server and related configurations.
@@ -12417,16 +14106,17 @@ var RestController = class _RestController {
         const parsedResponse = await this.parseFetchResponse(response);
         return parsedResponse.data;
       } catch (error) {
+        const loggedRequestInit = summarizeRequestInitForLogging(requestInit);
         if (error?.name === "AbortError") {
           CadenzaService.log(
             "Fetch request timed out.",
-            { error, URL: url, requestInit },
+            { error, URL: url, requestInit: loggedRequestInit },
             "warning"
           );
         } else {
           CadenzaService.log(
             "Fetch request error.",
-            { error, URL: url, requestInit },
+            { error, URL: url, requestInit: loggedRequestInit },
             "error"
           );
         }
@@ -12572,7 +14262,7 @@ var RestController = class _RestController {
             return { ...ctx, __app: app };
           },
           "Sets up the Express server according to the security profile"
-        ).attachSignal("meta.service_registry.instance_registration_requested").then(
+        ).then(
           CadenzaService.createMetaTask(
             "Define RestServer",
             (ctx) => {
@@ -12652,16 +14342,16 @@ var RestController = class _RestController {
                 };
                 CadenzaService.createEphemeralMetaTask(
                   "Resolve delegation",
-                  (endCtx) => resolveDelegation(endCtx, "success"),
+                  (endCtx) => resolveDelegation(
+                    endCtx,
+                    endCtx?.errored || endCtx?.failed ? "error" : "success"
+                  ),
                   "Resolves a delegation request",
                   { register: false }
-                ).doOn(`meta.node.graph_completed:${deputyExecId}`).emits(`meta.rest.delegation_resolved:${deputyExecId}`);
-                CadenzaService.createEphemeralMetaTask(
-                  "Resolve delegation target lookup failure",
-                  (endCtx) => resolveDelegation(endCtx, "error"),
-                  "Resolves delegation requests that cannot find a local task or routine",
-                  { register: false }
-                ).doOn(targetNotFoundSignal);
+                ).doOn(
+                  `meta.node.graph_completed:${deputyExecId}`,
+                  targetNotFoundSignal
+                ).emits(`meta.rest.delegation_resolved:${deputyExecId}`);
                 if (!CadenzaService.get(remoteRoutineName) && !CadenzaService.registry.routines.get(remoteRoutineName)) {
                   CadenzaService.emit(targetNotFoundSignal, {
                     ...ctx2,
@@ -12969,32 +14659,40 @@ var RestController = class _RestController {
           serviceName,
           URL2
         );
-        fetchDiagnostics.destroyed = false;
-        fetchDiagnostics.updatedAt = Date.now();
         if (CadenzaService.get(`Send Handshake to ${clientTaskSuffix}`)) {
-          console.error("Fetch client already exists", { URL: URL2, fetchId });
-          CadenzaService.schedule(
-            `meta.fetch.handshake_requested:${fetchId}`,
-            {
-              serviceInstanceId: ctx.serviceInstanceId,
-              serviceName,
-              communicationTypes: ctx.communicationTypes,
-              serviceTransportId: ctx.serviceTransportId,
-              serviceOrigin: URL2,
-              fetchId,
-              routeKey,
-              socketClientId: ctx.socketClientId ?? (routeKey ? buildTransportHandleKey(routeKey, "socket") : void 0),
-              transportProtocols: ctx.transportProtocols,
-              transportProtocol: "rest",
-              handshakeData: ctx.handshakeData
-            },
-            0
-          );
+          const shouldRetryHandshake = ctx.__forceHandshakeRecovery === true || fetchDiagnostics.destroyed === true || (fetchDiagnostics.connected !== true || typeof fetchDiagnostics.lastHandshakeError === "string") && fetchDiagnostics.handshakeInFlight !== true;
+          if (shouldRetryHandshake) {
+            fetchDiagnostics.destroyed = false;
+            fetchDiagnostics.handshakeInFlight = true;
+            fetchDiagnostics.updatedAt = Date.now();
+            console.error("Fetch client already exists", { URL: URL2, fetchId });
+            CadenzaService.debounce(
+              `meta.fetch.handshake_requested:${fetchId}`,
+              {
+                serviceInstanceId: ctx.serviceInstanceId,
+                serviceName,
+                communicationTypes: ctx.communicationTypes,
+                serviceTransportId: ctx.serviceTransportId,
+                serviceOrigin: URL2,
+                fetchId,
+                routeKey,
+                socketClientId: ctx.socketClientId ?? (routeKey ? buildTransportHandleKey(routeKey, "socket") : void 0),
+                transportProtocols: ctx.transportProtocols,
+                transportProtocol: "rest",
+                handshakeData: ctx.handshakeData
+              },
+              50
+            );
+          }
           return true;
         }
+        fetchDiagnostics.destroyed = false;
+        fetchDiagnostics.handshakeInFlight = false;
+        fetchDiagnostics.updatedAt = Date.now();
         const handshakeTask = CadenzaService.createMetaTask(
           `Send Handshake to ${clientTaskSuffix}`,
           async (ctx2, emit2) => {
+            fetchDiagnostics.handshakeInFlight = true;
             try {
               const response = await this.fetchDataWithTimeout(
                 `${URL2}/handshake`,
@@ -13010,6 +14708,7 @@ var RestController = class _RestController {
               if (response.__status !== "success") {
                 const error = response.__error ?? `Failed to connect to service ${serviceName} ${ctx2.serviceInstanceId}`;
                 fetchDiagnostics.connected = false;
+                fetchDiagnostics.handshakeInFlight = false;
                 fetchDiagnostics.lastHandshakeError = error;
                 fetchDiagnostics.updatedAt = Date.now();
                 this.recordFetchClientError(fetchId, serviceName, URL2, error);
@@ -13029,6 +14728,7 @@ var RestController = class _RestController {
               ctx2.serviceInstanceId = response.__serviceInstanceId;
               fetchDiagnostics.connected = true;
               fetchDiagnostics.destroyed = false;
+              fetchDiagnostics.handshakeInFlight = false;
               fetchDiagnostics.lastHandshakeAt = (/* @__PURE__ */ new Date()).toISOString();
               fetchDiagnostics.lastHandshakeError = null;
               fetchDiagnostics.updatedAt = Date.now();
@@ -13057,6 +14757,7 @@ var RestController = class _RestController {
               }
             } catch (e) {
               fetchDiagnostics.connected = false;
+              fetchDiagnostics.handshakeInFlight = false;
               fetchDiagnostics.lastHandshakeError = this.getErrorMessage(e);
               fetchDiagnostics.updatedAt = Date.now();
               this.recordFetchClientError(fetchId, serviceName, URL2, e);
@@ -13089,8 +14790,8 @@ var RestController = class _RestController {
             }
             const routedDelegateCtx = stripTransportSelectionRoutingContext(ctx2);
             const delegateCtx = ensureDelegationContextMetadata(
-              attachDelegationRequestSnapshot(
-                stripDelegationRequestSnapshot(routedDelegateCtx)
+              restoreDelegationRequestSnapshot(
+                attachDelegationRequestSnapshot(routedDelegateCtx)
               )
             );
             const deputyExecId = delegateCtx.__metadata.__deputyExecId;
@@ -13150,13 +14851,11 @@ var RestController = class _RestController {
               fetchDiagnostics.delegationFailures++;
               fetchDiagnostics.updatedAt = Date.now();
               this.recordFetchClientError(fetchId, serviceName, URL2, e);
-              resultContext = {
-                __signalName: "meta.fetch.delegate_failed",
-                __error: `Error: ${e}`,
-                errored: true,
-                ...delegateCtx,
-                ...delegateCtx.__metadata
-              };
+              resultContext = buildDelegationFailureContext(
+                "meta.fetch.delegate_failed",
+                delegateCtx,
+                e
+              );
               routeOutcome = "failure";
               emit2("meta.fetch.delegate_failed", resultContext);
             } finally {
@@ -13322,6 +15021,7 @@ var RestController = class _RestController {
               return false;
             }
             fetchDiagnostics.connected = false;
+            fetchDiagnostics.handshakeInFlight = false;
             fetchDiagnostics.destroyed = true;
             fetchDiagnostics.updatedAt = Date.now();
             CadenzaService.log("Destroying fetch client", { URL: URL2, serviceName });
@@ -13361,7 +15061,15 @@ var RestController = class _RestController {
           const fetchId = String(
             ctx.fetchId ?? ctx.__fetchId ?? (routeKey ? buildTransportHandleKey(routeKey, "rest") : serviceTransportId ?? "")
           );
-          CadenzaService.schedule(`meta.fetch.handshake_requested:${fetchId}`, {
+          const fetchDiagnostics = this.ensureFetchClientDiagnostics(
+            fetchId,
+            String(serviceName ?? ""),
+            String(serviceOrigin ?? "")
+          );
+          if (fetchDiagnostics.handshakeInFlight !== true) {
+            fetchDiagnostics.handshakeInFlight = true;
+          }
+          CadenzaService.debounce(`meta.fetch.handshake_requested:${fetchId}`, {
             serviceInstanceId,
             serviceName,
             communicationTypes,
@@ -13377,7 +15085,7 @@ var RestController = class _RestController {
               serviceName: CadenzaService.serviceRegistry.serviceName
               // JWT token...
             }
-          }, 0);
+          }, 50);
           return true;
         },
         "Prepares handshake"
@@ -13431,6 +15139,7 @@ var RestController = class _RestController {
         serviceName,
         url,
         connected: false,
+        handshakeInFlight: false,
         destroyed: false,
         lastHandshakeAt: null,
         lastHandshakeError: null,
@@ -14868,8 +16577,8 @@ var SocketController = class _SocketController {
               }
               const routedDelegateCtx = stripTransportSelectionRoutingContext(delegateCtx);
               const normalizedDelegateCtx = ensureDelegationContextMetadata(
-                attachDelegationRequestSnapshot(
-                  stripDelegationRequestSnapshot(routedDelegateCtx)
+                restoreDelegationRequestSnapshot(
+                  attachDelegationRequestSnapshot(routedDelegateCtx)
                 )
               );
               delete normalizedDelegateCtx.__isSubMeta;
@@ -14942,13 +16651,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,
@@ -15635,7 +17342,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;
@@ -15957,6 +17664,51 @@ import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@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_ENABLED4 = 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";
 }
@@ -16029,7 +17781,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,
@@ -16274,6 +18026,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() : "";
@@ -16436,16 +18198,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,
@@ -16536,7 +18302,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);
@@ -16764,6 +18530,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,
@@ -17381,40 +19153,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
           };
         }
@@ -17840,7 +19613,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);
@@ -17908,7 +19681,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)) {
@@ -18573,13 +20346,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
@@ -18621,40 +20431,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
@@ -18730,11 +20610,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;
 }
@@ -18812,6 +20718,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;
@@ -18875,10 +20784,10 @@ var GraphMetadataController = class _GraphMetadataController {
         task.registrationRequested = true;
       }
       return buildDatabaseTriggerContext(
-        {
+        sanitizePersistedTaskSourceFields2(task, {
           ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName
-        },
+        }),
         void 0,
         { onConflict },
         { onConflict }
@@ -18981,6 +20890,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;
@@ -19048,6 +21039,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,
@@ -19061,10 +21055,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 = {
@@ -19199,12 +21193,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
         );
       },
@@ -19218,10 +21213,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(
@@ -19454,12 +21449,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
         );
       },
@@ -20206,6 +22202,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) {
@@ -20332,7 +22337,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;
     }
@@ -20340,7 +22353,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);
@@ -20348,32 +22362,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(
@@ -20381,7 +22416,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, {
@@ -20389,32 +22427,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
         );
       }
@@ -20427,9 +22481,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
@@ -20439,13 +22497,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
@@ -20457,9 +22520,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",
@@ -21700,10 +23771,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) => {
@@ -21716,10 +23805,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();
@@ -21774,7 +23886,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.
@@ -22530,6 +24646,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();
   }
 };
@@ -22543,9 +24664,10 @@ 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 = [];
@@ -22579,6 +24701,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) {