@cadenza.io/service 2.18.1 → 2.18.3

package/dist/browser/index.js

@@ -55,8 +55,46 @@ module.exports = __toCommonJS(index_exports);
 var import_core5 = __toESM(require("@cadenza.io/core"));
 
 // src/graph/definition/DeputyTask.ts
-var import_uuid = require("uuid");
+var import_uuid2 = require("uuid");
 var import_core = require("@cadenza.io/core");
+
+// src/utils/delegation.ts
+var import_uuid = require("uuid");
+var ROOT_METADATA_PASSTHROUGH_KEYS = [
+  "__executionTraceId",
+  "__inquiryId",
+  "__inquirySourceTaskName",
+  "__inquirySourceTaskVersion",
+  "__inquirySourceTaskExecutionId",
+  "__inquirySourceRoutineExecutionId"
+];
+function hoistDelegationMetadataFields(input, metadataInput) {
+  const context = input && typeof input === "object" ? { ...input } : {};
+  const mutableContext = context;
+  const metadata = metadataInput && typeof metadataInput === "object" ? metadataInput : context.__metadata && typeof context.__metadata === "object" ? context.__metadata : {};
+  for (const key of ROOT_METADATA_PASSTHROUGH_KEYS) {
+    if ((mutableContext[key] === void 0 || mutableContext[key] === null) && metadata[key] !== void 0 && metadata[key] !== null) {
+      mutableContext[key] = metadata[key];
+    }
+  }
+  return context;
+}
+function ensureDelegationContextMetadata(input) {
+  const rawContext = input && typeof input === "object" ? { ...input } : {};
+  const metadata = rawContext.__metadata && typeof rawContext.__metadata === "object" ? { ...rawContext.__metadata } : {};
+  const context = hoistDelegationMetadataFields(rawContext, metadata);
+  const deputyExecId = typeof metadata.__deputyExecId === "string" && metadata.__deputyExecId.length > 0 ? metadata.__deputyExecId : typeof rawContext.__deputyExecId === "string" && rawContext.__deputyExecId.length > 0 ? context.__deputyExecId : (0, import_uuid.v4)();
+  return {
+    ...context,
+    __deputyExecId: deputyExecId,
+    __metadata: {
+      ...metadata,
+      __deputyExecId: deputyExecId
+    }
+  };
+}
+
+// src/graph/definition/DeputyTask.ts
 var DeputyTask = class extends import_core.Task {
   /**
    * Constructs a new instance of the class with the specified parameters.
@@ -94,7 +132,7 @@ var DeputyTask = class extends import_core.Task {
           resolve(context);
           return;
         }
-        const processId = (0, import_uuid.v4)();
+        const processId = (0, import_uuid2.v4)();
         context.__metadata.__deputyExecId = processId;
         emit("meta.deputy.delegation_requested", {
           ...context
@@ -182,7 +220,7 @@ var DeputyTask = class extends import_core.Task {
   execute(context, emit, inquire, progressCallback, nodeData) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       __timeout: this.timeout,
       __localTaskName: this.name,
       __localTaskVersion: this.version,
@@ -199,7 +237,7 @@ var DeputyTask = class extends import_core.Task {
         __deputyTaskName: this.name
       },
       ...ctx
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
@@ -280,7 +318,7 @@ var DatabaseTask = class extends DeputyTask {
       },
       ...dynamicQueryData
     };
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       ...ctx,
       __localTaskName: this.name,
       __localTaskVersion: this.version,
@@ -303,7 +341,7 @@ var DatabaseTask = class extends DeputyTask {
       filter: nextQueryData.filter ?? ctx.filter,
       fields: nextQueryData.fields ?? ctx.fields,
       queryData: nextQueryData
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
@@ -554,22 +592,6 @@ function getRouteableTransport(instance, role, protocol) {
   return selectTransportForRole(instance.transports ?? [], role, protocol);
 }
 
-// src/utils/delegation.ts
-var import_uuid2 = require("uuid");
-function ensureDelegationContextMetadata(input) {
-  const context = input && typeof input === "object" ? { ...input } : {};
-  const metadata = context.__metadata && typeof context.__metadata === "object" ? { ...context.__metadata } : {};
-  const deputyExecId = typeof metadata.__deputyExecId === "string" && metadata.__deputyExecId.length > 0 ? metadata.__deputyExecId : typeof context.__deputyExecId === "string" && context.__deputyExecId.length > 0 ? context.__deputyExecId : (0, import_uuid2.v4)();
-  return {
-    ...context,
-    __deputyExecId: deputyExecId,
-    __metadata: {
-      ...metadata,
-      __deputyExecId: deputyExecId
-    }
-  };
-}
-
 // src/utils/readiness.ts
 function evaluateDependencyReadiness(input) {
   const missedHeartbeats = Math.max(
@@ -739,6 +761,21 @@ var CADENZA_DB_GATHERED_SYNC_SIGNAL = "global.meta.cadenza_db.gathered_sync_data
 var META_GATHERED_SYNC_TRANSMISSION_RECONCILE_SIGNAL = "meta.service_registry.gathered_sync_transmission_reconcile_requested";
 var META_RUNTIME_STATUS_HEARTBEAT_TICK_SIGNAL = "meta.service_registry.runtime_status.heartbeat_tick";
 var META_RUNTIME_STATUS_MONITOR_TICK_SIGNAL = "meta.service_registry.runtime_status.monitor_tick";
+var EARLY_FULL_SYNC_DELAYS_MS = [
+  100,
+  1500,
+  5e3,
+  12e3,
+  25e3,
+  45e3,
+  7e4
+];
+var BOOTSTRAP_FULL_SYNC_RESPONDER_TASKS = [
+  "Query service_instance",
+  "Query service_instance_transport",
+  "Query signal_to_task_map",
+  "Query intent_to_task_map"
+];
 var INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
   "Track local routine start",
   "Track local routine end",
@@ -751,6 +788,10 @@ var INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
   "Collect distributed readiness",
   "Get status"
 ]);
+var SERVICE_REGISTRY_TRACE_SERVICE = (process.env.CADENZA_SERVICE_REGISTRY_TRACE_SERVICE ?? "").trim();
+function shouldTraceServiceRegistry(serviceName) {
+  return SERVICE_REGISTRY_TRACE_SERVICE.length > 0 && serviceName === SERVICE_REGISTRY_TRACE_SERVICE;
+}
 function buildServiceRegistryInsertQueryData(ctx, queryData) {
   const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
   const getJoinedValue = (key) => {
@@ -824,6 +865,45 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   }
   return result;
 }
+function resolveServiceInstanceRegistrationPayload(ctx, fallbackServiceName, fallbackServiceInstanceId) {
+  const candidateSources = [
+    ctx.__registrationData,
+    ctx.queryData?.data,
+    ctx.__resolverQueryData?.data,
+    ctx.__resolverOriginalContext?.__registrationData,
+    ctx.__resolverOriginalContext?.queryData?.data,
+    ctx.data,
+    ctx.__resolverOriginalContext?.data
+  ];
+  let resolvedData = null;
+  for (const candidate of candidateSources) {
+    if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+      resolvedData = {
+        ...candidate
+      };
+      break;
+    }
+  }
+  if (!resolvedData) {
+    return null;
+  }
+  const resolvedUuid = String(
+    resolvedData.uuid ?? ctx.__serviceInstanceId ?? ctx.__resolverOriginalContext?.__serviceInstanceId ?? fallbackServiceInstanceId ?? ""
+  ).trim();
+  const resolvedServiceName = String(
+    resolvedData.service_name ?? ctx.__serviceName ?? ctx.__resolverOriginalContext?.__serviceName ?? fallbackServiceName ?? ""
+  ).trim();
+  const resolvedProcessPid = typeof resolvedData.process_pid === "number" ? resolvedData.process_pid : typeof ctx.__resolverOriginalContext?.data?.process_pid === "number" ? ctx.__resolverOriginalContext.data.process_pid : typeof ctx.__resolverOriginalContext?.__registrationData?.process_pid === "number" ? ctx.__resolverOriginalContext.__registrationData.process_pid : typeof ctx.queryData?.data?.process_pid === "number" ? ctx.queryData.data.process_pid : typeof ctx.__registrationData?.process_pid === "number" ? ctx.__registrationData.process_pid : null;
+  if (!resolvedUuid || !resolvedServiceName || resolvedProcessPid === null) {
+    return null;
+  }
+  return {
+    ...resolvedData,
+    uuid: resolvedUuid,
+    service_name: resolvedServiceName,
+    process_pid: resolvedProcessPid
+  };
+}
 function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {}) {
   const remoteInsertTask = CadenzaService.createCadenzaDBInsertTask(
     tableName,
@@ -848,13 +928,24 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       });
       delegationContext.__metadata.__skipRemoteExecution = delegationContext.__metadata.__skipRemoteExecution ?? delegationContext.__skipRemoteExecution ?? false;
       delegationContext.__metadata.__blockRemoteExecution = delegationContext.__metadata.__blockRemoteExecution ?? delegationContext.__blockRemoteExecution ?? false;
-      return {
+      const nextContext = {
         ...delegationContext,
         __resolverOriginalContext: {
           ...ctx
         },
         __resolverQueryData: nextQueryData
       };
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+        console.log("[CADENZA_INSTANCE_DEBUG] prepare_service_registry_insert_execution", {
+          tableName,
+          signalName,
+          resolverRequestId: ctx.__resolverRequestId ?? null,
+          hasData: nextQueryData.data !== void 0,
+          queryDataKeys: Object.keys(nextQueryData),
+          dataKeys: nextQueryData.data && typeof nextQueryData.data === "object" ? Object.keys(nextQueryData.data) : []
+        });
+      }
+      return nextContext;
     },
     `Prepares ${tableName} service-registry insert payloads for runner execution.`,
     {
@@ -880,6 +971,18 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         ctx.__resolverQueryData ?? ctx.queryData ?? {},
         ctx
       );
+      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: !!normalized,
+          normalizedKeys: normalized && typeof normalized === "object" ? Object.keys(normalized) : [],
+          uuid: normalized && typeof normalized === "object" ? normalized.uuid ?? normalized.data?.uuid ?? normalized.queryData?.data?.uuid ?? null : null,
+          serviceName: normalized && typeof normalized === "object" ? normalized.__serviceName ?? normalized.data?.service_name ?? normalized.queryData?.data?.service_name ?? null : null,
+          errored: normalized && typeof normalized === "object" ? normalized.errored === true : false,
+          error: normalized && typeof normalized === "object" ? normalized.__error ?? null : null,
+          inquiryMeta: normalized && typeof normalized === "object" ? normalized.__inquiryMeta ?? null : null
+        });
+      }
       if (!normalized || typeof normalized !== "object") {
         return normalized;
       }
@@ -905,6 +1008,16 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       CadenzaService.createEphemeralMetaTask(
         `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
         (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;
           }
@@ -924,6 +1037,18 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       ).doOn(executionResolvedSignal, executionFailedSignal);
       const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
       const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+        console.log("[CADENZA_INSTANCE_DEBUG] resolve_service_registry_insert", {
+          tableName,
+          executionSignal,
+          hasLocalInsertTask: !!localInsertTask,
+          serviceName: ctx.__serviceName ?? ctx.data?.service_name ?? null,
+          serviceInstanceId: ctx.__serviceInstanceId ?? ctx.data?.uuid ?? null,
+          hasData: !!ctx.data,
+          dataKeys: ctx.data && typeof ctx.data === "object" ? Object.keys(ctx.data) : [],
+          registrationKeys: ctx.__registrationData && typeof ctx.__registrationData === "object" ? Object.keys(ctx.__registrationData) : []
+        });
+      }
       if (localInsertTask && !wiredLocalTaskNames.has(localInsertTask.name)) {
         wireExecutionTarget(localInsertTask, prepareLocalExecutionTask);
         wiredLocalTaskNames.add(localInsertTask.name);
@@ -1006,6 +1131,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.useSocket = false;
     this.retryCount = 3;
     this.isFrontend = false;
+    this.connectsToCadenzaDB = false;
     CadenzaService.defineIntent({
       name: META_RUNTIME_TRANSPORT_DIAGNOSTICS_INTENT,
       description: "Gather transport diagnostics across all services and communication clients.",
@@ -1364,6 +1490,9 @@ var ServiceRegistry = class _ServiceRegistry {
             )?.destroy();
             continue;
           }
+          if (map.serviceName === this.serviceName) {
+            continue;
+          }
           if (locallyEmittedSignals.includes(map.signalName)) {
             if (!this.remoteSignals.get(map.serviceName)) {
               this.remoteSignals.set(map.serviceName, /* @__PURE__ */ new Set());
@@ -1380,7 +1509,10 @@ var ServiceRegistry = class _ServiceRegistry {
         return true;
       },
       "Handles registration of remote signals"
-    ).emits("meta.service_registry.registered_global_signals").doOn("global.meta.cadenza_db.gathered_sync_data");
+    ).emits("meta.service_registry.registered_global_signals").doOn(
+      "global.meta.cadenza_db.gathered_sync_data",
+      "global.meta.graph_metadata.task_signal_observed"
+    );
     this.reconcileGatheredSyncTransmissionsTask = CadenzaService.createMetaTask(
       "Reconcile gathered sync signal transmissions",
       (ctx, emit) => this.reconcileGatheredSyncTransmissions(ctx, emit),
@@ -1394,6 +1526,13 @@ var ServiceRegistry = class _ServiceRegistry {
       "Handle global intent registration",
       (ctx, emit) => {
         const intentToTaskMaps = this.normalizeIntentMaps(ctx);
+        if (shouldTraceServiceRegistry(this.serviceName)) {
+          console.log("[CADENZA_SERVICE_REGISTRY_TRACE] handle_global_intents", {
+            localServiceName: this.serviceName,
+            intentCount: intentToTaskMaps.length,
+            sample: intentToTaskMaps.slice(0, 5)
+          });
+        }
         const sorted = intentToTaskMaps.sort((a, b) => {
           if (a.deleted && !b.deleted) return -1;
           if (!a.deleted && b.deleted) return 1;
@@ -1405,6 +1544,9 @@ var ServiceRegistry = class _ServiceRegistry {
               this.unregisterRemoteIntentDeputy(map);
               continue;
             }
+            if (map.serviceName === this.serviceName) {
+              continue;
+            }
             CadenzaService.inquiryBroker.addIntent({
               name: map.intentName
             });
@@ -1534,7 +1676,7 @@ var ServiceRegistry = class _ServiceRegistry {
     );
     this.handleSocketStatusUpdateTask = CadenzaService.createMetaTask(
       "Handle Socket Status Update",
-      (ctx) => {
+      (ctx, emit) => {
         const report = this.normalizeRuntimeStatusReport(ctx);
         if (!report) {
           return false;
@@ -1577,6 +1719,13 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!applied) {
           return false;
         }
+        const updatedInstance = this.getInstance(
+          report.serviceName,
+          report.serviceInstanceId
+        );
+        if (updatedInstance && !updatedInstance.isFrontend && (this.deputies.has(report.serviceName) || this.remoteIntents.has(report.serviceName) || this.remoteSignals.has(report.serviceName))) {
+          this.ensureDependeeClientForInstance(updatedInstance, emit, ctx);
+        }
         this.registerDependee(report.serviceName, report.serviceInstanceId);
         this.lastHeartbeatAtByInstance.set(report.serviceInstanceId, Date.now());
         this.missedHeartbeatsByInstance.set(report.serviceInstanceId, 0);
@@ -1587,9 +1736,28 @@ var ServiceRegistry = class _ServiceRegistry {
       },
       "Handles status update from socket broadcast"
     ).doOn("meta.socket_client.status_received");
+    CadenzaService.createMetaTask(
+      "Request full sync after CadenzaDB fetch handshake",
+      (ctx) => {
+        const serviceName = typeof ctx.serviceName === "string" ? ctx.serviceName.trim() : typeof ctx.__serviceName === "string" ? ctx.__serviceName.trim() : "";
+        if (serviceName !== "CadenzaDB") {
+          return false;
+        }
+        return this.scheduleEarlyFullSyncRequests("cadenza_db_fetch_handshake");
+      },
+      "Schedules a few early service-registry full-sync retries after the authority fetch transport comes up."
+    ).doOn("meta.fetch.handshake_complete");
     this.fullSyncTask = CadenzaService.createMetaTask(
       "Full sync",
       async (ctx) => {
+        if (this.connectsToCadenzaDB && this.serviceName !== "CadenzaDB" && !this.hasBootstrapFullSyncDeputies()) {
+          if (shouldTraceServiceRegistry(this.serviceName)) {
+            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] full_sync_skipped_missing_bootstrap_deputies", {
+              localServiceName: this.serviceName
+            });
+          }
+          return false;
+        }
         const inquiryResult = await CadenzaService.inquire(
           META_SERVICE_REGISTRY_FULL_SYNC_INTENT,
           {
@@ -1606,6 +1774,15 @@ var ServiceRegistry = class _ServiceRegistry {
         const serviceInstances = this.normalizeServiceInstancesFromSync(
           inquiryResult
         );
+        if (shouldTraceServiceRegistry(this.serviceName)) {
+          console.log("[CADENZA_SERVICE_REGISTRY_TRACE] full_sync_result", {
+            localServiceName: this.serviceName,
+            inquiryMeta: inquiryResult.__inquiryMeta,
+            signalToTaskMaps: signalToTaskMaps.length,
+            intentToTaskMaps: intentToTaskMaps.length,
+            serviceInstances: serviceInstances.length
+          });
+        }
         return {
           ...ctx,
           signalToTaskMaps,
@@ -1646,8 +1823,11 @@ var ServiceRegistry = class _ServiceRegistry {
     );
     this.handleDeputyRegistrationTask = CadenzaService.createMetaTask(
       "Handle Deputy Registration",
-      (ctx) => {
+      (ctx, emit) => {
         const { serviceName } = ctx;
+        if (!serviceName || serviceName === this.serviceName) {
+          return false;
+        }
         if (!this.deputies.has(serviceName)) this.deputies.set(serviceName, []);
         this.deputies.get(serviceName).push({
           serviceName,
@@ -1656,6 +1836,7 @@ var ServiceRegistry = class _ServiceRegistry {
           localTaskName: ctx.localTaskName,
           communicationType: ctx.communicationType
         });
+        this.ensureDependeeClientsForService(serviceName, emit, ctx);
       }
     ).doOn("meta.deputy.created");
     this.getAllInstances = CadenzaService.createMetaTask(
@@ -2208,9 +2389,29 @@ var ServiceRegistry = class _ServiceRegistry {
         retryDelayFactor: 1.3
       }
     ).emits("meta.service_registry.service_inserted").emitsOnFail("meta.service_registry.service_insertion_failed");
-    this.insertServiceInstanceTask = resolveServiceRegistryInsertTask(
+    const insertServiceInstanceResolverTask = resolveServiceRegistryInsertTask(
       "service_instance",
-      {},
+      {
+        onConflict: {
+          target: ["uuid"],
+          action: {
+            do: "update",
+            set: {
+              process_pid: "excluded",
+              is_primary: "excluded",
+              service_name: "excluded",
+              is_database: "excluded",
+              is_frontend: "excluded",
+              is_blocked: "excluded",
+              is_non_responsive: "excluded",
+              is_active: "excluded",
+              last_active: "excluded",
+              health: "excluded",
+              deleted: "false"
+            }
+          }
+        }
+      },
       {
         inputSchema: {
           type: "object",
@@ -2266,7 +2467,8 @@ var ServiceRegistry = class _ServiceRegistry {
         retryCount: 5,
         retryDelay: 1e3
       }
-    ).then(
+    ).emitsOnFail("meta.service_registry.instance_insertion_failed");
+    this.insertServiceInstanceTask = insertServiceInstanceResolverTask.then(
       CadenzaService.createMetaTask(
         "Setup service",
         (ctx) => {
@@ -2283,6 +2485,21 @@ var ServiceRegistry = class _ServiceRegistry {
             transports: ctx.__transportData ?? ctx.transportData ?? []
           });
           if (!normalizedLocalInstance?.uuid || !normalizedLocalInstance.serviceName) {
+            if (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") {
+              console.log("[CADENZA_INSTANCE_DEBUG] setup_service_rejected_instance", {
+                hasServiceInstance: !!serviceInstance,
+                hasData: !!data,
+                hasQueryDataData: !!queryData?.data,
+                serviceInstanceKeys: serviceInstance && typeof serviceInstance === "object" ? Object.keys(serviceInstance) : [],
+                dataKeys: data && typeof data === "object" ? Object.keys(data) : [],
+                queryDataDataKeys: queryData?.data && typeof queryData.data === "object" ? Object.keys(queryData.data) : [],
+                normalizedLocalInstance,
+                transportCount: Array.isArray(ctx.__transportData) ? ctx.__transportData.length : Array.isArray(ctx.transportData) ? ctx.transportData.length : 0,
+                errored: ctx.errored === true,
+                error: ctx.__error ?? null,
+                inquiryMeta: ctx.__inquiryMeta ?? null
+              });
+            }
             return false;
           }
           this.serviceInstanceId = normalizedLocalInstance.uuid;
@@ -2334,11 +2551,65 @@ var ServiceRegistry = class _ServiceRegistry {
         ).attachSignal("meta.service_registry.transport_registration_requested")
       )
     );
+    CadenzaService.createMetaTask(
+      "Retry local service instance registration after failed insert",
+      (ctx) => {
+        const registrationPayload = resolveServiceInstanceRegistrationPayload(
+          ctx,
+          this.serviceName,
+          this.serviceInstanceId
+        );
+        if (!registrationPayload) {
+          return false;
+        }
+        const serviceName = String(
+          registrationPayload.service_name ?? this.serviceName ?? ""
+        ).trim();
+        if (!serviceName || serviceName !== this.serviceName) {
+          return false;
+        }
+        CadenzaService.schedule(
+          "meta.service_registry.instance_registration_requested",
+          {
+            ...ctx,
+            data: registrationPayload,
+            __registrationData: registrationPayload,
+            __serviceName: serviceName,
+            __serviceInstanceId: registrationPayload.uuid
+          },
+          5e3
+        );
+        return true;
+      },
+      "Retries local service instance registration only after the previous insert attempt has failed.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn("meta.service_registry.instance_insertion_failed");
     CadenzaService.createMetaTask(
       "Prepare service instance registration",
       (ctx) => {
+        const registrationPayload = resolveServiceInstanceRegistrationPayload(
+          ctx,
+          this.serviceName,
+          this.serviceInstanceId
+        );
+        if (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") {
+          console.log("[CADENZA_INSTANCE_DEBUG] prepare_service_instance_registration", {
+            serviceName: registrationPayload?.service_name ?? ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? null,
+            serviceInstanceId: registrationPayload?.uuid ?? ctx.data?.uuid ?? ctx.__serviceInstanceId ?? this.serviceInstanceId ?? null,
+            hasData: !!registrationPayload,
+            dataKeys: registrationPayload && typeof registrationPayload === "object" ? Object.keys(registrationPayload) : [],
+            transportCount: Array.isArray(ctx.__transportData) ? ctx.__transportData.length : Array.isArray(ctx.transportData) ? ctx.transportData.length : 0,
+            skipRemoteExecution: ctx.__skipRemoteExecution === true
+          });
+        }
+        if (!registrationPayload) {
+          return false;
+        }
         const serviceName = String(
-          ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
+          registrationPayload.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
         ).trim();
         if (serviceName === "CadenzaDB" && !CadenzaService.getLocalCadenzaDBInsertTask("service_instance")) {
           CadenzaService.schedule(
@@ -2348,7 +2619,16 @@ var ServiceRegistry = class _ServiceRegistry {
           );
           return false;
         }
-        return ctx;
+        return {
+          ...ctx,
+          data: registrationPayload,
+          __registrationData: {
+            ...ctx.__registrationData ?? {},
+            ...registrationPayload
+          },
+          __serviceName: serviceName,
+          __serviceInstanceId: registrationPayload.uuid
+        };
       },
       "Waits for the exact local CadenzaDB service instance insert task during self-bootstrap."
     ).doOn("meta.service_registry.instance_registration_requested").then(this.insertServiceInstanceTask);
@@ -2529,21 +2809,40 @@ var ServiceRegistry = class _ServiceRegistry {
     return [];
   }
   normalizeSignalMaps(ctx) {
-    return this.readArrayPayload(ctx, [
+    const arrayPayload = this.readArrayPayload(ctx, [
       "signalToTaskMaps",
       "signal_to_task_maps",
       "signalToTaskMap",
       "signal_to_task_map"
-    ]).map((map) => ({
-      signalName: String(
-        map.signalName ?? map.signal_name ?? ""
-      ).trim(),
-      serviceName: String(
-        map.serviceName ?? map.service_name ?? ""
-      ).trim(),
-      isGlobal: Boolean(map.isGlobal ?? map.is_global ?? false),
-      deleted: Boolean(map.deleted)
-    })).filter((map) => map.signalName && map.serviceName);
+    ]);
+    if (arrayPayload.length > 0) {
+      return arrayPayload.map((map) => ({
+        signalName: String(
+          map.signalName ?? map.signal_name ?? ""
+        ).trim(),
+        serviceName: String(
+          map.serviceName ?? map.service_name ?? ""
+        ).trim(),
+        isGlobal: Boolean(map.isGlobal ?? map.is_global ?? false),
+        deleted: Boolean(map.deleted)
+      })).filter((map) => map.signalName && map.serviceName);
+    }
+    const single = ctx.signalToTaskMap ?? ctx.signal_to_task_map ?? ctx.data ?? (ctx.signalName ?? ctx.signal_name ? ctx : void 0);
+    if (!single || typeof single !== "object") {
+      return [];
+    }
+    return [
+      {
+        signalName: String(
+          single.signalName ?? single.signal_name ?? ""
+        ).trim(),
+        serviceName: String(
+          single.serviceName ?? single.service_name ?? ""
+        ).trim(),
+        isGlobal: Boolean(single.isGlobal ?? single.is_global ?? false),
+        deleted: Boolean(single.deleted)
+      }
+    ].filter((map) => map.signalName && map.serviceName);
   }
   normalizeIntentMaps(ctx) {
     const arrayPayload = this.readArrayPayload(ctx, [
@@ -2658,7 +2957,7 @@ var ServiceRegistry = class _ServiceRegistry {
       )?.destroy();
       this.gatheredSyncTransmissionServices.delete(serviceName);
     }
-    if (createdRecipients.length > 0 && ctx.__signalName === CADENZA_DB_GATHERED_SYNC_SIGNAL) {
+    if (createdRecipients.length > 0) {
       emit("meta.cadenza_db.sync_tick", {
         __syncing: true,
         __reason: "gathered_sync_transmissions_reconciled"
@@ -2704,6 +3003,15 @@ var ServiceRegistry = class _ServiceRegistry {
     };
     this.remoteIntentDeputiesByKey.set(key, descriptor);
     this.remoteIntentDeputiesByTask.set(deputyTask, descriptor);
+    if (shouldTraceServiceRegistry(this.serviceName)) {
+      console.log("[CADENZA_SERVICE_REGISTRY_TRACE] register_remote_intent_deputy", {
+        localServiceName: this.serviceName,
+        intentName: map.intentName,
+        remoteServiceName: map.serviceName,
+        remoteTaskName: map.taskName,
+        remoteTaskVersion: map.taskVersion
+      });
+    }
   }
   unregisterRemoteIntentDeputy(map) {
     const key = this.buildRemoteIntentDeputyKey(map);
@@ -2733,6 +3041,56 @@ var ServiceRegistry = class _ServiceRegistry {
       }
     }
   }
+  registerBootstrapFullSyncDeputies(emit, ctx) {
+    if (!this.serviceName || this.serviceName === "CadenzaDB") {
+      return false;
+    }
+    CadenzaService.inquiryBroker.addIntent({
+      name: META_SERVICE_REGISTRY_FULL_SYNC_INTENT
+    });
+    for (const taskName of BOOTSTRAP_FULL_SYNC_RESPONDER_TASKS) {
+      this.registerRemoteIntentDeputy({
+        intentName: META_SERVICE_REGISTRY_FULL_SYNC_INTENT,
+        serviceName: "CadenzaDB",
+        taskName,
+        taskVersion: 1
+      });
+    }
+    this.ensureDependeeClientsForService("CadenzaDB", emit, ctx);
+    return true;
+  }
+  hasBootstrapFullSyncDeputies() {
+    if (!this.serviceName || this.serviceName === "CadenzaDB") {
+      return true;
+    }
+    return BOOTSTRAP_FULL_SYNC_RESPONDER_TASKS.every(
+      (taskName) => this.remoteIntentDeputiesByKey.has(
+        this.buildRemoteIntentDeputyKey({
+          intentName: META_SERVICE_REGISTRY_FULL_SYNC_INTENT,
+          serviceName: "CadenzaDB",
+          taskName,
+          taskVersion: 1
+        })
+      )
+    );
+  }
+  scheduleEarlyFullSyncRequests(reason) {
+    for (const delayMs of EARLY_FULL_SYNC_DELAYS_MS) {
+      CadenzaService.schedule(
+        "meta.sync_requested",
+        {
+          __syncing: false,
+          __reason: reason
+        },
+        delayMs
+      );
+    }
+    return true;
+  }
+  bootstrapFullSync(emit, ctx, reason = "local_instance_inserted") {
+    this.registerBootstrapFullSyncDeputies(emit, ctx);
+    return this.scheduleEarlyFullSyncRequests(reason);
+  }
   getInquiryResponderDescriptor(task) {
     const remote = this.remoteIntentDeputiesByTask.get(task);
     if (remote) {
@@ -2761,6 +3119,9 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return this.getInstance(this.serviceName, this.serviceInstanceId);
   }
+  hasLocalInstanceRegistered() {
+    return Boolean(this.getLocalInstance());
+  }
   summarizeTransportForDebug(transport) {
     if (!transport) {
       return void 0;
@@ -2909,7 +3270,7 @@ var ServiceRegistry = class _ServiceRegistry {
     return communicationTypes;
   }
   ensureDependeeClientForInstance(instance, emit, ctx) {
-    if (!instance || instance.uuid === this.serviceInstanceId || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+    if (!instance || instance.uuid === this.serviceInstanceId || instance.serviceName === this.serviceName || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
       return false;
     }
     if (!this.deputies.has(instance.serviceName) && !this.remoteIntents.has(instance.serviceName) && !this.remoteSignals.has(instance.serviceName)) {
@@ -2937,6 +3298,9 @@ var ServiceRegistry = class _ServiceRegistry {
     return true;
   }
   ensureDependeeClientsForService(serviceName, emit, ctx) {
+    if (!serviceName || serviceName === this.serviceName) {
+      return;
+    }
     for (const instance of this.instances.get(serviceName) ?? []) {
       this.ensureDependeeClientForInstance(instance, emit, ctx);
     }
@@ -3729,7 +4093,7 @@ var SignalTransmissionTask = class extends import_core2.Task {
   execute(context, emit, inquire, progressCallback) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       __localTaskName: this.name,
       __localServiceName: CadenzaService.serviceRegistry.serviceName,
       __serviceName: this.serviceName,
@@ -3742,12 +4106,13 @@ var SignalTransmissionTask = class extends import_core2.Task {
       __signalName: this.signalName,
       __signalEmissionId: metadata.__signalEmission?.uuid,
       ...ctx
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
 
 // src/network/RestController.browser.ts
+var FETCH_HANDSHAKE_TIMEOUT_MS = 5e3;
 var RestController = class _RestController {
   constructor() {
     this.fetchClientDiagnostics = /* @__PURE__ */ new Map();
@@ -3793,7 +4158,15 @@ var RestController = class _RestController {
             is_blocked: false,
             health: {}
           },
-          __transportData: []
+          __transportData: Array.isArray(ctx.__declaredTransports) ? ctx.__declaredTransports.map((transport) => ({
+            uuid: transport.uuid,
+            service_instance_id: ctx.__serviceInstanceId,
+            role: transport.role,
+            origin: transport.origin,
+            protocols: transport.protocols ?? ["rest", "socket"],
+            ...transport.securityProfile ? { security_profile: transport.securityProfile } : {},
+            ...transport.authStrategy ? { auth_strategy: transport.authStrategy } : {}
+          })) : []
         });
         return true;
       },
@@ -3808,6 +4181,7 @@ var RestController = class _RestController {
         if (!serviceName || !URL2 || !fetchId) {
           return false;
         }
+        const clientTaskSuffix = `${URL2} (${fetchId})`;
         const fetchDiagnostics = this.ensureFetchClientDiagnostics(
           fetchId,
           serviceName,
@@ -3815,11 +4189,11 @@ var RestController = class _RestController {
         );
         fetchDiagnostics.destroyed = false;
         fetchDiagnostics.updatedAt = Date.now();
-        if (CadenzaService.get(`Send Handshake to ${URL2}`)) {
+        if (CadenzaService.get(`Send Handshake to ${clientTaskSuffix}`)) {
           return;
         }
         const handshakeTask = CadenzaService.createMetaTask(
-          `Send Handshake to ${URL2}`,
+          `Send Handshake to ${clientTaskSuffix}`,
           async (handshakeCtx, emit) => {
             try {
               const response = await this.fetchDataWithTimeout(
@@ -3831,7 +4205,7 @@ var RestController = class _RestController {
                   method: "POST",
                   body: JSON.stringify(handshakeCtx.handshakeData)
                 },
-                1e3
+                FETCH_HANDSHAKE_TIMEOUT_MS
               );
               if (response.__status !== "success") {
                 const error = response.__error ?? `Failed to connect to service ${serviceName} ${handshakeCtx.serviceInstanceId}`;
@@ -3867,13 +4241,19 @@ var RestController = class _RestController {
             return handshakeCtx;
           },
           "Sends handshake request",
-          { retryCount: 5, retryDelay: 1e3, retryDelayFactor: 1.5 }
+          {
+            retryCount: 5,
+            retryDelay: 1e3,
+            retryDelayFactor: 1.5,
+            register: false,
+            isHidden: true
+          }
         ).doOn(`meta.fetch.handshake_requested:${fetchId}`).emits("meta.fetch.handshake_complete").attachSignal(
           "meta.fetch.handshake_failed",
           "global.meta.fetch.service_communication_established"
         );
         const delegateTask = CadenzaService.createMetaTask(
-          `Delegate flow to REST server ${URL2}`,
+          `Delegate flow to REST server ${clientTaskSuffix}`,
           async (delegateCtx, emit) => {
             if (delegateCtx.__remoteRoutineName === void 0) {
               return;
@@ -3910,13 +4290,17 @@ var RestController = class _RestController {
             }
             return resultContext;
           },
-          "Sends delegation request"
+          "Sends delegation request",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn(
           `meta.service_registry.selected_instance_for_fetch:${fetchId}`,
           `meta.service_registry.socket_failed:${fetchId}`
         ).emitsOnFail("meta.fetch.delegate_failed").attachSignal("meta.fetch.delegated");
         const transmitTask = CadenzaService.createMetaTask(
-          `Transmit signal to server ${URL2}`,
+          `Transmit signal to server ${clientTaskSuffix}`,
           async (signalCtx, emit) => {
             if (signalCtx.__signalName === void 0) {
               return;
@@ -3951,10 +4335,14 @@ var RestController = class _RestController {
             }
             return response;
           },
-          "Sends signal request"
+          "Sends signal request",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn(`meta.service_registry.selected_instance_for_fetch:${fetchId}`).emitsOnFail("meta.fetch.signal_transmission_failed").attachSignal("meta.fetch.transmitted");
         const statusTask = CadenzaService.createMetaTask(
-          `Request status from ${URL2}`,
+          `Request status from ${clientTaskSuffix}`,
           async (statusCtx) => {
             fetchDiagnostics.statusChecks++;
             fetchDiagnostics.updatedAt = Date.now();
@@ -3977,17 +4365,29 @@ var RestController = class _RestController {
               };
             }
           },
-          "Requests status"
+          "Requests status",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn("meta.fetch.status_check_requested").emits("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
-        CadenzaService.createEphemeralMetaTask("Destroy fetch client", () => {
-          fetchDiagnostics.connected = false;
-          fetchDiagnostics.destroyed = true;
-          fetchDiagnostics.updatedAt = Date.now();
-          handshakeTask.destroy();
-          delegateTask.destroy();
-          transmitTask.destroy();
-          statusTask.destroy();
-        }).doOn(
+        CadenzaService.createEphemeralMetaTask(
+          `Destroy fetch client ${fetchId}`,
+          () => {
+            fetchDiagnostics.connected = false;
+            fetchDiagnostics.destroyed = true;
+            fetchDiagnostics.updatedAt = Date.now();
+            handshakeTask.destroy();
+            delegateTask.destroy();
+            transmitTask.destroy();
+            statusTask.destroy();
+          },
+          "",
+          {
+            register: false,
+            isHidden: true
+          }
+        ).doOn(
           `meta.fetch.destroy_requested:${fetchId}`,
           `meta.socket_client.disconnected:${fetchId}`,
           `meta.fetch.handshake_failed:${fetchId}`
@@ -5394,7 +5794,11 @@ var SocketController = class _SocketController {
                 }
               );
             },
-            "Handshakes with socket server"
+            "Handshakes with socket server",
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.socket_client.connected:${fetchId}`);
           runtimeHandle.delegateTask = CadenzaService.createMetaTask(
             `Delegate flow to Socket service ${url}`,
@@ -5472,7 +5876,11 @@ var SocketController = class _SocketController {
                 }
               }
             },
-            `Delegate flow to service ${serviceName} with address ${url}`
+            `Delegate flow to service ${serviceName} with address ${url}`,
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal(
             "meta.socket_client.delegated",
             "meta.socket_shutdown_requested"
@@ -5496,7 +5904,11 @@ var SocketController = class _SocketController {
               }
               return response;
             },
-            `Transmits signal to service ${serviceName} with address ${url}`
+            `Transmits signal to service ${serviceName} with address ${url}`,
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal("meta.socket_client.transmitted");
           CadenzaService.createEphemeralMetaTask(
             `Shutdown SocketClient ${url}`,
@@ -5540,7 +5952,11 @@ var SocketController = class _SocketController {
                 fetchId
               });
             },
-            "Shuts down the socket client"
+            "Shuts down the socket client",
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(
             `meta.socket_shutdown_requested:${fetchId}`,
             `meta.socket_client.disconnected:${fetchId}`,
@@ -5804,10 +6220,18 @@ function decomposeSignalName(signalName) {
 
 // src/signals/SignalController.ts
 function buildSignalDatabaseTriggerContext(data) {
+  const onConflict = {
+    target: ["name"],
+    action: {
+      do: "nothing"
+    }
+  };
   return {
     data: { ...data },
+    onConflict,
     queryData: {
-      data: { ...data }
+      data: { ...data },
+      onConflict
     }
   };
 }
@@ -5834,16 +6258,28 @@ var SignalController = class _SignalController {
     CadenzaService.createMetaTask(
       "Handle Signal Registration",
       (ctx, emit) => {
+        if (!CadenzaService.hasCompletedBootstrapSync()) {
+          return false;
+        }
         const { signalName } = ctx;
+        const signalObserver = CadenzaService.signalBroker.signalObservers?.get(
+          signalName
+        );
+        if (signalObserver?.registered || signalObserver?.registrationRequested) {
+          return false;
+        }
+        if (signalObserver) {
+          signalObserver.registrationRequested = true;
+        }
         const { isMeta, isGlobal, domain, action } = decomposeSignalName(signalName);
         emit(
           "global.meta.signal_controller.signal_added",
           buildSignalDatabaseTriggerContext({
             name: signalName,
-            isGlobal,
+            is_global: isGlobal,
             domain,
             action,
-            isMeta
+            is_meta: isMeta
           })
         );
         return ctx;
@@ -5852,12 +6288,35 @@ var SignalController = class _SignalController {
     ).doOn("meta.signal_broker.added").attachSignal("global.meta.signal_controller.signal_added");
     CadenzaService.createMetaTask(
       "Add data to signal emission",
-      (ctx) => {
+      (ctx, emit) => {
         const signalEmission = ctx.__signalEmission;
         delete ctx.__signalEmission;
         if (!signalEmission) {
           return false;
         }
+        if (typeof signalEmission.signalName === "string" && signalEmission.signalName.trim().length > 0 && !CadenzaService.signalBroker.signalObservers?.has(signalEmission.signalName)) {
+          CadenzaService.signalBroker.addSignal(signalEmission.signalName);
+        } else {
+          const signalObserver = CadenzaService.signalBroker.signalObservers?.get(
+            signalEmission.signalName
+          );
+          if (signalObserver && signalObserver.registered !== true && signalObserver.registrationRequested !== true && CadenzaService.hasCompletedBootstrapSync()) {
+            signalObserver.registrationRequested = true;
+            const { isMeta, isGlobal, domain, action } = decomposeSignalName(
+              signalEmission.signalName
+            );
+            emit(
+              "global.meta.signal_controller.signal_added",
+              buildSignalDatabaseTriggerContext({
+                name: signalEmission.signalName,
+                is_global: isGlobal,
+                domain,
+                action,
+                is_meta: isMeta
+              })
+            );
+          }
+        }
         return {
           data: {
             uuid: signalEmission.uuid,
@@ -6212,10 +6671,10 @@ function registerActorSessionPersistenceTasks() {
 }
 
 // src/graph/controllers/GraphMetadataController.ts
-function buildDatabaseTriggerContext(data, filter, extra = {}) {
+function buildDatabaseTriggerContext(data, filter, extra = {}, queryExtra = {}) {
   const nextData = data && typeof data === "object" ? { ...data } : void 0;
   const nextFilter = filter && typeof filter === "object" ? { ...filter } : void 0;
-  const queryData = {};
+  const queryData = { ...queryExtra };
   if (nextData !== void 0) {
     queryData.data = nextData;
   }
@@ -6229,33 +6688,125 @@ function buildDatabaseTriggerContext(data, filter, extra = {}) {
     ...Object.keys(queryData).length > 0 ? { queryData } : {}
   };
 }
+function resolveTaskFromMetadataContext(ctx) {
+  const taskName = String(
+    ctx?.taskName ?? ctx?.data?.taskName ?? ctx?.data?.task_name ?? ctx?.filter?.taskName ?? ctx?.filter?.task_name ?? ""
+  );
+  return taskName ? CadenzaService.get(taskName) : void 0;
+}
+function resolveTaskByName(name) {
+  const taskName = String(name ?? "");
+  return taskName ? CadenzaService.get(taskName) : 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 shouldSkipDirectTaskMetadata(task) {
+  return !task || !task.register || task.isHidden || task.isDeputy;
+}
+function shouldPersistBusinessTaskExecution(task) {
+  return !!task && task.register && !task.isHidden && !task.isMeta && !task.isSubMeta && !task.isDeputy;
+}
+function shouldEmitDirectPrimitiveMetadata() {
+  return CadenzaService.hasCompletedBootstrapSync();
+}
+function shouldPersistBusinessInquiry(ctx) {
+  const inquiryName = String(
+    ctx?.data?.name ?? ctx?.inquiry ?? ctx?.data?.metadata?.inquiryMeta?.inquiry ?? ""
+  );
+  if (!inquiryName) {
+    return false;
+  }
+  return !isMetaIntentName(inquiryName) && ctx?.data?.isMeta !== true && ctx?.data?.is_meta !== true;
+}
+function shouldPersistRoutineExecution(ctx) {
+  if (ctx?.data?.isMeta === true || ctx?.data?.is_meta === true) {
+    return false;
+  }
+  const routineTask = resolveTaskByName(ctx?.data?.name);
+  if (routineTask) {
+    return shouldPersistBusinessTaskExecution(routineTask);
+  }
+  return true;
+}
+function shouldPersistTaskExecutionMetadata(ctx) {
+  const task = resolveTaskFromMetadataContext(ctx);
+  return shouldPersistBusinessTaskExecution(task);
+}
+function shouldPersistTaskExecutionMap(ctx) {
+  return shouldPersistBusinessTaskExecution(resolveTaskFromMetadataContext(ctx)) && shouldPersistBusinessTaskExecution(resolvePredecessorTaskFromMetadataContext(ctx));
+}
+function hasInquiryLink(data) {
+  const metaContext = data?.metaContext ?? data?.meta_context;
+  const directInquiryId = metaContext?.__inquiryId ?? metaContext?.__metadata?.__inquiryId;
+  return typeof directInquiryId === "string" && directInquiryId.length > 0;
+}
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
     return this._instance;
   }
   constructor() {
+    const buildOnConflictDoNothing = (target) => ({
+      target,
+      action: {
+        do: "nothing"
+      }
+    });
     CadenzaService.createMetaTask("Handle task creation", (ctx) => {
-      return buildDatabaseTriggerContext({
-        ...ctx.data,
-        serviceName: CadenzaService.serviceRegistry.serviceName
-      });
-    }).doOn("meta.task.created").emits("global.meta.graph_metadata.task_created");
-    CadenzaService.createMetaTask("Handle task update", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const taskName = String(ctx.data?.name ?? ctx.data?.taskName ?? "");
+      const task = taskName ? CadenzaService.get(taskName) : void 0;
+      const onConflict = buildOnConflictDoNothing([
+        "name",
+        "service_name",
+        "version"
+      ]);
+      if (shouldSkipDirectTaskMetadata(task) || task?.registered || task?.registrationRequested) {
+        return false;
+      }
+      if (task) {
+        task.registrationRequested = true;
+      }
       return buildDatabaseTriggerContext(
-        ctx.data ?? void 0,
         {
-          ...ctx.filter,
+          ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName
-        }
+        },
+        void 0,
+        { onConflict },
+        { onConflict }
+      );
+    }).doOn("meta.task.created").emits("global.meta.graph_metadata.task_created");
+    CadenzaService.createMetaTask("Handle task update", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      return buildDatabaseTriggerContext(
+        ctx.data ?? void 0,
+        {
+          ...ctx.filter,
+          serviceName: CadenzaService.serviceRegistry.serviceName
+        }
       );
     }).doOn("meta.task.layer_index_changed", "meta.task.destroyed").emits("global.meta.graph_metadata.task_updated");
     CadenzaService.createMetaTask("Handle task relationship creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       const taskName = ctx.data?.taskName ?? ctx.data?.task_name;
       const predecessorTaskName = ctx.data?.predecessorTaskName ?? ctx.data?.predecessor_task_name;
       const task = taskName ? CadenzaService.get(taskName) : void 0;
       const predecessorTask = predecessorTaskName ? CadenzaService.get(predecessorTaskName) : void 0;
-      if (!task?.registered || !predecessorTask?.registered) {
+      if (shouldSkipDirectTaskMetadata(task) || shouldSkipDirectTaskMetadata(predecessorTask) || !task?.registered || !predecessorTask?.registered) {
         return false;
       }
       return buildDatabaseTriggerContext({
@@ -6268,14 +6819,35 @@ var GraphMetadataController = class _GraphMetadataController {
       CadenzaService.log(`Error in task ${ctx.data.taskName}`, ctx.data, "error");
     }).doOn("meta.node.errored");
     CadenzaService.createMetaTask("Handle task signal observation", (ctx) => {
-      const isGlobal = ctx.signalName.startsWith("global.");
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const signalName = String(
+        ctx.signalName ?? ctx.data?.signalName ?? ""
+      ).split(":")[0];
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      if (task?.registered && task.registeredSignals.has(signalName)) {
+        return false;
+      }
+      const isGlobal = signalName.startsWith("global.");
       return buildDatabaseTriggerContext({
         ...ctx.data,
+        signalName,
         isGlobal,
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.task.observed_signal").emits("global.meta.graph_metadata.task_signal_observed");
     CadenzaService.createMetaTask("Handle task signal attachment", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -6284,7 +6856,34 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       );
     }).doOn("meta.task.attached_signal").emits("global.meta.graph_metadata.task_attached_signal");
+    CadenzaService.createMetaTask("Handle task intent association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const intentName = String(ctx.data?.intentName ?? "");
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      if (task?.registered && task.__registeredIntents?.has(
+        intentName
+      )) {
+        return false;
+      }
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        intentName,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.task.intent_associated").emits("global.meta.graph_metadata.task_intent_associated");
     CadenzaService.createMetaTask("Handle task unsubscribing signal", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         {
           deleted: true
@@ -6296,6 +6895,13 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.unsubscribed_signal").emits("meta.graph_metadata.task_unsubscribed_signal");
     CadenzaService.createMetaTask("Handle task detaching signal", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         {
           deleted: true
@@ -6307,12 +6913,18 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.detached_signal").emits("global.meta.graph_metadata.task_detached_signal");
     CadenzaService.createMetaTask("Handle routine creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doAfter(CadenzaService.registry.registerRoutine).emits("global.meta.graph_metadata.routine_created");
     CadenzaService.createMetaTask("Handle routine update", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -6322,6 +6934,9 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.routine.destroyed").emits("global.meta.graph_metadata.routine_updated");
     CadenzaService.createMetaTask("Handle adding task to routine", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         serviceName: CadenzaService.serviceRegistry.serviceName
@@ -6337,8 +6952,12 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle routine execution creation",
       (ctx) => {
+        if (!shouldPersistRoutineExecution(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext({
           ...ctx.data,
+          previousRoutineExecution: hasInquiryLink(ctx.data) ? null : ctx.data?.previousRoutineExecution ?? ctx.data?.previous_routine_execution ?? null,
           serviceName: CadenzaService.serviceRegistry.serviceName,
           serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
         });
@@ -6375,6 +6994,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution creation",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext({
           ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName,
@@ -6387,6 +7009,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution mapped",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMap(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           ctx.data ?? void 0,
           ctx.filter ?? void 0
@@ -6398,6 +7023,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution started",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           ctx.data ?? void 0,
           ctx.filter ?? void 0
@@ -6409,6 +7037,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution ended",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           {
             ...ctx.data,
@@ -6421,9 +7052,39 @@ var GraphMetadataController = class _GraphMetadataController {
       "Handles task execution ended",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.ended").emits("global.meta.graph_metadata.task_execution_ended");
+    CadenzaService.createMetaTask(
+      "Handle inquiry creation",
+      (ctx) => {
+        if (!shouldPersistBusinessInquiry(ctx)) {
+          return false;
+        }
+        return buildDatabaseTriggerContext({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+          isMeta: false
+        });
+      },
+      "Handles inquiry creation",
+      { concurrency: 100, isSubMeta: true }
+    ).doOn("meta.inquiry_broker.inquiry_started").emits("global.meta.graph_metadata.inquiry_created");
+    CadenzaService.createMetaTask(
+      "Handle inquiry update",
+      (ctx) => {
+        return buildDatabaseTriggerContext(
+          ctx.data ?? void 0,
+          ctx.filter ?? void 0
+        );
+      },
+      "Handles inquiry completion updates",
+      { concurrency: 100, isSubMeta: true }
+    ).doOn("meta.inquiry_broker.inquiry_completed").emits("global.meta.graph_metadata.inquiry_updated");
     CadenzaService.createMetaTask(
       "Handle task execution relationship creation",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMap(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           {
             executionCount: "increment",
@@ -6439,12 +7100,18 @@ var GraphMetadataController = class _GraphMetadataController {
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped", "meta.node.detected_previous_task_execution").emits("global.meta.graph_metadata.relationship_executed");
     CadenzaService.createMetaTask("Handle actor creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         service_name: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.actor.created").emits("global.meta.graph_metadata.actor_created");
     CadenzaService.createMetaTask("Handle actor task association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         service_name: CadenzaService.serviceRegistry.serviceName
@@ -6452,6 +7119,9 @@ var GraphMetadataController = class _GraphMetadataController {
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
     registerActorSessionPersistenceTasks();
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       const intentName = ctx.data?.name;
       return buildDatabaseTriggerContext({
         ...ctx.data,
@@ -6573,7 +7243,7 @@ function buildIntentRegistryData(intent) {
     description: typeof intent?.description === "string" ? intent.description : "",
     input: intent?.input && typeof intent.input === "object" ? intent.input : { type: "object" },
     output: intent?.output && typeof intent.output === "object" ? intent.output : { type: "object" },
-    isMeta: isMetaIntentName(name)
+    is_meta: isMetaIntentName(name)
   };
 }
 function getJoinedContextValue(ctx, key) {
@@ -6646,34 +7316,7 @@ function buildSyncInsertQueryData(ctx, queryData = {}) {
   }
   return nextQueryData;
 }
-function buildSyncQueryQueryData(ctx, queryData = {}) {
-  const joinedQueryData = getJoinedContextValue(ctx, "queryData");
-  const existingQueryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : joinedQueryData && typeof joinedQueryData === "object" ? joinedQueryData : {};
-  const nextQueryData = {};
-  const allowedKeys = [
-    "transaction",
-    "filter",
-    "fields",
-    "joins",
-    "sort",
-    "limit",
-    "offset",
-    "queryMode",
-    "aggregates",
-    "groupBy"
-  ];
-  for (const key of allowedKeys) {
-    if (Object.prototype.hasOwnProperty.call(existingQueryData, key)) {
-      nextQueryData[key] = existingQueryData[key];
-    }
-  }
-  return {
-    ...nextQueryData,
-    ...queryData
-  };
-}
 var REMOTE_AUTHORITY_SYNC_INSERT_CONCURRENCY = 5;
-var REMOTE_AUTHORITY_SYNC_QUERY_CONCURRENCY = 3;
 function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
   if (!graph) {
     return void 0;
@@ -6686,11 +7329,27 @@ function wireSyncTaskGraph(predecessorTask, graph, ...completionTasks) {
 }
 function buildSyncExecutionEnvelope(ctx, queryData) {
   const originalContext = { ...ctx };
+  const syncSourceServiceName = typeof ctx.__syncSourceServiceName === "string" && ctx.__syncSourceServiceName.trim().length > 0 ? ctx.__syncSourceServiceName : typeof ctx.__serviceName === "string" && ctx.__serviceName.trim().length > 0 ? ctx.__serviceName : resolveSyncServiceName();
+  const rootDbOperationFields = {};
+  for (const key of [
+    "data",
+    "batch",
+    "transaction",
+    "onConflict",
+    "filter",
+    "fields"
+  ]) {
+    if (Object.prototype.hasOwnProperty.call(queryData, key)) {
+      rootDbOperationFields[key] = queryData[key];
+    }
+  }
   const nextContext = {
     __syncing: ctx.__syncing === true || ctx.__metadata?.__syncing === true || false,
+    __syncSourceServiceName: syncSourceServiceName,
     __preferredTransportProtocol: "rest",
     __resolverOriginalContext: originalContext,
     __resolverQueryData: queryData,
+    ...rootDbOperationFields,
     queryData
   };
   if (typeof ctx.__reason === "string" && ctx.__reason.trim().length > 0) {
@@ -6698,9 +7357,26 @@ function buildSyncExecutionEnvelope(ctx, queryData) {
   }
   return nextContext;
 }
+function markCompletedSyncCycle(completedCycles, cycleId, limit = 32) {
+  if (!cycleId) {
+    return false;
+  }
+  if (completedCycles.has(cycleId)) {
+    return false;
+  }
+  completedCycles.add(cycleId);
+  while (completedCycles.size > limit) {
+    const oldestCycleId = completedCycles.values().next().value;
+    if (!oldestCycleId) {
+      break;
+    }
+    completedCycles.delete(oldestCycleId);
+  }
+  return true;
+}
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
-  if (!localInsertTask && !isCadenzaDBReady) {
+  if (isCadenzaDBReady && !localInsertTask) {
     return void 0;
   }
   const targetTask = localInsertTask ?? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, {
@@ -6751,6 +7427,11 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
+      if (originalContext.__syncing === true && !didSyncInsertSucceed(normalizedContext)) {
+        CadenzaService.debounce("meta.sync_requested", {
+          delayMs: 1e3
+        });
+      }
       return normalizedContext;
     },
     `Finalizes ${tableName} graph-sync insert execution after the authority task finishes.`,
@@ -6778,86 +7459,82 @@ var CADENZA_DB_REQUIRED_LOCAL_SYNC_INSERT_TABLES = [
   "intent_to_task_map",
   "directional_task_graph_map"
 ];
-var AUTHORITY_QUERY_RESULT_KEYS = {
-  task: "tasks",
-  routine: "routines",
-  signal_registry: "signalRegistrys",
-  intent_registry: "intentRegistrys"
-};
-var EARLY_SYNC_REQUEST_DELAYS_MS = [2e3, 1e4, 3e4];
-function resolveSyncQueryRows(ctx, tableName) {
-  const resultKey = AUTHORITY_QUERY_RESULT_KEYS[tableName];
-  const rows = ctx?.[resultKey];
-  return Array.isArray(rows) ? rows : [];
+var BOOTSTRAP_SYNC_STALE_CYCLE_MS = 15e3;
+var EARLY_SYNC_TICK_DELAYS_MS = [
+  400,
+  BOOTSTRAP_SYNC_STALE_CYCLE_MS + 1e3,
+  BOOTSTRAP_SYNC_STALE_CYCLE_MS * 2 + 2e3,
+  BOOTSTRAP_SYNC_STALE_CYCLE_MS * 3 + 3e3
+];
+function shouldTraceSyncPhase(serviceName) {
+  const configured = process.env.CADENZA_SYNC_PHASE_TRACE_SERVICE;
+  if (!configured || !serviceName) {
+    return false;
+  }
+  return configured === serviceName;
 }
-function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
-  const localQueryTask = CadenzaService.getLocalCadenzaDBQueryTask(tableName);
-  if (!localQueryTask && !isCadenzaDBReady) {
-    return void 0;
+function canonicalizeSignalName(signalName) {
+  if (typeof signalName !== "string") {
+    return "";
   }
-  const targetTask = localQueryTask ?? CadenzaService.createCadenzaDBQueryTask(tableName, queryData, {
-    ...options,
-    concurrency: Number(options.concurrency) > 0 ? Math.min(
-      Number(options.concurrency),
-      REMOTE_AUTHORITY_SYNC_QUERY_CONCURRENCY
-    ) : REMOTE_AUTHORITY_SYNC_QUERY_CONCURRENCY,
-    register: false,
-    isHidden: true
-  });
-  const prepareQueryTask = CadenzaService.createMetaTask(
-    `Prepare graph sync query for ${tableName}`,
-    (ctx) => buildSyncExecutionEnvelope(
-      ctx,
-      buildSyncQueryQueryData(ctx, queryData)
-    ),
-    `Prepares ${tableName} graph-sync query payloads.`,
-    {
-      register: false,
-      isHidden: true
-    }
-  );
-  const finalizeQueryTask = CadenzaService.createMetaTask(
-    `Finalize graph sync query for ${tableName}`,
-    (ctx) => ctx,
-    `Finalizes ${tableName} graph-sync query payloads after authority lookup.`,
-    {
-      register: false,
-      isHidden: true
-    }
-  );
-  prepareQueryTask.then(targetTask);
-  targetTask.then(finalizeQueryTask);
-  return {
-    entryTask: prepareQueryTask,
-    completionTask: finalizeQueryTask
-  };
+  return signalName.split(":")[0]?.trim() ?? "";
+}
+function isBootstrapLocalOnlySignal(signalName) {
+  return signalName === "meta.service_registry.insert_execution_requested" || signalName.startsWith("meta.sync_controller.");
 }
 function getRegistrableTasks() {
   return Array.from(CadenzaService.registry.tasks.values()).filter(
-    (task) => task.register && !task.isHidden
+    (task) => task.register && !task.isHidden && !task.isDeputy
   );
 }
 function getRegistrableRoutines() {
   return Array.from(CadenzaService.registry.routines.values());
 }
-function isAuthoritySyncSignal(signalName) {
-  return decomposeSignalName(signalName).isGlobal;
-}
 function getRegistrableSignalObservers() {
   const signalObservers = CadenzaService.signalBroker.signalObservers;
   if (!signalObservers) {
     return [];
   }
-  return Array.from(signalObservers.entries()).filter(([signalName]) => isAuthoritySyncSignal(signalName)).map(([signalName, observer]) => ({
-    signalName,
-    ...observer
-  }));
+  const canonicalObservers = /* @__PURE__ */ new Map();
+  for (const [rawSignalName, observer] of signalObservers.entries()) {
+    const signalName = canonicalizeSignalName(rawSignalName);
+    if (!signalName || isBootstrapLocalOnlySignal(signalName)) {
+      continue;
+    }
+    const existing = canonicalObservers.get(signalName);
+    canonicalObservers.set(signalName, {
+      signalName,
+      registered: existing?.registered === true || observer?.registered === true
+    });
+  }
+  return Array.from(canonicalObservers.values());
+}
+function isLocallyHandledIntentName(intentName) {
+  const observer = CadenzaService.inquiryBroker.inquiryObservers.get(intentName);
+  if (!observer) {
+    return false;
+  }
+  for (const task of observer.tasks) {
+    if (task.register && !task.isHidden && !task.isDeputy) {
+      return true;
+    }
+  }
+  return false;
 }
 function getRegistrableIntentNames() {
   return Array.from(CadenzaService.inquiryBroker.intents.values()).map((intent) => buildIntentRegistryData(intent)).filter(
     (intentDefinition) => intentDefinition !== null
+  ).filter(
+    (intentDefinition) => isLocallyHandledIntentName(String(intentDefinition.name))
   ).map((intentDefinition) => String(intentDefinition.name));
 }
+function isRegistrableLocalIntentDefinition(intent) {
+  const intentData = buildIntentRegistryData(intent);
+  if (!intentData) {
+    return false;
+  }
+  return isLocallyHandledIntentName(String(intentData.name));
+}
 function buildActorRegistrationKey(actor, serviceName) {
   const data = buildActorRegistrationData(actor);
   const name = typeof data.name === "string" && data.name.trim().length > 0 ? data.name.trim() : "";
@@ -6899,10 +7576,23 @@ var GraphSyncController = class _GraphSyncController {
     this.signalsSynced = false;
     this.intentsSynced = false;
     this.routinesSynced = false;
+    this.directionalTaskMapsSynced = false;
+    this.signalTaskMapsSynced = false;
+    this.intentTaskMapsSynced = false;
+    this.actorTaskMapsSynced = false;
+    this.routineTaskMapsSynced = false;
     this.isCadenzaDBReady = false;
     this.initialized = false;
     this.initRetryScheduled = false;
     this.lastMissingLocalCadenzaDBInsertTablesKey = "";
+    this.syncCycleCounter = 0;
+    this.primitivePhaseCompletedCycles = /* @__PURE__ */ new Set();
+    this.mapPhaseCompletedCycles = /* @__PURE__ */ new Set();
+    this.activeSyncCycleId = null;
+    this.activeSyncCycleStartedAt = 0;
+    this.pendingBootstrapSyncRerun = false;
+    this.localServiceInserted = false;
+    this.localServiceInstanceInserted = false;
   }
   static get instance() {
     if (!this._instance) this._instance = new _GraphSyncController();
@@ -6976,45 +7666,16 @@ var GraphSyncController = class _GraphSyncController {
       },
       { concurrency: 30 }
     );
-    const ensureIntentRegistryBeforeIntentMapTask = resolveSyncInsertTask(
-      this.isCadenzaDBReady,
-      "intent_registry",
-      {
-        onConflict: {
-          target: ["name"],
-          action: {
-            do: "nothing"
-          }
-        }
-      },
-      { concurrency: 30 }
-    );
-    const authoritativeTaskQueryGraph = resolveSyncQueryTask(
-      this.isCadenzaDBReady,
-      "task",
-      {},
-      { concurrency: 10 }
-    );
-    const authoritativeRoutineQueryGraph = resolveSyncQueryTask(
-      this.isCadenzaDBReady,
-      "routine",
-      {},
-      { concurrency: 10 }
-    );
-    const authoritativeSignalQueryGraph = resolveSyncQueryTask(
-      this.isCadenzaDBReady,
-      "signal_registry",
-      {},
-      { concurrency: 10 }
-    );
-    const authoritativeIntentQueryGraph = resolveSyncQueryTask(
-      this.isCadenzaDBReady,
-      "intent_registry",
-      {},
-      { concurrency: 10 }
-    );
     const finalizeTaskSync = (emit, ctx) => {
       const pendingTasks = getRegistrableTasks().filter((task) => !task.registered);
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_tasks", {
+          serviceName: serviceName2,
+          pendingCount: pendingTasks.length,
+          sample: pendingTasks.slice(0, 5).map((task) => task.name)
+        });
+      }
       if (pendingTasks.length > 0) {
         this.tasksSynced = false;
         return false;
@@ -7033,6 +7694,14 @@ var GraphSyncController = class _GraphSyncController {
       const pendingRoutines = getRegistrableRoutines().filter(
         (routine) => !routine.registered
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_routines", {
+          serviceName: serviceName2,
+          pendingCount: pendingRoutines.length,
+          sample: pendingRoutines.slice(0, 5).map((routine) => routine.name)
+        });
+      }
       if (pendingRoutines.length > 0) {
         this.routinesSynced = false;
         return false;
@@ -7051,6 +7720,14 @@ var GraphSyncController = class _GraphSyncController {
       const pendingSignals = getRegistrableSignalObservers().filter(
         (observer) => observer.registered !== true
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_signals", {
+          serviceName: serviceName2,
+          pendingCount: pendingSignals.length,
+          sample: pendingSignals.slice(0, 5).map((observer) => observer.signalName)
+        });
+      }
       if (pendingSignals.length > 0) {
         this.signalsSynced = false;
         return false;
@@ -7069,6 +7746,14 @@ var GraphSyncController = class _GraphSyncController {
       const pendingIntentNames = getRegistrableIntentNames().filter(
         (intentName) => !this.registeredIntentDefinitions.has(intentName)
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_intents", {
+          serviceName: serviceName2,
+          pendingCount: pendingIntentNames.length,
+          sample: pendingIntentNames.slice(0, 5)
+        });
+      }
       if (pendingIntentNames.length > 0) {
         this.intentsSynced = false;
         return false;
@@ -7090,6 +7775,13 @@ var GraphSyncController = class _GraphSyncController {
         return false;
       }
       const pendingActorKeys = CadenzaService.getAllActors().map((actor) => buildActorRegistrationKey(actor, syncServiceName)).filter((registrationKey) => Boolean(registrationKey)).filter((registrationKey) => !this.registeredActors.has(registrationKey));
+      if (shouldTraceSyncPhase(syncServiceName)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_actors", {
+          serviceName: syncServiceName,
+          pendingCount: pendingActorKeys.length,
+          sample: pendingActorKeys.slice(0, 5)
+        });
+      }
       if (pendingActorKeys.length > 0) {
         this.actorsSynced = false;
         return false;
@@ -7170,8 +7862,8 @@ var GraphSyncController = class _GraphSyncController {
               name: routine.name,
               version: routine.version,
               description: routine.description,
-              serviceName: serviceName2,
-              isMeta: routine.isMeta
+              service_name: serviceName2,
+              is_meta: routine.isMeta
             },
             __routineName: routine.name
           };
@@ -7234,11 +7926,11 @@ var GraphSyncController = class _GraphSyncController {
               yield {
                 __syncing: ctx.__syncing,
                 data: {
-                  taskName: nextTask.name,
-                  taskVersion: nextTask.version,
-                  routineName: routine.name,
-                  routineVersion: routine.version,
-                  serviceName: serviceName2
+                  task_name: nextTask.name,
+                  task_version: nextTask.version,
+                  routine_name: routine.name,
+                  routine_version: routine.version,
+                  service_name: serviceName2
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
@@ -7296,12 +7988,20 @@ var GraphSyncController = class _GraphSyncController {
         });
         const { signals } = ctx;
         if (!signals) return;
-        const filteredSignals = signals.filter((signal) => {
-          if (signal.data.registered) {
+        const seenSignals = /* @__PURE__ */ new Set();
+        const filteredSignals = signals.map((signal) => ({
+          signalName: canonicalizeSignalName(signal.signal),
+          data: signal.data
+        })).filter((signal) => {
+          if (!signal.signalName || signal.data?.registered || isBootstrapLocalOnlySignal(signal.signalName)) {
+            return false;
+          }
+          if (seenSignals.has(signal.signalName)) {
             return false;
           }
-          return isAuthoritySyncSignal(signal.signal);
-        }).map((signal) => signal.signal);
+          seenSignals.add(signal.signalName);
+          return true;
+        }).map((signal) => signal.signalName);
         for (const signal of filteredSignals) {
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
           this.signalsSynced = false;
@@ -7309,10 +8009,10 @@ var GraphSyncController = class _GraphSyncController {
             __syncing: ctx.__syncing,
             data: {
               name: signal,
-              isGlobal,
+              is_global: isGlobal,
               domain,
               action,
-              isMeta
+              is_meta: isMeta
             },
             __signal: signal
           };
@@ -7334,14 +8034,15 @@ var GraphSyncController = class _GraphSyncController {
     );
     const processSignalRegistrationTask = CadenzaService.createMetaTask(
       "Process signal registration",
-      (ctx) => {
-        if (!didSyncInsertSucceed(ctx)) {
+      (ctx, emit) => {
+        const insertSucceeded = didSyncInsertSucceed(ctx);
+        const signalName = resolveSignalNameFromSyncContext(ctx);
+        if (!insertSucceeded) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        const signalName = resolveSignalNameFromSyncContext(ctx);
         if (!signalName) {
           return false;
         }
@@ -7352,7 +8053,14 @@ var GraphSyncController = class _GraphSyncController {
         const observer = signalObservers?.get(signalName);
         if (observer) {
           observer.registered = true;
+          observer.registrationRequested = false;
         }
+        emit(
+          "meta.sync_controller.signal_registered",
+          buildMinimalSyncSignalContext(ctx, {
+            __signal: signalName
+          })
+        );
         return { signalName };
       }
     ).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask);
@@ -7373,6 +8081,7 @@ var GraphSyncController = class _GraphSyncController {
           return;
         }
         for (const task of tasks) {
+          if (task.hidden || !task.register || task.isDeputy) continue;
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
           this.tasksSynced = false;
@@ -7382,32 +8091,33 @@ var GraphSyncController = class _GraphSyncController {
               name: task.name,
               version: task.version,
               description: task.description,
-              functionString: __functionString,
-              tagIdGetter: __getTagCallback,
-              layerIndex: task.layerIndex,
+              function_string: __functionString,
+              tag_id_getter: __getTagCallback,
+              layer_index: task.layerIndex,
               concurrency: task.concurrency,
               timeout: task.timeout,
-              isUnique: task.isUnique,
-              isSignal: task.isSignal,
-              isThrottled: task.isThrottled,
-              isDebounce: task.isDebounce,
-              isEphemeral: task.isEphemeral,
-              isMeta: task.isMeta,
-              isSubMeta: task.isSubMeta,
-              isHidden: task.isHidden,
-              validateInputContext: task.validateInputContext,
-              validateOutputContext: task.validateOutputContext,
-              retryCount: task.retryCount,
-              retryDelay: task.retryDelay,
-              retryDelayMax: task.retryDelayMax,
-              retryDelayFactor: task.retryDelayFactor,
+              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)
             },
             __taskName: task.name
           };
@@ -7430,17 +8140,20 @@ var GraphSyncController = class _GraphSyncController {
     const registerTaskTask = CadenzaService.createMetaTask(
       "Record registration",
       (ctx, emit) => {
-        if (!didSyncInsertSucceed(ctx)) {
+        const task = resolveLocalTaskFromSyncContext(ctx);
+        const serviceName2 = resolveSyncServiceName(task);
+        const insertSucceeded = didSyncInsertSucceed(ctx);
+        if (!insertSucceeded) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        const task = resolveLocalTaskFromSyncContext(ctx);
         if (!task) {
           return true;
         }
         task.registered = true;
+        task.registrationRequested = false;
         emit(
           "meta.sync_controller.task_registered",
           buildMinimalSyncSignalContext(ctx, {
@@ -7451,24 +8164,6 @@ var GraphSyncController = class _GraphSyncController {
       }
     ).then(gatherTaskRegistrationTask);
     wireSyncTaskGraph(this.splitTasksForRegistration, registerTaskGraph, registerTaskTask);
-    CadenzaService.createMetaTask(
-      "Prepare created task for immediate sync",
-      (ctx) => {
-        const task = ctx.taskInstance ?? (ctx.data?.name ? CadenzaService.get(String(ctx.data.name)) : void 0);
-        if (!task || task.hidden || !task.register || task.registered) {
-          return false;
-        }
-        return {
-          __syncing: true,
-          tasks: [task]
-        };
-      },
-      "Schedules newly created tasks into the graph sync registration flow without waiting for the next periodic tick.",
-      {
-        register: false,
-        isHidden: true
-      }
-    ).doOn("meta.task.created").then(this.splitTasksForRegistration);
     this.splitActorsForRegistration = CadenzaService.createMetaTask(
       "Split actors for registration",
       function* (ctx) {
@@ -7607,13 +8302,14 @@ var GraphSyncController = class _GraphSyncController {
     const registerSignalTask = CadenzaService.createMetaTask(
       "Record signal registration",
       (ctx) => {
+        const task = resolveLocalTaskFromSyncContext(ctx);
+        const serviceName2 = resolveSyncServiceName(task);
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        const task = resolveLocalTaskFromSyncContext(ctx);
         const signalName = resolveSignalNameFromSyncContext(ctx);
         if (!task || !signalName) {
           return true;
@@ -7625,7 +8321,8 @@ var GraphSyncController = class _GraphSyncController {
       "Split observed signals of task",
       function* (ctx) {
         const task = ctx.task;
-        if (task.hidden || !task.register || !task.registered) return false;
+        if (task.hidden || !task.register || task.isDeputy || !task.registered)
+          return false;
         const serviceName2 = resolveSyncServiceName(task);
         if (!serviceName2) {
           return false;
@@ -7644,11 +8341,11 @@ var GraphSyncController = class _GraphSyncController {
           yield {
             __syncing: ctx.__syncing,
             data: {
-              signalName: _signal,
-              isGlobal,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              signal_name: _signal,
+              is_global: isGlobal,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             },
             __taskName: task.name,
             __signal: signal
@@ -7689,6 +8386,9 @@ var GraphSyncController = class _GraphSyncController {
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
         for (const intent of intents) {
+          if (!isRegistrableLocalIntentDefinition(intent)) {
+            continue;
+          }
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
             continue;
@@ -7707,7 +8407,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const recordIntentDefinitionRegistrationTask = CadenzaService.createMetaTask(
       "Record intent definition registration",
-      (ctx) => {
+      (ctx, emit) => {
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
@@ -7715,6 +8415,12 @@ var GraphSyncController = class _GraphSyncController {
           delayMs: 3e3
         });
         this.registeredIntentDefinitions.add(ctx.__intentName);
+        emit(
+          "meta.sync_controller.intent_registered",
+          buildMinimalSyncSignalContext(ctx, {
+            __intentName: ctx.__intentName
+          })
+        );
         return true;
       }
     ).then(gatherIntentRegistrationTask);
@@ -7726,13 +8432,13 @@ var GraphSyncController = class _GraphSyncController {
     const registerIntentTask = CadenzaService.createMetaTask(
       "Record intent registration",
       (ctx) => {
+        const task = resolveLocalTaskFromSyncContext(ctx);
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        const task = resolveLocalTaskFromSyncContext(ctx);
         if (!task) {
           return true;
         }
@@ -7744,7 +8450,8 @@ var GraphSyncController = class _GraphSyncController {
       "Split intents of task",
       function* (ctx) {
         const task = ctx.task;
-        if (task.hidden || !task.register || !task.registered) return false;
+        if (task.hidden || !task.register || task.isDeputy || !task.registered)
+          return false;
         const serviceName2 = resolveSyncServiceName(task);
         if (!serviceName2) {
           return false;
@@ -7779,19 +8486,19 @@ var GraphSyncController = class _GraphSyncController {
           yield {
             __syncing: ctx.__syncing,
             data: {
-              intentName: intent,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              intent_name: intent,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             },
             __taskName: task.name,
             __intent: intent,
             __intentDefinition: intentDefinition,
             __intentMapData: {
-              intentName: intent,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              intent_name: intent,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             }
           };
           emittedCount += 1;
@@ -7799,30 +8506,6 @@ var GraphSyncController = class _GraphSyncController {
         return emittedCount > 0;
       }.bind(this)
     );
-    const prepareIntentDefinitionForIntentMapTask = CadenzaService.createMetaTask(
-      "Prepare intent definition for intent-to-task map",
-      (ctx) => {
-        if (!ctx.__intentDefinition || !ctx.__intentMapData) {
-          return false;
-        }
-        return {
-          ...ctx,
-          data: ctx.__intentDefinition
-        };
-      }
-    );
-    const restoreIntentToTaskMapPayloadTask = CadenzaService.createMetaTask(
-      "Restore intent-to-task map payload",
-      (ctx) => {
-        if (!ctx.__intentMapData) {
-          return false;
-        }
-        return {
-          ...ctx,
-          data: ctx.__intentMapData
-        };
-      }
-    );
     const intentToTaskMapGraph = resolveSyncInsertTask(
       this.isCadenzaDBReady,
       "intent_to_task_map",
@@ -7841,20 +8524,8 @@ var GraphSyncController = class _GraphSyncController {
       },
       { concurrency: 30 }
     );
-    this.registerIntentToTaskMapTask.then(prepareIntentDefinitionForIntentMapTask);
-    if (ensureIntentRegistryBeforeIntentMapTask) {
-      wireSyncTaskGraph(
-        prepareIntentDefinitionForIntentMapTask,
-        ensureIntentRegistryBeforeIntentMapTask,
-        restoreIntentToTaskMapPayloadTask
-      );
-    } else {
-      prepareIntentDefinitionForIntentMapTask.then(
-        restoreIntentToTaskMapPayloadTask
-      );
-    }
     wireSyncTaskGraph(
-      restoreIntentToTaskMapPayloadTask,
+      this.registerIntentToTaskMapTask,
       intentToTaskMapGraph,
       registerIntentTask
     );
@@ -7865,7 +8536,9 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        if (task.hidden || !task.register) return;
+        if (task.hidden || !task.register || task.isDeputy || !task.registered) {
+          return;
+        }
         const predecessorServiceName = resolveSyncServiceName(task);
         if (!predecessorServiceName) {
           return;
@@ -7880,12 +8553,12 @@ var GraphSyncController = class _GraphSyncController {
           }
           yield {
             data: {
-              taskName: t.name,
-              taskVersion: t.version,
-              predecessorTaskName: task.name,
-              predecessorTaskVersion: task.version,
-              serviceName: serviceName2,
-              predecessorServiceName
+              task_name: t.name,
+              task_version: t.version,
+              predecessor_task_name: task.name,
+              predecessor_task_version: task.version,
+              service_name: serviceName2,
+              predecessor_service_name: predecessorServiceName
             },
             __taskName: task.name,
             __nextTaskName: t.name
@@ -7932,519 +8605,598 @@ var GraphSyncController = class _GraphSyncController {
       taskMapRegistrationGraph,
       recordTaskMapRegistrationTask
     );
-    this.registerDeputyRelationshipTask = CadenzaService.createMetaTask(
-      "Register deputy relationship",
-      (ctx) => {
-        const task = ctx.task;
-        if (task.hidden || !task.register) return;
-        if (task.isDeputy && !task.signalName) {
-          if (task.registeredDeputyMap) return;
-          const serviceName2 = resolveSyncServiceName(task);
-          const predecessorServiceName = resolveSyncServiceName();
-          if (!serviceName2 || !predecessorServiceName) {
-            return;
-          }
-          return {
-            data: {
-              task_name: task.remoteRoutineName,
-              task_version: 1,
-              service_name: serviceName2,
-              predecessor_task_name: task.name,
-              predecessor_task_version: task.version,
-              predecessor_service_name: predecessorServiceName
-            },
-            __taskName: task.name
-          };
+    const hasPendingDirectionalTaskMaps = () => getRegistrableTasks().some((task) => {
+      if (task.isHidden || !task.register || !task.registered) {
+        return false;
+      }
+      const predecessorServiceName = resolveSyncServiceName(task);
+      if (!predecessorServiceName) {
+        return false;
+      }
+      for (const nextTask of task.nextTasks) {
+        if (task.taskMapRegistration.has(nextTask.name) || nextTask.isHidden || !nextTask.register || !nextTask.registered) {
+          continue;
+        }
+        if (resolveSyncServiceName(nextTask)) {
+          return true;
         }
       }
-    );
-    const deputyRelationshipRegistrationGraph = resolveSyncInsertTask(
-      this.isCadenzaDBReady,
-      "directional_task_graph_map",
-      {
-        onConflict: {
-          target: [
-            "task_name",
-            "predecessor_task_name",
-            "task_version",
-            "predecessor_task_version",
-            "service_name",
-            "predecessor_service_name"
-          ],
-          action: {
-            do: "nothing"
-          }
+      return false;
+    });
+    const hasPendingSignalTaskMaps = () => getRegistrableTasks().some((task) => {
+      if (task.isHidden || !task.register || !task.registered) {
+        return false;
+      }
+      for (const signal of task.observedSignals) {
+        if (task.registeredSignals.has(signal)) {
+          continue;
         }
-      },
-      { concurrency: 30 }
-    );
-    const recordDeputyRelationshipRegistrationTask = CadenzaService.createMetaTask(
-      "Record deputy relationship registration",
-      (ctx) => {
-        if (!didSyncInsertSucceed(ctx)) {
-          return;
+        const signalName = signal.split(":")[0];
+        if (!decomposeSignalName(signalName).isGlobal) {
+          continue;
         }
-        CadenzaService.debounce("meta.sync_controller.synced_resource", {
-          delayMs: 3e3
-        });
-        const task = resolveLocalTaskFromSyncContext(ctx);
-        if (!task) {
-          return true;
+        if (!CadenzaService.signalBroker.signalObservers?.get(signalName)?.registered) {
+          continue;
         }
-        task.registeredDeputyMap = true;
+        return true;
       }
-    );
-    wireSyncTaskGraph(
-      this.registerDeputyRelationshipTask,
-      deputyRelationshipRegistrationGraph,
-      recordDeputyRelationshipRegistrationTask
-    );
-    const reconcileTaskRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
-      "Reconcile task registration from authority",
-      (ctx, emit) => {
-        const authoritativeTasks = resolveSyncQueryRows(ctx, "task");
-        let changed = false;
-        for (const row of authoritativeTasks) {
-          const taskName = typeof row.name === "string" ? row.name : "";
-          if (!taskName) {
+      return false;
+    });
+    const hasPendingIntentTaskMaps = () => getRegistrableTasks().some((task) => {
+      if (task.isHidden || !task.register || !task.registered) {
+        return false;
+      }
+      const registeredIntents = task.__registeredIntents ?? /* @__PURE__ */ new Set();
+      for (const intent of task.handlesIntents) {
+        if (registeredIntents.has(intent) || isLocalOnlySyncIntent(intent)) {
+          continue;
+        }
+        if (isMetaIntentName(intent) && !task.isMeta) {
+          continue;
+        }
+        const intentDefinition = buildIntentRegistryData(CadenzaService.inquiryBroker.intents.get(intent)) ?? buildIntentRegistryData({ name: intent });
+        if (!intentDefinition) {
+          continue;
+        }
+        return true;
+      }
+      return false;
+    });
+    const hasPendingActorTaskMaps = () => getRegistrableTasks().some((task) => {
+      if (task.isHidden || !task.register || !task.registered) {
+        return false;
+      }
+      const metadata = getActorTaskRuntimeMetadata(task.taskFunction);
+      if (!metadata?.actorName) {
+        return false;
+      }
+      const serviceName2 = resolveSyncServiceName(task);
+      if (!serviceName2) {
+        return false;
+      }
+      const registrationKey = `${metadata.actorName}|${task.name}|${task.version}|${serviceName2}`;
+      return !this.registeredActorTaskMaps.has(registrationKey);
+    });
+    const hasPendingRoutineTaskMaps = () => getRegistrableRoutines().some((routine) => {
+      if (!routine.registered) {
+        return false;
+      }
+      for (const task of routine.tasks) {
+        if (!task) {
+          continue;
+        }
+        const tasks = task.getIterator();
+        while (tasks.hasNext()) {
+          const nextTask = tasks.next();
+          if (!nextTask?.registered) {
             continue;
           }
-          const task = CadenzaService.get(taskName);
-          if (!task || task.registered) {
-            continue;
+          if (!routine.registeredTasks.has(nextTask.name)) {
+            return true;
           }
-          task.registered = true;
-          changed = true;
-          emit("meta.sync_controller.task_registered", {
-            ...ctx,
-            __taskName: task.name,
-            task,
-            __authoritativeReconciliation: true
-          });
         }
-        if (authoritativeTasks.length > 0 || changed) {
-          finalizeTaskSync(emit, {
-            ...ctx,
-            __authoritativeReconciliation: true
-          });
+      }
+      return false;
+    });
+    const gatherDirectionalTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather directional task map registration",
+      (ctx) => {
+        if (hasPendingDirectionalTaskMaps()) {
+          this.directionalTaskMapsSynced = false;
+          return false;
         }
-        return changed;
+        this.directionalTaskMapsSynced = true;
+        return ctx;
       },
-      "Marks local tasks as registered when authority rows already exist.",
+      "Completes directional task graph registration when task edges and deputy edges are registered.",
       {
         register: false,
         isHidden: true
       }
     );
-    const reconcileRoutineRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
-      "Reconcile routine registration from authority",
-      (ctx, emit) => {
-        const authoritativeRoutines = resolveSyncQueryRows(ctx, "routine");
-        let changed = false;
-        for (const row of authoritativeRoutines) {
-          const routineName = typeof row.name === "string" ? row.name : "";
-          if (!routineName) {
-            continue;
-          }
-          const routine = CadenzaService.getRoutine(routineName);
-          if (!routine || routine.registered) {
-            continue;
-          }
-          routine.registered = true;
-          changed = true;
+    const gatherSignalTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather signal task map registration",
+      (ctx) => {
+        if (hasPendingSignalTaskMaps()) {
+          this.signalTaskMapsSynced = false;
+          return false;
         }
-        if (authoritativeRoutines.length > 0 || changed) {
-          finalizeRoutineSync(emit, {
-            ...ctx,
-            __authoritativeReconciliation: true
-          });
+        this.signalTaskMapsSynced = true;
+        return ctx;
+      },
+      "Completes signal-to-task map registration when all global observed signal edges are registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherIntentTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather intent task map registration",
+      (ctx) => {
+        if (hasPendingIntentTaskMaps()) {
+          this.intentTaskMapsSynced = false;
+          return false;
         }
-        return changed;
+        this.intentTaskMapsSynced = true;
+        return ctx;
       },
-      "Marks local routines as registered when authority rows already exist.",
+      "Completes intent-to-task map registration when all task responders are registered.",
       {
         register: false,
         isHidden: true
       }
     );
-    const reconcileSignalRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
-      "Reconcile signal registration from authority",
-      (ctx, emit) => {
-        const authoritativeSignals = resolveSyncQueryRows(ctx, "signal_registry");
-        const signalObservers = CadenzaService.signalBroker.signalObservers;
-        let changed = false;
-        for (const row of authoritativeSignals) {
-          const signalName = typeof row.name === "string" ? row.name : "";
-          if (!signalName) {
-            continue;
-          }
-          const observer = signalObservers?.get(signalName);
-          if (!observer || observer.registered) {
-            continue;
-          }
-          observer.registered = true;
-          changed = true;
+    const gatherActorTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather actor task map registration",
+      (ctx) => {
+        if (hasPendingActorTaskMaps()) {
+          this.actorTaskMapsSynced = false;
+          return false;
         }
-        if (authoritativeSignals.length > 0 || changed) {
-          finalizeSignalSync(emit, {
-            ...ctx,
-            __authoritativeReconciliation: true
-          });
+        this.actorTaskMapsSynced = true;
+        return ctx;
+      },
+      "Completes actor-to-task map registration when all actor-backed tasks are registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherRoutineTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather routine task map registration",
+      (ctx) => {
+        if (hasPendingRoutineTaskMaps()) {
+          this.routineTaskMapsSynced = false;
+          return false;
         }
-        return changed;
+        this.routineTaskMapsSynced = true;
+        return ctx;
       },
-      "Marks local signals as registered when authority rows already exist.",
+      "Completes task-to-routine map registration when all routine task memberships are registered.",
       {
         register: false,
         isHidden: true
       }
     );
-    const reconcileIntentRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
-      "Reconcile intent registration from authority",
+    const finishSyncTask = CadenzaService.createUniqueMetaTask(
+      "Finish sync",
       (ctx, emit) => {
-        const authoritativeIntents = resolveSyncQueryRows(ctx, "intent_registry");
-        let changed = false;
-        for (const row of authoritativeIntents) {
-          const intentName = typeof row.name === "string" ? row.name : "";
-          if (!intentName || !CadenzaService.inquiryBroker.intents.has(intentName)) {
-            continue;
-          }
-          if (this.registeredIntentDefinitions.has(intentName)) {
-            continue;
+        const syncCycleId = typeof ctx.__syncCycleId === "string" ? ctx.__syncCycleId.trim() : "";
+        if (syncCycleId && this.activeSyncCycleId === syncCycleId) {
+          this.activeSyncCycleId = null;
+          this.activeSyncCycleStartedAt = 0;
+        }
+        if (this.pendingBootstrapSyncRerun) {
+          this.pendingBootstrapSyncRerun = false;
+          CadenzaService.debounce("meta.sync_requested", {
+            delayMs: 100
+          });
+        }
+        emit("global.meta.sync_controller.synced", {
+          data: {
+            is_active: true,
+            is_non_responsive: false,
+            is_blocked: false,
+            last_active: formatTimestamp(Date.now())
+          },
+          filter: {
+            uuid: CadenzaService.serviceRegistry.serviceInstanceId
           }
-          this.registeredIntentDefinitions.add(intentName);
-          changed = true;
+        });
+        return true;
+      },
+      "Marks the current bootstrap sync cycle as complete.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).attachSignal("global.meta.sync_controller.synced");
+    const mapPhaseBarrierTask = CadenzaService.createUniqueMetaTask(
+      "Complete map sync phase",
+      (ctx) => {
+        const syncCycleId = typeof ctx.__syncCycleId === "string" ? ctx.__syncCycleId.trim() : "";
+        if (!syncCycleId) {
+          return false;
         }
-        if (authoritativeIntents.length > 0 || changed) {
-          finalizeIntentSync(emit, {
-            ...ctx,
-            __authoritativeReconciliation: true
+        const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+        if (shouldTraceSyncPhase(serviceName2)) {
+          console.log("[CADENZA_SYNC_PHASE_TRACE] map_barrier_check", {
+            serviceName: serviceName2,
+            syncCycleId,
+            directionalTaskMapsSynced: this.directionalTaskMapsSynced,
+            signalTaskMapsSynced: this.signalTaskMapsSynced,
+            intentTaskMapsSynced: this.intentTaskMapsSynced,
+            actorTaskMapsSynced: this.actorTaskMapsSynced,
+            routineTaskMapsSynced: this.routineTaskMapsSynced
           });
         }
-        return changed;
+        if (!this.directionalTaskMapsSynced || !this.signalTaskMapsSynced || !this.intentTaskMapsSynced || !this.actorTaskMapsSynced || !this.routineTaskMapsSynced) {
+          return false;
+        }
+        if (!markCompletedSyncCycle(this.mapPhaseCompletedCycles, syncCycleId)) {
+          return false;
+        }
+        return ctx;
       },
-      "Marks local intents as registered when authority rows already exist.",
+      "Fans in map branch completion and ends the current sync cycle once every map branch is complete.",
+      {
+        register: false,
+        isHidden: true
+      }
+    ).then(finishSyncTask);
+    const startDirectionalTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Start directional task map sync",
+      (ctx) => ctx,
+      "Starts the directional task graph map branch for the current sync cycle.",
       {
         register: false,
         isHidden: true
       }
     );
-    const skipAuthoritativeTaskReconciliationTask = CadenzaService.createMetaTask(
-      "Skip authoritative task reconciliation",
-      () => false,
-      "Skips task reconciliation when no authority query task is available.",
+    const startSignalTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Start signal task map sync",
+      (ctx) => ctx,
+      "Starts the signal-to-task map branch for the current sync cycle.",
       {
         register: false,
         isHidden: true
       }
     );
-    const skipAuthoritativeRoutineReconciliationTask = CadenzaService.createMetaTask(
-      "Skip authoritative routine reconciliation",
-      () => false,
-      "Skips routine reconciliation when no authority query task is available.",
+    const startIntentTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Start intent task map sync",
+      (ctx) => ctx,
+      "Starts the intent-to-task map branch for the current sync cycle.",
       {
         register: false,
         isHidden: true
       }
     );
-    const skipAuthoritativeSignalReconciliationTask = CadenzaService.createMetaTask(
-      "Skip authoritative signal reconciliation",
-      () => false,
-      "Skips signal reconciliation when no authority query task is available.",
+    const startActorTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Start actor task map sync",
+      (ctx) => ctx,
+      "Starts the actor-to-task map branch for the current sync cycle.",
       {
         register: false,
         isHidden: true
       }
     );
-    const skipAuthoritativeIntentReconciliationTask = CadenzaService.createMetaTask(
-      "Skip authoritative intent reconciliation",
-      () => false,
-      "Skips intent reconciliation when no authority query task is available.",
+    const startRoutineTaskMapSyncTask = CadenzaService.createMetaTask(
+      "Start routine task map sync",
+      (ctx) => ctx,
+      "Starts the task-to-routine map branch for the current sync cycle.",
       {
         register: false,
         isHidden: true
       }
     );
-    if (authoritativeTaskQueryGraph) {
-      authoritativeTaskQueryGraph.completionTask.then(
-        reconcileTaskRegistrationFromAuthorityTask
-      );
-    }
-    if (authoritativeRoutineQueryGraph) {
-      authoritativeRoutineQueryGraph.completionTask.then(
-        reconcileRoutineRegistrationFromAuthorityTask
-      );
-    }
-    if (authoritativeSignalQueryGraph) {
-      authoritativeSignalQueryGraph.completionTask.then(
-        reconcileSignalRegistrationFromAuthorityTask
-      );
-    }
-    if (authoritativeIntentQueryGraph) {
-      authoritativeIntentQueryGraph.completionTask.then(
-        reconcileIntentRegistrationFromAuthorityTask
-      );
-    }
-    const authoritativeRegistrationTriggers = [
-      "meta.service_registry.initial_sync_complete",
-      "meta.sync_requested",
-      "meta.sync_controller.synced_resource",
-      "meta.sync_controller.authority_registration_reconciliation_requested"
-    ];
-    CadenzaService.createMetaTask(
-      "Prepare authoritative task registration query",
+    const primitivePhaseBarrierTask = CadenzaService.createUniqueMetaTask(
+      "Complete primitive sync phase",
       (ctx) => {
-        if (!this.isCadenzaDBReady) {
+        const syncCycleId = typeof ctx.__syncCycleId === "string" ? ctx.__syncCycleId.trim() : "";
+        if (!syncCycleId) {
           return false;
         }
-        const serviceName2 = resolveSyncServiceName();
-        if (!serviceName2) {
+        const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+        if (shouldTraceSyncPhase(serviceName2)) {
+          console.log("[CADENZA_SYNC_PHASE_TRACE] primitive_barrier_check", {
+            serviceName: serviceName2,
+            syncCycleId,
+            tasksSynced: this.tasksSynced,
+            signalsSynced: this.signalsSynced,
+            intentsSynced: this.intentsSynced,
+            actorsSynced: this.actorsSynced,
+            routinesSynced: this.routinesSynced
+          });
+        }
+        if (!this.tasksSynced || !this.signalsSynced || !this.intentsSynced || !this.actorsSynced || !this.routinesSynced) {
           return false;
         }
-        return {
-          ...ctx,
-          __syncServiceName: serviceName2,
-          queryData: {
-            filter: {
-              service_name: serviceName2
-            },
-            fields: ["name", "version", "service_name"]
-          }
-        };
+        if (!markCompletedSyncCycle(this.primitivePhaseCompletedCycles, syncCycleId)) {
+          return false;
+        }
+        this.directionalTaskMapsSynced = false;
+        this.signalTaskMapsSynced = false;
+        this.intentTaskMapsSynced = false;
+        this.actorTaskMapsSynced = false;
+        this.routineTaskMapsSynced = false;
+        return ctx;
       },
-      "Builds the authority task query payload for the current service.",
+      "Fans in primitive registration and opens the map registration phase once every primitive branch is complete.",
       {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(
-      authoritativeTaskQueryGraph?.entryTask ?? skipAuthoritativeTaskReconciliationTask
-    );
-    CadenzaService.createMetaTask(
-      "Prepare authoritative routine registration query",
+    ).then(
+      startDirectionalTaskMapSyncTask,
+      startSignalTaskMapSyncTask,
+      startIntentTaskMapSyncTask,
+      startActorTaskMapSyncTask,
+      startRoutineTaskMapSyncTask
+    );
+    gatherTaskRegistrationTask.then(primitivePhaseBarrierTask);
+    gatherSignalRegistrationTask.then(primitivePhaseBarrierTask);
+    gatherIntentRegistrationTask.then(primitivePhaseBarrierTask);
+    gatherActorRegistrationTask.then(primitivePhaseBarrierTask);
+    gatherRoutineRegistrationTask.then(primitivePhaseBarrierTask);
+    const markLocalServiceInsertedForBootstrapSyncTask = CadenzaService.createUniqueMetaTask(
+      "Mark local service inserted for bootstrap sync",
       (ctx) => {
-        if (!this.isCadenzaDBReady) {
-          return false;
-        }
         const serviceName2 = resolveSyncServiceName();
-        if (!serviceName2) {
+        const insertedServiceName = typeof ctx.__serviceName === "string" ? ctx.__serviceName : typeof ctx.service_name === "string" ? ctx.service_name : null;
+        if (!serviceName2 || insertedServiceName !== serviceName2) {
           return false;
         }
-        return {
-          ...ctx,
-          __syncServiceName: serviceName2,
-          queryData: {
-            filter: {
-              service_name: serviceName2
-            },
-            fields: ["name", "version", "service_name"]
-          }
-        };
+        this.localServiceInserted = true;
+        return true;
       },
-      "Builds the authority routine query payload for the current service.",
+      "Marks that the local service row has been inserted in authority so bootstrap sync can start only after that prerequisite.",
       {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(
-      authoritativeRoutineQueryGraph?.entryTask ?? skipAuthoritativeRoutineReconciliationTask
-    );
-    CadenzaService.createMetaTask(
-      "Prepare authoritative signal registration query",
+    ).doOn("meta.service_registry.service_inserted");
+    const markLocalServiceInstanceInsertedForBootstrapSyncTask = CadenzaService.createUniqueMetaTask(
+      "Mark local service instance inserted for bootstrap sync",
       (ctx) => {
-        if (!this.isCadenzaDBReady) {
+        const serviceName2 = resolveSyncServiceName();
+        const insertedServiceName = typeof ctx.__serviceName === "string" ? ctx.__serviceName : typeof ctx.service_name === "string" ? ctx.service_name : null;
+        if (!serviceName2 || insertedServiceName !== serviceName2) {
           return false;
         }
-        return {
-          ...ctx,
-          queryData: {
-            fields: ["name"]
-          }
-        };
+        this.localServiceInstanceInserted = true;
+        return true;
       },
-      "Builds the authority signal query payload for local reconciliation.",
+      "Marks that the local service instance row has been inserted in authority so bootstrap sync can start only after that prerequisite.",
       {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(
-      authoritativeSignalQueryGraph?.entryTask ?? skipAuthoritativeSignalReconciliationTask
-    );
-    CadenzaService.createMetaTask(
-      "Prepare authoritative intent registration query",
+    ).doOn("meta.service_registry.instance_inserted");
+    const startBootstrapSyncTask = CadenzaService.createUniqueMetaTask(
+      "Start bootstrap graph sync",
       (ctx) => {
-        if (!this.isCadenzaDBReady) {
+        const now = Date.now();
+        const serviceName2 = resolveSyncServiceName();
+        const serviceInstanceId = CadenzaService.serviceRegistry.serviceInstanceId;
+        if (!serviceName2 || !serviceInstanceId) {
+          return false;
+        }
+        if (!this.localServiceInserted) {
+          return false;
+        }
+        if (!this.localServiceInstanceInserted) {
+          return false;
+        }
+        if (!ServiceRegistry.instance.hasLocalInstanceRegistered()) {
           return false;
         }
+        if (this.activeSyncCycleId) {
+          const activeCycleAgeMs = now - this.activeSyncCycleStartedAt;
+          if (activeCycleAgeMs < BOOTSTRAP_SYNC_STALE_CYCLE_MS) {
+            this.pendingBootstrapSyncRerun = true;
+            return false;
+          }
+        }
+        const syncCycleId = `${now}-${++this.syncCycleCounter}`;
+        this.activeSyncCycleId = syncCycleId;
+        this.activeSyncCycleStartedAt = now;
+        this.pendingBootstrapSyncRerun = false;
+        this.tasksSynced = false;
+        this.signalsSynced = false;
+        this.intentsSynced = false;
+        this.actorsSynced = false;
+        this.routinesSynced = false;
         return {
           ...ctx,
-          queryData: {
-            fields: ["name"]
-          }
+          __syncing: true,
+          __syncCycleId: syncCycleId,
+          __serviceName: serviceName2,
+          __serviceInstanceId: serviceInstanceId
         };
       },
-      "Builds the authority intent query payload for local reconciliation.",
+      "Starts a deterministic bootstrap sync cycle once the local service instance exists.",
       {
         register: false,
         isHidden: true
       }
-    ).doOn(...authoritativeRegistrationTriggers).then(
-      authoritativeIntentQueryGraph?.entryTask ?? skipAuthoritativeIntentReconciliationTask
-    );
-    CadenzaService.signalBroker.getSignalsTask.clone().doOn(
-      "meta.sync_controller.sync_tick",
-      "meta.service_registry.initial_sync_complete",
-      "meta.sync_requested"
-    ).then(this.splitSignalsTask);
-    CadenzaService.registry.getAllTasks.clone().doOn(
-      "meta.sync_controller.sync_tick",
-      "meta.sync_controller.synced_signals",
-      "meta.sync_requested"
-    ).then(this.splitTasksForRegistration);
-    CadenzaService.createMetaTask("Get all intents", (ctx) => {
-      return {
-        ...ctx,
-        intents: Array.from(CadenzaService.inquiryBroker.intents.values())
-      };
-    }).doOn(
-      "meta.sync_controller.sync_tick",
-      "meta.service_registry.initial_sync_complete",
-      "meta.sync_requested"
-    ).then(this.splitIntentsTask);
-    CadenzaService.registry.getAllRoutines.clone().doOn(
-      "meta.sync_controller.sync_tick",
-      "meta.service_registry.initial_sync_complete",
-      "meta.sync_requested"
-    ).then(this.splitRoutinesTask);
-    CadenzaService.createMetaTask("Get all actors", (ctx) => {
-      return {
-        ...ctx,
-        actors: CadenzaService.getAllActors()
-      };
-    }).doOn(
+    ).doOn(
+      "meta.service_registry.service_inserted",
+      "meta.service_registry.instance_inserted",
       "meta.sync_controller.sync_tick",
-      "meta.service_registry.initial_sync_complete",
       "meta.sync_requested"
-    ).then(this.splitActorsForRegistration);
-    CadenzaService.createMetaTask("Get registered task for task graph sync", (ctx) => {
-      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
-      if (!task) {
-        return false;
+    );
+    const startTaskPrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start task primitive sync",
+      (ctx) => ctx,
+      "Starts the task registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
       }
-      return {
-        ...ctx,
-        task
-      };
-    }).doOn("meta.sync_controller.task_registered").then(
-      this.registerTaskMapTask,
-      this.registerDeputyRelationshipTask
     );
-    CadenzaService.registry.doForEachTask.clone().doOn(
-      "meta.sync_controller.synced_signals",
-      "meta.sync_controller.synced_tasks",
-      "meta.sync_requested"
-    ).then(this.registerSignalToTaskMapTask);
-    CadenzaService.createMetaTask("Get registered task for signal sync", (ctx) => {
-      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
-      if (!task) {
-        return false;
+    const startSignalPrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start signal primitive sync",
+      (ctx) => ctx,
+      "Starts the signal registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
       }
-      return {
-        ...ctx,
-        task
-      };
-    }).doOn("meta.sync_controller.task_registered").then(this.registerSignalToTaskMapTask);
-    CadenzaService.registry.doForEachTask.clone().doOn(
-      "meta.sync_controller.synced_intents",
-      "meta.sync_controller.synced_tasks",
-      "meta.sync_requested"
-    ).then(this.registerIntentToTaskMapTask);
-    CadenzaService.createMetaTask("Get registered task for intent sync", (ctx) => {
-      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
-      if (!task) {
-        return false;
+    );
+    const startIntentPrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start intent primitive sync",
+      (ctx) => ctx,
+      "Starts the intent registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
       }
-      return {
-        ...ctx,
-        task
-      };
-    }).doOn("meta.sync_controller.task_registered").then(this.registerIntentToTaskMapTask);
-    CadenzaService.registry.doForEachTask.clone().doOn(
-      "meta.sync_controller.synced_actors",
-      "meta.sync_controller.synced_tasks",
-      "meta.sync_requested"
-    ).then(this.registerActorTaskMapTask);
-    CadenzaService.createMetaTask("Get registered task for actor sync", (ctx) => {
-      const task = ctx.task ?? (ctx.__taskName ? CadenzaService.get(ctx.__taskName) : void 0);
-      if (!task) {
-        return false;
+    );
+    const startActorPrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start actor primitive sync",
+      (ctx) => ctx,
+      "Starts the actor registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
       }
-      return {
+    );
+    const startRoutinePrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start routine primitive sync",
+      (ctx) => ctx,
+      "Starts the routine registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    startBootstrapSyncTask.then(
+      startTaskPrimitiveSyncTask,
+      startSignalPrimitiveSyncTask,
+      startIntentPrimitiveSyncTask,
+      startActorPrimitiveSyncTask,
+      startRoutinePrimitiveSyncTask
+    );
+    const getAllTasksForSyncTask = CadenzaService.registry.getAllTasks.clone();
+    startTaskPrimitiveSyncTask.then(
+      getAllTasksForSyncTask,
+      gatherTaskRegistrationTask
+    );
+    getAllTasksForSyncTask.then(this.splitTasksForRegistration);
+    const getSignalsForSyncTask = CadenzaService.signalBroker.getSignalsTask.clone();
+    startSignalPrimitiveSyncTask.then(
+      getSignalsForSyncTask,
+      gatherSignalRegistrationTask
+    );
+    getSignalsForSyncTask.then(this.splitSignalsTask);
+    const getAllIntentsForSyncTask = CadenzaService.createUniqueMetaTask(
+      "Get all intents for sync",
+      (ctx) => ({
         ...ctx,
-        task
-      };
-    }).doOn("meta.sync_controller.task_registered").then(
-      CadenzaService.createMetaTask(
-        "Ensure actor and task sync ready from task registration",
-        (ctx) => {
-          if (!this.tasksSynced || !this.actorsSynced) {
-            return false;
-          }
-          return ctx;
-        }
-      ).then(this.registerActorTaskMapTask)
+        intents: Array.from(CadenzaService.inquiryBroker.intents.values()).filter(
+          (intent) => isRegistrableLocalIntentDefinition(intent)
+        )
+      }),
+      "Collects local intents for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
+      }
     );
-    CadenzaService.registry.getAllRoutines.clone().doOn(
-      "meta.sync_controller.synced_routines",
-      "meta.sync_controller.synced_tasks",
-      "meta.sync_requested"
-    ).then(
-      CadenzaService.createMetaTask(
-        "Ensure routine and task sync ready",
-        (ctx) => {
-          if (!this.tasksSynced || !this.routinesSynced) {
-            return false;
-          }
-          return ctx;
-        }
-      ).then(this.splitTasksInRoutines)
+    startIntentPrimitiveSyncTask.then(
+      getAllIntentsForSyncTask,
+      gatherIntentRegistrationTask
     );
-    CadenzaService.createMetaTask("Finish sync", (ctx, emit) => {
-      emit("global.meta.sync_controller.synced", {
-        data: {
-          is_active: true,
-          is_non_responsive: false,
-          is_blocked: false,
-          last_active: formatTimestamp(Date.now())
-        },
-        filter: {
-          uuid: CadenzaService.serviceRegistry.serviceInstanceId
+    getAllIntentsForSyncTask.then(this.splitIntentsTask);
+    const getAllActorsForSyncTask = CadenzaService.createUniqueMetaTask(
+      "Get all actors for sync",
+      (ctx) => ({
+        ...ctx,
+        actors: CadenzaService.getAllActors()
+      }),
+      "Collects local actors for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    startActorPrimitiveSyncTask.then(
+      getAllActorsForSyncTask,
+      gatherActorRegistrationTask
+    );
+    getAllActorsForSyncTask.then(this.splitActorsForRegistration);
+    const getAllRoutinesForSyncTask = CadenzaService.registry.getAllRoutines.clone();
+    startRoutinePrimitiveSyncTask.then(
+      getAllRoutinesForSyncTask,
+      gatherRoutineRegistrationTask
+    );
+    getAllRoutinesForSyncTask.then(this.splitRoutinesTask);
+    const iterateTasksForDirectionalTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    startDirectionalTaskMapSyncTask.then(
+      iterateTasksForDirectionalTaskMapSyncTask,
+      gatherDirectionalTaskMapRegistrationTask
+    );
+    iterateTasksForDirectionalTaskMapSyncTask.then(this.registerTaskMapTask);
+    recordTaskMapRegistrationTask.then(gatherDirectionalTaskMapRegistrationTask);
+    gatherDirectionalTaskMapRegistrationTask.then(mapPhaseBarrierTask);
+    const iterateTasksForSignalTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    startSignalTaskMapSyncTask.then(
+      iterateTasksForSignalTaskMapSyncTask,
+      gatherSignalTaskMapRegistrationTask
+    );
+    iterateTasksForSignalTaskMapSyncTask.then(this.registerSignalToTaskMapTask);
+    registerSignalTask.then(gatherSignalTaskMapRegistrationTask);
+    gatherSignalTaskMapRegistrationTask.then(mapPhaseBarrierTask);
+    const iterateTasksForIntentTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    startIntentTaskMapSyncTask.then(
+      iterateTasksForIntentTaskMapSyncTask,
+      gatherIntentTaskMapRegistrationTask
+    );
+    iterateTasksForIntentTaskMapSyncTask.then(this.registerIntentToTaskMapTask);
+    registerIntentTask.then(gatherIntentTaskMapRegistrationTask);
+    gatherIntentTaskMapRegistrationTask.then(mapPhaseBarrierTask);
+    const iterateTasksForActorTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
+    startActorTaskMapSyncTask.then(
+      iterateTasksForActorTaskMapSyncTask,
+      gatherActorTaskMapRegistrationTask
+    );
+    iterateTasksForActorTaskMapSyncTask.then(this.registerActorTaskMapTask);
+    recordActorTaskMapRegistrationTask.then(gatherActorTaskMapRegistrationTask);
+    gatherActorTaskMapRegistrationTask.then(mapPhaseBarrierTask);
+    const getAllRoutinesForTaskMapSyncTask = CadenzaService.registry.getAllRoutines.clone();
+    startRoutineTaskMapSyncTask.then(
+      getAllRoutinesForTaskMapSyncTask,
+      gatherRoutineTaskMapRegistrationTask
+    );
+    getAllRoutinesForTaskMapSyncTask.then(this.splitTasksInRoutines);
+    registerTaskToRoutineMapTask.then(gatherRoutineTaskMapRegistrationTask);
+    gatherRoutineTaskMapRegistrationTask.then(mapPhaseBarrierTask);
+    CadenzaService.createMetaTask(
+      "Request sync after local service instance registration",
+      (ctx) => {
+        for (const delayMs of EARLY_SYNC_TICK_DELAYS_MS) {
+          CadenzaService.schedule(
+            "meta.sync_controller.sync_tick",
+            {
+              ...buildMinimalSyncSignalContext(ctx),
+              __syncing: true
+            },
+            delayMs
+          );
         }
-      });
-      CadenzaService.log("Synced resources...");
-    }).attachSignal("global.meta.sync_controller.synced").doOn("meta.sync_controller.synced_resource");
-    if (!this.isCadenzaDBReady) {
-      CadenzaService.interval(
-        "meta.sync_controller.sync_tick",
-        { __syncing: true },
-        3e5,
-        true
-      );
-    } else {
-      CadenzaService.interval(
-        "meta.sync_controller.sync_tick",
-        { __syncing: true },
-        18e4
-      );
-      CadenzaService.schedule(
-        "meta.sync_controller.sync_tick",
-        { __syncing: true },
-        250
-      );
-      for (const delayMs of EARLY_SYNC_REQUEST_DELAYS_MS) {
-        CadenzaService.schedule("meta.sync_requested", { __syncing: true }, delayMs);
+        return true;
+      },
+      "Schedules the early bootstrap sync burst after local instance registration so startup-defined primitives can converge deterministically.",
+      {
+        register: false,
+        isHidden: true
       }
-    }
+    ).doOn("meta.service_registry.instance_inserted");
+    CadenzaService.interval(
+      "meta.sync_controller.sync_tick",
+      { __syncing: true },
+      this.isCadenzaDBReady ? 18e4 : 3e5
+    );
   }
 };
 
@@ -8618,7 +9370,53 @@ function resolveBootstrapEndpoint(options) {
 }
 
 // src/Cadenza.ts
+var POSTGRES_SETUP_DEBUG_ENABLED = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
+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 CadenzaService = class {
+  static replayRegisteredTaskIntentAssociations() {
+    for (const task of this.registry.tasks.values()) {
+      if (!task.register || task.isHidden || task.handlesIntents.size === 0) {
+        continue;
+      }
+      for (const intentName of task.handlesIntents) {
+        task.emitWithMetadata("meta.task.intent_associated", {
+          data: {
+            intentName,
+            taskName: task.name,
+            taskVersion: task.version
+          },
+          taskInstance: task,
+          __isSubMeta: task.isSubMeta
+        });
+      }
+    }
+  }
+  static replayRegisteredTaskSignalObservations() {
+    for (const task of this.registry.tasks.values()) {
+      if (!task.register || task.isHidden || task.observedSignals.size === 0) {
+        continue;
+      }
+      for (const signalName of task.observedSignals) {
+        task.emitWithMetadata("meta.task.observed_signal", {
+          data: {
+            signalName,
+            taskName: task.name,
+            taskVersion: task.version
+          },
+          taskInstance: task,
+          signalName,
+          __isSubMeta: task.isSubMeta
+        });
+      }
+    }
+  }
+  static replayRegisteredTaskGraphMetadata() {
+    this.replayRegisteredTaskSignalObservations();
+    this.replayRegisteredTaskIntentAssociations();
+  }
   static buildLegacyLocalCadenzaDBTaskName(tableName, operation) {
     const operationPrefix = operation.charAt(0).toUpperCase() + operation.slice(1);
     const helperSuffix = (0, import_lodash_es.camelCase)(String(tableName ?? "").trim());
@@ -8761,6 +9559,12 @@ var CadenzaService = class {
   static setMode(mode) {
     import_core5.default.setMode(mode);
   }
+  static hasCompletedBootstrapSync() {
+    return !this.serviceCreated || this.bootstrapSyncCompleted;
+  }
+  static markBootstrapSyncCompleted() {
+    this.bootstrapSyncCompleted = true;
+  }
   /**
    * Emits a signal with the specified data using the associated broker.
    *
@@ -8848,6 +9652,46 @@ var CadenzaService = class {
       responders: statuses
     };
   }
+  static shouldPersistInquiry(inquiry, _context) {
+    return !isMetaIntentName(inquiry);
+  }
+  static splitInquiryPersistenceContext(context) {
+    const businessContext = {};
+    const metadata = context?.__metadata && typeof context.__metadata === "object" ? { ...context.__metadata } : {};
+    for (const [key, value] of Object.entries(context ?? {})) {
+      if (key === "__metadata") {
+        continue;
+      }
+      if (key.startsWith("__")) {
+        metadata[key] = value;
+        continue;
+      }
+      businessContext[key] = value;
+    }
+    return {
+      context: businessContext,
+      metadata
+    };
+  }
+  static buildInquiryPersistenceStartData(inquiryId, inquiry, context, startedAt) {
+    const normalizedTaskVersion = Number(context?.__inquirySourceTaskVersion);
+    const { context: inquiryContext, metadata } = this.splitInquiryPersistenceContext(context);
+    return {
+      uuid: inquiryId,
+      name: inquiry,
+      taskName: typeof context?.__inquirySourceTaskName === "string" ? context.__inquirySourceTaskName : null,
+      taskVersion: Number.isFinite(normalizedTaskVersion) && normalizedTaskVersion > 0 ? normalizedTaskVersion : null,
+      taskExecutionId: typeof context?.__inquirySourceTaskExecutionId === "string" ? context.__inquirySourceTaskExecutionId : null,
+      serviceName: this.serviceRegistry.serviceName,
+      serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+      executionTraceId: typeof (context?.__metadata?.__executionTraceId ?? context?.__executionTraceId) === "string" ? context.__metadata?.__executionTraceId ?? context.__executionTraceId : null,
+      routineExecutionId: typeof context?.__inquirySourceRoutineExecutionId === "string" ? context.__inquirySourceRoutineExecutionId : null,
+      context: inquiryContext,
+      metadata,
+      isMeta: false,
+      sentAt: formatTimestamp(startedAt)
+    };
+  }
   static async inquire(inquiry, context, options = {}) {
     this.bootstrap();
     const hydratedResult = this.consumeHydratedInquiryResult(
@@ -8862,6 +9706,20 @@ var CadenzaService = class {
       descriptor: this.getInquiryResponderDescriptor(task)
     })) : [];
     const isMetaInquiry = isMetaIntentName(inquiry);
+    const startedAt = Date.now();
+    const persistInquiry = this.shouldPersistInquiry(inquiry, context);
+    const logicalInquiryId = persistInquiry ? (0, import_uuid5.v4)() : null;
+    const inquiryStartData = logicalInquiryId ? this.buildInquiryPersistenceStartData(
+      logicalInquiryId,
+      inquiry,
+      context,
+      startedAt
+    ) : null;
+    if (inquiryStartData) {
+      this.emit("meta.inquiry_broker.inquiry_started", {
+        data: inquiryStartData
+      });
+    }
     const responders = allResponders.filter(({ task, descriptor }) => {
       const shouldExecute = shouldExecuteInquiryResponder(inquiry, task.isMeta);
       if (shouldExecute) {
@@ -8896,6 +9754,21 @@ var CadenzaService = class {
         durationMs: 0,
         responders: []
       };
+      if (logicalInquiryId) {
+        this.emit("meta.inquiry_broker.inquiry_completed", {
+          data: {
+            fulfilledAt: formatTimestamp(startedAt),
+            duration: 0,
+            metadata: {
+              ...inquiryStartData?.metadata ?? {},
+              inquiryMeta
+            }
+          },
+          filter: {
+            uuid: logicalInquiryId
+          }
+        });
+      }
       if (options.requireComplete) {
         throw {
           __inquiryMeta: inquiryMeta,
@@ -8911,7 +9784,6 @@ var CadenzaService = class {
     const overallTimeoutMs = options.overallTimeoutMs ?? options.timeout ?? 0;
     const requireComplete = options.requireComplete ?? false;
     const perResponderTimeoutMs = options.perResponderTimeoutMs;
-    const startedAt = Date.now();
     const statuses = [];
     const statusByTask = /* @__PURE__ */ new Map();
     for (const responder of responders) {
@@ -8957,10 +9829,26 @@ var CadenzaService = class {
           statuses,
           allResponders.length
         );
+        const finishedAt = Date.now();
         const responseContext = {
           ...mergedContext,
           __inquiryMeta: inquiryMeta
         };
+        if (logicalInquiryId) {
+          this.emit("meta.inquiry_broker.inquiry_completed", {
+            data: {
+              fulfilledAt: formatTimestamp(finishedAt),
+              duration: finishedAt - startedAt,
+              metadata: {
+                ...inquiryStartData?.metadata ?? {},
+                inquiryMeta
+              }
+            },
+            filter: {
+              uuid: logicalInquiryId
+            }
+          });
+        }
         if (requireComplete && (timedOut || inquiryMeta.failed > 0 || inquiryMeta.timedOut > 0 || inquiryMeta.pending > 0)) {
           reject({
             ...responseContext,
@@ -8976,7 +9864,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = (0, import_uuid5.v4)();
+        const responderInquiryId = (0, import_uuid5.v4)();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -9004,11 +9892,12 @@ var CadenzaService = class {
           },
           "Resolves distributed inquiry responder result",
           { register: false }
-        ).doOn(`meta.node.graph_completed:${inquiryId}`);
+        ).doOn(`meta.node.graph_completed:${responderInquiryId}`);
         resolverTasks.push(resolverTask);
         const executionContext = {
           ...context,
-          __routineExecId: inquiryId,
+          ...logicalInquiryId ? { __inquiryId: logicalInquiryId } : {},
+          __routineExecId: responderInquiryId,
           __isInquiry: true
         };
         if (perResponderTimeoutMs !== void 0) {
@@ -9170,8 +10059,8 @@ var CadenzaService = class {
     this.validateName(routineName);
     const name = `${routineName} (Proxy)`;
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DEPUTY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DEPUTY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: false,
@@ -9278,8 +10167,8 @@ var CadenzaService = class {
       return;
     }
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: true,
@@ -9340,8 +10229,8 @@ var CadenzaService = class {
     const description = `Executes a ${operation} on table ${tableName} in ${targetDatabaseServiceName}`;
     const taskName = `${operation.charAt(0).toUpperCase() + operation.slice(1)} ${tableName}`;
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: false,
@@ -9485,8 +10374,10 @@ var CadenzaService = class {
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
     const serviceId = options.customServiceId ?? (0, import_uuid5.v4)();
+    this.bootstrapSyncCompleted = false;
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
+    this.serviceRegistry.connectsToCadenzaDB = !!options.cadenzaDB?.connect;
     this.setHydrationResults(options.hydration);
     const explicitFrontendMode = options.isFrontend;
     options = {
@@ -9515,6 +10406,23 @@ var CadenzaService = class {
     this.serviceRegistry.useSocket = !!options.useSocket;
     this.serviceRegistry.retryCount = options.retryCount ?? 3;
     this.ensureTransportControllers(isFrontend);
+    if (!isFrontend) {
+      this.createMetaTask(
+        "Initialize graph metadata controller after initial sync",
+        () => {
+          this.markBootstrapSyncCompleted();
+          GraphMetadataController.instance;
+          return true;
+        },
+        "Delays direct graph-metadata registration until the bootstrap sync has completed.",
+        {
+          register: false,
+          isHidden: true
+        }
+      ).doOn("meta.service_registry.initial_sync_complete");
+      GraphSyncController.instance.isCadenzaDBReady = serviceName === "CadenzaDB";
+      GraphSyncController.instance.init();
+    }
     const resolvedBootstrapEndpoint = options.cadenzaDB?.connect ? resolveBootstrapEndpoint({
       runtime: isFrontend ? "browser" : "server",
       bootstrap: options.bootstrap,
@@ -9588,14 +10496,14 @@ var CadenzaService = class {
       data: {
         name: serviceName,
         description,
-        displayName: options.displayName ?? "",
-        isMeta: options.isMeta
+        display_name: options.displayName ?? "",
+        is_meta: options.isMeta
       },
       __registrationData: {
         name: serviceName,
         description,
-        displayName: options.displayName ?? "",
-        isMeta: options.isMeta
+        display_name: options.displayName ?? "",
+        is_meta: options.isMeta
       },
       __serviceName: serviceName,
       __serviceInstanceId: serviceId,
@@ -9626,14 +10534,13 @@ var CadenzaService = class {
         );
       }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
-    this.createMetaTask("Handle service setup completion", () => {
+    this.createMetaTask("Handle service setup completion", (ctx, emit) => {
+      if (options.cadenzaDB?.connect) {
+        this.serviceRegistry.bootstrapFullSync(emit, ctx, "service_setup_completed");
+      }
       if (isFrontend) {
         registerActorSessionPersistenceTasks();
         this.ensureFrontendSyncLoop();
-      } else {
-        GraphMetadataController.instance;
-        GraphSyncController.instance.isCadenzaDBReady = serviceName === "CadenzaDB" || !!options.cadenzaDB?.connect;
-        GraphSyncController.instance.init();
       }
       this.log("Service created.");
       return true;
@@ -9662,7 +10569,15 @@ var CadenzaService = class {
             is_blocked: false,
             health: {}
           },
-          __transportData: [],
+          __transportData: declaredTransports.map((transport) => ({
+            uuid: transport.uuid,
+            service_instance_id: serviceId,
+            role: transport.role,
+            origin: transport.origin,
+            protocols: transport.protocols ?? ["rest", "socket"],
+            ...transport.securityProfile ? { security_profile: transport.securityProfile } : {},
+            ...transport.authStrategy ? { auth_strategy: transport.authStrategy } : {}
+          })),
           __serviceName: serviceName,
           __serviceInstanceId: serviceId,
           __useSocket: options.useSocket,
@@ -9779,10 +10694,35 @@ var CadenzaService = class {
       registration.actorName
     );
     const createServiceTaskName = `Create database service ${name} after ${registration.actorName} setup`;
+    const traceSetupDoneTaskName = `Trace database service ${name} setup done`;
+    if (POSTGRES_SETUP_DEBUG_ENABLED && !this.get(traceSetupDoneTaskName)) {
+      this.createMetaTask(
+        traceSetupDoneTaskName,
+        (ctx) => {
+          console.log("[CADENZA_POSTGRES_SETUP_DEBUG] setup_done_signal_observed", {
+            serviceName: name,
+            actorName: registration.actorName,
+            payloadKeys: Object.keys(ctx ?? {})
+          });
+          return true;
+        },
+        "Debug trace for PostgresActor setup-done signal delivery.",
+        { isHidden: true, register: false }
+      ).doOn(registration.setupDoneSignal);
+    }
     if (!this.get(createServiceTaskName)) {
       this.createMetaTask(
         createServiceTaskName,
         () => {
+          if (POSTGRES_SETUP_DEBUG_ENABLED) {
+            console.log(
+              "[CADENZA_POSTGRES_SETUP_DEBUG] create_database_service_task_fired",
+              {
+                serviceName: name,
+                actorName: registration.actorName
+              }
+            );
+          }
           this.createCadenzaService(name, description, serviceOptions);
           return true;
         },
@@ -10314,6 +11254,7 @@ var CadenzaService = class {
     this.serviceRegistry?.reset();
     this.isBootstrapped = false;
     this.serviceCreated = false;
+    this.bootstrapSyncCompleted = false;
     this.defaultDatabaseServiceName = null;
     this.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
     this.hydratedInquiryResults = /* @__PURE__ */ new Map();
@@ -10322,6 +11263,7 @@ var CadenzaService = class {
 };
 CadenzaService.isBootstrapped = false;
 CadenzaService.serviceCreated = false;
+CadenzaService.bootstrapSyncCompleted = false;
 CadenzaService.defaultDatabaseServiceName = null;
 CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
 CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();