@cadenza.io/service 2.17.47 → 2.17.49

package/dist/browser/index.js

@@ -6246,10 +6246,21 @@ function buildSyncInsertQueryData(ctx, queryData = {}) {
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
   const remoteInsertTask = isCadenzaDBReady ? CadenzaService.createCadenzaDBInsertTask(tableName, queryData, options) : void 0;
+  const debugTable = shouldDebugSyncTable(tableName);
   if (!localInsertTask && !remoteInsertTask) {
     return void 0;
   }
   const targetTask = localInsertTask ?? remoteInsertTask;
+  if (debugTable) {
+    logSyncDebug("insert_task_resolved", {
+      tableName,
+      localInsertTaskName: localInsertTask?.name ?? null,
+      remoteInsertTaskName: remoteInsertTask?.name ?? null,
+      targetTaskName: targetTask.name,
+      queryData,
+      options
+    });
+  }
   const executionRequestedSignal = `meta.sync_controller.insert_execution_requested:${tableName}`;
   const executionResolvedSignal = `meta.sync_controller.insert_execution_resolved:${tableName}`;
   const executionFailedSignal = `meta.sync_controller.insert_execution_failed:${tableName}`;
@@ -6283,6 +6294,26 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       isHidden: true
     }
   ).doOn(executionRequestedSignal).emitsOnFail(executionFailedSignal);
+  if (debugTable) {
+    prepareExecutionTask.then(
+      CadenzaService.createMetaTask(
+        `Log prepared graph sync insert execution for ${tableName}`,
+        (ctx) => {
+          logSyncDebug("insert_prepare", {
+            tableName,
+            targetTaskName: targetTask.name,
+            ctx
+          });
+          return ctx;
+        },
+        `Logs prepared ${tableName} sync insert payloads.`,
+        {
+          register: false,
+          isHidden: true
+        }
+      )
+    );
+  }
   const finalizeExecutionTask = CadenzaService.createMetaTask(
     `Finalize graph sync insert execution for ${tableName}`,
     (ctx, emit) => {
@@ -6299,6 +6330,14 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
+      if (debugTable) {
+        logSyncDebug("insert_finalize", {
+          tableName,
+          targetTaskName: targetTask.name,
+          success: didSyncInsertSucceed(normalizedContext),
+          ctx: normalizedContext
+        });
+      }
       pendingResolverContexts.delete(ctx.__resolverRequestId);
       emit(executionResolvedSignal, normalizedContext);
       return normalizedContext;
@@ -6311,6 +6350,27 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
   );
   targetTask.then(finalizeExecutionTask).emitsOnFail(executionFailedSignal);
   prepareExecutionTask.then(targetTask);
+  if (debugTable) {
+    CadenzaService.createMetaTask(
+      `Log failed graph sync insert execution for ${tableName}`,
+      (ctx) => {
+        logSyncDebug("insert_failed", {
+          tableName,
+          targetTaskName: targetTask.name,
+          ctx
+        });
+        if (typeof ctx.__resolverRequestId === "string") {
+          pendingResolverContexts.delete(ctx.__resolverRequestId);
+        }
+        return false;
+      },
+      `Logs failed ${tableName} sync insert executions.`,
+      {
+        register: false,
+        isHidden: true
+      }
+    ).doOn(executionFailedSignal);
+  }
   return CadenzaService.createMetaTask(
     `Resolve graph sync insert for ${tableName}`,
     (ctx, emit) => new Promise((resolve) => {
@@ -6366,6 +6426,104 @@ var AUTHORITY_QUERY_RESULT_KEYS = {
   intent_registry: "intentRegistrys"
 };
 var EARLY_SYNC_REQUEST_DELAYS_MS = [2e3, 1e4, 3e4];
+var SYNC_DEBUG_PREFIX = "[CADENZA_SYNC_DEBUG]";
+var SYNC_DEBUG_TABLES = /* @__PURE__ */ new Set([
+  "task",
+  "routine",
+  "task_to_routine_map",
+  "signal_registry",
+  "intent_registry",
+  "signal_to_task_map",
+  "intent_to_task_map"
+]);
+var SYNC_DEBUG_TASK_NAMES = /* @__PURE__ */ new Set([
+  "Query service_instance",
+  "Query service_instance_transport",
+  "Query intent_to_task_map",
+  "Query signal_to_task_map",
+  "Prepare for signal sync",
+  "Compile sync data and broadcast",
+  "Forward service instance sync",
+  "Forward service transport sync",
+  "Forward intent to task map sync",
+  "Forward signal to task map sync"
+]);
+var SYNC_DEBUG_ROUTINE_NAMES = /* @__PURE__ */ new Set(["Sync services"]);
+var SYNC_DEBUG_INTENT_NAMES = /* @__PURE__ */ new Set([
+  "meta-service-registry-full-sync",
+  "runner-traffic-runtime-get",
+  "iot-telemetry-ingest",
+  "query-pg-CadenzaDBPostgresActor-service_instance",
+  "query-pg-CadenzaDBPostgresActor-service_instance_transport",
+  "query-pg-CadenzaDBPostgresActor-intent_to_task_map",
+  "query-pg-CadenzaDBPostgresActor-signal_to_task_map"
+]);
+function shouldDebugSyncTable(tableName) {
+  return SYNC_DEBUG_TABLES.has(tableName);
+}
+function shouldDebugSyncTaskName(taskName) {
+  return typeof taskName === "string" && SYNC_DEBUG_TASK_NAMES.has(taskName);
+}
+function shouldDebugSyncRoutineName(routineName) {
+  return typeof routineName === "string" && SYNC_DEBUG_ROUTINE_NAMES.has(routineName);
+}
+function shouldDebugSyncIntentName(intentName) {
+  return typeof intentName === "string" && SYNC_DEBUG_INTENT_NAMES.has(intentName);
+}
+function summarizeSyncDebugValue(value, depth = 0) {
+  if (value === null || value === void 0) {
+    return value;
+  }
+  if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (value instanceof Set) {
+    return {
+      __type: "Set",
+      size: value.size,
+      values: Array.from(value).slice(0, 8).map((item) => summarizeSyncDebugValue(item, depth + 1))
+    };
+  }
+  if (value instanceof Map) {
+    return {
+      __type: "Map",
+      size: value.size
+    };
+  }
+  if (Array.isArray(value)) {
+    return {
+      __type: "Array",
+      length: value.length,
+      items: value.slice(0, 5).map((item) => summarizeSyncDebugValue(item, depth + 1))
+    };
+  }
+  if (typeof value === "object") {
+    if (depth >= 2) {
+      return "[object]";
+    }
+    const output = {};
+    const entries = Object.entries(value).filter(
+      ([key]) => ![
+        "functionString",
+        "tagIdGetter",
+        "__functionString",
+        "__getTagCallback",
+        "joinedContexts",
+        "task",
+        "taskInstance",
+        "tasks"
+      ].includes(key)
+    ).slice(0, 12);
+    for (const [key, nestedValue] of entries) {
+      output[key] = summarizeSyncDebugValue(nestedValue, depth + 1);
+    }
+    return output;
+  }
+  return String(value);
+}
+function logSyncDebug(event, payload) {
+  console.log(`${SYNC_DEBUG_PREFIX} ${event}`, summarizeSyncDebugValue(payload));
+}
 function resolveSyncQueryRows(ctx, tableName) {
   const resultKey = AUTHORITY_QUERY_RESULT_KEYS[tableName];
   const rows = ctx?.[resultKey];
@@ -6394,6 +6552,31 @@ function resolveSyncQueryTask(isCadenzaDBReady, tableName, queryData = {}, optio
     }
   ).then(targetTask);
 }
+function getRegistrableTasks() {
+  return Array.from(CadenzaService.registry.tasks.values()).filter(
+    (task) => task.register && !task.isHidden
+  );
+}
+function getRegistrableRoutines() {
+  return Array.from(CadenzaService.registry.routines.values());
+}
+function getRegistrableSignalObservers() {
+  const signalObservers = CadenzaService.signalBroker.signalObservers;
+  return signalObservers ? Array.from(signalObservers.values()) : [];
+}
+function getRegistrableIntentNames() {
+  return Array.from(CadenzaService.inquiryBroker.intents.values()).map((intent) => buildIntentRegistryData(intent)).filter(
+    (intentDefinition) => intentDefinition !== null
+  ).map((intentDefinition) => String(intentDefinition.name));
+}
+function buildActorRegistrationKey(actor, serviceName) {
+  const data = buildActorRegistrationData(actor);
+  const name = typeof data.name === "string" && data.name.trim().length > 0 ? data.name.trim() : "";
+  if (!name) {
+    return null;
+  }
+  return `${name}|${data.version}|${serviceName}`;
+}
 var GraphSyncController = class _GraphSyncController {
   constructor() {
     this.registeredActors = /* @__PURE__ */ new Set();
@@ -6518,22 +6701,158 @@ var GraphSyncController = class _GraphSyncController {
       {},
       { concurrency: 10 }
     );
+    const finalizeTaskSync = (emit, ctx) => {
+      const pendingTasks = getRegistrableTasks().filter((task) => !task.registered);
+      if (pendingTasks.length > 0) {
+        this.tasksSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.tasksSynced;
+      this.tasksSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_tasks", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeRoutineSync = (emit, ctx) => {
+      const pendingRoutines = getRegistrableRoutines().filter(
+        (routine) => !routine.registered
+      );
+      if (pendingRoutines.length > 0) {
+        this.routinesSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.routinesSynced;
+      this.routinesSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_routines", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeSignalSync = (emit, ctx) => {
+      const pendingSignals = getRegistrableSignalObservers().filter(
+        (observer) => observer?.registered !== true
+      );
+      if (pendingSignals.length > 0) {
+        this.signalsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.signalsSynced;
+      this.signalsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_signals", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeIntentSync = (emit, ctx) => {
+      const pendingIntentNames = getRegistrableIntentNames().filter(
+        (intentName) => !this.registeredIntentDefinitions.has(intentName)
+      );
+      if (pendingIntentNames.length > 0) {
+        this.intentsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.intentsSynced;
+      this.intentsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_intents", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const finalizeActorSync = (emit, ctx) => {
+      const syncServiceName = resolveSyncServiceName();
+      if (!syncServiceName) {
+        this.actorsSynced = false;
+        return false;
+      }
+      const pendingActorKeys = CadenzaService.getAllActors().map((actor) => buildActorRegistrationKey(actor, syncServiceName)).filter((registrationKey) => Boolean(registrationKey)).filter((registrationKey) => !this.registeredActors.has(registrationKey));
+      if (pendingActorKeys.length > 0) {
+        this.actorsSynced = false;
+        return false;
+      }
+      const shouldEmit = !this.actorsSynced;
+      this.actorsSynced = true;
+      if (shouldEmit) {
+        emit("meta.sync_controller.synced_actors", {
+          __syncing: true,
+          ...ctx
+        });
+      }
+      return true;
+    };
+    const gatherTaskRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather task registration",
+      (ctx, emit) => finalizeTaskSync(emit, ctx),
+      "Completes task registration when all registrable tasks are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherRoutineRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather routine registration",
+      (ctx, emit) => finalizeRoutineSync(emit, ctx),
+      "Completes routine registration when all registrable routines are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherSignalRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather signal registration",
+      (ctx, emit) => finalizeSignalSync(emit, ctx),
+      "Completes signal registration when all signal observers are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherIntentRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather intent registration",
+      (ctx, emit) => finalizeIntentSync(emit, ctx),
+      "Completes intent registration when all registrable intents are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
+    const gatherActorRegistrationTask = CadenzaService.createUniqueMetaTask(
+      "Gather actor registration",
+      (ctx, emit) => finalizeActorSync(emit, ctx),
+      "Completes actor registration when all registrable actors are marked registered.",
+      {
+        register: false,
+        isHidden: true
+      }
+    );
     this.splitRoutinesTask = CadenzaService.createMetaTask(
       "Split routines for registration",
-      (ctx, emit) => {
+      function* (ctx) {
         const { routines } = ctx;
-        if (!routines) return false;
+        if (!routines) return;
         const serviceName2 = resolveSyncServiceName();
         if (!serviceName2) {
-          return false;
+          return;
         }
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 2e3
         });
-        let emittedCount = 0;
         for (const routine of routines) {
           if (routine.registered) continue;
-          emit("meta.sync_controller.routine_registration_split", {
+          this.routinesSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: {
               name: routine.name,
@@ -6543,13 +6862,11 @@ var GraphSyncController = class _GraphSyncController {
               isMeta: routine.isMeta
             },
             __routineName: routine.name
-          });
-          emittedCount += 1;
+          };
         }
-        return emittedCount > 0;
-      }
+      }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split routine registration", (ctx) => ctx).doOn("meta.sync_controller.routine_registration_split").then(
+    this.splitRoutinesTask.then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "routine",
@@ -6571,22 +6888,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           CadenzaService.getRoutine(ctx.__routineName).registered = true;
-          CadenzaService.debounce(
-            "meta.sync_controller.routine_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherRoutineRegistrationTask)
       )
     );
-    CadenzaService.createUniqueMetaTask(
-      "Gather routine registration",
-      () => {
-        this.routinesSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.routine_registration_settled").emits("meta.sync_controller.synced_routines");
     this.splitTasksInRoutines = CadenzaService.createMetaTask(
       "Split tasks in routines",
       function* (ctx) {
@@ -6612,6 +6917,16 @@ var GraphSyncController = class _GraphSyncController {
               if (!nextTask?.registered) {
                 continue;
               }
+              if (shouldDebugSyncRoutineName(routine.name) || shouldDebugSyncTaskName(nextTask.name)) {
+                logSyncDebug("task_to_routine_split", {
+                  routineName: routine.name,
+                  routineVersion: routine.version,
+                  taskName: nextTask.name,
+                  taskVersion: nextTask.version,
+                  serviceName: serviceName2,
+                  registered: nextTask.registered
+                });
+              }
               yield {
                 __syncing: ctx.__syncing,
                 data: {
@@ -6665,18 +6980,19 @@ var GraphSyncController = class _GraphSyncController {
     }
     this.splitSignalsTask = CadenzaService.createMetaTask(
       "Split signals for registration",
-      (ctx, emit) => {
+      function* (ctx) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const { signals } = ctx;
-        if (!signals) return false;
+        if (!signals) return;
         const filteredSignals = signals.filter(
           (signal) => !signal.data.registered
         ).map((signal) => signal.signal);
         for (const signal of filteredSignals) {
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
-          emit("meta.sync_controller.signal_registration_split", {
+          this.signalsSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: {
               name: signal,
@@ -6686,12 +7002,11 @@ var GraphSyncController = class _GraphSyncController {
               isMeta
             },
             __signal: signal
-          });
+          };
         }
-        return filteredSignals.length > 0;
-      }
+      }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split signal registration", (ctx) => ctx).doOn("meta.sync_controller.signal_registration_split").then(
+    this.splitSignalsTask.then(
       resolveSyncInsertTask(
         this.isCadenzaDBReady,
         "signal_registry",
@@ -6712,22 +7027,10 @@ var GraphSyncController = class _GraphSyncController {
           CadenzaService.debounce("meta.sync_controller.synced_resource", {
             delayMs: 3e3
           });
-          CadenzaService.debounce(
-            "meta.sync_controller.signal_registration_settled",
-            { __syncing: true },
-            300
-          );
           return { signalName: ctx.__signal };
-        }).then(CadenzaService.signalBroker.registerSignalTask)
+        }).then(CadenzaService.signalBroker.registerSignalTask).then(gatherSignalRegistrationTask)
       )
     );
-    CadenzaService.createUniqueMetaTask(
-      "Gather signal registration",
-      () => {
-        this.signalsSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.signal_registration_settled").emits("meta.sync_controller.synced_signals");
     this.splitTasksForRegistration = CadenzaService.createMetaTask(
       "Split tasks for registration",
       function* (ctx) {
@@ -6742,6 +7045,19 @@ var GraphSyncController = class _GraphSyncController {
         for (const task of tasks) {
           if (task.registered) continue;
           const { __functionString, __getTagCallback } = task.export();
+          this.tasksSynced = false;
+          if (shouldDebugSyncTaskName(task.name)) {
+            logSyncDebug("task_registration_split", {
+              taskName: task.name,
+              taskVersion: task.version,
+              serviceName: serviceName2,
+              register: task.register,
+              registered: task.registered,
+              hidden: task.hidden,
+              observedSignals: Array.from(task.observedSignals),
+              handledIntents: Array.from(task.handlesIntents)
+            });
+          }
           yield {
             __syncing: ctx.__syncing,
             data: {
@@ -6778,7 +7094,7 @@ var GraphSyncController = class _GraphSyncController {
             __taskName: task.name
           };
         }
-      }
+      }.bind(this)
     );
     const registerTaskTask = resolveSyncInsertTask(
       this.isCadenzaDBReady,
@@ -6794,6 +7110,13 @@ var GraphSyncController = class _GraphSyncController {
       { concurrency: 30 }
     )?.then(
       CadenzaService.createMetaTask("Record registration", (ctx, emit) => {
+        if (shouldDebugSyncTaskName(ctx.__taskName)) {
+          logSyncDebug("task_registration_result", {
+            taskName: ctx.__taskName,
+            success: didSyncInsertSucceed(ctx),
+            ctx
+          });
+        }
         if (!didSyncInsertSucceed(ctx)) {
           return;
         }
@@ -6805,13 +7128,8 @@ var GraphSyncController = class _GraphSyncController {
           ...ctx,
           task: CadenzaService.get(ctx.__taskName)
         });
-        CadenzaService.debounce(
-          "meta.sync_controller.task_registration_settled",
-          { __syncing: true },
-          300
-        );
         return true;
-      })
+      }).then(gatherTaskRegistrationTask)
     );
     if (registerTaskTask) {
       this.splitTasksForRegistration.then(registerTaskTask);
@@ -6820,6 +7138,16 @@ var GraphSyncController = class _GraphSyncController {
       "Prepare created task for immediate sync",
       (ctx) => {
         const task = ctx.taskInstance ?? (ctx.data?.name ? CadenzaService.get(String(ctx.data.name)) : void 0);
+        if (shouldDebugSyncTaskName(task?.name ?? ctx?.data?.name)) {
+          logSyncDebug("task_created_for_immediate_sync", {
+            incomingTaskName: ctx?.data?.name ?? null,
+            resolvedTaskName: task?.name ?? null,
+            exists: Boolean(task),
+            hidden: task?.hidden ?? null,
+            register: task?.register ?? null,
+            registered: task?.registered ?? null
+          });
+        }
         if (!task || task.hidden || !task.register || task.registered) {
           return false;
         }
@@ -6834,13 +7162,6 @@ var GraphSyncController = class _GraphSyncController {
         isHidden: true
       }
     ).doOn("meta.task.created").then(this.splitTasksForRegistration);
-    CadenzaService.createUniqueMetaTask(
-      "Gather task registration",
-      () => {
-        this.tasksSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.task_registration_settled").emits("meta.sync_controller.synced_tasks");
     this.splitActorsForRegistration = CadenzaService.createMetaTask(
       "Split actors for registration",
       function* (ctx) {
@@ -6864,6 +7185,7 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredActors.has(registrationKey)) {
             continue;
           }
+          this.actorsSynced = false;
           yield {
             data,
             __actorRegistrationKey: registrationKey
@@ -6892,22 +7214,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           this.registeredActors.add(ctx.__actorRegistrationKey);
-          CadenzaService.debounce(
-            "meta.sync_controller.actor_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherActorRegistrationTask)
       )
     );
-    CadenzaService.createUniqueMetaTask(
-      "Gather actor registration",
-      () => {
-        this.actorsSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.actor_registration_settled").emits("meta.sync_controller.synced_actors");
     this.registerActorTaskMapTask = CadenzaService.createMetaTask(
       "Split actor task maps",
       function* (ctx) {
@@ -7004,6 +7314,17 @@ var GraphSyncController = class _GraphSyncController {
             continue;
           }
           const { isGlobal } = decomposeSignalName(_signal);
+          if (shouldDebugSyncTaskName(task.name)) {
+            logSyncDebug("signal_to_task_map_split", {
+              taskName: task.name,
+              signalName: _signal,
+              rawSignal: signal,
+              serviceName: serviceName2,
+              observerRegistered: CadenzaService.signalBroker.signalObservers?.get(
+                _signal
+              )?.registered
+            });
+          }
           emit("meta.sync_controller.signal_task_map_split", {
             __syncing: ctx.__syncing,
             data: {
@@ -7043,12 +7364,11 @@ var GraphSyncController = class _GraphSyncController {
     );
     this.splitIntentsTask = CadenzaService.createMetaTask(
       "Split intents for registration",
-      function(ctx, emit) {
+      function* (ctx) {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
-        let emittedCount = 0;
         for (const intent of intents) {
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
@@ -7057,17 +7377,16 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredIntentDefinitions.has(intentData.name)) {
             continue;
           }
-          emit("meta.sync_controller.intent_registration_split", {
+          this.intentsSynced = false;
+          yield {
             __syncing: ctx.__syncing,
             data: intentData,
             __intentName: intentData.name
-          });
-          emittedCount += 1;
+          };
         }
-        return emittedCount > 0;
       }.bind(this)
     );
-    CadenzaService.createMetaTask("Process split intent registration", (ctx) => ctx).doOn("meta.sync_controller.intent_registration_split").then(
+    this.splitIntentsTask.then(
       insertIntentRegistryTask?.then(
         CadenzaService.createMetaTask("Record intent definition registration", (ctx) => {
           if (!didSyncInsertSucceed(ctx)) {
@@ -7077,22 +7396,10 @@ var GraphSyncController = class _GraphSyncController {
             delayMs: 3e3
           });
           this.registeredIntentDefinitions.add(ctx.__intentName);
-          CadenzaService.debounce(
-            "meta.sync_controller.intent_registration_settled",
-            { __syncing: true },
-            300
-          );
           return true;
-        })
+        }).then(gatherIntentRegistrationTask)
       )
     );
-    CadenzaService.createUniqueMetaTask(
-      "Gather intent registration",
-      () => {
-        this.intentsSynced = true;
-        return true;
-      }
-    ).doOn("meta.sync_controller.intent_registration_settled").emits("meta.sync_controller.synced_intents");
     const registerIntentTask = CadenzaService.createMetaTask(
       "Record intent registration",
       (ctx) => {
@@ -7142,6 +7449,15 @@ var GraphSyncController = class _GraphSyncController {
           if (!intentDefinition) {
             continue;
           }
+          if (shouldDebugSyncTaskName(task.name) || shouldDebugSyncIntentName(intent)) {
+            logSyncDebug("intent_to_task_map_split", {
+              taskName: task.name,
+              taskVersion: task.version,
+              intentName: intent,
+              serviceName: serviceName2,
+              intentDefinition
+            });
+          }
           emit("meta.sync_controller.intent_task_map_split", {
             __syncing: ctx.__syncing,
             data: {
@@ -7171,6 +7487,13 @@ var GraphSyncController = class _GraphSyncController {
           if (!ctx.__intentDefinition || !ctx.__intentMapData) {
             return false;
           }
+          if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+            logSyncDebug("intent_definition_prepare", {
+              taskName: ctx.__taskName,
+              intentName: ctx.__intent,
+              intentDefinition: ctx.__intentDefinition
+            });
+          }
           return {
             ...ctx,
             data: ctx.__intentDefinition
@@ -7184,6 +7507,13 @@ var GraphSyncController = class _GraphSyncController {
               if (!ctx.__intentMapData) {
                 return false;
               }
+              if (shouldDebugSyncTaskName(ctx.__taskName) || shouldDebugSyncIntentName(ctx.__intent)) {
+                logSyncDebug("intent_map_payload_restore", {
+                  taskName: ctx.__taskName,
+                  intentName: ctx.__intent,
+                  intentMapData: ctx.__intentMapData
+                });
+              }
               return {
                 ...ctx,
                 data: ctx.__intentMapData
@@ -7363,15 +7693,11 @@ var GraphSyncController = class _GraphSyncController {
             __authoritativeReconciliation: true
           });
         }
-        if (authoritativeTasks.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.task_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeTasks.length > 0 || changed) {
+          finalizeTaskSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -7383,7 +7709,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileRoutineRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile routine registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeRoutines = resolveSyncQueryRows(ctx, "routine");
         let changed = false;
         for (const row of authoritativeRoutines) {
@@ -7398,15 +7724,11 @@ var GraphSyncController = class _GraphSyncController {
           routine.registered = true;
           changed = true;
         }
-        if (authoritativeRoutines.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.routine_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeRoutines.length > 0 || changed) {
+          finalizeRoutineSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -7418,7 +7740,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileSignalRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile signal registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeSignals = resolveSyncQueryRows(ctx, "signal_registry");
         const signalObservers = CadenzaService.signalBroker.signalObservers;
         let changed = false;
@@ -7434,15 +7756,11 @@ var GraphSyncController = class _GraphSyncController {
           observer.registered = true;
           changed = true;
         }
-        if (authoritativeSignals.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.signal_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeSignals.length > 0 || changed) {
+          finalizeSignalSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },
@@ -7454,7 +7772,7 @@ var GraphSyncController = class _GraphSyncController {
     );
     const reconcileIntentRegistrationFromAuthorityTask = CadenzaService.createMetaTask(
       "Reconcile intent registration from authority",
-      (ctx) => {
+      (ctx, emit) => {
         const authoritativeIntents = resolveSyncQueryRows(ctx, "intent_registry");
         let changed = false;
         for (const row of authoritativeIntents) {
@@ -7468,15 +7786,11 @@ var GraphSyncController = class _GraphSyncController {
           this.registeredIntentDefinitions.add(intentName);
           changed = true;
         }
-        if (authoritativeIntents.length > 0) {
-          CadenzaService.debounce(
-            "meta.sync_controller.intent_registration_settled",
-            {
-              __syncing: true,
-              __authoritativeReconciliation: true
-            },
-            300
-          );
+        if (authoritativeIntents.length > 0 || changed) {
+          finalizeIntentSync(emit, {
+            ...ctx,
+            __authoritativeReconciliation: true
+          });
         }
         return changed;
       },