@cadenza.io/service 2.17.48 → 2.17.50

package/dist/index.js

@@ -8763,6 +8763,17 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       CadenzaService.createMetaTask(
         `Log prepared graph sync insert execution for ${tableName}`,
         (ctx) => {
+          if (tableName === "task") {
+            if (!shouldDebugTaskSyncPayload(ctx)) {
+              return ctx;
+            }
+            logSyncDebug("insert_prepare", {
+              tableName,
+              targetTaskName: targetTask.name,
+              payload: buildTaskSyncDebugPayload(ctx)
+            });
+            return ctx;
+          }
           logSyncDebug("insert_prepare", {
             tableName,
             targetTaskName: targetTask.name,
@@ -8795,12 +8806,23 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
       if (debugTable) {
-        logSyncDebug("insert_finalize", {
-          tableName,
-          targetTaskName: targetTask.name,
-          success: didSyncInsertSucceed(normalizedContext),
-          ctx: normalizedContext
-        });
+        if (tableName === "task") {
+          if (shouldDebugTaskSyncPayload(normalizedContext)) {
+            logSyncDebug("insert_finalize", {
+              tableName,
+              targetTaskName: targetTask.name,
+              success: didSyncInsertSucceed(normalizedContext),
+              payload: buildTaskSyncDebugPayload(normalizedContext)
+            });
+          }
+        } else {
+          logSyncDebug("insert_finalize", {
+            tableName,
+            targetTaskName: targetTask.name,
+            success: didSyncInsertSucceed(normalizedContext),
+            ctx: normalizedContext
+          });
+        }
       }
       pendingResolverContexts.delete(ctx.__resolverRequestId);
       emit(executionResolvedSignal, normalizedContext);
@@ -8818,11 +8840,21 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
     CadenzaService.createMetaTask(
       `Log failed graph sync insert execution for ${tableName}`,
       (ctx) => {
-        logSyncDebug("insert_failed", {
-          tableName,
-          targetTaskName: targetTask.name,
-          ctx
-        });
+        if (tableName === "task") {
+          if (shouldDebugTaskSyncPayload(ctx)) {
+            logSyncDebug("insert_failed", {
+              tableName,
+              targetTaskName: targetTask.name,
+              payload: buildTaskSyncDebugPayload(ctx)
+            });
+          }
+        } else {
+          logSyncDebug("insert_failed", {
+            tableName,
+            targetTaskName: targetTask.name,
+            ctx
+          });
+        }
         if (typeof ctx.__resolverRequestId === "string") {
           pendingResolverContexts.delete(ctx.__resolverRequestId);
         }
@@ -8988,6 +9020,37 @@ function summarizeSyncDebugValue(value, depth = 0) {
 function logSyncDebug(event, payload) {
   console.log(`${SYNC_DEBUG_PREFIX} ${event}`, summarizeSyncDebugValue(payload));
 }
+function buildTaskSyncDebugPayload(ctx) {
+  const data = ctx.data && typeof ctx.data === "object" ? ctx.data : {};
+  const queryData = ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : {};
+  const queryDataData = queryData.data && typeof queryData.data === "object" ? queryData.data : {};
+  const taskPayload = Object.keys(queryDataData).length > 0 ? queryDataData : data;
+  const functionString = typeof taskPayload.functionString === "string" ? taskPayload.functionString : typeof taskPayload.function_string === "string" ? taskPayload.function_string : void 0;
+  const tagIdGetter = typeof taskPayload.tagIdGetter === "string" ? taskPayload.tagIdGetter : typeof taskPayload.tag_id_getter === "string" ? taskPayload.tag_id_getter : void 0;
+  const signals = taskPayload.signals && typeof taskPayload.signals === "object" ? taskPayload.signals : {};
+  const intents = taskPayload.intents && typeof taskPayload.intents === "object" ? taskPayload.intents : {};
+  return {
+    taskName: taskPayload.name ?? taskPayload.taskName ?? taskPayload.task_name ?? ctx.__taskName ?? null,
+    serviceName: taskPayload.service_name ?? taskPayload.serviceName ?? ctx.__syncServiceName ?? null,
+    functionStringLength: functionString?.length ?? null,
+    tagIdGetterLength: tagIdGetter?.length ?? null,
+    isMeta: taskPayload.isMeta ?? taskPayload.is_meta ?? null,
+    isSubMeta: taskPayload.isSubMeta ?? taskPayload.is_sub_meta ?? null,
+    isHidden: taskPayload.isHidden ?? taskPayload.is_hidden ?? null,
+    signalsEmitsCount: Array.isArray(signals.emits) ? signals.emits.length : null,
+    signalsObservedCount: Array.isArray(signals.observed) ? signals.observed.length : null,
+    intentHandlesCount: Array.isArray(intents.handles) ? intents.handles.length : null,
+    intentInquiresCount: Array.isArray(intents.inquires) ? intents.inquires.length : null,
+    rowCount: ctx.rowCount ?? null,
+    errored: ctx.errored ?? false,
+    success: ctx.__success ?? null,
+    error: ctx.__error ?? null
+  };
+}
+function shouldDebugTaskSyncPayload(ctx) {
+  const payload = buildTaskSyncDebugPayload(ctx);
+  return shouldDebugSyncTaskName(payload.taskName);
+}
 function resolveSyncQueryRows(ctx, tableName) {
   const resultKey = AUTHORITY_QUERY_RESULT_KEYS[tableName];
   const rows = ctx?.[resultKey];
@@ -9016,6 +9079,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();
@@ -9140,22 +9228,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,
@@ -9165,13 +9389,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",
@@ -9193,22 +9415,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) {
@@ -9297,18 +9507,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,
@@ -9318,12 +9529,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",
@@ -9344,22 +9554,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) {
@@ -9374,6 +9572,7 @@ 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,
@@ -9382,6 +9581,8 @@ var GraphSyncController = class _GraphSyncController {
               register: task.register,
               registered: task.registered,
               hidden: task.hidden,
+              exportFunctionLength: __functionString?.length ?? null,
+              exportTagGetterLength: __getTagCallback?.length ?? null,
               observedSignals: Array.from(task.observedSignals),
               handledIntents: Array.from(task.handlesIntents)
             });
@@ -9422,7 +9623,7 @@ var GraphSyncController = class _GraphSyncController {
             __taskName: task.name
           };
         }
-      }
+      }.bind(this)
     );
     const registerTaskTask = resolveSyncInsertTask(
       this.isCadenzaDBReady,
@@ -9456,13 +9657,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);
@@ -9495,13 +9691,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) {
@@ -9525,6 +9714,7 @@ var GraphSyncController = class _GraphSyncController {
           if (this.registeredActors.has(registrationKey)) {
             continue;
           }
+          this.actorsSynced = false;
           yield {
             data,
             __actorRegistrationKey: registrationKey
@@ -9553,22 +9743,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) {
@@ -9715,12 +9893,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) {
@@ -9729,17 +9906,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)) {
@@ -9749,22 +9925,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) => {
@@ -10058,15 +10222,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;
       },
@@ -10078,7 +10238,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) {
@@ -10093,15 +10253,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;
       },
@@ -10113,7 +10269,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;
@@ -10129,15 +10285,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;
       },
@@ -10149,7 +10301,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) {
@@ -10163,15 +10315,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;
       },