@cadenza.io/service 2.18.2 → 2.18.3

package/dist/index.js

@@ -55,8 +55,46 @@ module.exports = __toCommonJS(index_exports);
 var import_core5 = __toESM(require("@cadenza.io/core"));
 
 // src/graph/definition/DeputyTask.ts
-var import_uuid = require("uuid");
+var import_uuid2 = require("uuid");
 var import_core = require("@cadenza.io/core");
+
+// src/utils/delegation.ts
+var import_uuid = require("uuid");
+var ROOT_METADATA_PASSTHROUGH_KEYS = [
+  "__executionTraceId",
+  "__inquiryId",
+  "__inquirySourceTaskName",
+  "__inquirySourceTaskVersion",
+  "__inquirySourceTaskExecutionId",
+  "__inquirySourceRoutineExecutionId"
+];
+function hoistDelegationMetadataFields(input, metadataInput) {
+  const context = input && typeof input === "object" ? { ...input } : {};
+  const mutableContext = context;
+  const metadata = metadataInput && typeof metadataInput === "object" ? metadataInput : context.__metadata && typeof context.__metadata === "object" ? context.__metadata : {};
+  for (const key of ROOT_METADATA_PASSTHROUGH_KEYS) {
+    if ((mutableContext[key] === void 0 || mutableContext[key] === null) && metadata[key] !== void 0 && metadata[key] !== null) {
+      mutableContext[key] = metadata[key];
+    }
+  }
+  return context;
+}
+function ensureDelegationContextMetadata(input) {
+  const rawContext = input && typeof input === "object" ? { ...input } : {};
+  const metadata = rawContext.__metadata && typeof rawContext.__metadata === "object" ? { ...rawContext.__metadata } : {};
+  const context = hoistDelegationMetadataFields(rawContext, metadata);
+  const deputyExecId = typeof metadata.__deputyExecId === "string" && metadata.__deputyExecId.length > 0 ? metadata.__deputyExecId : typeof rawContext.__deputyExecId === "string" && rawContext.__deputyExecId.length > 0 ? context.__deputyExecId : (0, import_uuid.v4)();
+  return {
+    ...context,
+    __deputyExecId: deputyExecId,
+    __metadata: {
+      ...metadata,
+      __deputyExecId: deputyExecId
+    }
+  };
+}
+
+// src/graph/definition/DeputyTask.ts
 var DeputyTask = class extends import_core.Task {
   /**
    * Constructs a new instance of the class with the specified parameters.
@@ -94,7 +132,7 @@ var DeputyTask = class extends import_core.Task {
           resolve(context);
           return;
         }
-        const processId = (0, import_uuid.v4)();
+        const processId = (0, import_uuid2.v4)();
         context.__metadata.__deputyExecId = processId;
         emit("meta.deputy.delegation_requested", {
           ...context
@@ -182,7 +220,7 @@ var DeputyTask = class extends import_core.Task {
   execute(context, emit, inquire, progressCallback, nodeData) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       __timeout: this.timeout,
       __localTaskName: this.name,
       __localTaskVersion: this.version,
@@ -199,7 +237,7 @@ var DeputyTask = class extends import_core.Task {
         __deputyTaskName: this.name
       },
       ...ctx
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
@@ -280,7 +318,7 @@ var DatabaseTask = class extends DeputyTask {
       },
       ...dynamicQueryData
     };
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       ...ctx,
       __localTaskName: this.name,
       __localTaskVersion: this.version,
@@ -303,7 +341,7 @@ var DatabaseTask = class extends DeputyTask {
       filter: nextQueryData.filter ?? ctx.filter,
       fields: nextQueryData.fields ?? ctx.fields,
       queryData: nextQueryData
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
@@ -554,22 +592,6 @@ function getRouteableTransport(instance, role, protocol) {
   return selectTransportForRole(instance.transports ?? [], role, protocol);
 }
 
-// src/utils/delegation.ts
-var import_uuid2 = require("uuid");
-function ensureDelegationContextMetadata(input) {
-  const context = input && typeof input === "object" ? { ...input } : {};
-  const metadata = context.__metadata && typeof context.__metadata === "object" ? { ...context.__metadata } : {};
-  const deputyExecId = typeof metadata.__deputyExecId === "string" && metadata.__deputyExecId.length > 0 ? metadata.__deputyExecId : typeof context.__deputyExecId === "string" && context.__deputyExecId.length > 0 ? context.__deputyExecId : (0, import_uuid2.v4)();
-  return {
-    ...context,
-    __deputyExecId: deputyExecId,
-    __metadata: {
-      ...metadata,
-      __deputyExecId: deputyExecId
-    }
-  };
-}
-
 // src/utils/readiness.ts
 function evaluateDependencyReadiness(input) {
   const missedHeartbeats = Math.max(
@@ -766,6 +788,10 @@ var INTERNAL_RUNTIME_STATUS_TASK_NAMES = /* @__PURE__ */ new Set([
   "Collect distributed readiness",
   "Get status"
 ]);
+var SERVICE_REGISTRY_TRACE_SERVICE = (process.env.CADENZA_SERVICE_REGISTRY_TRACE_SERVICE ?? "").trim();
+function shouldTraceServiceRegistry(serviceName) {
+  return SERVICE_REGISTRY_TRACE_SERVICE.length > 0 && serviceName === SERVICE_REGISTRY_TRACE_SERVICE;
+}
 function buildServiceRegistryInsertQueryData(ctx, queryData) {
   const joinedContexts = Array.isArray(ctx.joinedContexts) ? ctx.joinedContexts : [];
   const getJoinedValue = (key) => {
@@ -839,6 +865,45 @@ function normalizeServiceRegistryInsertResult(tableName, ctx, queryData, rawResu
   }
   return result;
 }
+function resolveServiceInstanceRegistrationPayload(ctx, fallbackServiceName, fallbackServiceInstanceId) {
+  const candidateSources = [
+    ctx.__registrationData,
+    ctx.queryData?.data,
+    ctx.__resolverQueryData?.data,
+    ctx.__resolverOriginalContext?.__registrationData,
+    ctx.__resolverOriginalContext?.queryData?.data,
+    ctx.data,
+    ctx.__resolverOriginalContext?.data
+  ];
+  let resolvedData = null;
+  for (const candidate of candidateSources) {
+    if (candidate && typeof candidate === "object" && !Array.isArray(candidate)) {
+      resolvedData = {
+        ...candidate
+      };
+      break;
+    }
+  }
+  if (!resolvedData) {
+    return null;
+  }
+  const resolvedUuid = String(
+    resolvedData.uuid ?? ctx.__serviceInstanceId ?? ctx.__resolverOriginalContext?.__serviceInstanceId ?? fallbackServiceInstanceId ?? ""
+  ).trim();
+  const resolvedServiceName = String(
+    resolvedData.service_name ?? ctx.__serviceName ?? ctx.__resolverOriginalContext?.__serviceName ?? fallbackServiceName ?? ""
+  ).trim();
+  const resolvedProcessPid = typeof resolvedData.process_pid === "number" ? resolvedData.process_pid : typeof ctx.__resolverOriginalContext?.data?.process_pid === "number" ? ctx.__resolverOriginalContext.data.process_pid : typeof ctx.__resolverOriginalContext?.__registrationData?.process_pid === "number" ? ctx.__resolverOriginalContext.__registrationData.process_pid : typeof ctx.queryData?.data?.process_pid === "number" ? ctx.queryData.data.process_pid : typeof ctx.__registrationData?.process_pid === "number" ? ctx.__registrationData.process_pid : null;
+  if (!resolvedUuid || !resolvedServiceName || resolvedProcessPid === null) {
+    return null;
+  }
+  return {
+    ...resolvedData,
+    uuid: resolvedUuid,
+    service_name: resolvedServiceName,
+    process_pid: resolvedProcessPid
+  };
+}
 function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {}) {
   const remoteInsertTask = CadenzaService.createCadenzaDBInsertTask(
     tableName,
@@ -863,13 +928,24 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       });
       delegationContext.__metadata.__skipRemoteExecution = delegationContext.__metadata.__skipRemoteExecution ?? delegationContext.__skipRemoteExecution ?? false;
       delegationContext.__metadata.__blockRemoteExecution = delegationContext.__metadata.__blockRemoteExecution ?? delegationContext.__blockRemoteExecution ?? false;
-      return {
+      const nextContext = {
         ...delegationContext,
         __resolverOriginalContext: {
           ...ctx
         },
         __resolverQueryData: nextQueryData
       };
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+        console.log("[CADENZA_INSTANCE_DEBUG] prepare_service_registry_insert_execution", {
+          tableName,
+          signalName,
+          resolverRequestId: ctx.__resolverRequestId ?? null,
+          hasData: nextQueryData.data !== void 0,
+          queryDataKeys: Object.keys(nextQueryData),
+          dataKeys: nextQueryData.data && typeof nextQueryData.data === "object" ? Object.keys(nextQueryData.data) : []
+        });
+      }
+      return nextContext;
     },
     `Prepares ${tableName} service-registry insert payloads for runner execution.`,
     {
@@ -895,7 +971,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
         ctx.__resolverQueryData ?? ctx.queryData ?? {},
         ctx
       );
-      if (tableName === "service_instance" && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
         console.log("[CADENZA_INSTANCE_DEBUG] finalize_service_registry_insert", {
           tableName,
           hasNormalized: !!normalized,
@@ -932,6 +1008,16 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       CadenzaService.createEphemeralMetaTask(
         `Resolve service registry insert execution for ${tableName} (${resolverRequestId})`,
         (resultCtx) => {
+          if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+            console.log("[CADENZA_INSTANCE_DEBUG] resolve_service_registry_insert_signal", {
+              tableName,
+              resolverRequestId,
+              incomingResolverRequestId: resultCtx.__resolverRequestId ?? null,
+              errored: resultCtx.errored === true,
+              error: resultCtx.__error ?? null,
+              keys: resultCtx && typeof resultCtx === "object" ? Object.keys(resultCtx) : []
+            });
+          }
           if (resultCtx.__resolverRequestId !== resolverRequestId) {
             return false;
           }
@@ -951,7 +1037,7 @@ function resolveServiceRegistryInsertTask(tableName, queryData = {}, options = {
       ).doOn(executionResolvedSignal, executionFailedSignal);
       const localInsertTask = CadenzaService.getLocalCadenzaDBInsertTask(tableName);
       const executionSignal = localInsertTask ? localExecutionRequestedSignal : remoteExecutionRequestedSignal;
-      if (tableName === "service_instance" && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
+      if ((tableName === "service_instance" || tableName === "service") && (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true")) {
         console.log("[CADENZA_INSTANCE_DEBUG] resolve_service_registry_insert", {
           tableName,
           executionSignal,
@@ -1404,6 +1490,9 @@ var ServiceRegistry = class _ServiceRegistry {
             )?.destroy();
             continue;
           }
+          if (map.serviceName === this.serviceName) {
+            continue;
+          }
           if (locallyEmittedSignals.includes(map.signalName)) {
             if (!this.remoteSignals.get(map.serviceName)) {
               this.remoteSignals.set(map.serviceName, /* @__PURE__ */ new Set());
@@ -1437,6 +1526,13 @@ var ServiceRegistry = class _ServiceRegistry {
       "Handle global intent registration",
       (ctx, emit) => {
         const intentToTaskMaps = this.normalizeIntentMaps(ctx);
+        if (shouldTraceServiceRegistry(this.serviceName)) {
+          console.log("[CADENZA_SERVICE_REGISTRY_TRACE] handle_global_intents", {
+            localServiceName: this.serviceName,
+            intentCount: intentToTaskMaps.length,
+            sample: intentToTaskMaps.slice(0, 5)
+          });
+        }
         const sorted = intentToTaskMaps.sort((a, b) => {
           if (a.deleted && !b.deleted) return -1;
           if (!a.deleted && b.deleted) return 1;
@@ -1448,6 +1544,9 @@ var ServiceRegistry = class _ServiceRegistry {
               this.unregisterRemoteIntentDeputy(map);
               continue;
             }
+            if (map.serviceName === this.serviceName) {
+              continue;
+            }
             CadenzaService.inquiryBroker.addIntent({
               name: map.intentName
             });
@@ -1652,6 +1751,11 @@ var ServiceRegistry = class _ServiceRegistry {
       "Full sync",
       async (ctx) => {
         if (this.connectsToCadenzaDB && this.serviceName !== "CadenzaDB" && !this.hasBootstrapFullSyncDeputies()) {
+          if (shouldTraceServiceRegistry(this.serviceName)) {
+            console.log("[CADENZA_SERVICE_REGISTRY_TRACE] full_sync_skipped_missing_bootstrap_deputies", {
+              localServiceName: this.serviceName
+            });
+          }
           return false;
         }
         const inquiryResult = await CadenzaService.inquire(
@@ -1670,6 +1774,15 @@ var ServiceRegistry = class _ServiceRegistry {
         const serviceInstances = this.normalizeServiceInstancesFromSync(
           inquiryResult
         );
+        if (shouldTraceServiceRegistry(this.serviceName)) {
+          console.log("[CADENZA_SERVICE_REGISTRY_TRACE] full_sync_result", {
+            localServiceName: this.serviceName,
+            inquiryMeta: inquiryResult.__inquiryMeta,
+            signalToTaskMaps: signalToTaskMaps.length,
+            intentToTaskMaps: intentToTaskMaps.length,
+            serviceInstances: serviceInstances.length
+          });
+        }
         return {
           ...ctx,
           signalToTaskMaps,
@@ -1712,6 +1825,9 @@ var ServiceRegistry = class _ServiceRegistry {
       "Handle Deputy Registration",
       (ctx, emit) => {
         const { serviceName } = ctx;
+        if (!serviceName || serviceName === this.serviceName) {
+          return false;
+        }
         if (!this.deputies.has(serviceName)) this.deputies.set(serviceName, []);
         this.deputies.get(serviceName).push({
           serviceName,
@@ -2438,15 +2554,29 @@ var ServiceRegistry = class _ServiceRegistry {
     CadenzaService.createMetaTask(
       "Retry local service instance registration after failed insert",
       (ctx) => {
+        const registrationPayload = resolveServiceInstanceRegistrationPayload(
+          ctx,
+          this.serviceName,
+          this.serviceInstanceId
+        );
+        if (!registrationPayload) {
+          return false;
+        }
         const serviceName = String(
-          ctx.__serviceName ?? ctx.data?.service_name ?? this.serviceName ?? ""
+          registrationPayload.service_name ?? this.serviceName ?? ""
         ).trim();
         if (!serviceName || serviceName !== this.serviceName) {
           return false;
         }
         CadenzaService.schedule(
           "meta.service_registry.instance_registration_requested",
-          { ...ctx },
+          {
+            ...ctx,
+            data: registrationPayload,
+            __registrationData: registrationPayload,
+            __serviceName: serviceName,
+            __serviceInstanceId: registrationPayload.uuid
+          },
           5e3
         );
         return true;
@@ -2460,18 +2590,26 @@ var ServiceRegistry = class _ServiceRegistry {
     CadenzaService.createMetaTask(
       "Prepare service instance registration",
       (ctx) => {
+        const registrationPayload = resolveServiceInstanceRegistrationPayload(
+          ctx,
+          this.serviceName,
+          this.serviceInstanceId
+        );
         if (process.env.CADENZA_INSTANCE_DEBUG === "1" || process.env.CADENZA_INSTANCE_DEBUG === "true") {
           console.log("[CADENZA_INSTANCE_DEBUG] prepare_service_instance_registration", {
-            serviceName: ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? null,
-            serviceInstanceId: ctx.data?.uuid ?? ctx.__serviceInstanceId ?? this.serviceInstanceId ?? null,
-            hasData: !!ctx.data,
-            dataKeys: ctx.data && typeof ctx.data === "object" ? Object.keys(ctx.data) : [],
+            serviceName: registrationPayload?.service_name ?? ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? null,
+            serviceInstanceId: registrationPayload?.uuid ?? ctx.data?.uuid ?? ctx.__serviceInstanceId ?? this.serviceInstanceId ?? null,
+            hasData: !!registrationPayload,
+            dataKeys: registrationPayload && typeof registrationPayload === "object" ? Object.keys(registrationPayload) : [],
             transportCount: Array.isArray(ctx.__transportData) ? ctx.__transportData.length : Array.isArray(ctx.transportData) ? ctx.transportData.length : 0,
             skipRemoteExecution: ctx.__skipRemoteExecution === true
           });
         }
+        if (!registrationPayload) {
+          return false;
+        }
         const serviceName = String(
-          ctx.data?.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
+          registrationPayload.service_name ?? ctx.__serviceName ?? this.serviceName ?? ""
         ).trim();
         if (serviceName === "CadenzaDB" && !CadenzaService.getLocalCadenzaDBInsertTask("service_instance")) {
           CadenzaService.schedule(
@@ -2481,7 +2619,16 @@ var ServiceRegistry = class _ServiceRegistry {
           );
           return false;
         }
-        return ctx;
+        return {
+          ...ctx,
+          data: registrationPayload,
+          __registrationData: {
+            ...ctx.__registrationData ?? {},
+            ...registrationPayload
+          },
+          __serviceName: serviceName,
+          __serviceInstanceId: registrationPayload.uuid
+        };
       },
       "Waits for the exact local CadenzaDB service instance insert task during self-bootstrap."
     ).doOn("meta.service_registry.instance_registration_requested").then(this.insertServiceInstanceTask);
@@ -2856,6 +3003,15 @@ var ServiceRegistry = class _ServiceRegistry {
     };
     this.remoteIntentDeputiesByKey.set(key, descriptor);
     this.remoteIntentDeputiesByTask.set(deputyTask, descriptor);
+    if (shouldTraceServiceRegistry(this.serviceName)) {
+      console.log("[CADENZA_SERVICE_REGISTRY_TRACE] register_remote_intent_deputy", {
+        localServiceName: this.serviceName,
+        intentName: map.intentName,
+        remoteServiceName: map.serviceName,
+        remoteTaskName: map.taskName,
+        remoteTaskVersion: map.taskVersion
+      });
+    }
   }
   unregisterRemoteIntentDeputy(map) {
     const key = this.buildRemoteIntentDeputyKey(map);
@@ -3114,7 +3270,7 @@ var ServiceRegistry = class _ServiceRegistry {
     return communicationTypes;
   }
   ensureDependeeClientForInstance(instance, emit, ctx) {
-    if (!instance || instance.uuid === this.serviceInstanceId || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
+    if (!instance || instance.uuid === this.serviceInstanceId || instance.serviceName === this.serviceName || instance.isFrontend || !instance.isActive || instance.isNonResponsive || instance.isBlocked) {
       return false;
     }
     if (!this.deputies.has(instance.serviceName) && !this.remoteIntents.has(instance.serviceName) && !this.remoteSignals.has(instance.serviceName)) {
@@ -3142,6 +3298,9 @@ var ServiceRegistry = class _ServiceRegistry {
     return true;
   }
   ensureDependeeClientsForService(serviceName, emit, ctx) {
+    if (!serviceName || serviceName === this.serviceName) {
+      return;
+    }
     for (const instance of this.instances.get(serviceName) ?? []) {
       this.ensureDependeeClientForInstance(instance, emit, ctx);
     }
@@ -3934,7 +4093,7 @@ var SignalTransmissionTask = class extends import_core2.Task {
   execute(context, emit, inquire, progressCallback) {
     const ctx = context.getContext();
     const metadata = context.getMetadata();
-    const deputyContext = {
+    const deputyContext = hoistDelegationMetadataFields({
       __localTaskName: this.name,
       __localServiceName: CadenzaService.serviceRegistry.serviceName,
       __serviceName: this.serviceName,
@@ -3947,7 +4106,7 @@ var SignalTransmissionTask = class extends import_core2.Task {
       __signalName: this.signalName,
       __signalEmissionId: metadata.__signalEmission?.uuid,
       ...ctx
-    };
+    });
     return this.taskFunction(deputyContext, emit, inquire, progressCallback);
   }
 };
@@ -4146,8 +4305,11 @@ var RestController = class _RestController {
               const app = ctx.__app;
               app.post("/handshake", (req, res) => {
                 try {
-                  CadenzaService.log("New fetch connection.", req.body);
-                  CadenzaService.emit("meta.rest.handshake", req.body);
+                  const handshakePayload = req.body && typeof req.body === "object" ? req.body : {};
+                  if (Object.keys(handshakePayload).length > 0) {
+                    CadenzaService.log("New fetch connection.", handshakePayload);
+                  }
+                  CadenzaService.emit("meta.rest.handshake", handshakePayload);
                   res.send({
                     __status: "success",
                     __serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
@@ -4544,7 +4706,13 @@ var RestController = class _RestController {
             return ctx2;
           },
           "Sends handshake request",
-          { retryCount: 5, retryDelay: 1e3, retryDelayFactor: 1.5 }
+          {
+            retryCount: 5,
+            retryDelay: 1e3,
+            retryDelayFactor: 1.5,
+            register: false,
+            isHidden: true
+          }
         ).doOn(`meta.fetch.handshake_requested:${fetchId}`).emits("meta.fetch.handshake_complete").attachSignal(
           "meta.fetch.handshake_failed",
           "global.meta.fetch.service_communication_established"
@@ -4598,7 +4766,11 @@ var RestController = class _RestController {
             }
             return resultContext;
           },
-          "Sends delegation request"
+          "Sends delegation request",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn(
           `meta.service_registry.selected_instance_for_fetch:${fetchId}`,
           `meta.service_registry.socket_failed:${fetchId}`
@@ -4650,7 +4822,11 @@ var RestController = class _RestController {
             }
             return response;
           },
-          "Sends signal request"
+          "Sends signal request",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn(
           `meta.service_registry.selected_instance_for_fetch:${fetchId}`,
           `meta.signal_controller.remote_signal_registered:${serviceName}`,
@@ -4692,18 +4868,30 @@ var RestController = class _RestController {
             }
             return status;
           },
-          "Requests status"
+          "Requests status",
+          {
+            register: false,
+            isHidden: true
+          }
         ).doOn("meta.fetch.status_check_requested").emits("meta.fetch.status_checked").emitsOnFail("meta.fetch.status_check_failed");
-        CadenzaService.createEphemeralMetaTask(`Destroy fetch client ${fetchId}`, () => {
-          fetchDiagnostics.connected = false;
-          fetchDiagnostics.destroyed = true;
-          fetchDiagnostics.updatedAt = Date.now();
-          CadenzaService.log("Destroying fetch client", { URL: URL2, serviceName });
-          handshakeTask.destroy();
-          delegateTask.destroy();
-          transmitTask.destroy();
-          statusTask.destroy();
-        }).doOn(
+        CadenzaService.createEphemeralMetaTask(
+          `Destroy fetch client ${fetchId}`,
+          () => {
+            fetchDiagnostics.connected = false;
+            fetchDiagnostics.destroyed = true;
+            fetchDiagnostics.updatedAt = Date.now();
+            CadenzaService.log("Destroying fetch client", { URL: URL2, serviceName });
+            handshakeTask.destroy();
+            delegateTask.destroy();
+            transmitTask.destroy();
+            statusTask.destroy();
+          },
+          "",
+          {
+            register: false,
+            isHidden: true
+          }
+        ).doOn(
           `meta.fetch.destroy_requested:${fetchId}`,
           `meta.socket_client.disconnected:${fetchId}`,
           `meta.fetch.handshake_failed:${fetchId}`
@@ -6122,7 +6310,11 @@ var SocketController = class _SocketController {
                 }
               );
             },
-            "Handshakes with socket server"
+            "Handshakes with socket server",
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.socket_client.connected:${fetchId}`);
           runtimeHandle.delegateTask = CadenzaService.createMetaTask(
             `Delegate flow to Socket service ${url}`,
@@ -6200,7 +6392,11 @@ var SocketController = class _SocketController {
                 }
               }
             },
-            `Delegate flow to service ${serviceName} with address ${url}`
+            `Delegate flow to service ${serviceName} with address ${url}`,
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal(
             "meta.socket_client.delegated",
             "meta.socket_shutdown_requested"
@@ -6224,7 +6420,11 @@ var SocketController = class _SocketController {
               }
               return response;
             },
-            `Transmits signal to service ${serviceName} with address ${url}`
+            `Transmits signal to service ${serviceName} with address ${url}`,
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(`meta.service_registry.selected_instance_for_socket:${fetchId}`).attachSignal("meta.socket_client.transmitted");
           CadenzaService.createEphemeralMetaTask(
             `Shutdown SocketClient ${url}`,
@@ -6268,7 +6468,11 @@ var SocketController = class _SocketController {
                 fetchId
               });
             },
-            "Shuts down the socket client"
+            "Shuts down the socket client",
+            {
+              register: false,
+              isHidden: true
+            }
           ).doOn(
             `meta.socket_shutdown_requested:${fetchId}`,
             `meta.socket_client.disconnected:${fetchId}`,
@@ -6532,10 +6736,18 @@ function decomposeSignalName(signalName) {
 
 // src/signals/SignalController.ts
 function buildSignalDatabaseTriggerContext(data) {
+  const onConflict = {
+    target: ["name"],
+    action: {
+      do: "nothing"
+    }
+  };
   return {
     data: { ...data },
+    onConflict,
     queryData: {
-      data: { ...data }
+      data: { ...data },
+      onConflict
     }
   };
 }
@@ -6562,16 +6774,28 @@ var SignalController = class _SignalController {
     CadenzaService.createMetaTask(
       "Handle Signal Registration",
       (ctx, emit) => {
+        if (!CadenzaService.hasCompletedBootstrapSync()) {
+          return false;
+        }
         const { signalName } = ctx;
+        const signalObserver = CadenzaService.signalBroker.signalObservers?.get(
+          signalName
+        );
+        if (signalObserver?.registered || signalObserver?.registrationRequested) {
+          return false;
+        }
+        if (signalObserver) {
+          signalObserver.registrationRequested = true;
+        }
         const { isMeta, isGlobal, domain, action } = decomposeSignalName(signalName);
         emit(
           "global.meta.signal_controller.signal_added",
           buildSignalDatabaseTriggerContext({
             name: signalName,
-            isGlobal,
+            is_global: isGlobal,
             domain,
             action,
-            isMeta
+            is_meta: isMeta
           })
         );
         return ctx;
@@ -6580,12 +6804,35 @@ var SignalController = class _SignalController {
     ).doOn("meta.signal_broker.added").attachSignal("global.meta.signal_controller.signal_added");
     CadenzaService.createMetaTask(
       "Add data to signal emission",
-      (ctx) => {
+      (ctx, emit) => {
         const signalEmission = ctx.__signalEmission;
         delete ctx.__signalEmission;
         if (!signalEmission) {
           return false;
         }
+        if (typeof signalEmission.signalName === "string" && signalEmission.signalName.trim().length > 0 && !CadenzaService.signalBroker.signalObservers?.has(signalEmission.signalName)) {
+          CadenzaService.signalBroker.addSignal(signalEmission.signalName);
+        } else {
+          const signalObserver = CadenzaService.signalBroker.signalObservers?.get(
+            signalEmission.signalName
+          );
+          if (signalObserver && signalObserver.registered !== true && signalObserver.registrationRequested !== true && CadenzaService.hasCompletedBootstrapSync()) {
+            signalObserver.registrationRequested = true;
+            const { isMeta, isGlobal, domain, action } = decomposeSignalName(
+              signalEmission.signalName
+            );
+            emit(
+              "global.meta.signal_controller.signal_added",
+              buildSignalDatabaseTriggerContext({
+                name: signalEmission.signalName,
+                is_global: isGlobal,
+                domain,
+                action,
+                is_meta: isMeta
+              })
+            );
+          }
+        }
         return {
           data: {
             uuid: signalEmission.uuid,
@@ -6940,10 +7187,10 @@ function registerActorSessionPersistenceTasks() {
 }
 
 // src/graph/controllers/GraphMetadataController.ts
-function buildDatabaseTriggerContext(data, filter, extra = {}) {
+function buildDatabaseTriggerContext(data, filter, extra = {}, queryExtra = {}) {
   const nextData = data && typeof data === "object" ? { ...data } : void 0;
   const nextFilter = filter && typeof filter === "object" ? { ...filter } : void 0;
-  const queryData = {};
+  const queryData = { ...queryExtra };
   if (nextData !== void 0) {
     queryData.data = nextData;
   }
@@ -6957,19 +7204,108 @@ function buildDatabaseTriggerContext(data, filter, extra = {}) {
     ...Object.keys(queryData).length > 0 ? { queryData } : {}
   };
 }
+function resolveTaskFromMetadataContext(ctx) {
+  const taskName = String(
+    ctx?.taskName ?? ctx?.data?.taskName ?? ctx?.data?.task_name ?? ctx?.filter?.taskName ?? ctx?.filter?.task_name ?? ""
+  );
+  return taskName ? CadenzaService.get(taskName) : void 0;
+}
+function resolveTaskByName(name) {
+  const taskName = String(name ?? "");
+  return taskName ? CadenzaService.get(taskName) : void 0;
+}
+function resolvePredecessorTaskFromMetadataContext(ctx) {
+  return resolveTaskByName(
+    ctx?.predecessorTaskName ?? ctx?.data?.predecessorTaskName ?? ctx?.data?.predecessor_task_name ?? ctx?.filter?.predecessorTaskName ?? ctx?.filter?.predecessor_task_name
+  );
+}
+function shouldSkipDirectTaskMetadata(task) {
+  return !task || !task.register || task.isHidden || task.isDeputy;
+}
+function shouldPersistBusinessTaskExecution(task) {
+  return !!task && task.register && !task.isHidden && !task.isMeta && !task.isSubMeta && !task.isDeputy;
+}
+function shouldEmitDirectPrimitiveMetadata() {
+  return CadenzaService.hasCompletedBootstrapSync();
+}
+function shouldPersistBusinessInquiry(ctx) {
+  const inquiryName = String(
+    ctx?.data?.name ?? ctx?.inquiry ?? ctx?.data?.metadata?.inquiryMeta?.inquiry ?? ""
+  );
+  if (!inquiryName) {
+    return false;
+  }
+  return !isMetaIntentName(inquiryName) && ctx?.data?.isMeta !== true && ctx?.data?.is_meta !== true;
+}
+function shouldPersistRoutineExecution(ctx) {
+  if (ctx?.data?.isMeta === true || ctx?.data?.is_meta === true) {
+    return false;
+  }
+  const routineTask = resolveTaskByName(ctx?.data?.name);
+  if (routineTask) {
+    return shouldPersistBusinessTaskExecution(routineTask);
+  }
+  return true;
+}
+function shouldPersistTaskExecutionMetadata(ctx) {
+  const task = resolveTaskFromMetadataContext(ctx);
+  return shouldPersistBusinessTaskExecution(task);
+}
+function shouldPersistTaskExecutionMap(ctx) {
+  return shouldPersistBusinessTaskExecution(resolveTaskFromMetadataContext(ctx)) && shouldPersistBusinessTaskExecution(resolvePredecessorTaskFromMetadataContext(ctx));
+}
+function hasInquiryLink(data) {
+  const metaContext = data?.metaContext ?? data?.meta_context;
+  const directInquiryId = metaContext?.__inquiryId ?? metaContext?.__metadata?.__inquiryId;
+  return typeof directInquiryId === "string" && directInquiryId.length > 0;
+}
 var GraphMetadataController = class _GraphMetadataController {
   static get instance() {
     if (!this._instance) this._instance = new _GraphMetadataController();
     return this._instance;
   }
   constructor() {
+    const buildOnConflictDoNothing = (target) => ({
+      target,
+      action: {
+        do: "nothing"
+      }
+    });
     CadenzaService.createMetaTask("Handle task creation", (ctx) => {
-      return buildDatabaseTriggerContext({
-        ...ctx.data,
-        serviceName: CadenzaService.serviceRegistry.serviceName
-      });
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const taskName = String(ctx.data?.name ?? ctx.data?.taskName ?? "");
+      const task = taskName ? CadenzaService.get(taskName) : void 0;
+      const onConflict = buildOnConflictDoNothing([
+        "name",
+        "service_name",
+        "version"
+      ]);
+      if (shouldSkipDirectTaskMetadata(task) || task?.registered || task?.registrationRequested) {
+        return false;
+      }
+      if (task) {
+        task.registrationRequested = true;
+      }
+      return buildDatabaseTriggerContext(
+        {
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName
+        },
+        void 0,
+        { onConflict },
+        { onConflict }
+      );
     }).doOn("meta.task.created").emits("global.meta.graph_metadata.task_created");
     CadenzaService.createMetaTask("Handle task update", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -6979,11 +7315,14 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.layer_index_changed", "meta.task.destroyed").emits("global.meta.graph_metadata.task_updated");
     CadenzaService.createMetaTask("Handle task relationship creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       const taskName = ctx.data?.taskName ?? ctx.data?.task_name;
       const predecessorTaskName = ctx.data?.predecessorTaskName ?? ctx.data?.predecessor_task_name;
       const task = taskName ? CadenzaService.get(taskName) : void 0;
       const predecessorTask = predecessorTaskName ? CadenzaService.get(predecessorTaskName) : void 0;
-      if (!task?.registered || !predecessorTask?.registered) {
+      if (shouldSkipDirectTaskMetadata(task) || shouldSkipDirectTaskMetadata(predecessorTask) || !task?.registered || !predecessorTask?.registered) {
         return false;
       }
       return buildDatabaseTriggerContext({
@@ -6996,14 +7335,35 @@ var GraphMetadataController = class _GraphMetadataController {
       CadenzaService.log(`Error in task ${ctx.data.taskName}`, ctx.data, "error");
     }).doOn("meta.node.errored");
     CadenzaService.createMetaTask("Handle task signal observation", (ctx) => {
-      const isGlobal = ctx.signalName.startsWith("global.");
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const signalName = String(
+        ctx.signalName ?? ctx.data?.signalName ?? ""
+      ).split(":")[0];
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      if (task?.registered && task.registeredSignals.has(signalName)) {
+        return false;
+      }
+      const isGlobal = signalName.startsWith("global.");
       return buildDatabaseTriggerContext({
         ...ctx.data,
+        signalName,
         isGlobal,
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.task.observed_signal").emits("global.meta.graph_metadata.task_signal_observed");
     CadenzaService.createMetaTask("Handle task signal attachment", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -7013,12 +7373,33 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.attached_signal").emits("global.meta.graph_metadata.task_attached_signal");
     CadenzaService.createMetaTask("Handle task intent association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const intentName = String(ctx.data?.intentName ?? "");
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
+      if (task?.registered && task.__registeredIntents?.has(
+        intentName
+      )) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
+        intentName,
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.task.intent_associated").emits("global.meta.graph_metadata.task_intent_associated");
     CadenzaService.createMetaTask("Handle task unsubscribing signal", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         {
           deleted: true
@@ -7030,6 +7411,13 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.unsubscribed_signal").emits("meta.graph_metadata.task_unsubscribed_signal");
     CadenzaService.createMetaTask("Handle task detaching signal", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
+      const task = resolveTaskFromMetadataContext(ctx);
+      if (shouldSkipDirectTaskMetadata(task)) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         {
           deleted: true
@@ -7041,12 +7429,18 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.task.detached_signal").emits("global.meta.graph_metadata.task_detached_signal");
     CadenzaService.createMetaTask("Handle routine creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         serviceName: CadenzaService.serviceRegistry.serviceName
       });
     }).doAfter(CadenzaService.registry.registerRoutine).emits("global.meta.graph_metadata.routine_created");
     CadenzaService.createMetaTask("Handle routine update", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext(
         ctx.data ?? void 0,
         {
@@ -7056,6 +7450,9 @@ var GraphMetadataController = class _GraphMetadataController {
       );
     }).doOn("meta.routine.destroyed").emits("global.meta.graph_metadata.routine_updated");
     CadenzaService.createMetaTask("Handle adding task to routine", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         serviceName: CadenzaService.serviceRegistry.serviceName
@@ -7071,8 +7468,12 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle routine execution creation",
       (ctx) => {
+        if (!shouldPersistRoutineExecution(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext({
           ...ctx.data,
+          previousRoutineExecution: hasInquiryLink(ctx.data) ? null : ctx.data?.previousRoutineExecution ?? ctx.data?.previous_routine_execution ?? null,
           serviceName: CadenzaService.serviceRegistry.serviceName,
           serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId
         });
@@ -7109,6 +7510,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution creation",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext({
           ...ctx.data,
           serviceName: CadenzaService.serviceRegistry.serviceName,
@@ -7121,6 +7525,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution mapped",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMap(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           ctx.data ?? void 0,
           ctx.filter ?? void 0
@@ -7132,6 +7539,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution started",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           ctx.data ?? void 0,
           ctx.filter ?? void 0
@@ -7143,6 +7553,9 @@ var GraphMetadataController = class _GraphMetadataController {
     CadenzaService.createMetaTask(
       "Handle task execution ended",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMetadata(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           {
             ...ctx.data,
@@ -7155,9 +7568,39 @@ var GraphMetadataController = class _GraphMetadataController {
       "Handles task execution ended",
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.ended").emits("global.meta.graph_metadata.task_execution_ended");
+    CadenzaService.createMetaTask(
+      "Handle inquiry creation",
+      (ctx) => {
+        if (!shouldPersistBusinessInquiry(ctx)) {
+          return false;
+        }
+        return buildDatabaseTriggerContext({
+          ...ctx.data,
+          serviceName: CadenzaService.serviceRegistry.serviceName,
+          serviceInstanceId: CadenzaService.serviceRegistry.serviceInstanceId,
+          isMeta: false
+        });
+      },
+      "Handles inquiry creation",
+      { concurrency: 100, isSubMeta: true }
+    ).doOn("meta.inquiry_broker.inquiry_started").emits("global.meta.graph_metadata.inquiry_created");
+    CadenzaService.createMetaTask(
+      "Handle inquiry update",
+      (ctx) => {
+        return buildDatabaseTriggerContext(
+          ctx.data ?? void 0,
+          ctx.filter ?? void 0
+        );
+      },
+      "Handles inquiry completion updates",
+      { concurrency: 100, isSubMeta: true }
+    ).doOn("meta.inquiry_broker.inquiry_completed").emits("global.meta.graph_metadata.inquiry_updated");
     CadenzaService.createMetaTask(
       "Handle task execution relationship creation",
       (ctx) => {
+        if (!shouldPersistTaskExecutionMap(ctx)) {
+          return false;
+        }
         return buildDatabaseTriggerContext(
           {
             executionCount: "increment",
@@ -7173,12 +7616,18 @@ var GraphMetadataController = class _GraphMetadataController {
       { concurrency: 100, isSubMeta: true }
     ).doOn("meta.node.mapped", "meta.node.detected_previous_task_execution").emits("global.meta.graph_metadata.relationship_executed");
     CadenzaService.createMetaTask("Handle actor creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         service_name: CadenzaService.serviceRegistry.serviceName
       });
     }).doOn("meta.actor.created").emits("global.meta.graph_metadata.actor_created");
     CadenzaService.createMetaTask("Handle actor task association", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       return buildDatabaseTriggerContext({
         ...ctx.data,
         service_name: CadenzaService.serviceRegistry.serviceName
@@ -7186,6 +7635,9 @@ var GraphMetadataController = class _GraphMetadataController {
     }).doOn("meta.actor.task_associated").emits("global.meta.graph_metadata.actor_task_associated");
     registerActorSessionPersistenceTasks();
     CadenzaService.createMetaTask("Handle Intent Creation", (ctx) => {
+      if (!shouldEmitDirectPrimitiveMetadata()) {
+        return false;
+      }
       const intentName = ctx.data?.name;
       return buildDatabaseTriggerContext({
         ...ctx.data,
@@ -7236,6 +7688,9 @@ var AUTHORITY_SYNC_DEBUG_TASK_NAMES = /* @__PURE__ */ new Set([
 ]);
 var AUTHORITY_SYNC_DEBUG_ROUTINE_NAMES = /* @__PURE__ */ new Set(["Sync services"]);
 var INTENT_MAP_DEBUG_ENABLED = process.env.CADENZA_INTENT_MAP_DEBUG === "1" || process.env.CADENZA_INTENT_MAP_DEBUG === "true";
+var POSTGRES_SETUP_DEBUG_ENABLED = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
+var GENERATED_POSTGRES_WRITE_TASK_CONCURRENCY = 200;
+var GENERATED_POSTGRES_WRITE_TASK_TIMEOUT_MS = 12e4;
 function logAuthoritySyncDebug(event, payload) {
   if (!AUTHORITY_SYNC_DEBUG_ENABLED) {
     return;
@@ -7281,6 +7736,12 @@ function logIntentMapSetupDebug(event, payload) {
   }
   console.log("[CADENZA_INTENT_MAP_DEBUG]", event, payload);
 }
+function logPostgresSetupDebug(event, payload) {
+  if (!POSTGRES_SETUP_DEBUG_ENABLED) {
+    return;
+  }
+  console.log("[CADENZA_POSTGRES_SETUP_DEBUG]", event, payload);
+}
 function buildAuthoritySyncDebugSummary(payload, context) {
   const data = payload.data && typeof payload.data === "object" && !Array.isArray(payload.data) ? payload.data : {};
   return {
@@ -7492,7 +7953,55 @@ function errorMessage(error) {
   }
   return String(error);
 }
-function isTransientDatabaseError(error) {
+var EXECUTION_OBSERVABILITY_RETRYABLE_FOREIGN_KEYS = /* @__PURE__ */ new Set([
+  "routine_execution_execution_trace_id_fkey",
+  "routine_execution_previous_routine_execution_fkey",
+  "task_execution_routine_execution_id_fkey",
+  "task_execution_execution_trace_id_fkey",
+  "task_execution_signal_emission_id_fkey",
+  "task_execution_inquiry_id_fkey",
+  "task_execution_map_task_execution_id_fkey",
+  "task_execution_map_previous_task_execution_id_fkey",
+  "signal_emission_execution_trace_id_fkey",
+  "signal_emission_routine_execution_id_fkey",
+  "signal_emission_task_execution_id_fkey",
+  "inquiry_execution_trace_id_fkey",
+  "inquiry_routine_execution_id_fkey",
+  "inquiry_task_execution_id_fkey"
+]);
+function resolveOperationTableName(operationLabel) {
+  if (!operationLabel) {
+    return null;
+  }
+  const match = /^insert\s+([a-z0-9_]+)$/i.exec(operationLabel.trim());
+  return match?.[1]?.toLowerCase() ?? null;
+}
+function isRetryableExecutionObservabilityForeignKeyError(error, operationLabel) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const dbError = error;
+  if (String(dbError.code ?? "") !== "23503") {
+    return false;
+  }
+  const constraint = String(dbError.constraint ?? "").toLowerCase();
+  if (constraint && EXECUTION_OBSERVABILITY_RETRYABLE_FOREIGN_KEYS.has(constraint)) {
+    return true;
+  }
+  const table = String(dbError.table ?? "").toLowerCase() || resolveOperationTableName(operationLabel) || "";
+  if (![
+    "routine_execution",
+    "task_execution",
+    "task_execution_map",
+    "signal_emission",
+    "inquiry"
+  ].includes(table)) {
+    return false;
+  }
+  const message = String(dbError.message ?? "").toLowerCase();
+  return message.includes("foreign key constraint") && (message.includes("execution_trace") || message.includes("routine_execution") || message.includes("task_execution") || message.includes("signal_emission") || message.includes("inquiry"));
+}
+function isTransientDatabaseError(error, operationLabel) {
   if (!error || typeof error !== "object") {
     return false;
   }
@@ -7502,7 +8011,10 @@ function isTransientDatabaseError(error) {
     return true;
   }
   const message = String(dbError.message ?? "").toLowerCase();
-  return message.includes("timeout") || message.includes("terminating connection") || message.includes("connection reset");
+  if (message.includes("timeout") || message.includes("terminating connection") || message.includes("connection reset")) {
+    return true;
+  }
+  return isRetryableExecutionObservabilityForeignKeyError(error, operationLabel);
 }
 function isSqlIdentifier(value) {
   return /^[a-z_][a-z0-9_]*$/.test(value);
@@ -7536,6 +8048,37 @@ function resolveDataRows(data) {
   }
   return [ensurePlainObject(data, "data")];
 }
+var DB_OPERATION_CONTEXT_KEYS = [
+  "data",
+  "batch",
+  "transaction",
+  "onConflict",
+  "filter",
+  "fields",
+  "joins",
+  "sort",
+  "limit",
+  "offset",
+  "queryMode",
+  "aggregates",
+  "groupBy"
+];
+function mergeTriggerQueryData(context, triggerQueryData) {
+  const existingQueryData = typeof context.queryData === "object" && context.queryData ? { ...context.queryData } : {};
+  for (const key of DB_OPERATION_CONTEXT_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(existingQueryData, key) && context[key] !== void 0) {
+      existingQueryData[key] = context[key];
+    }
+  }
+  return {
+    ...existingQueryData,
+    ...triggerQueryData
+  };
+}
+function resolveOperationPayload(context) {
+  const queryData = typeof context.queryData === "object" && context.queryData ? context.queryData : {};
+  return mergeTriggerQueryData(context, queryData);
+}
 function buildAddConstraintIfMissingStatement(tableName, constraintName, constraintDefinition) {
   const escapedConstraintName = constraintName.replace(/'/g, "''");
   const escapedTableName = tableName.replace(/'/g, "''");
@@ -7673,9 +8216,19 @@ var DatabaseController = class _DatabaseController {
     };
     const runtimeState = registration.actor.getRuntimeState(registration.actorKey);
     if (runtimeState?.ready) {
+      logPostgresSetupDebug("setup_already_ready", {
+        actorName: registration.actorName,
+        databaseName: registration.databaseName
+      });
       this.emitSetupDone(registration, payload);
       return registration;
     }
+    logPostgresSetupDebug("emit_setup_requested", {
+      actorName: registration.actorName,
+      databaseName: registration.databaseName,
+      ownerServiceName: registration.ownerServiceName,
+      payloadKeys: Object.keys(payload)
+    });
     CadenzaService.emit(registration.setupSignal, payload);
     return registration;
   }
@@ -7727,6 +8280,11 @@ var DatabaseController = class _DatabaseController {
       `Setup ${registration.actorName}`,
       registration.actor.task(
         async ({ input, state, runtimeState, setState, setRuntimeState, emit }) => {
+          logPostgresSetupDebug("setup_task_started", {
+            actorName: registration.actorName,
+            databaseName: registration.databaseName,
+            inputKeys: Object.keys(input ?? {})
+          });
           const requestedDatabaseName = String(
             input.options?.databaseName ?? input.databaseName ?? registration.databaseName
           );
@@ -7745,11 +8303,19 @@ var DatabaseController = class _DatabaseController {
           }
           try {
             await this.createDatabaseIfMissing(requestedDatabaseName);
+            logPostgresSetupDebug("database_ready", {
+              actorName: registration.actorName,
+              databaseName: requestedDatabaseName
+            });
             const pool = this.createTargetPool(
               requestedDatabaseName,
               state.safetyPolicy.statementTimeoutMs
             );
             await this.checkPoolHealth(pool, state.safetyPolicy);
+            logPostgresSetupDebug("pool_healthy", {
+              actorName: registration.actorName,
+              databaseName: requestedDatabaseName
+            });
             this.validateSchema({
               schema: registration.schema,
               options: registration.options
@@ -7797,6 +8363,10 @@ var DatabaseController = class _DatabaseController {
             this.emitSetupDone(registration, {
               ...input
             });
+            logPostgresSetupDebug("setup_task_completed", {
+              actorName: registration.actorName,
+              databaseName: requestedDatabaseName
+            });
             return {
               ...input,
               __success: true,
@@ -7806,6 +8376,11 @@ var DatabaseController = class _DatabaseController {
             };
           } catch (error) {
             const message = errorMessage(error);
+            logPostgresSetupDebug("setup_task_failed", {
+              actorName: registration.actorName,
+              databaseName: requestedDatabaseName,
+              error: message
+            });
             setRuntimeState({
               pool: null,
               ready: false,
@@ -7933,7 +8508,7 @@ var DatabaseController = class _DatabaseController {
         return await work();
       } catch (error) {
         lastError = error;
-        const transient = isTransientDatabaseError(error);
+        const transient = isTransientDatabaseError(error, operationLabel);
         if (!transient || attempt >= attempts) {
           break;
         }
@@ -8599,7 +9174,7 @@ var DatabaseController = class _DatabaseController {
       description: `Macro upsert operation for table ${tableName}`,
       input: insertSchema
     });
-    CadenzaService.createThrottledTask(
+    CadenzaService.createTask(
       `UPSERT ${tableName}`,
       registration.actor.task(
         async ({ input }) => {
@@ -8620,9 +9195,11 @@ var DatabaseController = class _DatabaseController {
         },
         { mode: "write" }
       ),
-      (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
       `Macro upsert task for ${tableName}`,
       {
+        concurrency: GENERATED_POSTGRES_WRITE_TASK_CONCURRENCY,
+        timeout: GENERATED_POSTGRES_WRITE_TASK_TIMEOUT_MS,
+        getTagCallback: () => `upsert:${registration.actorToken}:${tableName}`,
         isMeta: registration.options.isMeta,
         isSubMeta: registration.options.isMeta,
         validateInputContext: shouldValidateGeneratedDbTaskInput(registration),
@@ -8653,15 +9230,15 @@ var DatabaseController = class _DatabaseController {
               };
             }
             if (trigger.queryData) {
-              context.queryData = {
-                ...context.queryData ?? {},
-                ...trigger.queryData
-              };
+              context.queryData = mergeTriggerQueryData(
+                context,
+                trigger.queryData
+              );
               payloadModifiedByTriggers = true;
             }
           }
         }
-        const operationPayload = typeof context.queryData === "object" && context.queryData ? context.queryData : context;
+        const operationPayload = resolveOperationPayload(context);
         const shouldDebugAuthoritySync = shouldDebugAuthoritySyncPayload(
           tableName,
           operationPayload
@@ -8758,18 +9335,29 @@ var DatabaseController = class _DatabaseController {
       },
       { mode: op === "query" ? "read" : "write" }
     );
-    const task = CadenzaService.createThrottledTask(
+    const taskOptions = {
+      isMeta: registration.options.isMeta,
+      isSubMeta: registration.options.isMeta,
+      validateInputContext: shouldValidateGeneratedDbTaskInput(registration),
+      inputSchema: schema
+    };
+    const task = (op === "insert" ? CadenzaService.createTask(
       taskName,
       databaseTaskFunction,
-      (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
       `Auto-generated ${op} task for ${tableName} (PostgresActor)`,
       {
-        isMeta: registration.options.isMeta,
-        isSubMeta: registration.options.isMeta,
-        validateInputContext: shouldValidateGeneratedDbTaskInput(registration),
-        inputSchema: schema
+        ...taskOptions,
+        concurrency: GENERATED_POSTGRES_WRITE_TASK_CONCURRENCY,
+        timeout: GENERATED_POSTGRES_WRITE_TASK_TIMEOUT_MS,
+        getTagCallback: () => `insert:${registration.actorToken}:${tableName}`
       }
-    ).doOn(
+    ) : CadenzaService.createThrottledTask(
+      taskName,
+      databaseTaskFunction,
+      (context) => context?.__metadata?.__executionTraceId ?? context?.__executionTraceId ?? "default",
+      `Auto-generated ${op} task for ${tableName} (PostgresActor)`,
+      taskOptions
+    )).doOn(
       ...table.customSignals?.triggers?.[op]?.map(
         (signal) => typeof signal === "string" ? signal : signal.signal
       ) ?? []
@@ -9426,7 +10014,7 @@ function buildIntentRegistryData(intent) {
     description: typeof intent?.description === "string" ? intent.description : "",
     input: intent?.input && typeof intent.input === "object" ? intent.input : { type: "object" },
     output: intent?.output && typeof intent.output === "object" ? intent.output : { type: "object" },
-    isMeta: isMetaIntentName(name)
+    is_meta: isMetaIntentName(name)
   };
 }
 function getJoinedContextValue(ctx, key) {
@@ -9649,6 +10237,22 @@ var EARLY_SYNC_TICK_DELAYS_MS = [
   BOOTSTRAP_SYNC_STALE_CYCLE_MS * 2 + 2e3,
   BOOTSTRAP_SYNC_STALE_CYCLE_MS * 3 + 3e3
 ];
+function shouldTraceSyncPhase(serviceName) {
+  const configured = process.env.CADENZA_SYNC_PHASE_TRACE_SERVICE;
+  if (!configured || !serviceName) {
+    return false;
+  }
+  return configured === serviceName;
+}
+function canonicalizeSignalName(signalName) {
+  if (typeof signalName !== "string") {
+    return "";
+  }
+  return signalName.split(":")[0]?.trim() ?? "";
+}
+function isBootstrapLocalOnlySignal(signalName) {
+  return signalName === "meta.service_registry.insert_execution_requested" || signalName.startsWith("meta.sync_controller.");
+}
 function getRegistrableTasks() {
   return Array.from(CadenzaService.registry.tasks.values()).filter(
     (task) => task.register && !task.isHidden && !task.isDeputy
@@ -9657,24 +10261,51 @@ function getRegistrableTasks() {
 function getRegistrableRoutines() {
   return Array.from(CadenzaService.registry.routines.values());
 }
-function isAuthoritySyncSignal(signalName) {
-  return decomposeSignalName(signalName).isGlobal;
-}
 function getRegistrableSignalObservers() {
   const signalObservers = CadenzaService.signalBroker.signalObservers;
   if (!signalObservers) {
     return [];
   }
-  return Array.from(signalObservers.entries()).filter(([signalName]) => isAuthoritySyncSignal(signalName)).map(([signalName, observer]) => ({
-    signalName,
-    ...observer
-  }));
+  const canonicalObservers = /* @__PURE__ */ new Map();
+  for (const [rawSignalName, observer] of signalObservers.entries()) {
+    const signalName = canonicalizeSignalName(rawSignalName);
+    if (!signalName || isBootstrapLocalOnlySignal(signalName)) {
+      continue;
+    }
+    const existing = canonicalObservers.get(signalName);
+    canonicalObservers.set(signalName, {
+      signalName,
+      registered: existing?.registered === true || observer?.registered === true
+    });
+  }
+  return Array.from(canonicalObservers.values());
+}
+function isLocallyHandledIntentName(intentName) {
+  const observer = CadenzaService.inquiryBroker.inquiryObservers.get(intentName);
+  if (!observer) {
+    return false;
+  }
+  for (const task of observer.tasks) {
+    if (task.register && !task.isHidden && !task.isDeputy) {
+      return true;
+    }
+  }
+  return false;
 }
 function getRegistrableIntentNames() {
   return Array.from(CadenzaService.inquiryBroker.intents.values()).map((intent) => buildIntentRegistryData(intent)).filter(
     (intentDefinition) => intentDefinition !== null
+  ).filter(
+    (intentDefinition) => isLocallyHandledIntentName(String(intentDefinition.name))
   ).map((intentDefinition) => String(intentDefinition.name));
 }
+function isRegistrableLocalIntentDefinition(intent) {
+  const intentData = buildIntentRegistryData(intent);
+  if (!intentData) {
+    return false;
+  }
+  return isLocallyHandledIntentName(String(intentData.name));
+}
 function buildActorRegistrationKey(actor, serviceName) {
   const data = buildActorRegistrationData(actor);
   const name = typeof data.name === "string" && data.name.trim().length > 0 ? data.name.trim() : "";
@@ -9809,6 +10440,13 @@ var GraphSyncController = class _GraphSyncController {
     const finalizeTaskSync = (emit, ctx) => {
       const pendingTasks = getRegistrableTasks().filter((task) => !task.registered);
       const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_tasks", {
+          serviceName: serviceName2,
+          pendingCount: pendingTasks.length,
+          sample: pendingTasks.slice(0, 5).map((task) => task.name)
+        });
+      }
       if (pendingTasks.length > 0) {
         this.tasksSynced = false;
         return false;
@@ -9828,6 +10466,13 @@ var GraphSyncController = class _GraphSyncController {
         (routine) => !routine.registered
       );
       const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_routines", {
+          serviceName: serviceName2,
+          pendingCount: pendingRoutines.length,
+          sample: pendingRoutines.slice(0, 5).map((routine) => routine.name)
+        });
+      }
       if (pendingRoutines.length > 0) {
         this.routinesSynced = false;
         return false;
@@ -9847,6 +10492,13 @@ var GraphSyncController = class _GraphSyncController {
         (observer) => observer.registered !== true
       );
       const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_signals", {
+          serviceName: serviceName2,
+          pendingCount: pendingSignals.length,
+          sample: pendingSignals.slice(0, 5).map((observer) => observer.signalName)
+        });
+      }
       if (pendingSignals.length > 0) {
         this.signalsSynced = false;
         return false;
@@ -9866,6 +10518,13 @@ var GraphSyncController = class _GraphSyncController {
         (intentName) => !this.registeredIntentDefinitions.has(intentName)
       );
       const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+      if (shouldTraceSyncPhase(serviceName2)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_intents", {
+          serviceName: serviceName2,
+          pendingCount: pendingIntentNames.length,
+          sample: pendingIntentNames.slice(0, 5)
+        });
+      }
       if (pendingIntentNames.length > 0) {
         this.intentsSynced = false;
         return false;
@@ -9887,6 +10546,13 @@ var GraphSyncController = class _GraphSyncController {
         return false;
       }
       const pendingActorKeys = CadenzaService.getAllActors().map((actor) => buildActorRegistrationKey(actor, syncServiceName)).filter((registrationKey) => Boolean(registrationKey)).filter((registrationKey) => !this.registeredActors.has(registrationKey));
+      if (shouldTraceSyncPhase(syncServiceName)) {
+        console.log("[CADENZA_SYNC_PHASE_TRACE] finalize_actors", {
+          serviceName: syncServiceName,
+          pendingCount: pendingActorKeys.length,
+          sample: pendingActorKeys.slice(0, 5)
+        });
+      }
       if (pendingActorKeys.length > 0) {
         this.actorsSynced = false;
         return false;
@@ -9967,8 +10633,8 @@ var GraphSyncController = class _GraphSyncController {
               name: routine.name,
               version: routine.version,
               description: routine.description,
-              serviceName: serviceName2,
-              isMeta: routine.isMeta
+              service_name: serviceName2,
+              is_meta: routine.isMeta
             },
             __routineName: routine.name
           };
@@ -10031,11 +10697,11 @@ var GraphSyncController = class _GraphSyncController {
               yield {
                 __syncing: ctx.__syncing,
                 data: {
-                  taskName: nextTask.name,
-                  taskVersion: nextTask.version,
-                  routineName: routine.name,
-                  routineVersion: routine.version,
-                  serviceName: serviceName2
+                  task_name: nextTask.name,
+                  task_version: nextTask.version,
+                  routine_name: routine.name,
+                  routine_version: routine.version,
+                  service_name: serviceName2
                 },
                 __routineName: routine.name,
                 __taskName: nextTask.name
@@ -10093,12 +10759,20 @@ var GraphSyncController = class _GraphSyncController {
         });
         const { signals } = ctx;
         if (!signals) return;
-        const filteredSignals = signals.filter((signal) => {
-          if (signal.data.registered) {
+        const seenSignals = /* @__PURE__ */ new Set();
+        const filteredSignals = signals.map((signal) => ({
+          signalName: canonicalizeSignalName(signal.signal),
+          data: signal.data
+        })).filter((signal) => {
+          if (!signal.signalName || signal.data?.registered || isBootstrapLocalOnlySignal(signal.signalName)) {
+            return false;
+          }
+          if (seenSignals.has(signal.signalName)) {
             return false;
           }
-          return isAuthoritySyncSignal(signal.signal);
-        }).map((signal) => signal.signal);
+          seenSignals.add(signal.signalName);
+          return true;
+        }).map((signal) => signal.signalName);
         for (const signal of filteredSignals) {
           const { isMeta, isGlobal, domain, action } = decomposeSignalName(signal);
           this.signalsSynced = false;
@@ -10106,10 +10780,10 @@ var GraphSyncController = class _GraphSyncController {
             __syncing: ctx.__syncing,
             data: {
               name: signal,
-              isGlobal,
+              is_global: isGlobal,
               domain,
               action,
-              isMeta
+              is_meta: isMeta
             },
             __signal: signal
           };
@@ -10150,6 +10824,7 @@ var GraphSyncController = class _GraphSyncController {
         const observer = signalObservers?.get(signalName);
         if (observer) {
           observer.registered = true;
+          observer.registrationRequested = false;
         }
         emit(
           "meta.sync_controller.signal_registered",
@@ -10187,25 +10862,25 @@ var GraphSyncController = class _GraphSyncController {
               name: task.name,
               version: task.version,
               description: task.description,
-              functionString: __functionString,
-              tagIdGetter: __getTagCallback,
-              layerIndex: task.layerIndex,
+              function_string: __functionString,
+              tag_id_getter: __getTagCallback,
+              layer_index: task.layerIndex,
               concurrency: task.concurrency,
               timeout: task.timeout,
-              isUnique: task.isUnique,
-              isSignal: task.isSignal,
-              isThrottled: task.isThrottled,
-              isDebounce: task.isDebounce,
-              isEphemeral: task.isEphemeral,
-              isMeta: task.isMeta,
-              isSubMeta: task.isSubMeta,
-              isHidden: task.isHidden,
-              validateInputContext: task.validateInputContext,
-              validateOutputContext: task.validateOutputContext,
-              retryCount: task.retryCount,
-              retryDelay: task.retryDelay,
-              retryDelayMax: task.retryDelayMax,
-              retryDelayFactor: task.retryDelayFactor,
+              is_unique: task.isUnique,
+              is_signal: task.isSignal,
+              is_throttled: task.isThrottled,
+              is_debounce: task.isDebounce,
+              is_ephemeral: task.isEphemeral,
+              is_meta: task.isMeta,
+              is_sub_meta: task.isSubMeta,
+              is_hidden: task.isHidden,
+              validate_input_context: task.validateInputContext,
+              validate_output_context: task.validateOutputContext,
+              retry_count: task.retryCount,
+              retry_delay: task.retryDelay,
+              retry_delay_max: task.retryDelayMax,
+              retry_delay_factor: task.retryDelayFactor,
               service_name: serviceName2,
               signals: {
                 emits: Array.from(task.emitsSignals),
@@ -10249,6 +10924,7 @@ var GraphSyncController = class _GraphSyncController {
           return true;
         }
         task.registered = true;
+        task.registrationRequested = false;
         emit(
           "meta.sync_controller.task_registered",
           buildMinimalSyncSignalContext(ctx, {
@@ -10436,11 +11112,11 @@ var GraphSyncController = class _GraphSyncController {
           yield {
             __syncing: ctx.__syncing,
             data: {
-              signalName: _signal,
-              isGlobal,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              signal_name: _signal,
+              is_global: isGlobal,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             },
             __taskName: task.name,
             __signal: signal
@@ -10481,6 +11157,9 @@ var GraphSyncController = class _GraphSyncController {
         });
         const intents = Array.isArray(ctx.intents) ? ctx.intents : Array.from(CadenzaService.inquiryBroker.intents.values());
         for (const intent of intents) {
+          if (!isRegistrableLocalIntentDefinition(intent)) {
+            continue;
+          }
           const intentData = buildIntentRegistryData(intent);
           if (!intentData) {
             continue;
@@ -10578,19 +11257,19 @@ var GraphSyncController = class _GraphSyncController {
           yield {
             __syncing: ctx.__syncing,
             data: {
-              intentName: intent,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              intent_name: intent,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             },
             __taskName: task.name,
             __intent: intent,
             __intentDefinition: intentDefinition,
             __intentMapData: {
-              intentName: intent,
-              taskName: task.name,
-              taskVersion: task.version,
-              serviceName: serviceName2
+              intent_name: intent,
+              task_name: task.name,
+              task_version: task.version,
+              service_name: serviceName2
             }
           };
           emittedCount += 1;
@@ -10628,7 +11307,9 @@ var GraphSyncController = class _GraphSyncController {
         CadenzaService.debounce("meta.sync_controller.synced_resource", {
           delayMs: 3e3
         });
-        if (task.hidden || !task.register || task.isDeputy) return;
+        if (task.hidden || !task.register || task.isDeputy || !task.registered) {
+          return;
+        }
         const predecessorServiceName = resolveSyncServiceName(task);
         if (!predecessorServiceName) {
           return;
@@ -10643,12 +11324,12 @@ var GraphSyncController = class _GraphSyncController {
           }
           yield {
             data: {
-              taskName: t.name,
-              taskVersion: t.version,
-              predecessorTaskName: task.name,
-              predecessorTaskVersion: task.version,
-              serviceName: serviceName2,
-              predecessorServiceName
+              task_name: t.name,
+              task_version: t.version,
+              predecessor_task_name: task.name,
+              predecessor_task_version: task.version,
+              service_name: serviceName2,
+              predecessor_service_name: predecessorServiceName
             },
             __taskName: task.name,
             __nextTaskName: t.name
@@ -10695,75 +11376,7 @@ var GraphSyncController = class _GraphSyncController {
       taskMapRegistrationGraph,
       recordTaskMapRegistrationTask
     );
-    this.registerDeputyRelationshipTask = CadenzaService.createMetaTask(
-      "Register deputy relationship",
-      (ctx) => {
-        const task = ctx.task;
-        if (task.hidden || !task.register) return;
-        if (task.isDeputy && !task.signalName) {
-          if (task.registeredDeputyMap) return;
-          const serviceName2 = resolveSyncServiceName(task);
-          const predecessorServiceName = resolveSyncServiceName();
-          if (!serviceName2 || !predecessorServiceName) {
-            return;
-          }
-          return {
-            data: {
-              task_name: task.remoteRoutineName,
-              task_version: 1,
-              service_name: serviceName2,
-              predecessor_task_name: task.name,
-              predecessor_task_version: task.version,
-              predecessor_service_name: predecessorServiceName
-            },
-            __taskName: task.name
-          };
-        }
-      }
-    );
-    const deputyRelationshipRegistrationGraph = resolveSyncInsertTask(
-      this.isCadenzaDBReady,
-      "directional_task_graph_map",
-      {
-        onConflict: {
-          target: [
-            "task_name",
-            "predecessor_task_name",
-            "task_version",
-            "predecessor_task_version",
-            "service_name",
-            "predecessor_service_name"
-          ],
-          action: {
-            do: "nothing"
-          }
-        }
-      },
-      { concurrency: 30 }
-    );
-    const recordDeputyRelationshipRegistrationTask = CadenzaService.createMetaTask(
-      "Record deputy relationship registration",
-      (ctx) => {
-        if (!didSyncInsertSucceed(ctx)) {
-          return;
-        }
-        CadenzaService.debounce("meta.sync_controller.synced_resource", {
-          delayMs: 3e3
-        });
-        const task = resolveLocalTaskFromSyncContext(ctx);
-        if (!task) {
-          return true;
-        }
-        task.registeredDeputyMap = true;
-      }
-    );
-    wireSyncTaskGraph(
-      this.registerDeputyRelationshipTask,
-      deputyRelationshipRegistrationGraph,
-      recordDeputyRelationshipRegistrationTask
-    );
     const hasPendingDirectionalTaskMaps = () => getRegistrableTasks().some((task) => {
-      const taskWithDeputyState = task;
       if (task.isHidden || !task.register || !task.registered) {
         return false;
       }
@@ -10779,9 +11392,6 @@ var GraphSyncController = class _GraphSyncController {
           return true;
         }
       }
-      if (task.isDeputy && !taskWithDeputyState.signalName && !taskWithDeputyState.registeredDeputyMap) {
-        return Boolean(resolveSyncServiceName(task) && resolveSyncServiceName());
-      }
       return false;
     });
     const hasPendingSignalTaskMaps = () => getRegistrableTasks().some((task) => {
@@ -10979,6 +11589,18 @@ var GraphSyncController = class _GraphSyncController {
         if (!syncCycleId) {
           return false;
         }
+        const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+        if (shouldTraceSyncPhase(serviceName2)) {
+          console.log("[CADENZA_SYNC_PHASE_TRACE] map_barrier_check", {
+            serviceName: serviceName2,
+            syncCycleId,
+            directionalTaskMapsSynced: this.directionalTaskMapsSynced,
+            signalTaskMapsSynced: this.signalTaskMapsSynced,
+            intentTaskMapsSynced: this.intentTaskMapsSynced,
+            actorTaskMapsSynced: this.actorTaskMapsSynced,
+            routineTaskMapsSynced: this.routineTaskMapsSynced
+          });
+        }
         if (!this.directionalTaskMapsSynced || !this.signalTaskMapsSynced || !this.intentTaskMapsSynced || !this.actorTaskMapsSynced || !this.routineTaskMapsSynced) {
           return false;
         }
@@ -11046,6 +11668,17 @@ var GraphSyncController = class _GraphSyncController {
           return false;
         }
         const serviceName2 = typeof ctx.__serviceName === "string" ? ctx.__serviceName : resolveSyncServiceName();
+        if (shouldTraceSyncPhase(serviceName2)) {
+          console.log("[CADENZA_SYNC_PHASE_TRACE] primitive_barrier_check", {
+            serviceName: serviceName2,
+            syncCycleId,
+            tasksSynced: this.tasksSynced,
+            signalsSynced: this.signalsSynced,
+            intentsSynced: this.intentsSynced,
+            actorsSynced: this.actorsSynced,
+            routinesSynced: this.routinesSynced
+          });
+        }
         if (!this.tasksSynced || !this.signalsSynced || !this.intentsSynced || !this.actorsSynced || !this.routinesSynced) {
           return false;
         }
@@ -11231,7 +11864,9 @@ var GraphSyncController = class _GraphSyncController {
       "Get all intents for sync",
       (ctx) => ({
         ...ctx,
-        intents: Array.from(CadenzaService.inquiryBroker.intents.values())
+        intents: Array.from(CadenzaService.inquiryBroker.intents.values()).filter(
+          (intent) => isRegistrableLocalIntentDefinition(intent)
+        )
       }),
       "Collects local intents for the primitive sync phase.",
       {
@@ -11272,14 +11907,8 @@ var GraphSyncController = class _GraphSyncController {
       iterateTasksForDirectionalTaskMapSyncTask,
       gatherDirectionalTaskMapRegistrationTask
     );
-    iterateTasksForDirectionalTaskMapSyncTask.then(
-      this.registerTaskMapTask,
-      this.registerDeputyRelationshipTask
-    );
+    iterateTasksForDirectionalTaskMapSyncTask.then(this.registerTaskMapTask);
     recordTaskMapRegistrationTask.then(gatherDirectionalTaskMapRegistrationTask);
-    recordDeputyRelationshipRegistrationTask.then(
-      gatherDirectionalTaskMapRegistrationTask
-    );
     gatherDirectionalTaskMapRegistrationTask.then(mapPhaseBarrierTask);
     const iterateTasksForSignalTaskMapSyncTask = CadenzaService.registry.doForEachTask.clone();
     startSignalTaskMapSyncTask.then(
@@ -11512,6 +12141,11 @@ function resolveBootstrapEndpoint(options) {
 }
 
 // src/Cadenza.ts
+var POSTGRES_SETUP_DEBUG_ENABLED2 = process.env.CADENZA_POSTGRES_SETUP_DEBUG === "1" || process.env.CADENZA_POSTGRES_SETUP_DEBUG === "true";
+var DEFAULT_DEPUTY_TASK_CONCURRENCY = 50;
+var DEFAULT_DEPUTY_TASK_TIMEOUT_MS = 12e4;
+var DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY = 50;
+var DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS = 12e4;
 var CadenzaService = class {
   static replayRegisteredTaskIntentAssociations() {
     for (const task of this.registry.tasks.values()) {
@@ -11696,6 +12330,12 @@ var CadenzaService = class {
   static setMode(mode) {
     import_core5.default.setMode(mode);
   }
+  static hasCompletedBootstrapSync() {
+    return !this.serviceCreated || this.bootstrapSyncCompleted;
+  }
+  static markBootstrapSyncCompleted() {
+    this.bootstrapSyncCompleted = true;
+  }
   /**
    * Emits a signal with the specified data using the associated broker.
    *
@@ -11783,6 +12423,46 @@ var CadenzaService = class {
       responders: statuses
     };
   }
+  static shouldPersistInquiry(inquiry, _context) {
+    return !isMetaIntentName(inquiry);
+  }
+  static splitInquiryPersistenceContext(context) {
+    const businessContext = {};
+    const metadata = context?.__metadata && typeof context.__metadata === "object" ? { ...context.__metadata } : {};
+    for (const [key, value] of Object.entries(context ?? {})) {
+      if (key === "__metadata") {
+        continue;
+      }
+      if (key.startsWith("__")) {
+        metadata[key] = value;
+        continue;
+      }
+      businessContext[key] = value;
+    }
+    return {
+      context: businessContext,
+      metadata
+    };
+  }
+  static buildInquiryPersistenceStartData(inquiryId, inquiry, context, startedAt) {
+    const normalizedTaskVersion = Number(context?.__inquirySourceTaskVersion);
+    const { context: inquiryContext, metadata } = this.splitInquiryPersistenceContext(context);
+    return {
+      uuid: inquiryId,
+      name: inquiry,
+      taskName: typeof context?.__inquirySourceTaskName === "string" ? context.__inquirySourceTaskName : null,
+      taskVersion: Number.isFinite(normalizedTaskVersion) && normalizedTaskVersion > 0 ? normalizedTaskVersion : null,
+      taskExecutionId: typeof context?.__inquirySourceTaskExecutionId === "string" ? context.__inquirySourceTaskExecutionId : null,
+      serviceName: this.serviceRegistry.serviceName,
+      serviceInstanceId: this.serviceRegistry.serviceInstanceId,
+      executionTraceId: typeof (context?.__metadata?.__executionTraceId ?? context?.__executionTraceId) === "string" ? context.__metadata?.__executionTraceId ?? context.__executionTraceId : null,
+      routineExecutionId: typeof context?.__inquirySourceRoutineExecutionId === "string" ? context.__inquirySourceRoutineExecutionId : null,
+      context: inquiryContext,
+      metadata,
+      isMeta: false,
+      sentAt: formatTimestamp(startedAt)
+    };
+  }
   static async inquire(inquiry, context, options = {}) {
     this.bootstrap();
     const hydratedResult = this.consumeHydratedInquiryResult(
@@ -11797,6 +12477,20 @@ var CadenzaService = class {
       descriptor: this.getInquiryResponderDescriptor(task)
     })) : [];
     const isMetaInquiry = isMetaIntentName(inquiry);
+    const startedAt = Date.now();
+    const persistInquiry = this.shouldPersistInquiry(inquiry, context);
+    const logicalInquiryId = persistInquiry ? (0, import_uuid6.v4)() : null;
+    const inquiryStartData = logicalInquiryId ? this.buildInquiryPersistenceStartData(
+      logicalInquiryId,
+      inquiry,
+      context,
+      startedAt
+    ) : null;
+    if (inquiryStartData) {
+      this.emit("meta.inquiry_broker.inquiry_started", {
+        data: inquiryStartData
+      });
+    }
     const responders = allResponders.filter(({ task, descriptor }) => {
       const shouldExecute = shouldExecuteInquiryResponder(inquiry, task.isMeta);
       if (shouldExecute) {
@@ -11831,6 +12525,21 @@ var CadenzaService = class {
         durationMs: 0,
         responders: []
       };
+      if (logicalInquiryId) {
+        this.emit("meta.inquiry_broker.inquiry_completed", {
+          data: {
+            fulfilledAt: formatTimestamp(startedAt),
+            duration: 0,
+            metadata: {
+              ...inquiryStartData?.metadata ?? {},
+              inquiryMeta
+            }
+          },
+          filter: {
+            uuid: logicalInquiryId
+          }
+        });
+      }
       if (options.requireComplete) {
         throw {
           __inquiryMeta: inquiryMeta,
@@ -11846,7 +12555,6 @@ var CadenzaService = class {
     const overallTimeoutMs = options.overallTimeoutMs ?? options.timeout ?? 0;
     const requireComplete = options.requireComplete ?? false;
     const perResponderTimeoutMs = options.perResponderTimeoutMs;
-    const startedAt = Date.now();
     const statuses = [];
     const statusByTask = /* @__PURE__ */ new Map();
     for (const responder of responders) {
@@ -11892,10 +12600,26 @@ var CadenzaService = class {
           statuses,
           allResponders.length
         );
+        const finishedAt = Date.now();
         const responseContext = {
           ...mergedContext,
           __inquiryMeta: inquiryMeta
         };
+        if (logicalInquiryId) {
+          this.emit("meta.inquiry_broker.inquiry_completed", {
+            data: {
+              fulfilledAt: formatTimestamp(finishedAt),
+              duration: finishedAt - startedAt,
+              metadata: {
+                ...inquiryStartData?.metadata ?? {},
+                inquiryMeta
+              }
+            },
+            filter: {
+              uuid: logicalInquiryId
+            }
+          });
+        }
         if (requireComplete && (timedOut || inquiryMeta.failed > 0 || inquiryMeta.timedOut > 0 || inquiryMeta.pending > 0)) {
           reject({
             ...responseContext,
@@ -11911,7 +12635,7 @@ var CadenzaService = class {
       }
       for (const responder of responders) {
         const { task, descriptor } = responder;
-        const inquiryId = (0, import_uuid6.v4)();
+        const responderInquiryId = (0, import_uuid6.v4)();
         startTimeByTask.set(task, Date.now());
         const resolverTask = this.createEphemeralMetaTask(
           `Resolve inquiry ${inquiry} for ${descriptor.localTaskName}`,
@@ -11939,11 +12663,12 @@ var CadenzaService = class {
           },
           "Resolves distributed inquiry responder result",
           { register: false }
-        ).doOn(`meta.node.graph_completed:${inquiryId}`);
+        ).doOn(`meta.node.graph_completed:${responderInquiryId}`);
         resolverTasks.push(resolverTask);
         const executionContext = {
           ...context,
-          __routineExecId: inquiryId,
+          ...logicalInquiryId ? { __inquiryId: logicalInquiryId } : {},
+          __routineExecId: responderInquiryId,
           __isInquiry: true
         };
         if (perResponderTimeoutMs !== void 0) {
@@ -12105,8 +12830,8 @@ var CadenzaService = class {
     this.validateName(routineName);
     const name = `${routineName} (Proxy)`;
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DEPUTY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DEPUTY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: false,
@@ -12213,8 +12938,8 @@ var CadenzaService = class {
       return;
     }
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: true,
@@ -12275,8 +13000,8 @@ var CadenzaService = class {
     const description = `Executes a ${operation} on table ${tableName} in ${targetDatabaseServiceName}`;
     const taskName = `${operation.charAt(0).toUpperCase() + operation.slice(1)} ${tableName}`;
     options = {
-      concurrency: 100,
-      timeout: 0,
+      concurrency: DEFAULT_DATABASE_PROXY_TASK_CONCURRENCY,
+      timeout: DEFAULT_DATABASE_PROXY_TASK_TIMEOUT_MS,
       register: true,
       isUnique: false,
       isMeta: false,
@@ -12420,6 +13145,7 @@ var CadenzaService = class {
     this.validateName(serviceName);
     this.validateServiceName(serviceName);
     const serviceId = options.customServiceId ?? (0, import_uuid6.v4)();
+    this.bootstrapSyncCompleted = false;
     this.serviceRegistry.serviceName = serviceName;
     this.serviceRegistry.serviceInstanceId = serviceId;
     this.serviceRegistry.connectsToCadenzaDB = !!options.cadenzaDB?.connect;
@@ -12455,6 +13181,7 @@ var CadenzaService = class {
       this.createMetaTask(
         "Initialize graph metadata controller after initial sync",
         () => {
+          this.markBootstrapSyncCompleted();
           GraphMetadataController.instance;
           return true;
         },
@@ -12540,14 +13267,14 @@ var CadenzaService = class {
       data: {
         name: serviceName,
         description,
-        displayName: options.displayName ?? "",
-        isMeta: options.isMeta
+        display_name: options.displayName ?? "",
+        is_meta: options.isMeta
       },
       __registrationData: {
         name: serviceName,
         description,
-        displayName: options.displayName ?? "",
-        isMeta: options.isMeta
+        display_name: options.displayName ?? "",
+        is_meta: options.isMeta
       },
       __serviceName: serviceName,
       __serviceInstanceId: serviceId,
@@ -12738,10 +13465,35 @@ var CadenzaService = class {
       registration.actorName
     );
     const createServiceTaskName = `Create database service ${name} after ${registration.actorName} setup`;
+    const traceSetupDoneTaskName = `Trace database service ${name} setup done`;
+    if (POSTGRES_SETUP_DEBUG_ENABLED2 && !this.get(traceSetupDoneTaskName)) {
+      this.createMetaTask(
+        traceSetupDoneTaskName,
+        (ctx) => {
+          console.log("[CADENZA_POSTGRES_SETUP_DEBUG] setup_done_signal_observed", {
+            serviceName: name,
+            actorName: registration.actorName,
+            payloadKeys: Object.keys(ctx ?? {})
+          });
+          return true;
+        },
+        "Debug trace for PostgresActor setup-done signal delivery.",
+        { isHidden: true, register: false }
+      ).doOn(registration.setupDoneSignal);
+    }
     if (!this.get(createServiceTaskName)) {
       this.createMetaTask(
         createServiceTaskName,
         () => {
+          if (POSTGRES_SETUP_DEBUG_ENABLED2) {
+            console.log(
+              "[CADENZA_POSTGRES_SETUP_DEBUG] create_database_service_task_fired",
+              {
+                serviceName: name,
+                actorName: registration.actorName
+              }
+            );
+          }
           this.createCadenzaService(name, description, serviceOptions);
           return true;
         },
@@ -13273,6 +14025,7 @@ var CadenzaService = class {
     this.serviceRegistry?.reset();
     this.isBootstrapped = false;
     this.serviceCreated = false;
+    this.bootstrapSyncCompleted = false;
     this.defaultDatabaseServiceName = null;
     this.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
     this.hydratedInquiryResults = /* @__PURE__ */ new Map();
@@ -13281,6 +14034,7 @@ var CadenzaService = class {
 };
 CadenzaService.isBootstrapped = false;
 CadenzaService.serviceCreated = false;
+CadenzaService.bootstrapSyncCompleted = false;
 CadenzaService.defaultDatabaseServiceName = null;
 CadenzaService.warnedInvalidMetaIntentResponderKeys = /* @__PURE__ */ new Set();
 CadenzaService.hydratedInquiryResults = /* @__PURE__ */ new Map();