@cadenza.io/service 2.18.1 → 2.18.2

package/dist/browser/index.js

@@ -739,6 +739,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",
@@ -880,6 +895,18 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         ctx.__resolverQueryData ?? ctx.queryData ?? {},
         ctx
       );
+      if (tableName === "service_instance" && (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;
       }
@@ -924,6 +951,18 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       ).doOn(executionResolvedSignal, executionFailedSignal);
       const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
       const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
+      if (tableName === "service_instance" && (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 +1045,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.",
@@ -1380,7 +1420,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),
@@ -1534,7 +1577,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 +1620,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 +1637,23 @@ 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()) {
+          return false;
+        }
         const inquiryResult = await CadenzaService.inquire(
           META_SERVICE_REGISTRY_FULL_SYNC_INTENT,
           {
@@ -1646,7 +1710,7 @@ var ServiceRegistry = class _ServiceRegistry {
     );
     this.handleDeputyRegistrationTask = CadenzaService.createMetaTask(
       "Handle Deputy Registration",
-      (ctx) => {
+      (ctx, emit) => {
         const { serviceName } = ctx;
         if (!this.deputies.has(serviceName)) this.deputies.set(serviceName, []);
         this.deputies.get(serviceName).push({
@@ -1656,6 +1720,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 +2273,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 +2351,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 +2369,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,9 +2435,41 @@ var ServiceRegistry = class _ServiceRegistry {
         ).attachSignal("meta.service_registry.transport_registration_requested")
       )
     );
+    CadenzaService.createMetaTask(
+      "Retry local service instance registration after failed insert",
+      (ctx) => {
+        const serviceName = String(
+          ctx.__serviceName ?? ctx.data?.service_name ?? this.serviceName ?? ""
+        ).trim();
+        if (!serviceName || serviceName !== this.serviceName) {
+          return false;
+        }
+        CadenzaService.schedule(
+          "meta.service_registry.instance_registration_requested",
+          { ...ctx },
+          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) => {
+        if (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") {
+          console.log("[CADENZA_INSTANCE_DEBUG] prepare_service_instance_registration", {
+            serviceName: ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? null,
+            serviceInstanceId: ctx.data?.uuid ?? ctx.__serviceInstanceId ?? this.serviceInstanceId ?? null,
+            hasData: !!ctx.data,
+            dataKeys: ctx.data && typeof ctx.data === "object" ? Object.keys(ctx.data) : [],
+            transportCount: Array.isArray(ctx.__transportData) ? ctx.__transportData.length : Array.isArray(ctx.transportData) ? ctx.transportData.length : 0,
+            skipRemoteExecution: ctx.__skipRemoteExecution === true
+          });
+        }
         const serviceName = String(
           ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
         ).trim();
@@ -2529,21 +2662,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 +2810,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"
@@ -2733,6 +2885,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 +2963,9 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return this.getInstance(this.serviceName, this.serviceInstanceId);
   }
+  hasLocalInstanceRegistered() {
+    return Boolean(this.getLocalInstance());
+  }
   summarizeTransportForDebug(transport) {
     if (!transport) {
       return void 0;
@@ -3748,6 +3953,7 @@ var SignalTransmissionTask = class extends import_core2.Task {
 };
 
 // src/network/RestController.browser.ts
+var FETCH_HANDSHAKE_TIMEOUT_MS = 5e3;
 var RestController = class _RestController {
   constructor() {
     this.fetchClientDiagnostics = /* @__PURE__ */ new Map();
@@ -3793,7 +3999,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 +4022,7 @@ var RestController = class _RestController {
         if (!serviceName || !URL2 || !fetchId) {
           return false;
         }
+        const clientTaskSuffix = `${URL2} (${fetchId})`;
         const fetchDiagnostics = this.ensureFetchClientDiagnostics(
           fetchId,
           serviceName,
@@ -3815,11 +4030,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 +4046,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}`;
@@ -3873,7 +4088,7 @@ var RestController = class _RestController {
           "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;
@@ -3916,7 +4131,7 @@ var RestController = class _RestController {
           `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;
@@ -3954,7 +4169,7 @@ var RestController = class _RestController {
           "Sends signal request"
         ).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();
@@ -3979,7 +4194,7 @@ var RestController = class _RestController {
           },
           "Requests status"
         ).doOn("meta.fetch.status_check_requested").emits("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
-        CadenzaService.createEphemeralMetaTask("Destroy fetch client", () => {
+        CadenzaService.createEphemeralMetaTask(`Destroy fetch client ${fetchId}`, () => {
           fetchDiagnostics.connected = false;
           fetchDiagnostics.destroyed = true;
           fetchDiagnostics.updatedAt = Date.now();
@@ -6284,6 +6499,12 @@ var GraphMetadataController = class _GraphMetadataController {
         }
       );
     }).doOn("meta.task.attached_signal").emits("global.meta.graph_metadata.task_attached_signal");
+    CadenzaService.createMetaTask("Handle task intent association", (ctx) => {
+      return buildDatabaseTriggerContext({
+        ...ctx.data,
+        serviceName: CadenzaService.serviceRegistry.serviceName
+      });
+    }).doOn("meta.task.intent_associated").emits("global.meta.graph_metadata.task_intent_associated");
     CadenzaService.createMetaTask("Handle task unsubscribing signal", (ctx) => {
       return buildDatabaseTriggerContext(
         {
@@ -6646,34 +6867,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 +6880,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 +6908,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 +6978,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,63 +7010,16 @@ 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 : [];
-}
-function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
-  const localQueryTask = CadenzaService.getLocalCadenzaDBQueryTask(tableName);
-  if (!localQueryTask && !isCadenzaDBReady) {
-    return void 0;
-  }
-  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
-  };
-}
+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 getRegistrableTasks() {
   return Array.from(CadenzaService.registry.tasks.values()).filter(
-    (task) => task.register && !task.isHidden
+    (task) => task.register && !task.isHidden && !task.isDeputy
   );
 }
 function getRegistrableRoutines() {
@@ -6899,10 +7084,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 +7174,9 @@ 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 (pendingTasks.length > 0) {
         this.tasksSynced = false;
         return false;
@@ -7033,6 +7195,7 @@ var GraphSyncController = class _GraphSyncController {
       const pendingRoutines = getRegistrableRoutines().filter(
         (routine) => !routine.registered
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
       if (pendingRoutines.length > 0) {
         this.routinesSynced = false;
         return false;
@@ -7051,6 +7214,7 @@ var GraphSyncController = class _GraphSyncController {
       const pendingSignals = getRegistrableSignalObservers().filter(
         (observer) => observer.registered !== true
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
       if (pendingSignals.length > 0) {
         this.signalsSynced = false;
         return false;
@@ -7069,6 +7233,7 @@ var GraphSyncController = class _GraphSyncController {
       const pendingIntentNames = getRegistrableIntentNames().filter(
         (intentName) => !this.registeredIntentDefinitions.has(intentName)
       );
+      const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
       if (pendingIntentNames.length > 0) {
         this.intentsSynced = false;
         return false;
@@ -7334,14 +7499,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;
         }
@@ -7353,6 +7519,12 @@ var GraphSyncController = class _GraphSyncController {
         if (observer) {
           observer.registered = true;
         }
+        emit(
+          "meta.sync_controller.signal_registered",
+          buildMinimalSyncSignalContext(ctx, {
+            __signal: signalName
+          })
+        );
         return { signalName };
       }
     ).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask);
@@ -7373,6 +7545,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;
@@ -7407,7 +7580,8 @@ var GraphSyncController = class _GraphSyncController {
                 signalsToEmitAfter: Array.from(task.signalsToEmitAfter),
                 signalsToEmitOnFail: Array.from(task.signalsToEmitOnFail),
                 observed: Array.from(task.observedSignals)
-              }
+              },
+              intents: Array.from(task.handlesIntents)
             },
             __taskName: task.name
           };
@@ -7430,13 +7604,15 @@ 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;
         }
@@ -7451,24 +7627,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 +7765,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 +7784,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;
@@ -7707,7 +7867,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const recordIntentDefinitionRegistrationTask = CadenzaService.createMetaTask(
       "Record intent definition registration",
-      (ctx) => {
+      (ctx, emit) => {
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
@@ -7715,6 +7875,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 +7892,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 +7910,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;
@@ -7799,30 +7966,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 +7984,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 +7996,7 @@ 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) return;
         const predecessorServiceName = resolveSyncServiceName(task);
         if (!predecessorServiceName) {
           return;
@@ -7999,452 +8130,583 @@ var GraphSyncController = class _GraphSyncController {
       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) {
-            continue;
-          }
-          const task = CadenzaService.get(taskName);
-          if (!task || task.registered) {
-            continue;
-          }
-          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 changed;
-      },
-      "Marks local tasks as registered when authority rows already exist.",
-      {
-        register: false,
-        isHidden: true
+    const hasPendingDirectionalTaskMaps = () => getRegistrableTasks().some((task) => {
+      const taskWithDeputyState = task;
+      if (task.isHidden || !task.register || !task.registered) {
+        return false;
       }
-    );
-    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 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 (authoritativeRoutines.length > 0 || changed) {
-          finalizeRoutineSync(emit, {
-            ...ctx,
-            __authoritativeReconciliation: true
-          });
+        if (resolveSyncServiceName(nextTask)) {
+          return true;
         }
-        return changed;
-      },
-      "Marks local routines as registered when authority rows already exist.",
-      {
-        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) {
+      if (task.isDeputy && !taskWithDeputyState.signalName && !taskWithDeputyState.registeredDeputyMap) {
+        return Boolean(resolveSyncServiceName(task) && resolveSyncServiceName());
+      }
+      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;
+        }
+        const signalName = signal.split(":")[0];
+        if (!decomposeSignalName(signalName).isGlobal) {
+          continue;
+        }
+        if (!CadenzaService.signalBroker.signalObservers?.get(signalName)?.registered) {
+          continue;
+        }
+        return true;
+      }
+      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 observer = signalObservers?.get(signalName);
-          if (!observer || observer.registered) {
-            continue;
+          if (!routine.registeredTasks.has(nextTask.name)) {
+            return true;
           }
-          observer.registered = true;
-          changed = true;
         }
-        if (authoritativeSignals.length > 0 || changed) {
-          finalizeSignalSync(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 signals 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 reconcileIntentRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
-      "Reconcile intent registration from authority",
+    const gatherSignalTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather signal task map registration",
+      (ctx) => {
+        if (hasPendingSignalTaskMaps()) {
+          this.signalTaskMapsSynced = false;
+          return false;
+        }
+        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;
+        }
+        this.intentTaskMapsSynced = true;
+        return ctx;
+      },
+      "Completes intent-to-task map registration when all task responders are registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherActorTaskMapRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather actor task map registration",
+      (ctx) => {
+        if (hasPendingActorTaskMaps()) {
+          this.actorTaskMapsSynced = false;
+          return false;
+        }
+        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;
+        }
+        this.routineTaskMapsSynced = true;
+        return ctx;
+      },
+      "Completes task-to-routine map registration when all routine task memberships are registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    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
-          });
+        if (!this.directionalTaskMapsSynced || !this.signalTaskMapsSynced || !this.intentTaskMapsSynced || !this.actorTaskMapsSynced || !this.routineTaskMapsSynced) {
+          return false;
+        }
+        if (!markCompletedSyncCycle(this.mapPhaseCompletedCycles, syncCycleId)) {
+          return false;
         }
-        return changed;
+        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 (!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 {
+    );
+    const startActorPrimitiveSyncTask = CadenzaService.createMetaTask(
+      "Start actor primitive sync",
+      (ctx) => ctx,
+      "Starts the actor registration branch for the current sync cycle.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    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(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;
+        intents: Array.from(CadenzaService.inquiryBroker.intents.values())
+      }),
+      "Collects local intents for the primitive sync phase.",
+      {
+        register: false,
+        isHidden: true
       }
-      return {
+    );
+    startIntentPrimitiveSyncTask.then(
+      getAllIntentsForSyncTask,
+      gatherIntentRegistrationTask
+    );
+    getAllIntentsForSyncTask.then(this.splitIntentsTask);
+    const getAllActorsForSyncTask = CadenzaService.createUniqueMetaTask(
+      "Get all actors 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)
+        actors: CadenzaService.getAllActors()
+      }),
+      "Collects local actors 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)
+    startActorPrimitiveSyncTask.then(
+      getAllActorsForSyncTask,
+      gatherActorRegistrationTask
     );
-    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
+    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,
+      this.registerDeputyRelationshipTask
+    );
+    recordTaskMapRegistrationTask.then(gatherDirectionalTaskMapRegistrationTask);
+    recordDeputyRelationshipRegistrationTask.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
+    );
   }
 };
 
@@ -8619,6 +8881,47 @@ function resolveBootstrapEndpoint(options) {
 
 // src/Cadenza.ts
 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());
@@ -9487,6 +9790,7 @@ var CadenzaService = class {
     const serviceId = options.customServiceId ?? (0, import_uuid5.v4)();
     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 +9819,22 @@ 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",
+        () => {
+          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,
@@ -9626,14 +9946,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 +9981,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,