@bastani/atomic 0.9.26-alpha.3 → 0.9.26-alpha.5

package/dist/builtin/workflows/src/index.js

@@ -63,6 +63,92 @@ function raceAbort2(operation, signal) {
   });
 }
 
+// dist/builtin/workflows/src/durable/dbos-database-diagnostics.ts
+function redactedDatabaseEndpoint(url) {
+  try {
+    const parsed = new URL(url);
+    parsed.username = "";
+    parsed.password = "";
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString();
+  } catch {
+    return "unparseable PostgreSQL endpoint";
+  }
+}
+function redactedDatabaseMessage(message, url) {
+  let safe = message.replace(/postgres(?:ql)?:\/\/[^\s"'<>]+/gi, (value) => redactedDatabaseEndpoint(value));
+  let configuredSecrets = [];
+  if (url !== undefined) {
+    try {
+      const parsed = new URL(url);
+      configuredSecrets = [parsed.username, parsed.password, ...parsed.searchParams.values()].flatMap((secret) => {
+        try {
+          return [secret, decodeURIComponent(secret)];
+        } catch {
+          return [secret];
+        }
+      }).filter((secret) => secret.length > 0);
+    } catch {
+      return "PostgreSQL diagnostic could not be safely redacted; check the configured endpoint.";
+    }
+  }
+  safe = safe.replace(/\b(password|passwd|token|secret|sslpassword|user(?:name)?)\s*(?:([=:])\s*|((?:is|was)\s+)|\s+)(?:"([^"]*)"|'([^']*)'|([^\s,;]+))/gi, (match, key, separator, filler, doubleQuoted, singleQuoted, bare) => {
+    const value = doubleQuoted ?? singleQuoted ?? bare ?? "";
+    const isUserContext = /^user(?:name)?$/i.test(key);
+    if (separator === undefined && !isUserContext && !configuredSecrets.includes(value))
+      return match;
+    const rendered = doubleQuoted !== undefined ? '"[redacted]"' : singleQuoted !== undefined ? "'[redacted]'" : "[redacted]";
+    return `${key}${separator ?? " "}${filler ?? ""}${rendered}`;
+  });
+  for (const secret of new Set(configuredSecrets)) {
+    if (secret.length < 4)
+      continue;
+    const escaped = secret.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const expression = new RegExp(`(?<![\\p{L}\\p{N}_\\[])${escaped}(?![\\p{L}\\p{N}_\\]])`, "gu");
+    safe = safe.replace(expression, "[redacted]");
+  }
+  return safe;
+}
+function databaseDependencyMessage(message, diagnostics) {
+  const safe = redactedDatabaseMessage(message, diagnostics?.url);
+  if (diagnostics === undefined)
+    return safe;
+  const failure = diagnostics.failure === undefined ? "" : ` Last probe/recovery failure: ${redactedDatabaseMessage(diagnostics.failure, diagnostics.url)}`;
+  return `${safe} Provider: ${diagnostics.provider}; endpoint: ${redactedDatabaseEndpoint(diagnostics.url)}.${failure}`;
+}
+
+// dist/builtin/workflows/src/durable/dbos-process-owner.ts
+function emptyOwner() {
+  return {
+    version: 1,
+    state: "uninitialized",
+    configured: undefined,
+    active: undefined,
+    launchPromise: undefined,
+    shutdownPromise: undefined,
+    failure: undefined,
+    wrappers: undefined,
+    leases: new Set
+  };
+}
+function ownerBag() {
+  return globalThis;
+}
+function getDbosProcessOwner() {
+  const bag = ownerBag();
+  const existing = bag[DBOS_PROCESS_OWNER_KEY];
+  if (existing !== undefined && existing.version === 1)
+    return existing;
+  const created = emptyOwner();
+  bag[DBOS_PROCESS_OWNER_KEY] = created;
+  return created;
+}
+var DBOS_PROCESS_OWNER_KEY;
+var init_dbos_process_owner = __esm(() => {
+  DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
+});
+
 // dist/builtin/workflows/src/durable/dbos-admission.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 function isDbosDependencyError(error) {
@@ -81,6 +167,8 @@ async function boundedAdmission(operation, signal, timeoutMs = DBOS_ADMISSION_TI
     return await raceAbort2(operation(controller.signal), controller.signal);
   } catch (error) {
     controller.abort(error);
+    if (isDbosDependencyError(error) && error.admissionDetail !== undefined)
+      throw new DbosDependencyError(error.admissionDetail, null);
     throw error;
   } finally {
     clearTimeout(timer);
@@ -89,10 +177,13 @@ async function boundedAdmission(operation, signal, timeoutMs = DBOS_ADMISSION_TI
 }
 var DBOS_ADMISSION_TIMEOUT_MS = 1e4, DbosDependencyError, key2, bag, dbosAdmissionContext;
 var init_dbos_admission = __esm(() => {
+  init_dbos_process_owner();
   DbosDependencyError = class DbosDependencyError extends Error {
     code = "ATOMIC_DBOS_DEPENDENCY";
-    constructor(message = "Workflow database unavailable during admission. Restore PostgreSQL before retrying.") {
-      super(message);
+    admissionDetail;
+    constructor(message = "Workflow database unavailable during admission. Restore PostgreSQL before retrying.", diagnostics = getDbosProcessOwner().databaseDiagnostics?.(), admissionDetail) {
+      super(databaseDependencyMessage(message, diagnostics ?? undefined));
+      this.admissionDetail = admissionDetail === undefined ? undefined : redactedDatabaseMessage(admissionDetail);
       this.name = "DbosDependencyError";
     }
   };
@@ -30263,11 +30354,11 @@ function fenceDbosAdmissionPool(pool) {
   const connect = pool.connect.bind(pool);
   async function acquire(signal) {
     if (signal.aborted)
-      throw new DbosDependencyError;
+      throw sdkDependencyError();
     const pending = connect().then((client) => {
       if (signal.aborted) {
         client.release(true);
-        throw new DbosDependencyError;
+        throw sdkDependencyError();
       }
       return fencedClient(client, signal);
     });
@@ -30311,7 +30402,7 @@ function fencedClient(client, signal) {
       const callback = typeof last === "function" ? values.pop() : undefined;
       const pending = (async () => {
         if (signal.aborted || released)
-          throw new DbosDependencyError;
+          throw sdkDependencyError();
         try {
           return await raceAbort2(new Promise((resolve, reject) => {
             Reflect.apply(target, client, [
@@ -30343,9 +30434,15 @@ function fencedClient(client, signal) {
     }
   });
 }
+function sdkDependencyError(message) {
+  const reported = message === undefined ? new DbosDependencyError : new DbosDependencyError(message, null);
+  return new DbosDependencyError(undefined, null, reported.message);
+}
 function databaseError(error, signal) {
   if (signal.aborted)
-    return new DbosDependencyError;
+    return sdkDependencyError();
+  if (isDbosDependencyError(error))
+    return sdkDependencyError(error.admissionDetail ?? error.message);
   const pending = [error];
   const seen = new Set;
   while (pending.length > 0) {
@@ -30362,7 +30459,7 @@ function databaseError(error, signal) {
     const code = "code" in value && typeof value.code === "string" ? value.code : undefined;
     const message = value instanceof Error ? value.message : "";
     if (code !== undefined && (/^(?:08|53|57)[0-9A-Z]{3}$|^40003$/.test(code) || connectionErrnos.has(code)) || code === undefined && connectionMessages.has(message)) {
-      return new DbosDependencyError;
+      return sdkDependencyError();
     }
   }
   return error;
@@ -30385,7 +30482,9 @@ var init_dbos_admission_pool = __esm(() => {
     "Connection terminated unexpectedly",
     "Connection terminated due to connection timeout",
     "Client has encountered a connection error and is not queryable",
-    "timeout exceeded when trying to connect"
+    "timeout exceeded when trying to connect",
+    "Client was closed and is not queryable",
+    "Postgres connection pool changed while acquiring a connection"
   ]);
 });
 
@@ -30673,6 +30772,11 @@ function defaultDatabaseUrl(name) {
 function configureAdmissionDatabase(sdk, config, launchLock = withDbosLaunchLock) {
   const systemDatabaseUrl = config.systemDatabaseUrl ?? defaultDatabaseUrl(config.name);
   const health = resolvedPostgresHealth(systemDatabaseUrl);
+  getDbosProcessOwner().databaseDiagnostics = () => ({
+    provider: health === undefined ? config.systemDatabaseUrl === undefined ? "docker" : "configured" : "managed",
+    url: health?.endpoint ?? systemDatabaseUrl,
+    failure: health?.lastFailure?.message
+  });
   const createPool = () => {
     let unsubscribe;
     const managed = createRecoverablePostgresPool(systemDatabaseUrl, {
@@ -30710,6 +30814,7 @@ var import_datasource2;
 var init_dbos_admission_config = __esm(() => {
   init_dbos_admission_pool();
   init_dbos_launch_lock();
+  init_dbos_process_owner();
   init_dbos_recoverable_pool();
   import_datasource2 = __toESM(require_datasource(), 1);
 });
@@ -32519,10 +32624,10 @@ function recordPendingStageMessageDeliveries(messages, runId, messageId, records
   if (index < 0)
     return messages;
   const entry = messages[index];
-  const recorded = new Set((entry.deliveries ?? []).map((delivery) => `${delivery.runId}\x00${delivery.stageId}`));
+  const recorded = new Set((entry.deliveries ?? []).map((delivery) => JSON.stringify([delivery.runId, delivery.stageId, delivery.sessionId, delivery.admission])));
   const additions = [];
   for (const record of records) {
-    const key = `${record.runId}\x00${record.stageId}`;
+    const key = JSON.stringify([record.runId, record.stageId, record.sessionId, record.admission]);
     if (recorded.has(key))
       continue;
     recorded.add(key);
@@ -32530,6 +32635,8 @@ function recordPendingStageMessageDeliveries(messages, runId, messageId, records
       runId: record.runId,
       stageId: record.stageId,
       ...record.stageName === undefined ? {} : { stageName: record.stageName },
+      ...record.sessionId === undefined ? {} : { sessionId: record.sessionId },
+      ...record.admission === undefined ? {} : { admission: record.admission },
       deliveredAt
     });
   }
@@ -37789,10 +37896,11 @@ function hasInvocationData(checkpoints, replayKey) {
 
 // dist/builtin/workflows/src/engine/run.ts
 init_dbos_admission();
+init_dbos_process_owner();
 
 // dist/builtin/workflows/src/durable/backend-process-owner.ts
 var DURABLE_BACKEND_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/durable-backend-process-owner@1");
-function emptyOwner() {
+function emptyOwner2() {
   return {
     version: 1,
     injectedBackend: undefined,
@@ -37802,15 +37910,15 @@ function emptyOwner() {
     warningReported: false
   };
 }
-function ownerBag() {
+function ownerBag2() {
   return globalThis;
 }
 function getDurableBackendProcessOwner() {
-  const bag = ownerBag();
+  const bag = ownerBag2();
   const existing = bag[DURABLE_BACKEND_PROCESS_OWNER_KEY];
   if (existing !== undefined && existing.version === 1)
     return existing;
-  const created = emptyOwner();
+  const created = emptyOwner2();
   bag[DURABLE_BACKEND_PROCESS_OWNER_KEY] = created;
   return created;
 }
@@ -39022,33 +39130,8 @@ function classifyDbosDeletionTombstone(records, workflowId) {
   return isCurrentDurableFormat(raw.version) ? "current" : "unknown";
 }
 
-// dist/builtin/workflows/src/durable/dbos-process-owner.ts
-var DBOS_PROCESS_OWNER_KEY = Symbol.for("atomic-workflows/dbos-process-owner@1");
-function emptyOwner2() {
-  return {
-    version: 1,
-    state: "uninitialized",
-    configured: undefined,
-    active: undefined,
-    launchPromise: undefined,
-    shutdownPromise: undefined,
-    failure: undefined,
-    wrappers: undefined,
-    leases: new Set
-  };
-}
-function ownerBag2() {
-  return globalThis;
-}
-function getDbosProcessOwner() {
-  const bag = ownerBag2();
-  const existing = bag[DBOS_PROCESS_OWNER_KEY];
-  if (existing !== undefined && existing.version === 1)
-    return existing;
-  const created = emptyOwner2();
-  bag[DBOS_PROCESS_OWNER_KEY] = created;
-  return created;
-}
+// dist/builtin/workflows/src/durable/dbos-backend.ts
+init_dbos_process_owner();
 
 // dist/builtin/workflows/src/durable/dbos-sdk-handle.ts
 var ATOMIC_EXECUTOR_ID = `atomic-${process.pid.toString(36)}-${crypto.randomUUID().slice(0, 8)}`;
@@ -39169,6 +39252,7 @@ function statusToInfo(status, fallbackId) {
 }
 
 // dist/builtin/workflows/src/durable/dbos-system-database-url.ts
+init_dbos_process_owner();
 function nonEmptyTrimmed(value) {
   const trimmed = value?.trim();
   return trimmed === undefined || trimmed.length === 0 ? undefined : trimmed;
@@ -39183,9 +39267,7 @@ class DbosSystemDatabaseConflictError extends Error {
 function redactDatabaseUrl(url) {
   try {
     const parsed = new URL(url);
-    if (parsed.password !== "")
-      parsed.password = "***";
-    return parsed.toString();
+    return parsed.host;
   } catch {
     return "the requested database";
   }
@@ -40902,6 +40984,7 @@ class PostgresHealth {
   attempts = 0;
   nextRecoveryAt = 0;
   failure;
+  healthySinceFailure = false;
   revision = 0;
   listeners = new Set;
   constructor(operations) {
@@ -40910,6 +40993,18 @@ class PostgresHealth {
   get lastFailure() {
     return this.failure;
   }
+  get endpoint() {
+    return this.operations.url?.();
+  }
+  retainFailure(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const safe = redactedDatabaseMessage(message, this.endpoint);
+    this.failure = new Error(safe);
+    this.healthySinceFailure = false;
+  }
+  dependencyFailure(message) {
+    return new DbosDependencyError(message, this.endpoint === undefined ? undefined : { provider: "managed", url: this.endpoint, failure: this.failure?.message });
+  }
   subscribe(listener) {
     this.listeners.add(listener);
     return () => this.listeners.delete(listener);
@@ -40932,12 +41027,15 @@ class PostgresHealth {
         await this.operations.validate?.(client);
       }
     } catch (error) {
-      this.failure = error instanceof Error ? error : new Error(String(error));
+      this.retainFailure(error);
       if (!isQueryReadTimeout(error)) {
         this.invalidate();
-        throw error;
+        if (this.endpoint === undefined)
+          throw error;
+        const failure = this.dependencyFailure("Managed PostgreSQL connection validation refused. Preserve its data and ownership records.");
+        throw error instanceof DbosDependencyError ? failure : new Error(failure.message);
       }
-      throw new DbosDependencyError("Managed PostgreSQL did not answer a connection identity check in time.");
+      throw this.dependencyFailure("Managed PostgreSQL did not answer a connection identity check in time.");
     }
   }
   check() {
@@ -40978,7 +41076,7 @@ class PostgresHealth {
       } catch (retryError) {
         if (!isMonitoringConnectionFailure(retryError))
           throw retryError;
-        this.failure = retryError;
+        this.retainFailure(retryError);
         return;
       }
     }
@@ -40993,6 +41091,7 @@ class PostgresHealth {
     this.available = identity;
     this.attempts = 0;
     this.nextRecoveryAt = 0;
+    this.healthySinceFailure = true;
     return identity.url;
   }
   async refresh() {
@@ -41002,19 +41101,21 @@ class PostgresHealth {
         return ready;
     } catch (error) {
       if (isQueryReadTimeout(error)) {
-        this.failure = new DbosDependencyError("Managed PostgreSQL did not answer a health check in time.");
-        throw this.failure;
+        this.retainFailure(new Error("Managed PostgreSQL did not answer a health check in time."));
+        throw this.dependencyFailure("Managed PostgreSQL did not answer a health check in time.");
       }
-      this.failure = error instanceof Error ? error : new Error(String(error));
+      this.retainFailure(error);
       if (!(error instanceof Error && ("code" in error) && error.code === "53300"))
         this.invalidate();
-      throw error;
+      throw this.endpoint === undefined ? error : this.dependencyFailure("Managed PostgreSQL recovery refused after a health probe failure. Preserve its data and ownership records.");
+    }
+    if (this.attempts === 0 && (this.failure === undefined || this.healthySinceFailure)) {
+      this.retainFailure(new Error("Managed PostgreSQL failed its live health check."));
+      this.healthySinceFailure = false;
     }
-    if (this.attempts === 0)
-      this.failure = new DbosDependencyError("Managed PostgreSQL failed its live health check.");
     this.invalidate();
     if ((this.operations.now ?? Date.now)() < this.nextRecoveryAt)
-      throw new DbosDependencyError("Managed Postgres recovery is cooling down after bounded attempts.");
+      throw this.dependencyFailure("Managed Postgres recovery is cooling down after bounded attempts.");
     while (!this.stopped && this.attempts < RECOVERY_ATTEMPTS) {
       const attempt = this.attempts++;
       if (attempt > 0)
@@ -41027,12 +41128,12 @@ class PostgresHealth {
         if (ready !== undefined)
           return ready;
       } catch (error) {
-        this.failure = error instanceof Error ? error : new Error(String(error));
+        this.retainFailure(error);
       }
     }
     this.attempts = 0;
     this.nextRecoveryAt = (this.operations.now ?? Date.now)() + HEALTH_INTERVAL_MS;
-    throw new DbosDependencyError("Managed Postgres is unavailable after bounded recovery. Preserve its data and ownership records.");
+    throw this.dependencyFailure("Managed Postgres is unavailable after bounded recovery. Preserve its data and ownership records.");
   }
 }
 
@@ -41688,6 +41789,8 @@ async function ensureCluster(options = {}) {
           const server = current.server;
           if (!server)
             throw new Error("Managed Postgres published identity is missing.");
+          if (managedPostmaster(current) === undefined)
+            return;
           if (!managedPostgresRuntimeHealthy(current, server.port)) {
             verifyManagedPostmasterProcess(current, server);
             return;
@@ -41704,6 +41807,7 @@ async function ensureCluster(options = {}) {
         };
         health = new PostgresHealth({
           probe: () => inspect(),
+          url: embeddedDbosSystemDatabaseUrl,
           validate: async (client) => {
             const identity = await inspect(async () => {
               const query = { text: POSTGRES_IDENTITY_SQL, query_timeout: POSTGRES_HEALTH_QUERY_TIMEOUT_MS };
@@ -42791,6 +42895,9 @@ async function requireDockerSuccess(action, args) {
   throw new Error(`Could not ${action}: ${commandFailureDetail(result)}`);
 }
 
+// dist/builtin/workflows/src/durable/dbos-lifecycle.ts
+init_dbos_process_owner();
+
 // dist/builtin/workflows/src/durable/dbos-registration-diagnostics.ts
 var cachedErrorModule;
 var errorModuleLoad;
@@ -51124,14 +51231,21 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
   };
   return {
     routeCapability: workflowPendingStageRouteCapability(activeStore, runId),
-    deliverPending(deliver) {
+    deliverPending(deliver, recipient) {
       if (drainPromise !== undefined)
         return drainPromise;
       if (terminalError !== undefined)
         return Promise.resolve();
       drainError = undefined;
-      const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver);
-      const drain = attempt.then(() => resolveReady?.(), (error) => {
+      const attempt = deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver, recipient);
+      const drain = attempt.then(() => {
+        resolveReady?.();
+        readyPromise = undefined;
+        resolveReady = undefined;
+        rejectReady = undefined;
+        if (drainPromise === drain)
+          drainPromise = undefined;
+      }, (error) => {
         drainError = error;
         rejectReady?.(error);
         readyPromise = undefined;
@@ -51144,8 +51258,8 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
       drainPromise = drain;
       return drainPromise;
     },
-    ready() {
-      if (activeStore.pendingStageMessagesFor(runId, stageId).length === 0 && (stageId === stageName || activeStore.pendingStageMessagesFor(runId, stageName).length === 0) && stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName).length === 0) {
+    ready(sessionId) {
+      if (activeStore.pendingStageMessagesFor(runId, stageId).length === 0 && (stageId === stageName || activeStore.pendingStageMessagesFor(runId, stageName).length === 0) && stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, sessionId === undefined ? undefined : { sessionId }).length === 0) {
         return;
       }
       if (terminalError !== undefined)
@@ -51163,8 +51277,8 @@ function createWorkflowPendingStageDelivery(activeStore, runId, stageId, stageNa
     }
   };
 }
-async function deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver) {
-  const stickyEntries = stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName);
+async function deliverPendingStageMessages(activeStore, runId, stageId, stageName, deliver, recipient) {
+  const stickyEntries = stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient);
   const candidateIds = new Set([
     ...activeStore.pendingStageMessagesFor(runId, stageId),
     ...activeStore.pendingStageMessagesFor(runId, stageName),
@@ -51186,7 +51300,8 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
     if (releaseClaim === undefined)
       continue;
     try {
-      await deliver(toPendingStageSender(entry), entry.message);
+      if (!recipient?.receivedMessageIds.includes(entry.message.id))
+        await deliver(toPendingStageSender(entry), entry.message);
       if (entry.sticky === true) {
         const entryBackend = durableBackendForRun(rootBackend, activeStore.runs(), entry.runId);
         if (entryBackend === undefined) {
@@ -51196,7 +51311,8 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
           {
             runId,
             stageId,
-            ...stageName === stageId ? {} : { stageName }
+            ...stageName === stageId ? {} : { stageName },
+            ...recipient === undefined ? {} : { sessionId: recipient.sessionId, admission: "context" }
           }
         ], new Date().toISOString(), entryBackend)) {
           throw new Error(`atomic-workflows: pending-stage message ${entry.id} changed during delivery`);
@@ -51211,7 +51327,7 @@ async function deliverPendingStageMessages(activeStore, runId, stageId, stageNam
     }
   }
 }
-function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName) {
+function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageName, recipient) {
   const runs = activeStore.runs();
   const rootRunId = durableRootRunIdForRun(runs, runId);
   if (rootRunId === undefined)
@@ -51228,9 +51344,8 @@ function stickyPendingStageEntriesForStage(activeStore, runId, stageId, stageNam
     const parsed = entry.targetPath === undefined ? undefined : parseWorkflowStageTarget(entry.targetPath);
     if (parsed === undefined || parsed.rootRunId !== rootRunId)
       return false;
-    if ((entry.deliveries ?? []).some((delivery) => delivery.runId === runId && delivery.stageId === stageId)) {
+    if ((entry.deliveries ?? []).some((delivery) => delivery.runId === runId && delivery.stageId === stageId && (recipient === undefined || delivery.admission === "context" && delivery.sessionId === recipient.sessionId && (recipient.receivedMessageIds === undefined || recipient.receivedMessageIds.includes(entry.message.id)))))
       return false;
-    }
     return stageMatchesPathPattern(parsed.segments, hops, [stageId, stageName]);
   });
 }
@@ -53758,7 +53873,7 @@ class StageSessionController {
     const attachedSession = session instanceof Promise ? await session : session;
     this.reportStartupPhase("delivery-readiness");
     try {
-      await this.sharedOrchestrationContext?.pendingStageDelivery?.ready();
+      await this.sharedOrchestrationContext?.pendingStageDelivery?.ready(attachedSession.sessionId);
       await this.opts.onSessionReady?.();
       if (this.disposed || this.opts.signal?.aborted || this.abortGeneration !== startGeneration)
         throw this.staleCreationReason(startGeneration);
@@ -55733,7 +55848,7 @@ async function run(def, inputs, opts = {}) {
         if (control === latestControl && !ownController.signal.aborted && isDbosDependencyError(error)) {
           activeStore.recordRunExecutionState(runId, {
             phase: "blocked_dependency",
-            dependencyError: `Workflow database unavailable during ${status === "paused" ? "pause" : "resume"}; persistence not confirmed.`
+            dependencyError: `Workflow database unavailable during ${status === "paused" ? "pause" : "resume"}; persistence not confirmed. ${error.message}`
           });
           if (status === "paused")
             return;
@@ -55780,7 +55895,7 @@ async function run(def, inputs, opts = {}) {
       if (!admission.admitting)
         return pausePersistence;
       backgroundAdmissionControl(durableBackend, runId, pausePersistence, (error, resumable) => {
-        admissionControlError = unknownErrorMessage(error);
+        admissionControlError = databaseDependencyMessage(unknownErrorMessage(error), getDbosProcessOwner().databaseDiagnostics?.());
         runSnapshot.error = admissionControlError;
         activeStore.recordRunPaused(runId, undefined, { resumable });
         return runSnapshot.error;
@@ -55797,7 +55912,7 @@ async function run(def, inputs, opts = {}) {
         } catch (error) {
           if (admission.failed) {
             scheduler.releaseRun();
-            throw error;
+            throw new Error(admissionControlError ?? databaseDependencyMessage(unknownErrorMessage(error), getDbosProcessOwner().databaseDiagnostics?.()));
           }
         }
         if (generation !== pauseGeneration)
@@ -55870,12 +55985,21 @@ async function run(def, inputs, opts = {}) {
     }).catch((error) => {
       const isTopologyError = typeof error === "object" && error !== null && "name" in error && error.name === "DurableNestedTopologyError";
       if (!isDbosDependencyError(error) && !isTopologyError) {
-        durableAdmissionFailure = { error };
-        classifiedFailures.set(error, classifyWorkflowFailure({
+        const admissionDetail = unknownErrorMessage(error);
+        const diagnostics = getDbosProcessOwner().databaseDiagnostics?.();
+        const safeMessage = databaseDependencyMessage(admissionDetail, diagnostics);
+        activeStore.recordRunExecutionState(runId, {
+          phase: "blocked_dependency",
+          dependencyError: safeMessage
+        });
+        const safeError = new Error(safeMessage);
+        durableAdmissionFailure = { error: safeError };
+        classifiedFailures.set(safeError, classifyWorkflowFailure({
           code: "ATOMIC_DURABLE_ADMISSION_REJECTED",
-          message: unknownErrorMessage(error),
-          cause: error
+          message: safeMessage,
+          cause: safeError
         }));
+        throw safeError;
       }
       throw error;
     }), ownController.signal);

package/dist/core/agent-session-export.js

@@ -114,7 +114,7 @@ export async function exportToHtml(outputPath, options = {}) {
     ]);
     // Create tool renderer if we have an extension runner (for custom tool HTML rendering)
     const toolRenderer = createToolHtmlRenderer({
-        getToolDefinition: (name) => this.getToolDefinition(name),
+        getToolRenderers: (name) => this.extensionRunner.resolveToolRenderers(name, () => this.getToolDefinition(name)),
         theme,
         cwd: this.sessionManager.getCwd(),
     });