@cadenza.io/service 2.17.79 → 2.18.0

package/dist/browser/index.mjs

@@ -220,6 +220,13 @@ var DatabaseTask = class extends DeputyTask {
     const metadata = context.getMetadata();
     const dynamicQueryData = ctx.queryData ?? {};
     delete ctx.queryData;
+    const nextQueryData = {
+      ...this.queryData,
+      data: {
+        ...ctx.data
+      },
+      ...dynamicQueryData
+    };
     const deputyContext = {
       ...ctx,
       __localTaskName: this.name,
@@ -236,13 +243,13 @@ var DatabaseTask = class extends DeputyTask {
         __blockRemoteExecution: metadata.__blockRemoteExecution ?? ctx.__blockRemoteExecution ?? false,
         __deputyTaskName: this.name
       },
-      queryData: {
-        ...this.queryData,
-        data: {
-          ...ctx.data
-        },
-        ...dynamicQueryData
-      }
+      data: nextQueryData.data ?? ctx.data,
+      batch: nextQueryData.batch ?? ctx.batch,
+      transaction: nextQueryData.transaction ?? ctx.transaction,
+      onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
+      filter: nextQueryData.filter ?? ctx.filter,
+      fields: nextQueryData.fields ?? ctx.fields,
+      queryData: nextQueryData
     };
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
@@ -675,6 +682,8 @@ function hasSignificantRuntimeStatusChange(previous, next) {
 
 // src/registry/ServiceRegistry.ts
 var META_SERVICE_REGISTRY_FULL_SYNC_INTENT = "meta-service-registry-full-sync";
+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 INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
@@ -762,18 +771,6 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   }
   return result;
 }
-function shouldTraceIotDbRegistryPath(localServiceName, targetServiceName) {
-  return targetServiceName === "IotDbService" && localServiceName !== "IotDbService";
-}
-function summarizeTransportDescriptors(transports) {
-  return transports.map((transport) => ({
-    uuid: transport.uuid,
-    serviceInstanceId: transport.serviceInstanceId,
-    role: transport.role,
-    origin: transport.origin,
-    protocols: transport.protocols
-  }));
-}
 function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {}) {
   const remoteInsertTask = CadenzaService.createCadenzaDBInsertTask(
     tableName,
@@ -790,6 +787,10 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       const nextQueryData = buildServiceRegistryInsertQueryData(ctx, queryData);
       const delegationContext = ensureDelegationContextMetadata({
         ...ctx,
+        data: nextQueryData.data !== void 0 ? nextQueryData.data : ctx.data,
+        batch: nextQueryData.batch !== void 0 ? nextQueryData.batch : ctx.batch,
+        onConflict: Object.prototype.hasOwnProperty.call(nextQueryData, "onConflict") ? nextQueryData.onConflict : void 0,
+        transaction: nextQueryData.transaction !== void 0 ? nextQueryData.transaction : ctx.transaction,
         queryData: nextQueryData
       });
       delegationContext.__metadata.__skipRemoteExecution = delegationContext.__metadata.__skipRemoteExecution ?? delegationContext.__skipRemoteExecution ?? false;
@@ -913,6 +914,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.deputies = /* @__PURE__ */ new Map();
     this.remoteSignals = /* @__PURE__ */ new Map();
     this.remoteIntents = /* @__PURE__ */ new Map();
+    this.gatheredSyncTransmissionServices = /* @__PURE__ */ new Set();
     this.remoteIntentDeputiesByKey = /* @__PURE__ */ new Map();
     this.remoteIntentDeputiesByTask = /* @__PURE__ */ new Map();
     this.dependeesByService = /* @__PURE__ */ new Map();
@@ -1164,21 +1166,6 @@ var ServiceRegistry = class _ServiceRegistry {
           trackedInstance.acceptingWork = snapshot.acceptingWork;
           trackedInstance.reportedAt = trackedInstance.reportedAt ?? (/* @__PURE__ */ new Date()).toISOString();
         }
-        if (shouldTraceIotDbRegistryPath(this.serviceName, serviceName)) {
-          console.log("[CADENZA_REGISTRY_DEBUG] handle_instance_update", {
-            localServiceName: this.serviceName,
-            localServiceInstanceId: this.serviceInstanceId,
-            targetServiceName: serviceName,
-            targetServiceInstanceId: uuid7,
-            existingInstance: !!existing,
-            deleted,
-            remoteInterest: this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName),
-            hasDeputies: this.deputies.has(serviceName),
-            hasRemoteIntents: this.remoteIntents.has(serviceName),
-            hasRemoteSignals: this.remoteSignals.has(serviceName),
-            transports: trackedInstance ? summarizeTransportDescriptors(trackedInstance.transports) : []
-          });
-        }
         if (!serviceInstance.isBootstrapPlaceholder) {
           this.reconcileBootstrapPlaceholderInstance(serviceName, uuid7, emit);
         }
@@ -1191,7 +1178,8 @@ var ServiceRegistry = class _ServiceRegistry {
         if (this.deputies.has(serviceName) || this.remoteIntents.has(serviceName) || this.remoteSignals.has(serviceName)) {
           const connected = this.ensureDependeeClientForInstance(
             trackedInstance,
-            emit
+            emit,
+            ctx
           );
           if (!connected) {
             emit("meta.service_registry.routeable_transport_missing", {
@@ -1234,27 +1222,6 @@ var ServiceRegistry = class _ServiceRegistry {
             break;
           }
         }
-        if (shouldTraceIotDbRegistryPath(
-          this.serviceName,
-          ownerInstance?.serviceName ?? ctx.serviceName ?? void 0
-        )) {
-          console.log("[CADENZA_REGISTRY_DEBUG] handle_transport_update", {
-            localServiceName: this.serviceName,
-            localServiceInstanceId: this.serviceInstanceId,
-            transport: {
-              uuid: transport.uuid,
-              serviceInstanceId: transport.serviceInstanceId,
-              role: transport.role,
-              origin: transport.origin,
-              protocols: transport.protocols,
-              deleted: transport.deleted
-            },
-            ownerFound: !!ownerInstance,
-            ownerServiceName: ownerInstance?.serviceName,
-            ownerInstanceId: ownerInstance?.uuid,
-            ownerTransports: ownerInstance ? summarizeTransportDescriptors(ownerInstance.transports) : []
-          });
-        }
         if (!ownerInstance) {
           return false;
         }
@@ -1280,7 +1247,7 @@ var ServiceRegistry = class _ServiceRegistry {
         if (!hasRemoteInterest) {
           return true;
         }
-        this.ensureDependeeClientForInstance(ownerInstance, emit);
+        this.ensureDependeeClientForInstance(ownerInstance, emit, ctx);
         return true;
       },
       "Handles service transport updates independently from instance rows."
@@ -1310,29 +1277,12 @@ var ServiceRegistry = class _ServiceRegistry {
       "Tracks remote dependency instances for runtime heartbeat monitoring."
     ).doOn("meta.service_registry.dependee_registered");
     const normalizeServiceInstancesFromSync = (ctx) => this.normalizeServiceInstancesFromSync(ctx);
-    const getLocalTraceContext = () => ({
-      localServiceName: this.serviceName,
-      localServiceInstanceId: this.serviceInstanceId
-    });
     CadenzaService.createMetaTask("Split service instances", function* (ctx) {
       const serviceInstances = normalizeServiceInstancesFromSync(ctx);
       if (serviceInstances.length === 0) {
         return;
       }
       for (const serviceInstance of serviceInstances) {
-        const { localServiceName, localServiceInstanceId } = getLocalTraceContext();
-        if (shouldTraceIotDbRegistryPath(
-          localServiceName,
-          serviceInstance.serviceName
-        )) {
-          console.log("[CADENZA_REGISTRY_DEBUG] split_service_instance", {
-            localServiceName,
-            localServiceInstanceId,
-            targetServiceName: serviceInstance.serviceName,
-            targetServiceInstanceId: serviceInstance.uuid,
-            transports: summarizeTransportDescriptors(serviceInstance.transports)
-          });
-        }
         yield { serviceInstance };
       }
     }).doOn(
@@ -1378,6 +1328,15 @@ var ServiceRegistry = class _ServiceRegistry {
       },
       "Handles registration of remote signals"
     ).emits("meta.service_registry.registered_global_signals").doOn("global.meta.cadenza_db.gathered_sync_data");
+    this.reconcileGatheredSyncTransmissionsTask = CadenzaService.createMetaTask(
+      "Reconcile gathered sync signal transmissions",
+      (ctx, emit) => this.reconcileGatheredSyncTransmissions(ctx, emit),
+      "Keeps gathered sync transmitters aligned with known remote service instances."
+    ).doOn(
+      CADENZA_DB_GATHERED_SYNC_SIGNAL,
+      META_GATHERED_SYNC_TRANSMISSION_RECONCILE_SIGNAL,
+      "meta.service_registry.service_discovered"
+    );
     this.handleGlobalIntentRegistrationTask = CadenzaService.createMetaTask(
       "Handle global intent registration",
       (ctx, emit) => {
@@ -1388,15 +1347,19 @@ var ServiceRegistry = class _ServiceRegistry {
           return 0;
         });
         for (const map of sorted) {
-          if (map.deleted) {
-            this.unregisterRemoteIntentDeputy(map);
-            continue;
+          try {
+            if (map.deleted) {
+              this.unregisterRemoteIntentDeputy(map);
+              continue;
+            }
+            CadenzaService.inquiryBroker.addIntent({
+              name: map.intentName
+            });
+            this.registerRemoteIntentDeputy(map);
+            this.ensureDependeeClientsForService(map.serviceName, emit);
+          } catch (error) {
+            throw error;
           }
-          CadenzaService.inquiryBroker.addIntent({
-            name: map.intentName
-          });
-          this.registerRemoteIntentDeputy(map);
-          this.ensureDependeeClientsForService(map.serviceName, emit);
         }
         return true;
       },
@@ -1548,7 +1511,7 @@ var ServiceRegistry = class _ServiceRegistry {
               {
                 uuid: report.transportId,
                 serviceInstanceId: report.serviceInstanceId,
-                role: this.getRoutingTransportRole(),
+                role: report.transportRole ?? this.getRoutingTransportRole(),
                 origin: report.transportOrigin,
                 protocols: report.transportProtocols && report.transportProtocols.length > 0 ? report.transportProtocols : ["rest", "socket"],
                 securityProfile: null,
@@ -1590,21 +1553,6 @@ var ServiceRegistry = class _ServiceRegistry {
         const serviceInstances = this.normalizeServiceInstancesFromSync(
           inquiryResult
         );
-        if (shouldTraceIotDbRegistryPath(this.serviceName, "IotDbService")) {
-          const tracedInstances = serviceInstances.filter((instance) => instance.serviceName === "IotDbService").map((instance) => ({
-            uuid: instance.uuid,
-            isActive: instance.isActive,
-            isNonResponsive: instance.isNonResponsive,
-            isBlocked: instance.isBlocked,
-            transports: summarizeTransportDescriptors(instance.transports)
-          }));
-          console.log("[CADENZA_REGISTRY_DEBUG] full_sync_instances", {
-            localServiceName: this.serviceName,
-            localServiceInstanceId: this.serviceInstanceId,
-            totalServiceInstances: serviceInstances.length,
-            tracedInstances
-          });
-        }
         return {
           ...ctx,
           signalToTaskMaps,
@@ -1701,44 +1649,6 @@ var ServiceRegistry = class _ServiceRegistry {
         let retries = __retries ?? 0;
         let triedInstances = __triedInstances ?? [];
         const preferredRole = this.getRoutingTransportRole();
-        const allInstances = this.instances.get(__serviceName) ?? [];
-        const candidateDiagnostics = shouldTraceIotDbRegistryPath(
-          this.serviceName,
-          __serviceName ?? void 0
-        ) ? allInstances.map((instance) => ({
-          uuid: instance.uuid,
-          isActive: instance.isActive,
-          isNonResponsive: instance.isNonResponsive,
-          isBlocked: instance.isBlocked,
-          isFrontend: instance.isFrontend,
-          transports: summarizeTransportDescriptors(instance.transports),
-          selectedTransport: instance.isFrontend ? null : this.selectTransportForInstance(
-            instance,
-            context,
-            preferredRole
-          ) ? {
-            uuid: this.selectTransportForInstance(
-              instance,
-              context,
-              preferredRole
-            ).uuid,
-            role: this.selectTransportForInstance(
-              instance,
-              context,
-              preferredRole
-            ).role,
-            origin: this.selectTransportForInstance(
-              instance,
-              context,
-              preferredRole
-            ).origin,
-            protocols: this.selectTransportForInstance(
-              instance,
-              context,
-              preferredRole
-            ).protocols
-          } : null
-        })) : void 0;
         const instances = this.instances.get(__serviceName)?.filter((instance) => {
           if (targetServiceInstanceId && instance.uuid !== targetServiceInstanceId) {
             return false;
@@ -1771,20 +1681,6 @@ var ServiceRegistry = class _ServiceRegistry {
           }
           return (a.numberOfRunningGraphs ?? 0) - (b.numberOfRunningGraphs ?? 0);
         });
-        if (candidateDiagnostics) {
-          console.log("[CADENZA_REGISTRY_DEBUG] get_balanced_instance", {
-            localServiceName: this.serviceName,
-            localServiceInstanceId: this.serviceInstanceId,
-            targetServiceName: __serviceName,
-            preferredRole,
-            useSocket: this.useSocket,
-            targetServiceInstanceId,
-            retries,
-            triedInstances,
-            candidateDiagnostics,
-            filteredInstanceIds: instances?.map((instance) => instance.uuid) ?? []
-          });
-        }
         if (!instances || instances.length === 0 || retries > this.retryCount) {
           context.errored = true;
           context.__error = this.isFrontend && preferredRole === "public" ? `No public transport available for ${__serviceName}.` : `No routeable ${preferredRole} transport available for ${__serviceName}. Retries: ${retries}.`;
@@ -2042,6 +1938,7 @@ var ServiceRegistry = class _ServiceRegistry {
           serviceName: report.serviceName,
           serviceInstanceId: report.serviceInstanceId,
           transportId: report.transportId,
+          transportRole: report.transportRole,
           transportOrigin: report.transportOrigin,
           transportProtocols: report.transportProtocols,
           isFrontend: report.isFrontend,
@@ -2658,6 +2555,64 @@ var ServiceRegistry = class _ServiceRegistry {
       (instance) => !!instance && !!instance.isActive && !instance.isNonResponsive && !instance.isBlocked
     );
   }
+  shouldReconcileGatheredSyncTransmissions() {
+    return this.serviceName === "CadenzaDB";
+  }
+  collectGatheredSyncTransmissionRecipients(ctx) {
+    const recipients = /* @__PURE__ */ new Set();
+    const addRecipient = (serviceName) => {
+      const normalizedServiceName = String(serviceName ?? "").trim();
+      if (!normalizedServiceName || normalizedServiceName === this.serviceName) {
+        return;
+      }
+      recipients.add(normalizedServiceName);
+    };
+    addRecipient(ctx.serviceName ?? ctx.__serviceName);
+    for (const instance of this.normalizeServiceInstancesFromSync(ctx)) {
+      addRecipient(instance.serviceName);
+    }
+    for (const [serviceName, instances] of this.instances.entries()) {
+      if (!instances?.length) {
+        continue;
+      }
+      addRecipient(serviceName);
+    }
+    return recipients;
+  }
+  reconcileGatheredSyncTransmissions(ctx, emit) {
+    if (!this.shouldReconcileGatheredSyncTransmissions()) {
+      return false;
+    }
+    const desiredRecipients = this.collectGatheredSyncTransmissionRecipients(ctx);
+    const createdRecipients = [];
+    for (const serviceName of desiredRecipients) {
+      if (this.gatheredSyncTransmissionServices.has(serviceName)) {
+        continue;
+      }
+      CadenzaService.createSignalTransmissionTask(
+        CADENZA_DB_GATHERED_SYNC_SIGNAL,
+        serviceName
+      );
+      this.gatheredSyncTransmissionServices.add(serviceName);
+      createdRecipients.push(serviceName);
+    }
+    for (const serviceName of Array.from(this.gatheredSyncTransmissionServices)) {
+      if (desiredRecipients.has(serviceName)) {
+        continue;
+      }
+      CadenzaService.get(
+        `Transmit signal: ${CADENZA_DB_GATHERED_SYNC_SIGNAL} to ${serviceName}`
+      )?.destroy();
+      this.gatheredSyncTransmissionServices.delete(serviceName);
+    }
+    if (createdRecipients.length > 0 && ctx.__signalName === CADENZA_DB_GATHERED_SYNC_SIGNAL) {
+      emit("meta.cadenza_db.sync_tick", {
+        __syncing: true,
+        __reason: "gathered_sync_transmissions_reconciled"
+      });
+    }
+    return createdRecipients.length > 0 || this.gatheredSyncTransmissionServices.size > 0;
+  }
   registerRemoteIntentDeputy(map) {
     if (!this.serviceName || map.serviceName === this.serviceName) {
       return;
@@ -2900,38 +2855,18 @@ var ServiceRegistry = class _ServiceRegistry {
     }
     return communicationTypes;
   }
-  ensureDependeeClientForInstance(instance, emit) {
+  ensureDependeeClientForInstance(instance, emit, ctx) {
     if (!instance || instance.uuid === this.serviceInstanceId || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
       return false;
     }
     if (!this.deputies.has(instance.serviceName) && !this.remoteIntents.has(instance.serviceName) && !this.remoteSignals.has(instance.serviceName)) {
       return false;
     }
-    const transport = this.getRouteableTransport(
+    const transport = this.selectTransportForInstance(
       instance,
-      this.useSocket ? "socket" : "rest"
-    );
-    if (shouldTraceIotDbRegistryPath(this.serviceName, instance.serviceName)) {
-      console.log("[CADENZA_REGISTRY_DEBUG] ensure_dependee_client_for_instance", {
-        localServiceName: this.serviceName,
-        localServiceInstanceId: this.serviceInstanceId,
-        targetServiceName: instance.serviceName,
-        targetServiceInstanceId: instance.uuid,
-        useSocket: this.useSocket,
-        routeableRole: this.getRoutingTransportRole(),
-        hasDeputies: this.deputies.has(instance.serviceName),
-        hasRemoteIntents: this.remoteIntents.has(instance.serviceName),
-        hasRemoteSignals: this.remoteSignals.has(instance.serviceName),
-        clientCreatedTransportIds: instance.clientCreatedTransportIds ?? [],
-        transports: summarizeTransportDescriptors(instance.transports),
-        selectedTransport: transport ? {
-          uuid: transport.uuid,
-          role: transport.role,
-          origin: transport.origin,
-          protocols: transport.protocols
-        } : null
-      });
-    }
+      ctx ?? {},
+      this.getRoutingTransportRole()
+    );
     if (!transport || this.hasTransportClientCreated(instance, transport.uuid)) {
       return false;
     }
@@ -2948,9 +2883,9 @@ var ServiceRegistry = class _ServiceRegistry {
     this.markTransportClientCreated(instance, transport.uuid);
     return true;
   }
-  ensureDependeeClientsForService(serviceName, emit) {
+  ensureDependeeClientsForService(serviceName, emit, ctx) {
     for (const instance of this.instances.get(serviceName) ?? []) {
-      this.ensureDependeeClientForInstance(instance, emit);
+      this.ensureDependeeClientForInstance(instance, emit, ctx);
     }
   }
   hasTransportClientCreated(instance, transportId) {
@@ -3009,6 +2944,10 @@ var ServiceRegistry = class _ServiceRegistry {
     if (!instances?.length) {
       return;
     }
+    const resolvedInstance = instances.find(
+      (instance) => instance.uuid === resolvedInstanceId
+    );
+    const frontendRoutingRole = this.isFrontend ? this.getRoutingTransportRole() : null;
     const placeholders = instances.filter(
       (instance) => instance.uuid !== resolvedInstanceId && instance.isBootstrapPlaceholder
     );
@@ -3020,7 +2959,33 @@ var ServiceRegistry = class _ServiceRegistry {
       const requiredForReadiness = this.readinessDependeeByInstance.has(
         placeholder.uuid
       );
+      const preservedTransportIds = /* @__PURE__ */ new Set();
+      if (resolvedInstance && frontendRoutingRole) {
+        const resolvedHasFrontendRoute = resolvedInstance.transports.some(
+          (transport) => transport.role === frontendRoutingRole && !transport.deleted
+        );
+        if (!resolvedHasFrontendRoute) {
+          const transportsToPreserve = placeholder.transports.filter(
+            (transport) => transport.role === frontendRoutingRole && !transport.deleted
+          );
+          for (const transport of transportsToPreserve) {
+            if (resolvedInstance.transports.some(
+              (existingTransport) => existingTransport.role === transport.role && existingTransport.origin === transport.origin
+            )) {
+              continue;
+            }
+            resolvedInstance.transports.push({
+              ...transport,
+              serviceInstanceId: resolvedInstanceId
+            });
+            preservedTransportIds.add(transport.uuid);
+          }
+        }
+      }
       for (const transport of placeholder.transports) {
+        if (preservedTransportIds.has(transport.uuid)) {
+          continue;
+        }
         const transportKey = buildTransportClientKey(transport);
         emit(`meta.socket_shutdown_requested:${transportKey}`, {});
         emit(`meta.fetch.destroy_requested:${transportKey}`, {});
@@ -3141,6 +3106,7 @@ var ServiceRegistry = class _ServiceRegistry {
       return null;
     }
     const transportId = ctx.transportId ?? ctx.serviceTransportId ?? ctx.serviceTransport?.uuid ?? void 0;
+    const transportRole = ctx.transportRole ?? ctx.transport_role ?? ctx.serviceTransport?.role ?? void 0;
     const transportOrigin = ctx.transportOrigin ?? ctx.serviceOrigin ?? ctx.serviceTransport?.origin ?? void 0;
     const transportProtocols = Array.isArray(
       ctx.transportProtocols ?? ctx.serviceTransport?.protocols
@@ -3166,6 +3132,7 @@ var ServiceRegistry = class _ServiceRegistry {
       serviceName,
       serviceInstanceId,
       transportId: typeof transportId === "string" && transportId.trim().length > 0 ? transportId : void 0,
+      transportRole: transportRole === "internal" || transportRole === "public" ? transportRole : void 0,
       transportOrigin: typeof transportOrigin === "string" && transportOrigin.trim().length > 0 ? transportOrigin : void 0,
       transportProtocols: transportProtocols && transportProtocols.length > 0 ? Array.from(new Set(transportProtocols)) : void 0,
       isFrontend: typeof ctx.isFrontend === "boolean" ? ctx.isFrontend : typeof ctx.serviceInstance?.isFrontend === "boolean" ? ctx.serviceInstance.isFrontend : void 0,
@@ -3188,13 +3155,16 @@ var ServiceRegistry = class _ServiceRegistry {
       const protocols = report.transportProtocols && report.transportProtocols.length > 0 ? report.transportProtocols : ["rest", "socket"];
       const existingTransport = this.getTransportById(instance, report.transportId);
       if (existingTransport) {
+        if (report.transportRole) {
+          existingTransport.role = report.transportRole;
+        }
         existingTransport.origin = report.transportOrigin;
         existingTransport.protocols = protocols;
       } else {
         instance.transports.push({
           uuid: report.transportId,
           serviceInstanceId: report.serviceInstanceId,
-          role: this.getRoutingTransportRole(),
+          role: report.transportRole ?? this.getRoutingTransportRole(),
           origin: report.transportOrigin,
           protocols,
           securityProfile: null,
@@ -3240,24 +3210,18 @@ var ServiceRegistry = class _ServiceRegistry {
       localInstance.isBlocked
     );
     const reportedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const transport = this.getRouteableTransport(
+      localInstance,
+      this.useSocket ? "socket" : "rest",
+      "internal"
+    );
     const report = {
       serviceName: this.serviceName,
       serviceInstanceId: this.serviceInstanceId,
-      transportId: this.getRouteableTransport(
-        localInstance,
-        this.useSocket ? "socket" : "rest",
-        "internal"
-      )?.uuid ?? void 0,
-      transportOrigin: this.getRouteableTransport(
-        localInstance,
-        this.useSocket ? "socket" : "rest",
-        "internal"
-      )?.origin ?? void 0,
-      transportProtocols: this.getRouteableTransport(
-        localInstance,
-        this.useSocket ? "socket" : "rest",
-        "internal"
-      )?.protocols ?? void 0,
+      transportId: transport?.uuid ?? void 0,
+      transportRole: transport?.role ?? void 0,
+      transportOrigin: transport?.origin ?? void 0,
+      transportProtocols: transport?.protocols ?? void 0,
       isFrontend: localInstance.isFrontend,
       reportedAt,
       state: snapshot.state,
@@ -3621,6 +3585,7 @@ var ServiceRegistry = class _ServiceRegistry {
     this.deputies.clear();
     this.remoteSignals.clear();
     this.remoteIntents.clear();
+    this.gatheredSyncTransmissionServices.clear();
     this.remoteIntentDeputiesByKey.clear();
     this.remoteIntentDeputiesByTask.clear();
     this.dependeesByService.clear();
@@ -4872,10 +4837,14 @@ var SocketController = class _SocketController {
           const communicationTypes = this.normalizeCommunicationTypes(
             input.communicationTypes
           );
+          const transportProtocols = Array.isArray(input.transportProtocols) ? input.transportProtocols.map((entry) => String(entry)) : [];
           const serviceName = String(input.serviceName ?? "");
           const serviceTransportId = String(input.serviceTransportId ?? "");
           const serviceOrigin = String(input.serviceOrigin ?? "");
           const parsedOrigin = parseTransportOrigin(serviceOrigin);
+          if (!transportProtocols.includes("socket")) {
+            return false;
+          }
           if (!serviceTransportId || !serviceOrigin || !parsedOrigin) {
             CadenzaService.log(
               "Socket client setup skipped due to missing transport origin",
@@ -4901,7 +4870,7 @@ var SocketController = class _SocketController {
               serviceName,
               serviceTransportId,
               serviceOrigin,
-              transportProtocols: input.transportProtocols,
+              transportProtocols,
               url
             });
           };
@@ -4922,7 +4891,7 @@ var SocketController = class _SocketController {
             serviceName,
             serviceTransportId,
             serviceOrigin,
-            transportProtocols: Array.isArray(input.transportProtocols) ? input.transportProtocols.map((entry) => String(entry)) : [],
+            transportProtocols,
             url,
             destroyed: false,
             updatedAt: Date.now()
@@ -5501,7 +5470,7 @@ var SocketController = class _SocketController {
                 communicationTypes,
                 serviceTransportId,
                 serviceOrigin,
-                transportProtocols: input.transportProtocols,
+                transportProtocols,
                 handshakeData: {
                   instanceId: CadenzaService.serviceRegistry.serviceInstanceId,
                   serviceName: CadenzaService.serviceRegistry.serviceName
@@ -5861,6 +5830,209 @@ var SignalController = class _SignalController {
   }
 };
 
+// src/runtime/RuntimeValidationController.ts
+var RUNTIME_VALIDATION_INTENTS = {
+  getPolicy: "meta-runtime-validation-policy-get",
+  setPolicy: "meta-runtime-validation-policy-set",
+  replacePolicy: "meta-runtime-validation-policy-replace",
+  clearPolicy: "meta-runtime-validation-policy-clear",
+  listScopes: "meta-runtime-validation-scope-list",
+  upsertScope: "meta-runtime-validation-scope-upsert",
+  removeScope: "meta-runtime-validation-scope-remove",
+  clearScopes: "meta-runtime-validation-scope-clear"
+};
+var RUNTIME_VALIDATION_SIGNALS = {
+  setPolicyRequested: "meta.runtime_validation.policy_set_requested",
+  replacePolicyRequested: "meta.runtime_validation.policy_replace_requested",
+  clearPolicyRequested: "meta.runtime_validation.policy_clear_requested",
+  upsertScopeRequested: "meta.runtime_validation.scope_upsert_requested",
+  removeScopeRequested: "meta.runtime_validation.scope_remove_requested",
+  clearScopesRequested: "meta.runtime_validation.scope_clear_requested",
+  policyUpdated: "meta.runtime_validation.policy_updated",
+  policyCleared: "meta.runtime_validation.policy_cleared",
+  scopeUpserted: "meta.runtime_validation.scope_upserted",
+  scopeRemoved: "meta.runtime_validation.scope_removed",
+  scopesCleared: "meta.runtime_validation.scopes_cleared"
+};
+function normalizePolicyContext(ctx) {
+  const source = ctx.policy && typeof ctx.policy === "object" && !Array.isArray(ctx.policy) ? ctx.policy : ctx;
+  const policy = {};
+  for (const key of [
+    "metaInput",
+    "metaOutput",
+    "businessInput",
+    "businessOutput",
+    "warnOnMissingMetaInputSchema",
+    "warnOnMissingMetaOutputSchema",
+    "warnOnMissingBusinessInputSchema",
+    "warnOnMissingBusinessOutputSchema"
+  ]) {
+    if (source[key] !== void 0) {
+      policy[key] = source[key];
+    }
+  }
+  return policy;
+}
+function normalizeScopeContext(ctx) {
+  const source = ctx.scope && typeof ctx.scope === "object" && !Array.isArray(ctx.scope) ? ctx.scope : ctx;
+  return {
+    id: source.id,
+    active: source.active,
+    startTaskNames: Array.isArray(source.startTaskNames) ? source.startTaskNames : void 0,
+    startRoutineNames: Array.isArray(source.startRoutineNames) ? source.startRoutineNames : void 0,
+    policy: source.policy && typeof source.policy === "object" ? normalizePolicyContext({ policy: source.policy }) : void 0
+  };
+}
+var RuntimeValidationController = class _RuntimeValidationController {
+  static get instance() {
+    if (!this._instance) {
+      this._instance = new _RuntimeValidationController();
+    }
+    return this._instance;
+  }
+  constructor() {
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.getPolicy,
+      description: "Get the active runtime validation policy.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.setPolicy,
+      description: "Merge fields into the active runtime validation policy.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.replacePolicy,
+      description: "Replace the active runtime validation policy.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.clearPolicy,
+      description: "Clear the active runtime validation policy.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.listScopes,
+      description: "List active runtime validation scopes.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.upsertScope,
+      description: "Create or update a runtime validation scope for targeted subflow validation.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.removeScope,
+      description: "Remove a runtime validation scope by id.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.defineIntent({
+      name: RUNTIME_VALIDATION_INTENTS.clearScopes,
+      description: "Clear all runtime validation scopes.",
+      input: { type: "object" },
+      output: { type: "object" }
+    });
+    CadenzaService.createMetaTask("Get runtime validation policy", () => {
+      return {
+        policy: CadenzaService.getRuntimeValidationPolicy()
+      };
+    }).respondsTo(RUNTIME_VALIDATION_INTENTS.getPolicy);
+    CadenzaService.createMetaTask(
+      "Set runtime validation policy",
+      (ctx, emit) => {
+        const policy = normalizePolicyContext(ctx);
+        const nextPolicy = CadenzaService.setRuntimeValidationPolicy(policy);
+        emit(RUNTIME_VALIDATION_SIGNALS.policyUpdated, {
+          policy: nextPolicy
+        });
+        return {
+          policy: nextPolicy
+        };
+      },
+      "Merges runtime validation policy fields at runtime."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.setPolicy).doOn(RUNTIME_VALIDATION_SIGNALS.setPolicyRequested);
+    CadenzaService.createMetaTask(
+      "Replace runtime validation policy",
+      (ctx, emit) => {
+        const policy = normalizePolicyContext(ctx);
+        const nextPolicy = CadenzaService.replaceRuntimeValidationPolicy(policy);
+        emit(RUNTIME_VALIDATION_SIGNALS.policyUpdated, {
+          policy: nextPolicy
+        });
+        return {
+          policy: nextPolicy
+        };
+      },
+      "Replaces runtime validation policy fields at runtime."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.replacePolicy).doOn(RUNTIME_VALIDATION_SIGNALS.replacePolicyRequested);
+    CadenzaService.createMetaTask(
+      "Clear runtime validation policy",
+      (_ctx, emit) => {
+        CadenzaService.clearRuntimeValidationPolicy();
+        emit(RUNTIME_VALIDATION_SIGNALS.policyCleared, {});
+        return {
+          policy: CadenzaService.getRuntimeValidationPolicy()
+        };
+      },
+      "Clears the runtime validation policy."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.clearPolicy).doOn(RUNTIME_VALIDATION_SIGNALS.clearPolicyRequested);
+    CadenzaService.createMetaTask("List runtime validation scopes", () => {
+      return {
+        scopes: CadenzaService.getRuntimeValidationScopes()
+      };
+    }).respondsTo(RUNTIME_VALIDATION_INTENTS.listScopes);
+    CadenzaService.createMetaTask(
+      "Upsert runtime validation scope",
+      (ctx, emit) => {
+        const scope = normalizeScopeContext(ctx);
+        const nextScope = CadenzaService.upsertRuntimeValidationScope(scope);
+        emit(RUNTIME_VALIDATION_SIGNALS.scopeUpserted, {
+          scope: nextScope
+        });
+        return {
+          scope: nextScope
+        };
+      },
+      "Upserts a runtime validation scope for targeted debugging."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.upsertScope).doOn(RUNTIME_VALIDATION_SIGNALS.upsertScopeRequested);
+    CadenzaService.createMetaTask(
+      "Remove runtime validation scope",
+      (ctx, emit) => {
+        if (!ctx.id) {
+          throw new Error("Runtime validation scope id is required");
+        }
+        CadenzaService.removeRuntimeValidationScope(ctx.id);
+        emit(RUNTIME_VALIDATION_SIGNALS.scopeRemoved, {
+          id: ctx.id
+        });
+        return {
+          id: ctx.id,
+          scopes: CadenzaService.getRuntimeValidationScopes()
+        };
+      },
+      "Removes a runtime validation scope."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.removeScope).doOn(RUNTIME_VALIDATION_SIGNALS.removeScopeRequested);
+    CadenzaService.createMetaTask(
+      "Clear runtime validation scopes",
+      (_ctx, emit) => {
+        CadenzaService.clearRuntimeValidationScopes();
+        emit(RUNTIME_VALIDATION_SIGNALS.scopesCleared, {});
+        return {
+          scopes: CadenzaService.getRuntimeValidationScopes()
+        };
+      },
+      "Clears all runtime validation scopes."
+    ).respondsTo(RUNTIME_VALIDATION_INTENTS.clearScopes).doOn(RUNTIME_VALIDATION_SIGNALS.clearScopesRequested);
+  }
+};
+
 // src/graph/controllers/registerActorSessionPersistence.ts
 import { META_ACTOR_SESSION_STATE_PERSIST_INTENT } from "@cadenza.io/core";
 function registerActorSessionPersistenceTasks() {
@@ -6477,7 +6649,6 @@ function buildSyncExecutionEnvelope(ctx, queryData) {
 }
 function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, options = {}) {
   const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
-  const debugTable = shouldDebugSyncTable(tableName);
   if (!localInsertTask && !isCadenzaDBReady) {
     return void 0;
   }
@@ -6490,16 +6661,6 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
     register: false,
     isHidden: true
   });
-  if (debugTable) {
-    logSyncDebug("insert_task_resolved", {
-      tableName,
-      localInsertTaskName: localInsertTask?.name ?? null,
-      remoteInsertTaskName: isCadenzaDBReady ? targetTask.name : null,
-      targetTaskName: targetTask.name,
-      queryData,
-      options
-    });
-  }
   const prepareExecutionTask = CadenzaService.createMetaTask(
     `Prepare graph sync insert for ${tableName}`,
     (ctx) => {
@@ -6510,12 +6671,12 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       if ((tableName === "signal_registry" || tableName === "directional_task_graph_map") && originalQueryData.data && typeof originalQueryData.data === "object" && !Array.isArray(originalQueryData.data) && Object.keys(originalQueryData.data).length === 0) {
         console.warn(
           "[CADENZA_SYNC_EMPTY_INSERT]",
-          summarizeSyncDebugValue({
+          {
             tableName,
             queryData: originalQueryData,
             ctx,
             joinedContexts: Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : []
-          })
+          }
         );
       }
       return buildSyncExecutionEnvelope(
@@ -6529,37 +6690,6 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
       isHidden: true
     }
   );
-  if (debugTable) {
-    prepareExecutionTask.then(
-      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,
-            ctx
-          });
-          return ctx;
-        },
-        `Logs prepared ${tableName} sync insert payloads.`,
-        {
-          register: false,
-          isHidden: true
-        }
-      )
-    );
-  }
   const finalizeExecutionTask = CadenzaService.createMetaTask(
     `Finalize graph sync insert for ${tableName}`,
     (ctx) => {
@@ -6570,25 +6700,6 @@ function resolveSyncInsertTask(isCadenzaDBReady, tableName, queryData = {}, opti
         ...ctx,
         queryData: ctx.queryData && typeof ctx.queryData === "object" ? ctx.queryData : originalQueryData
       };
-      if (debugTable) {
-        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
-          });
-        }
-      }
       return normalizedContext;
     },
     `Finalizes ${tableName} graph-sync insert execution after the authority task finishes.`,
@@ -6623,139 +6734,6 @@ 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_ENABLED = typeof process !== "undefined" && typeof process.env === "object" && process.env.CADENZA_SYNC_DEBUG === "true";
-var SYNC_DEBUG_TABLES = /* @__PURE__ */ new Set(["intent_to_task_map", "task"]);
-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",
-  "Normalize telemetry ingest payload",
-  "Get telemetry session state",
-  "Normalize anomaly detect input",
-  "Read anomaly runtime session",
-  "Normalize prediction compute input",
-  "Normalize telemetry insert queryData"
-]);
-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",
-  "iot-telemetry-session-get",
-  "iot-anomaly-detect",
-  "iot-anomaly-runtime-get",
-  "iot-prediction-compute",
-  "iot-db-telemetry-insert",
-  "query-pg-cadenza-db-postgres-actor-service_instance",
-  "query-pg-cadenza-db-postgres-actor-service_instance_transport",
-  "query-pg-cadenza-db-postgres-actor-intent_to_task_map",
-  "query-pg-cadenza-db-postgres-actor-signal_to_task_map"
-]);
-function shouldDebugSyncTable(tableName) {
-  return SYNC_DEBUG_ENABLED && SYNC_DEBUG_TABLES.has(tableName);
-}
-function shouldDebugSyncTaskName(taskName) {
-  return SYNC_DEBUG_ENABLED && typeof taskName === "string" && SYNC_DEBUG_TASK_NAMES.has(taskName);
-}
-function shouldDebugSyncRoutineName(routineName) {
-  return SYNC_DEBUG_ENABLED && typeof routineName === "string" && SYNC_DEBUG_ROUTINE_NAMES.has(routineName);
-}
-function shouldDebugSyncIntentName(intentName) {
-  return SYNC_DEBUG_ENABLED && 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 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];
@@ -7202,16 +7180,6 @@ 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: {
@@ -7357,20 +7325,6 @@ var GraphSyncController = class _GraphSyncController {
           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,
-              exportFunctionLength: __functionString?.length ?? null,
-              exportTagGetterLength: __getTagCallback?.length ?? null,
-              observedSignals: Array.from(task.observedSignals),
-              handledIntents: Array.from(task.handlesIntents)
-            });
-          }
           yield {
             __syncing: ctx.__syncing,
             data: {
@@ -7425,13 +7379,6 @@ var GraphSyncController = class _GraphSyncController {
     const registerTaskTask = 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;
         }
@@ -7457,16 +7404,6 @@ 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;
         }
@@ -7653,17 +7590,6 @@ var GraphSyncController = class _GraphSyncController {
           if (!isGlobal) {
             continue;
           }
-          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
-            });
-          }
           yield {
             __syncing: ctx.__syncing,
             data: {
@@ -7774,21 +7700,6 @@ var GraphSyncController = class _GraphSyncController {
         }
         task.__registeredIntents = task.__registeredIntents ?? /* @__PURE__ */ new Set();
         task.__invalidMetaIntentWarnings = task.__invalidMetaIntentWarnings ?? /* @__PURE__ */ new Set();
-        const shouldDebugTask = shouldDebugSyncTaskName(task.name);
-        if (shouldDebugTask) {
-          logSyncDebug("intent_map_task_state", {
-            taskName: task.name,
-            taskVersion: task.version,
-            serviceName: serviceName2,
-            registered: task.registered,
-            register: task.register,
-            hidden: task.hidden,
-            handledIntents: Array.from(task.handlesIntents),
-            registeredIntents: Array.from(task.__registeredIntents),
-            tasksSynced: this.tasksSynced,
-            intentsSynced: this.intentsSynced
-          });
-        }
         let emittedCount = 0;
         for (const intent of task.handlesIntents) {
           if (task.__registeredIntents.has(intent)) continue;
@@ -7814,15 +7725,6 @@ 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
-            });
-          }
           yield {
             __syncing: ctx.__syncing,
             data: {
@@ -7843,15 +7745,6 @@ var GraphSyncController = class _GraphSyncController {
           };
           emittedCount += 1;
         }
-        if (shouldDebugTask && emittedCount === 0) {
-          logSyncDebug("intent_map_task_noop", {
-            taskName: task.name,
-            taskVersion: task.version,
-            serviceName: serviceName2,
-            handledIntents: Array.from(task.handlesIntents),
-            registeredIntents: Array.from(task.__registeredIntents)
-          });
-        }
         return emittedCount > 0;
       }.bind(this)
     );
@@ -7861,13 +7754,6 @@ 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
@@ -7880,13 +7766,6 @@ 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
@@ -8708,6 +8587,13 @@ var CadenzaService = class {
     if (this.isBootstrapped) return;
     this.isBootstrapped = true;
     Cadenza.bootstrap();
+    Cadenza.setRuntimeInquiryDelegate(
+      (inquiry, context, options) => this.inquire(
+        inquiry,
+        context,
+        options ?? {}
+      )
+    );
     this.signalBroker = Cadenza.signalBroker;
     this.inquiryBroker = Cadenza.inquiryBroker;
     this.runner = Cadenza.runner;
@@ -8716,7 +8602,7 @@ var CadenzaService = class {
     this.serviceRegistry = ServiceRegistry.instance;
     RestController.instance;
     SocketController.instance;
-    console.log("BOOTSTRAPPED");
+    RuntimeValidationController.instance;
   }
   static ensureTransportControllers(isFrontend) {
     if (!isFrontend) {
@@ -8855,6 +8741,38 @@ var CadenzaService = class {
     this.inquiryBroker?.addIntent(intent);
     return intent;
   }
+  static getRuntimeValidationPolicy() {
+    this.bootstrap();
+    return Cadenza.getRuntimeValidationPolicy();
+  }
+  static setRuntimeValidationPolicy(policy = {}) {
+    this.bootstrap();
+    return Cadenza.setRuntimeValidationPolicy(policy);
+  }
+  static replaceRuntimeValidationPolicy(policy = {}) {
+    this.bootstrap();
+    return Cadenza.replaceRuntimeValidationPolicy(policy);
+  }
+  static clearRuntimeValidationPolicy() {
+    this.bootstrap();
+    Cadenza.clearRuntimeValidationPolicy();
+  }
+  static getRuntimeValidationScopes() {
+    this.bootstrap();
+    return Cadenza.getRuntimeValidationScopes();
+  }
+  static upsertRuntimeValidationScope(scope) {
+    this.bootstrap();
+    return Cadenza.upsertRuntimeValidationScope(scope);
+  }
+  static removeRuntimeValidationScope(id) {
+    this.bootstrap();
+    Cadenza.removeRuntimeValidationScope(id);
+  }
+  static clearRuntimeValidationScopes() {
+    this.bootstrap();
+    Cadenza.clearRuntimeValidationScopes();
+  }
   static getInquiryResponderDescriptor(task) {
     return this.serviceRegistry.getInquiryResponderDescriptor(task);
   }
@@ -9615,7 +9533,6 @@ var CadenzaService = class {
         }
       });
     });
-    console.log("Creating service...");
     const initContext = {
       data: {
         name: serviceName,
@@ -9648,10 +9565,13 @@ var CadenzaService = class {
       }).doOn("meta.fetch.handshake_complete");
     } else {
       this.emit("meta.create_service_requested", initContext);
-      this.createMetaTask("Create signal transmission for sync", (ctx) => {
-        this.createSignalTransmissionTask(
-          "global.meta.cadenza_db.gathered_sync_data",
-          ctx.serviceName
+      this.createMetaTask("Create signal transmission for sync", (ctx, emit) => {
+        emit(
+          "meta.service_registry.gathered_sync_transmission_reconcile_requested",
+          {
+            serviceName: ctx.serviceName,
+            __reason: "handshake"
+          }
         );
       }).doOn("meta.rest.handshake", "meta.socket.handshake");
     }
@@ -10646,6 +10566,8 @@ export {
   EphemeralTask2 as EphemeralTask,
   GraphMetadataController,
   GraphRoutine2 as GraphRoutine,
+  RUNTIME_VALIDATION_INTENTS,
+  RUNTIME_VALIDATION_SIGNALS,
   RestController,
   ServiceRegistry,
   SignalController,