@opengeni/api-router 3.0.1 → 3.0.2-canary.38894290271001

package/dist/index.js

@@ -4,10 +4,18 @@ import {
   apiRequestBindingsForTransportPeer,
   cleanupScheduledTaskConnectorAuthorization,
   createAppComposition,
+  createAutomaticAgentUpdater,
+  createLocalBrowserBoundary,
   createOpenGeniSlackBotInteractionClient,
+  localBrowserBoundaryResponse,
+  reconcileScreenControlOnHello,
+  sql,
+  startApiMetricsListener,
   startSlackInteractionPump,
-  startTemporalScheduleCleanupPump
-} from "./chunk-AJ62T5QN.js";
+  startTemporalScheduleCleanupPump,
+  withAccessGrantSessionRlsContext
+} from "./chunk-GBUJ2DYZ.js";
+import "./chunk-OGQDXVXY.js";
 
 // src/index.ts
 import { scheduledTaskKnowledgeSource } from "@opengeni/contracts";
@@ -23,6 +31,7 @@ import {
 } from "@opengeni/config";
 import {
   assertRuntimeDatabasePosture,
+  isRetryableRuntimeDatabaseStartupError,
   createDb,
   markSessionWorkflowWakeDelivered,
   runtimeDatabaseReadyCheck
@@ -33,11 +42,12 @@ import {
   logStartupDependencyRetry
 } from "@opengeni/observability";
 import { createObjectStorage } from "@opengeni/storage";
-import { createNativeRemoteMcpCredentialsPort } from "@opengeni/core/remote-mcp-credentials";
 import { isArtifactRuntimeConfigured } from "@opengeni/artifact-tool/runtime/development";
 import {
   resolveCatalogSettings,
-  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID
+  SESSION_WORKFLOW_WAKE_DISPATCH_REQUESTED_SIGNAL,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_ID,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE
 } from "@opengeni/core";
 import {
   Connection,
@@ -48,6 +58,15 @@ import {
 } from "@temporalio/client";
 
 // src/observability.ts
+import {
+  natsSubscriptionTerminationCounter
+} from "@opengeni/events";
+function observabilityEventBusOptions(observability) {
+  return {
+    logger: observabilityEventLogger(observability),
+    onSubscriptionTerminated: natsSubscriptionTerminationCounter(observability)
+  };
+}
 function observabilityEventLogger(observability) {
   return {
     debug: (message, attributes) => observability.debug(message, eventAttributes(attributes)),
@@ -76,6 +95,8 @@ function eventAttributeValue(value) {
 }
 
 // src/sandbox/auth-callout.ts
+import { createHash } from "crypto";
+import { createLogThrottle } from "@opengeni/observability";
 import {
   resolveEnrollmentSigningSecret
 } from "@opengeni/config";
@@ -96,14 +117,43 @@ var AGENT_CONNECTION_LEASE_MS = 2e4;
 // src/sandbox/auth-callout.ts
 var AUTH_CALLOUT_SUBJECT = "$SYS.REQ.USER.AUTH";
 var NATS_USER_JWT_TTL_SECONDS = 5 * 60;
+var AUTH_CALLOUT_DENIAL_WARNING_INTERVAL_MS = 6e4;
+var processDenialWarningThrottle = createLogThrottle({
+  intervalMs: AUTH_CALLOUT_DENIAL_WARNING_INTERVAL_MS,
+  maxKeys: 1024
+});
+function warnDenial(deps, key, reason, message, attributes = {}) {
+  const admission = (deps.denialWarningThrottle ?? processDenialWarningThrottle).admit(key);
+  if (!admission) return;
+  deps.observability?.warn?.(message, {
+    ...attributes,
+    reason,
+    ...admission.suppressedCount > 0 ? { suppressedCount: admission.suppressedCount } : {}
+  });
+}
+function recordMachineConnect(deps, outcome, reason) {
+  try {
+    deps.observability?.incrementCounter({
+      name: "opengeni_machine_connect_total",
+      help: "Connected Machine agent NATS connect decisions (auth callout) by outcome and closed denial reason.",
+      labels: { outcome, reason }
+    });
+  } catch {
+  }
+}
+function rejectedBearerKey(bearer) {
+  return `invalid-bearer:${createHash("sha256").update(bearer).digest("hex").slice(0, 32)}`;
+}
 async function handleAuthorizationRequest(deps, requestBytes) {
   const requestJwt = Buffer.from(requestBytes).toString("utf8");
   const decoded = decodeAuthRequest(requestJwt);
   if (!decoded) {
     deps.observability?.warn?.("auth-callout: undecodable authorization request", {});
+    recordMachineConnect(deps, "denied", "undecodable");
     throw new Error("undecodable authorization request");
   }
-  const deny = (reason) => {
+  const deny = (code, reason) => {
+    recordMachineConnect(deps, "denied", code);
     const response2 = mintAuthResponse({
       userPublicKey: decoded.userNkey,
       serverId: decoded.serverId,
@@ -114,34 +164,42 @@ async function handleAuthorizationRequest(deps, requestBytes) {
   };
   const bearer = decoded.authToken;
   if (!bearer) {
-    return deny("missing enrollment bearer");
+    return deny("missing_bearer", "missing enrollment bearer");
   }
   const secret = resolveEnrollmentSigningSecret(deps.settings);
   if (!secret) {
-    return deny("enrollment credential plane disabled");
+    return deny("plane_disabled", "enrollment credential plane disabled");
   }
   const claims = await verifyEnrollmentBearer(secret, bearer);
   if (!claims) {
-    deps.observability?.warn?.("auth-callout: rejected an invalid enrollment bearer", {});
-    return deny("invalid or expired enrollment bearer");
+    warnDenial(
+      deps,
+      rejectedBearerKey(bearer),
+      "invalid_bearer",
+      "auth-callout: rejected an invalid enrollment bearer"
+    );
+    return deny("invalid_bearer", "invalid or expired enrollment bearer");
   }
   const enrollment = await getEnrollment(deps.db, claims.workspaceId, claims.enrollmentId);
   if (!enrollment || enrollment.status !== "active") {
-    deps.observability?.warn?.("auth-callout: denied a revoked or unknown enrollment", {
-      workspaceId: claims.workspaceId,
-      agentId: claims.agentId
-    });
-    return deny("enrollment is not active");
+    warnDenial(
+      deps,
+      `inactive:${claims.workspaceId}:${claims.agentId}`,
+      "inactive_enrollment",
+      "auth-callout: denied a revoked or unknown enrollment",
+      { workspaceId: claims.workspaceId, agentId: claims.agentId }
+    );
+    return deny("inactive_enrollment", "enrollment is not active");
   }
   if (enrollment.workspaceId !== claims.workspaceId || enrollment.id !== claims.enrollmentId || enrollment.id !== claims.agentId || claims.agentId !== claims.enrollmentId || claims.subjectPrefix !== `agent.${claims.workspaceId}.${claims.agentId}`) {
-    return deny("enrollment identity mismatch");
+    return deny("identity_mismatch", "enrollment identity mismatch");
   }
   if (enrollment.credentialGeneration !== claims.credentialGeneration) {
-    return deny("enrollment credential generation mismatch");
+    return deny("generation_mismatch", "enrollment credential generation mismatch");
   }
   const connectionInstanceId = parseAgentConnectionName(decoded.name);
   if (!connectionInstanceId) {
-    return deny("missing or invalid agent connection instance");
+    return deny("invalid_instance", "missing or invalid agent connection instance");
   }
   const claim = await claimEnrollmentConnection(deps.db, {
     workspaceId: claims.workspaceId,
@@ -151,11 +209,14 @@ async function handleAuthorizationRequest(deps, requestBytes) {
     leaseMs: AGENT_CONNECTION_LEASE_MS
   });
   if (!claim.claimed) {
-    deps.observability?.warn?.("auth-callout: denied a duplicate live runner", {
-      workspaceId: claims.workspaceId,
-      agentId: claims.agentId
-    });
-    return deny("another runner instance currently owns this enrollment");
+    warnDenial(
+      deps,
+      `duplicate:${claims.workspaceId}:${claims.agentId}`,
+      "duplicate_runner",
+      "auth-callout: denied a duplicate live runner",
+      { workspaceId: claims.workspaceId, agentId: claims.agentId }
+    );
+    return deny("duplicate_runner", "another runner instance currently owns this enrollment");
   }
   const permissions = workspaceAgentPermissions(
     claims.workspaceId,
@@ -183,6 +244,7 @@ async function handleAuthorizationRequest(deps, requestBytes) {
     accountSeed: deps.callout.accountSeed,
     userJwt
   });
+  recordMachineConnect(deps, "granted", "none");
   deps.observability?.info?.("auth-callout: granted a workspace-scoped NATS credential", {
     workspaceId: claims.workspaceId,
     agentId: claims.agentId,
@@ -198,10 +260,10 @@ async function startAuthCalloutResponder(deps, natsUrl) {
     (bytes) => handleAuthorizationRequest(deps, bytes),
     {
       name: "opengeni-auth-callout",
-      ...deps.observability ? { logger: observabilityEventLogger(deps.observability) } : {}
+      ...deps.observability ? observabilityEventBusOptions(deps.observability) : {}
     }
   );
-  deps.observability?.info?.("OpenGeni NATS auth-callout responder started", {
+  deps.observability?.info?.("Opengeni NATS auth-callout responder started", {
     subject: AUTH_CALLOUT_SUBJECT
   });
   return connection;
@@ -212,6 +274,8 @@ import {
   clearEnrollmentWentOffline,
   disconnectAttachedBrowserDevices,
   advanceEnrollmentAgentUpdate,
+  enrollmentMacPermissionCapabilities,
+  enrollmentMacPermissions,
   getEnrollment as getEnrollment2,
   getLiveEnrollmentConnection,
   ingestMachineMetricsSample,
@@ -224,6 +288,7 @@ import {
   setEnrollmentOpStreamState
 } from "@opengeni/db";
 import {
+  AttachedBrowserConnectionEnd as AttachedBrowserConnectionEndContract,
   AttachedBrowserInventorySnapshot as AttachedBrowserInventoryContract
 } from "@opengeni/contracts";
 import { appendAndPublishEvents } from "@opengeni/events";
@@ -232,6 +297,7 @@ import {
   AgentEvent,
   AgentUpdateStage,
   Arch,
+  AttachedBrowserConnectionEndReason as WireConnectionEndReason,
   GoingOfflineReason,
   Hello,
   Os,
@@ -385,8 +451,42 @@ function wireAttachedBrowserInventoryToContract(wire) {
       ),
       tabCount: safeWireInteger(device.tabCount, "attached browser tab count"),
       capabilities: device.capabilities
-    }))
+    })),
+    connectionEnds: (wire.connectionEnds ?? []).flatMap(wireConnectionEndToContract)
+  });
+}
+var WIRE_CONNECTION_END_REASONS = /* @__PURE__ */ new Map([
+  [
+    WireConnectionEndReason.ATTACHED_BROWSER_CONNECTION_END_REASON_BROWSER_CLOSED_PORT,
+    "browser_closed_port"
+  ],
+  [
+    WireConnectionEndReason.ATTACHED_BROWSER_CONNECTION_END_REASON_BROWSER_MESSAGE_INVALID,
+    "browser_message_invalid"
+  ],
+  [
+    WireConnectionEndReason.ATTACHED_BROWSER_CONNECTION_END_REASON_BROWSER_OUTPUT_FAILED,
+    "browser_output_failed"
+  ],
+  [
+    WireConnectionEndReason.ATTACHED_BROWSER_CONNECTION_END_REASON_NATIVE_HOST_LOST,
+    "native_host_lost"
+  ],
+  [WireConnectionEndReason.ATTACHED_BROWSER_CONNECTION_END_REASON_AGENT_REJECTED, "agent_rejected"]
+]);
+function wireConnectionEndToContract(wire) {
+  const reason = WIRE_CONNECTION_END_REASONS.get(wire.reason);
+  const endedAtMs = Number(wire.endedAtUnixMs);
+  if (!reason || !Number.isSafeInteger(endedAtMs) || endedAtMs <= 0) return [];
+  const parsed = AttachedBrowserConnectionEndContract.safeParse({
+    deviceId: wire.deviceId,
+    connectionGeneration: wire.connectionGeneration,
+    reason,
+    detail: wire.detail.slice(0, 512) || null,
+    endedAt: new Date(endedAtMs).toISOString(),
+    connectedMs: Math.min(Number(wire.connectedMs) || 0, Number.MAX_SAFE_INTEGER)
   });
+  return parsed.success ? [parsed.data] : [];
 }
 function safeWireInteger(value, label) {
   let parsed;
@@ -462,7 +562,7 @@ async function fanOutMachineLinkEvents(db, bus, observability, workspaceId, enro
     }
   }
 }
-async function handleAgentEventPayload(db, observability, payload, subject, bus) {
+async function handleAgentEventPayload(db, observability, payload, subject, bus, agentUpdates) {
   const ids = parseAgentEventSubject(subject);
   if (!ids) {
     return;
@@ -608,6 +708,7 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
     });
     return;
   }
+  agentUpdates?.consider(enrollment);
   if (heartbeat.attachedBrowserInventory) {
     try {
       await ingestAttachedBrowserInventory(db, {
@@ -622,6 +723,31 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
       });
     }
   }
+  if (heartbeat.desktopStatus) {
+    try {
+      const status = heartbeat.desktopStatus;
+      const available = status.available && !status.unavailableReason;
+      const reason = status.unavailableReason || null;
+      const macPermissions = status.macPermissions;
+      const stored = enrollmentMacPermissions(enrollment.agentCapabilities);
+      if (enrollment.hasDisplay !== available || (enrollment.desktopUnavailableReason ?? null) !== reason || enrollment.agentCapabilities?.desktop !== available || macPermissions !== void 0 && (stored?.screenRecording !== macPermissions.screenRecording || stored?.accessibility !== macPermissions.accessibility || stored?.inputMonitoring !== macPermissions.inputMonitoring)) {
+        await refreshEnrollmentDisplay(db, {
+          workspaceId: ids.workspaceId,
+          agentId: ids.agentId,
+          hasDisplay: available,
+          desktopUnavailableReason: reason,
+          runtimeDesktop: available,
+          ...macPermissions ? { macPermissions } : {},
+          connectionInstanceId: ids.connectionInstanceId
+        });
+      }
+    } catch (error) {
+      observability?.warn?.("Failed to refresh a machine desktop heartbeat", {
+        subject,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   const metrics = heartbeat.metrics;
   if (!metrics) return;
   try {
@@ -640,7 +766,14 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
 }
 function startMetricsIngestion(deps) {
   const scheduler = createAgentEventIngestionScheduler(
-    (payload, subject) => handleAgentEventPayload(deps.db, deps.observability, payload, subject, deps.bus),
+    (payload, subject) => handleAgentEventPayload(
+      deps.db,
+      deps.observability,
+      payload,
+      subject,
+      deps.bus,
+      deps.agentUpdates
+    ),
     {
       onHeartbeatCoalesced: () => deps.observability?.incrementCounter({
         name: "opengeni_machine_heartbeat_coalesced_total",
@@ -686,7 +819,10 @@ function helloRuntimeCapabilities(hello) {
     browserBridge: caps.browserBridge === true,
     operationResourcePolicy: caps.operationResourcePolicy === true,
     operationCpuQuota: caps.operationCpuQuota === true,
-    transactionalFsWrite: caps.transactionalFsWrite === true
+    transactionalFsWrite: caps.transactionalFsWrite === true,
+    credentialRenew: caps.credentialRenew === true,
+    screenControl: caps.consentedScreenControl === true,
+    ...caps.macPermissions ? enrollmentMacPermissionCapabilities(caps.macPermissions) : {}
   };
 }
 function helloCompletedUpdate(hello) {
@@ -707,7 +843,11 @@ async function refreshEnrollmentDisplay(db, input) {
   if (!enrollment) {
     return { updated: false };
   }
-  if (enrollment.hasDisplay === input.hasDisplay && (enrollment.desktopUnavailableReason ?? null) === desktopUnavailableReason) {
+  if (enrollment.hasDisplay === input.hasDisplay && (enrollment.desktopUnavailableReason ?? null) === desktopUnavailableReason && (input.runtimeDesktop === void 0 || enrollment.agentCapabilities?.desktop === input.runtimeDesktop) && (input.macPermissions === void 0 || JSON.stringify(enrollmentMacPermissions(enrollment.agentCapabilities)) === JSON.stringify({
+    screenRecording: input.macPermissions.screenRecording,
+    accessibility: input.macPermissions.accessibility,
+    inputMonitoring: input.macPermissions.inputMonitoring
+  }))) {
     return { updated: false };
   }
   return await setEnrollmentDisplayState(db, {
@@ -716,6 +856,8 @@ async function refreshEnrollmentDisplay(db, input) {
     enrollmentId: input.agentId,
     hasDisplay: input.hasDisplay,
     desktopUnavailableReason,
+    ...input.runtimeDesktop !== void 0 ? { runtimeDesktop: input.runtimeDesktop } : {},
+    ...input.macPermissions ? { macPermissions: input.macPermissions } : {},
     ...input.connectionInstanceId ? { connectionInstanceId: input.connectionInstanceId } : {}
   });
 }
@@ -804,6 +946,18 @@ async function handleHelloPayload(db, observability, payload, subject, bus) {
       error: error instanceof Error ? error.message : String(error)
     });
   }
+  void reconcileScreenControlOnHello(
+    { bus, observability },
+    {
+      authority,
+      hello,
+      target: {
+        workspaceId: ids.workspaceId,
+        enrollmentId: ids.agentId,
+        connectionInstanceId: ids.connectionInstanceId
+      }
+    }
+  );
   try {
     const { cleared } = await clearEnrollmentWentOffline(db, {
       accountId: authority.accountId,
@@ -1006,6 +1160,816 @@ function escapeSlackText(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
+// src/scheduled-task-lifecycle.ts
+import {
+  acknowledgeScheduledTaskScheduleReconciliation,
+  deferScheduledTaskScheduleReconciliation,
+  listExhaustedScheduledTasks,
+  listScheduledTaskScheduleReconciliations,
+  retireExhaustedScheduledTask
+} from "@opengeni/db";
+
+// src/scheduled-task-blockers.ts
+import {
+  NOTIFICATION_SUBTITLE_MAX_CHARS,
+  SessionNotificationPostedPayload,
+  SessionNotificationWithdrawnPayload
+} from "@opengeni/contracts";
+import {
+  getPendingScheduledTaskBlockerNotice,
+  listScheduledTaskBlockerReviews,
+  reviewScheduledTaskBlockers,
+  settleScheduledTaskBlockerNotice
+} from "@opengeni/db";
+import { appendAndPublishEvents as appendAndPublishEvents2 } from "@opengeni/events";
+var SCHEDULED_TASK_BLOCKER_STREAK = 3;
+var SETTLED = /* @__PURE__ */ new Set(["succeeded", "failed", "skipped"]);
+var RESUME = "then resume the schedule.";
+var NON_RETRYABLE_REFUSAL_TEXT = {
+  scheduled_authority_unavailable: `The access it was set up with is no longer valid. Refresh the schedule's access, ${RESUME}`,
+  machine_target_unavailable: `The machine it runs on is no longer available. Choose another machine or reconnect this one, ${RESUME}`,
+  machine_enrollment_inactive: `The machine it runs on is disconnected from Opengeni. Reconnect the machine, ${RESUME}`,
+  variable_set_unavailable: `A variable set it uses no longer exists or can't be used. Edit the schedule, ${RESUME}`,
+  rig_version_unavailable: `Its rig has no usable version. Publish a rig version or edit the schedule, ${RESUME}`,
+  scheduled_model_unavailable: `Its model is no longer available. Edit the schedule to choose another model, ${RESUME}`
+};
+var RETRYABLE_REFUSAL_TEXT = {
+  machine_enrollment_inactive: "the machine it runs on is disconnected",
+  insufficient_credits: "the workspace is out of credits",
+  allowance_exhausted: "the usage allowance is used up",
+  monthly_model_cost_limit: "the monthly model cost limit was reached",
+  monthly_agent_run_limit: "the monthly run limit was reached",
+  session_usage_limit: "the schedule reached its usage limit"
+};
+function scheduledRunHardBlocker(task, run) {
+  if (run.admissionDiagnostic) {
+    return {
+      reason: "connection_account_unavailable",
+      text: `A connected account it needs can no longer be used. Reconnect that account or refresh the schedule's access, ${RESUME}`
+    };
+  }
+  if (run.admissionRefusal && !run.admissionRefusal.retryable) {
+    const reason = run.admissionRefusal.reason;
+    return {
+      reason,
+      text: NON_RETRYABLE_REFUSAL_TEXT[reason] ?? `Every run is refused before it starts (${reason}). Fix that, ${RESUME}`
+    };
+  }
+  switch (run.error) {
+    case "scheduled_session_paused":
+      return {
+        reason: run.error,
+        text: `Its chat is paused, so no run can start there. Resume the chat, ${RESUME}`
+      };
+    case "session_cancelled":
+      return task.runMode === "new_session_per_run" ? null : {
+        reason: run.error,
+        text: `The chat it runs in has ended, so no run can start there. Point the schedule at another chat or let it start a new chat each run, ${RESUME}`
+      };
+    case "scheduled_target_session_unavailable":
+      return {
+        reason: run.error,
+        text: `The chat it runs in no longer exists. Point the schedule at another chat or let it start a new chat each run, ${RESUME}`
+      };
+    case "scheduled_model_unavailable":
+      return { reason: run.error, text: NON_RETRYABLE_REFUSAL_TEXT.scheduled_model_unavailable };
+    default:
+      return null;
+  }
+}
+function streakBlocker(streak) {
+  const count = streak.length;
+  if (streak.every((run) => run.error === "scheduled_session_not_idle")) {
+    return {
+      reason: "scheduled_session_not_idle",
+      text: `The last ${count} scheduled runs were skipped because its chat was still busy with earlier work. Check whether that chat is stuck. The schedule keeps trying.`
+    };
+  }
+  const refusal = streak[0]?.admissionRefusal;
+  if (refusal?.retryable && streak.every(
+    (run) => run.admissionRefusal?.retryable && run.admissionRefusal.reason === refusal.reason
+  )) {
+    return {
+      reason: refusal.reason,
+      text: `The last ${count} scheduled runs were skipped because ${RETRYABLE_REFUSAL_TEXT[refusal.reason] ?? `they were refused (${refusal.reason})`}. Runs start again once that clears.`
+    };
+  }
+  const latest = streak[0];
+  return {
+    reason: latest.error ?? latest.status,
+    text: `The last ${count} scheduled runs failed or were skipped. Open the latest run to see why. The schedule keeps trying.`
+  };
+}
+function scheduledTaskBlockerNoticeKey(taskId) {
+  return `schedule-${taskId}`;
+}
+function clip(text, max) {
+  return text.length <= max ? text : `${text.slice(0, max - 1).trimEnd()}\u2026`;
+}
+function notice(facts, run, state, blocker) {
+  const sessionId = run.sessionId ?? facts.task.reusableSessionId ?? facts.runs.find((candidate) => candidate.sessionId !== null)?.sessionId ?? null;
+  if (!sessionId) return null;
+  const key = scheduledTaskBlockerNoticeKey(facts.task.id);
+  const payload = SessionNotificationPostedPayload.parse({
+    key,
+    title: state === "paused" ? "Schedule paused itself" : "Schedule needs attention",
+    subtitle: clip(facts.task.name.trim() || "Scheduled task", NOTIFICATION_SUBTITLE_MAX_CHARS),
+    body: state === "paused" ? `${blocker.text} It stays paused until someone resumes it.` : blocker.text,
+    urgency: "normal",
+    replaced: false
+  });
+  return { sessionId, key, payload };
+}
+function decideScheduledTaskBlocker(facts) {
+  const { task, review, runs } = facts;
+  const blocked = review !== null && review.state !== "clear";
+  if (task.deleted) return blocked ? { kind: "clear", reviewedRunId: null } : none(null);
+  if (review?.state === "paused" && task.status === "active") {
+    return { kind: "clear", reviewedRunId: null };
+  }
+  if (review?.state === "notified" && task.status !== "active") {
+    return { kind: "clear", reviewedRunId: null };
+  }
+  if (task.status !== "active") return none(null);
+  const latest = runs[0];
+  if (!latest || !SETTLED.has(latest.status) || latest.id === review?.reviewedRunId) {
+    return none(null);
+  }
+  if (latest.status === "succeeded") {
+    return review?.state === "notified" ? { kind: "clear", reviewedRunId: latest.id } : none(latest.id);
+  }
+  const current = (run) => run.createdAt >= task.updatedAt;
+  const hard = current(latest) ? scheduledRunHardBlocker(task, latest) : null;
+  if (hard) {
+    return {
+      kind: "block",
+      state: "paused",
+      reason: hard.reason,
+      message: hard.text,
+      blockedRunId: latest.id,
+      blockedSince: latest.createdAt,
+      reviewedRunId: latest.id,
+      notice: notice(facts, latest, "paused", hard)
+    };
+  }
+  if (review?.state === "notified") return none(latest.id);
+  const streak = [];
+  for (const run of runs) {
+    if (!SETTLED.has(run.status) || run.status === "succeeded" || !current(run)) break;
+    streak.push(run);
+  }
+  if (streak.length < SCHEDULED_TASK_BLOCKER_STREAK) return none(latest.id);
+  const soft = streakBlocker(streak);
+  const first = streak.at(-1);
+  return {
+    kind: "block",
+    state: "notified",
+    reason: soft.reason,
+    message: soft.text,
+    blockedRunId: first.id,
+    blockedSince: first.createdAt,
+    reviewedRunId: latest.id,
+    notice: notice(facts, latest, "notified", soft)
+  };
+}
+function none(reviewedRunId) {
+  return { kind: "none", reviewedRunId };
+}
+function sessionMissing(error) {
+  return error instanceof Error && /^Session not found: /u.test(error.message);
+}
+async function deliverScheduledTaskBlockerNotice(deps, workspaceId, taskId) {
+  const pending = await getPendingScheduledTaskBlockerNotice(deps.db, workspaceId, taskId);
+  if (!pending) return;
+  try {
+    await appendAndPublishEvents2(deps.db, deps.bus, workspaceId, pending.sessionId, [
+      pending.pending === "post" ? {
+        type: "session.notification.posted",
+        payload: SessionNotificationPostedPayload.parse(pending.payload)
+      } : {
+        type: "session.notification.withdrawn",
+        payload: SessionNotificationWithdrawnPayload.parse({ key: pending.key })
+      }
+    ]);
+  } catch (error) {
+    if (!sessionMissing(error)) throw error;
+  }
+  await settleScheduledTaskBlockerNotice(deps.db, workspaceId, taskId, pending);
+}
+async function reviewScheduledTaskBlockerInventory(deps) {
+  for (const candidate of await listScheduledTaskBlockerReviews(deps.db)) {
+    try {
+      await reviewScheduledTaskBlockers(
+        deps.db,
+        candidate.workspace_id,
+        candidate.id,
+        decideScheduledTaskBlocker
+      );
+      await deliverScheduledTaskBlockerNotice(deps, candidate.workspace_id, candidate.id);
+    } catch (error) {
+      deps.observability?.error("Scheduled task blocker review will retry", {
+        taskId: candidate.id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+
+// src/scheduled-task-lifecycle.ts
+async function reconcileExhaustedScheduledTasks(deps) {
+  for (const candidate of await listExhaustedScheduledTasks(deps.db)) {
+    await retireExhaustedScheduledTask(deps.db, candidate.workspace_id, candidate.id);
+  }
+  if (deps.bus) {
+    await reviewScheduledTaskBlockerInventory({
+      db: deps.db,
+      bus: deps.bus,
+      observability: deps.observability
+    });
+  }
+  for (const pending of await listScheduledTaskScheduleReconciliations(deps.db)) {
+    try {
+      await deps.sync({
+        id: pending.task_id,
+        workspaceId: pending.workspace_id,
+        temporalScheduleId: pending.temporal_schedule_id
+      });
+      await acknowledgeScheduledTaskScheduleReconciliation(
+        deps.db,
+        pending.workspace_id,
+        pending.id
+      );
+    } catch (error) {
+      await deferScheduledTaskScheduleReconciliation(deps.db, pending.workspace_id, pending.id);
+      deps.observability?.error("Exhausted schedule reconciliation will retry", {
+        taskId: pending.task_id,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+function startScheduledTaskLifecyclePump(deps, intervalMs = 3e4) {
+  let stopped = false;
+  let running;
+  const tick = () => {
+    if (stopped || running) return;
+    running = reconcileExhaustedScheduledTasks(deps).catch((error) => {
+      deps.observability?.error("Exhausted schedule inventory failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }).finally(() => {
+      running = void 0;
+    });
+  };
+  const timer = setInterval(tick, intervalMs);
+  queueMicrotask(tick);
+  return async () => {
+    stopped = true;
+    clearInterval(timer);
+    await running;
+  };
+}
+
+// src/temporal-schedule-sync.ts
+import { getScheduledTaskIncludingDeleted } from "@opengeni/db";
+var LOCK_TIMEOUT = "5s";
+var WRITE_TIMEOUT_MS = 5e3;
+function createTemporalScheduleSynchronizer(deps) {
+  const write = async (temporalScheduleId, work) => deps.db.transaction(async (tx) => {
+    await tx.execute(sql`select set_config('lock_timeout', ${LOCK_TIMEOUT}, true)`);
+    await tx.execute(sql`select pg_advisory_xact_lock(
+        hashtextextended(${`scheduled-task-temporal:${temporalScheduleId}`}, 0)
+      )`);
+    return await work(tx);
+  });
+  return {
+    async sync(task, onFailure) {
+      const result = await write(task.temporalScheduleId, async (tx) => {
+        try {
+          await deps.withDeadline(Date.now() + WRITE_TIMEOUT_MS, async () => {
+            const current = await getScheduledTaskIncludingDeleted(tx, task.workspaceId, task.id);
+            if (current && current.temporalScheduleId !== task.temporalScheduleId)
+              throw new Error("Scheduled task Temporal identity changed");
+            if (!current || current.deletedAt !== null || current.schedule.type === "manual") {
+              await deps.remove(task.temporalScheduleId);
+              return;
+            }
+            const { deletedAt: _deletedAt, ...latest } = current;
+            await deps.upsert(latest);
+          });
+          return { ok: true };
+        } catch (error) {
+          return { ok: false, error: onFailure ? await onFailure(tx, error) : error };
+        }
+      });
+      if (!result.ok) throw result.error;
+    },
+    async remove(temporalScheduleId) {
+      await write(
+        temporalScheduleId,
+        async () => deps.withDeadline(Date.now() + WRITE_TIMEOUT_MS, () => deps.remove(temporalScheduleId))
+      );
+    }
+  };
+}
+
+// src/native-push-dispatch.ts
+import { createSign, randomUUID } from "crypto";
+import { connect } from "http2";
+import {
+  claimNativePushDeliveries,
+  listSessionHumanInputRequests,
+  pruneNativePushDeliveries,
+  settleNativePushDelivery
+} from "@opengeni/db";
+var POLL_INTERVAL_MS = 1e3;
+var CLAIM_SECONDS = 60;
+var MAX_ATTEMPTS = 6;
+var PRUNE_EVERY_TICKS = 600;
+var SECRET_QUESTION_PUSH_BODY = "Open Opengeni to answer. The answer is saved to a vault.";
+async function markSecretQuestionDeliveries(db, deliveries) {
+  const secretSessions = /* @__PURE__ */ new Map();
+  return await Promise.all(
+    deliveries.map(async (delivery) => {
+      if (delivery.payload.eventType !== "session.humanInput.requested") return delivery;
+      const key = `${delivery.payload.workspaceId}:${delivery.payload.sessionId}`;
+      let lookup = secretSessions.get(key);
+      if (!lookup) {
+        lookup = listSessionHumanInputRequests(
+          db,
+          delivery.payload.workspaceId,
+          delivery.payload.sessionId,
+          { status: "pending", limit: 20 }
+        ).then(
+          (requests) => requests.some(
+            (request) => request.questions.some((question) => question.kind === "secret")
+          )
+        ).catch(() => false);
+        secretSessions.set(key, lookup);
+      }
+      if (!await lookup) return delivery;
+      const payload = { ...delivery.payload, secretQuestion: true };
+      return { ...delivery, payload };
+    })
+  );
+}
+function plainNotificationText(markdown) {
+  return markdown.replace(/\[([^\]]+)\]\((?:[^)]+)\)/gu, "$1").replace(/(\*\*|__)(.+?)\1/gu, "$2").replace(/`([^`]+)`/gu, "$1").replace(/^[ \t]*[-*][ \t]+/gmu, "\u2022 ").replace(/\n{3,}/gu, "\n\n").trim();
+}
+function nativePushAlert(payload) {
+  if (payload.secretQuestion) {
+    return { title: payload.title ?? "The agent needs a secret", body: SECRET_QUESTION_PUSH_BODY };
+  }
+  const fallback = payload.rule === "needs_input" ? "The agent needs you" : payload.rule === "failed" ? "A turn failed" : payload.rule === "reply_ready" ? "Reply ready" : "Opengeni";
+  const facts = (payload.facts ?? []).slice(0, 4).map((fact) => `${fact.label}: ${fact.value}`).join("\n");
+  const message = payload.body ? plainNotificationText(payload.body) : "";
+  const lines = [message === payload.title ? "" : message, facts].filter(Boolean);
+  const body = lines.join("\n\n");
+  return {
+    title: payload.title ?? fallback,
+    ...payload.subtitle ? { subtitle: payload.subtitle } : {},
+    ...body || payload.rule !== "agent" ? { body: body || fallback } : {}
+  };
+}
+function nativePushInterruptionLevel(payload) {
+  if ((payload.rule === "agent" || payload.rule === "needs_input") && payload.urgency === "time_sensitive") {
+    return "time-sensitive";
+  }
+  return "active";
+}
+function nativePushData(payload) {
+  return {
+    sessionId: payload.sessionId,
+    workspaceId: payload.workspaceId,
+    subjectId: payload.subjectId,
+    rule: payload.rule,
+    ...payload.eventType ? { eventType: payload.eventType } : {},
+    ...payload.sequence ? { sequence: payload.sequence } : {}
+  };
+}
+function nativePushCategory(payload) {
+  if (payload.secretQuestion) return void 0;
+  if (payload.eventType === "session.requiresAction") return "og.approval";
+  if (payload.eventType === "session.humanInput.requested") return "og.question";
+  return void 0;
+}
+function base64Url(input) {
+  return Buffer.from(input).toString("base64url");
+}
+function signJwt(header, claims, privateKey, algorithm) {
+  const unsigned = `${base64Url(JSON.stringify(header))}.${base64Url(JSON.stringify(claims))}`;
+  const signer = createSign("SHA256");
+  signer.update(unsigned);
+  const signature = algorithm === "ES256" ? signer.sign({ key: privateKey, dsaEncoding: "ieee-p1363" }) : signer.sign(privateKey);
+  return `${unsigned}.${base64Url(signature)}`;
+}
+function pem(value) {
+  return value.includes("\\n") ? value.replace(/\\n/gu, "\n") : value;
+}
+function createApnsSender(input) {
+  const key = pem(input.privateKey);
+  let token = null;
+  const sessions = /* @__PURE__ */ new Map();
+  const bearer = () => {
+    const now = Math.floor(Date.now() / 1e3);
+    if (!token || now - token.issuedAt > 40 * 60) {
+      token = {
+        value: signJwt(
+          { alg: "ES256", kid: input.keyId },
+          { iss: input.teamId, iat: now },
+          key,
+          "ES256"
+        ),
+        issuedAt: now
+      };
+    }
+    return token.value;
+  };
+  const session = (host) => {
+    const existing = sessions.get(host);
+    if (existing && !existing.closed && !existing.destroyed) return existing;
+    const created = connect(`https://${host}`);
+    created.on("error", () => sessions.delete(host));
+    created.on("close", () => sessions.delete(host));
+    sessions.set(host, created);
+    return created;
+  };
+  return async (delivery) => {
+    const host = delivery.environment === "development" ? "api.sandbox.push.apple.com" : "api.push.apple.com";
+    const alert = nativePushAlert(delivery.payload);
+    const category = nativePushCategory(delivery.payload);
+    const body = JSON.stringify({
+      aps: {
+        alert,
+        sound: "default",
+        "thread-id": delivery.payload.sessionId,
+        "interruption-level": nativePushInterruptionLevel(delivery.payload),
+        ...category ? { category } : {}
+      },
+      body: nativePushData(delivery.payload)
+    });
+    return await new Promise((resolve) => {
+      const request = session(host).request({
+        ":method": "POST",
+        ":path": `/3/device/${delivery.token}`,
+        authorization: `bearer ${bearer()}`,
+        "apns-topic": delivery.appId,
+        "apns-push-type": "alert",
+        "apns-priority": "10",
+        "apns-collapse-id": `${delivery.payload.sessionId}:${delivery.payload.rule}`.slice(0, 64),
+        "content-type": "application/json"
+      });
+      let status = 0;
+      let text = "";
+      request.setTimeout(1e4, () => request.close());
+      request.on("response", (headers) => {
+        status = Number(headers[":status"] ?? 0);
+      });
+      request.on("data", (chunk) => {
+        text += chunk.toString("utf8");
+      });
+      request.on("error", (error) => resolve({ outcome: "retry", error: String(error) }));
+      request.on("close", () => {
+        if (status === 200) return resolve({ outcome: "delivered" });
+        const reason = (() => {
+          try {
+            return JSON.parse(text).reason ?? text;
+          } catch {
+            return text || `status ${status}`;
+          }
+        })();
+        if (status === 410 || reason === "BadDeviceToken" || reason === "Unregistered") {
+          return resolve({ outcome: "unregistered", error: `${status} ${reason}` });
+        }
+        resolve({
+          outcome: status === 429 || status >= 500 || status === 0 ? "retry" : "failed",
+          error: `${status} ${reason}`
+        });
+      });
+      request.end(body);
+    });
+  };
+}
+function createFcmSender(input) {
+  const account = JSON.parse(input.serviceAccountJson);
+  const http = input.fetch ?? fetch;
+  let access = null;
+  const accessToken = async () => {
+    if (access && access.expiresAt - 6e4 > Date.now()) return access.token;
+    const now = Math.floor(Date.now() / 1e3);
+    const tokenUri = account.token_uri ?? "https://oauth2.googleapis.com/token";
+    const assertion = signJwt(
+      { alg: "RS256", typ: "JWT" },
+      {
+        iss: account.client_email,
+        scope: "https://www.googleapis.com/auth/firebase.messaging",
+        aud: tokenUri,
+        iat: now,
+        exp: now + 3600
+      },
+      pem(account.private_key),
+      "RS256"
+    );
+    const response = await http(tokenUri, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        assertion
+      })
+    });
+    if (!response.ok) throw new Error(`FCM token exchange failed: ${response.status}`);
+    const json = await response.json();
+    access = { token: json.access_token, expiresAt: Date.now() + json.expires_in * 1e3 };
+    return access.token;
+  };
+  return async (delivery) => {
+    try {
+      const alert = nativePushAlert(delivery.payload);
+      const response = await http(
+        `https://fcm.googleapis.com/v1/projects/${account.project_id}/messages:send`,
+        {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${await accessToken()}`,
+            "content-type": "application/json"
+          },
+          body: JSON.stringify({
+            message: {
+              token: delivery.token,
+              android: { priority: "HIGH", collapse_key: delivery.payload.sessionId },
+              data: {
+                title: alert.title,
+                message: [alert.subtitle, alert.body].filter(Boolean).join("\n") || alert.title,
+                body: JSON.stringify(nativePushData(delivery.payload))
+              }
+            }
+          }),
+          signal: AbortSignal.timeout(1e4)
+        }
+      );
+      if (response.ok) return { outcome: "delivered" };
+      const text = await response.text();
+      if (response.status === 404 || text.includes("UNREGISTERED")) {
+        return { outcome: "unregistered", error: `${response.status} ${text.slice(0, 200)}` };
+      }
+      return {
+        outcome: response.status === 429 || response.status >= 500 ? "retry" : "failed",
+        error: `${response.status} ${text.slice(0, 200)}`
+      };
+    } catch (error) {
+      return { outcome: "retry", error: String(error).slice(0, 300) };
+    }
+  };
+}
+function configuredNativePushSenders(settings) {
+  const senders = {};
+  if (settings.apnsKeyId && settings.apnsTeamId && settings.apnsPrivateKey) {
+    senders.ios = createApnsSender({
+      keyId: settings.apnsKeyId,
+      teamId: settings.apnsTeamId,
+      privateKey: settings.apnsPrivateKey
+    });
+  }
+  if (settings.fcmServiceAccountJson) {
+    senders.android = createFcmSender({ serviceAccountJson: settings.fcmServiceAccountJson });
+  }
+  return senders;
+}
+async function drainNativePushDeliveries(deps) {
+  const senders = deps.senders ?? configuredNativePushSenders(deps.settings);
+  const claimId = randomUUID();
+  const claimed = await markSecretQuestionDeliveries(
+    deps.db,
+    await claimNativePushDeliveries(deps.db, {
+      claimId,
+      limit: 32,
+      claimSeconds: CLAIM_SECONDS
+    })
+  );
+  let delivered = 0;
+  await Promise.all(
+    claimed.map(async (delivery) => {
+      const sender = senders[delivery.platform];
+      const result = sender ? await sender(delivery).catch((error) => ({
+        outcome: "retry",
+        error: String(error)
+      })) : { outcome: "failed", error: `No ${delivery.platform} push credentials configured` };
+      const outcome = result.outcome === "retry" && delivery.attempts >= MAX_ATTEMPTS ? "failed" : result.outcome;
+      if (outcome === "delivered") delivered += 1;
+      else
+        deps.observability?.warn("Native push not delivered", {
+          platform: delivery.platform,
+          outcome,
+          error: result.error
+        });
+      await settleNativePushDelivery(deps.db, {
+        claimId,
+        deliveryId: delivery.deliveryId,
+        outcome,
+        error: result.error ?? null,
+        retrySeconds: Math.min(3600, 5 * 2 ** delivery.attempts)
+      });
+    })
+  );
+  return { claimed: claimed.length, delivered };
+}
+function startNativePushDispatchPump(deps) {
+  const senders = deps.senders ?? configuredNativePushSenders(deps.settings);
+  let stopped = false;
+  let ticks = 0;
+  let running = null;
+  const tick = async () => {
+    ticks += 1;
+    try {
+      const { claimed } = await drainNativePushDeliveries({ ...deps, senders });
+      if (claimed > 0) deps.observability?.info("Native push batch", { claimed });
+      if (ticks % PRUNE_EVERY_TICKS === 0) await pruneNativePushDeliveries(deps.db);
+    } catch (error) {
+      deps.observability?.error("Native push dispatch failed", { error: String(error) });
+    }
+  };
+  const timer = setInterval(() => {
+    if (stopped || running) return;
+    running = tick().finally(() => {
+      running = null;
+    });
+  }, POLL_INTERVAL_MS);
+  return async () => {
+    stopped = true;
+    clearInterval(timer);
+    await running;
+  };
+}
+
+// src/workspace-webhook-dispatch.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { environmentsEncryptionKeyBytes } from "@opengeni/config";
+import {
+  OPENGENI_DELIVERY_ID_HEADER,
+  OPENGENI_EVENT_ID_HEADER,
+  OPENGENI_SIGNATURE_HEADER,
+  signOpenGeniPayload
+} from "@opengeni/contracts";
+import {
+  claimWorkspaceWebhookDeliveries,
+  claimOrganizationWebhookDeliveries,
+  decryptEnvironmentValue,
+  maintainSessionUsageLimits,
+  maintainWorkspaceAllowances,
+  pruneOrganizationWebhookDeliveries,
+  pruneWorkspaceWebhookDeliveries,
+  settleOrganizationWebhookDelivery,
+  settleWorkspaceWebhookDelivery
+} from "@opengeni/db";
+import { pinnedFetch } from "@opengeni/network";
+import { recordSessionUsageLimitEvent } from "@opengeni/core";
+var WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE = 32;
+var CLAIM_SECONDS2 = 60;
+var POLL_INTERVAL_MS2 = 2e3;
+var DELIVERY_TIMEOUT_MS = 1e4;
+var PRUNE_EVERY_TICKS2 = 300;
+function errorText(error) {
+  if (error instanceof Error) {
+    if (error.name === "TimeoutError" || error.name === "AbortError") return "timeout";
+    return `${error.name}: ${error.message}`.slice(0, 500);
+  }
+  return String(error).slice(0, 500);
+}
+async function deliverOne(deps, key, claimId, delivery, organization = false) {
+  let status = null;
+  let error = null;
+  try {
+    const body = JSON.stringify(delivery.payload);
+    const secret = decryptEnvironmentValue(key, delivery.secretEncrypted);
+    const response = await (deps.fetch ?? pinnedFetch)(
+      delivery.url,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          "user-agent": "OpenGeni-Webhooks/1",
+          [OPENGENI_SIGNATURE_HEADER]: await signOpenGeniPayload(secret, body),
+          [OPENGENI_EVENT_ID_HEADER]: delivery.eventId,
+          [OPENGENI_DELIVERY_ID_HEADER]: delivery.deliveryId
+        },
+        body,
+        signal: AbortSignal.timeout(DELIVERY_TIMEOUT_MS)
+      },
+      deps.settings,
+      {
+        label: organization ? "Organization webhook" : "Workspace webhook",
+        requireHttpsOutsideLocalTest: true
+      }
+    );
+    status = response.status;
+    await response.body?.cancel().catch(() => void 0);
+    if (status < 200 || status >= 300) error = `HTTP ${status}`;
+  } catch (caught) {
+    error = errorText(caught);
+  }
+  await (organization ? settleOrganizationWebhookDelivery : settleWorkspaceWebhookDelivery)(
+    deps.db,
+    {
+      deliveryId: delivery.deliveryId,
+      claimId,
+      status,
+      error
+    }
+  );
+  return error === null ? "delivered" : "failed";
+}
+async function importLegacySessionUsage(deps) {
+  const sink = deps.observability?.incrementCounter ? deps.observability : null;
+  const metrics = sink;
+  try {
+    const result = await maintainSessionUsageLimits(deps.db);
+    recordSessionUsageLimitEvent(metrics, "import", "imported", result.processed);
+    recordSessionUsageLimitEvent(metrics, "import", "import_failed", result.failed);
+    recordSessionUsageLimitEvent(metrics, "single_call", "lost_resolved", result.resolvedLost);
+    if (result.failed > 0) {
+      deps.observability?.warn("Session usage limit import pages failed", {
+        failed: result.failed,
+        sqlstates: JSON.stringify(result.errors)
+      });
+    }
+  } catch (error) {
+    recordSessionUsageLimitEvent(metrics, "import", "import_failed");
+    deps.observability?.warn("Session usage limit import failed", { error: errorText(error) });
+  }
+}
+async function drainWorkspaceWebhookDeliveries(deps) {
+  await importLegacySessionUsage(deps);
+  await maintainWorkspaceAllowances(deps.db);
+  const key = environmentsEncryptionKeyBytes(deps.settings);
+  if (!key) return { claimed: 0, delivered: 0, failed: 0 };
+  const claimId = randomUUID2();
+  const claims = await claimWorkspaceWebhookDeliveries(deps.db, {
+    claimId,
+    limit: WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE,
+    claimSeconds: CLAIM_SECONDS2
+  });
+  const organizationClaims = await claimOrganizationWebhookDeliveries(deps.db, {
+    claimId,
+    limit: WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE,
+    claimSeconds: CLAIM_SECONDS2
+  });
+  const outcomes = await Promise.all(
+    [
+      ...claims.map((delivery) => ({ delivery, organization: false })),
+      ...organizationClaims.map((delivery) => ({ delivery, organization: true }))
+    ].map(async ({ delivery, organization }) => {
+      try {
+        return await deliverOne(deps, key, claimId, delivery, organization);
+      } catch (error) {
+        deps.observability?.warn("Workspace webhook settlement failed", {
+          deliveryId: delivery.deliveryId,
+          error: errorText(error)
+        });
+        return "failed";
+      }
+    })
+  );
+  return {
+    claimed: claims.length + organizationClaims.length,
+    delivered: outcomes.filter((outcome) => outcome === "delivered").length,
+    failed: outcomes.filter((outcome) => outcome === "failed").length
+  };
+}
+function startWorkspaceWebhookDispatchPump(deps, options = {}) {
+  const intervalMs = Math.max(100, options.intervalMs ?? POLL_INTERVAL_MS2);
+  const drain = options.drain ?? drainWorkspaceWebhookDeliveries;
+  let stopped = false;
+  let running;
+  let ticks = 0;
+  const tick = () => {
+    if (stopped || running) return;
+    ticks += 1;
+    let backlog = false;
+    running = (async () => {
+      const result = await drain(deps);
+      backlog = result.claimed >= WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE;
+      if (result.claimed > 0) deps.observability?.info("Workspace webhook batch settled", result);
+      if (ticks % PRUNE_EVERY_TICKS2 === 0) {
+        await pruneWorkspaceWebhookDeliveries(deps.db);
+        await pruneOrganizationWebhookDeliveries(deps.db);
+      }
+    })().catch((error) => {
+      deps.observability?.error("Workspace webhook dispatch failed", { error: errorText(error) });
+    }).finally(() => {
+      running = void 0;
+      if (backlog && !stopped) queueMicrotask(tick);
+    });
+  };
+  const timer = setInterval(tick, intervalMs);
+  queueMicrotask(tick);
+  return async () => {
+    stopped = true;
+    clearInterval(timer);
+    await running;
+  };
+}
+
 // src/editable-artifact-websocket.ts
 import {
   EditableArtifactDomainError,
@@ -1019,8 +1983,9 @@ var EDITABLE_ARTIFACT_LIVE_WEBSOCKET_MAX_MESSAGE_BYTES = 8 * 1024 * 1024 + 64 *
 var MAX_QUEUED_MESSAGES = 64;
 var MAX_QUEUED_BYTES = 12 * 1024 * 1024;
 var EditableArtifactWebSocketTransport = class {
-  constructor(application) {
+  constructor(application, authorizeSourceSession) {
     this.application = application;
+    this.authorizeSourceSession = authorizeSourceSession;
     this.websocket = Object.freeze({
       open: (socket) => socket.data.attach(socket),
       message: (socket, message) => socket.data.receive(message),
@@ -1044,7 +2009,10 @@ var EditableArtifactWebSocketTransport = class {
     if (!offeredProtocol(request.headers.get("sec-websocket-protocol"))) {
       return new Response("WebSocket protocol required", { status: 426 });
     }
-    const connection = new EditableArtifactWebSocketConnection(this.application);
+    const connection = new EditableArtifactWebSocketConnection(
+      this.application,
+      this.authorizeSourceSession
+    );
     const upgraded = server.upgrade(request, {
       data: connection,
       headers: {
@@ -1055,8 +2023,9 @@ var EditableArtifactWebSocketTransport = class {
   }
 };
 var EditableArtifactWebSocketConnection = class {
-  constructor(application) {
+  constructor(application, authorizeSourceSession) {
     this.application = application;
+    this.authorizeSourceSession = authorizeSourceSession;
   }
   socket = null;
   session = null;
@@ -1142,7 +2111,8 @@ var EditableArtifactWebSocketConnection = class {
         artifactId: frame.artifactId,
         protocolVersion: frame.protocolVersion,
         resume: frame.resume,
-        sink: this
+        sink: this,
+        ...this.authorizeSourceSession ? { authorizeSourceSession: this.authorizeSourceSession } : {}
       });
       if (this.terminal) {
         await session.close("transport_error");
@@ -1249,14 +2219,121 @@ function closeCode(reason) {
   return 4400;
 }
 
+// src/editable-artifact-source-session.ts
+import {
+  hasPermission,
+  requireExternalContinuationAuthority,
+  requireSessionAuthorization
+} from "@opengeni/core";
+import {
+  findActiveWorkspaceApiKeyById,
+  getSession,
+  getWorkspaceGrant,
+  hasEditableArtifactSessionLink,
+  lockExternalWorkspaceMembershipLifecycle,
+  withRlsContext
+} from "@opengeni/db";
+function editableArtifactSourceSessionAuthorizer(deps) {
+  return async (ticket, permission, transaction, signal) => {
+    signal?.throwIfAborted();
+    const authority = ticket.sourceSessionAuthority;
+    if (!authority) return true;
+    const { grant } = authority;
+    const required = permission === "edit" ? "artifacts:publish" : "artifacts:read";
+    if (!hasPermission(grant.permissions, required) || !hasPermission(grant.permissions, "sessions:read")) {
+      return false;
+    }
+    if (grant.metadata?.externalActor && !authority.externalContinuation) return false;
+    try {
+      const scopedDeps = transaction ? { ...deps, db: transaction } : deps;
+      if (transaction) {
+        await lockExternalWorkspaceMembershipLifecycle(transaction, ticket.scope.accountId);
+        signal?.throwIfAborted();
+        await transaction.execute(sql`select pg_advisory_xact_lock_shared(
+          hashtextextended(${`session-tenancy:${ticket.scope.workspaceId}`}, 0))`);
+        signal?.throwIfAborted();
+      }
+      return await withAccessGrantSessionRlsContext(scopedDeps, grant, async () => {
+        return await withRlsContext(scopedDeps.db, ticket.scope, async (tx) => {
+          if (authority.externalContinuation) {
+            await requireExternalContinuationAuthority(
+              tx,
+              authority.externalContinuation,
+              { ...ticket.scope, subjectId: grant.subjectId },
+              ["sessions:read", required]
+            );
+            signal?.throwIfAborted();
+          } else if (transaction) {
+            const actor = ticket.actor;
+            if (actor.kind === "human" || actor.kind === "service" && actor.service === "configured_key") {
+              await tx.execute(sql`select subject_id from workspace_memberships
+                where account_id = ${ticket.scope.accountId}::uuid
+                  and workspace_id = ${ticket.scope.workspaceId}::uuid
+                  and subject_id = ${grant.subjectId} for share`);
+              const live = await getWorkspaceGrant(tx, grant.subjectId, ticket.scope.workspaceId);
+              if (!live || !hasPermission(live.permissions, "sessions:read")) return false;
+            } else if (actor.kind === "service" && actor.service === "api_key") {
+              await tx.execute(sql`select id from api_keys
+                where account_id = ${ticket.scope.accountId}::uuid
+                  and id::text = ${grant.subjectId.slice("api_key:".length)}
+                for share`);
+              const live = await findActiveWorkspaceApiKeyById(tx, {
+                ...ticket.scope,
+                apiKeyId: grant.subjectId.slice("api_key:".length)
+              });
+              if (!live || !hasPermission(live.permissions, "sessions:read")) return false;
+            } else if (actor.kind === "agent") {
+              const live = await getSession(tx, ticket.scope.workspaceId, actor.sessionId);
+              if (!live || live.firstPartyMcpPermissions !== null && !hasPermission(live.firstPartyMcpPermissions, "sessions:read")) {
+                return false;
+              }
+            } else {
+              return false;
+            }
+            signal?.throwIfAborted();
+          }
+          const linked = await hasEditableArtifactSessionLink(
+            tx,
+            ticket.scope,
+            authority.sessionId,
+            ticket.artifactId,
+            { lockForCommit: transaction !== void 0 }
+          );
+          signal?.throwIfAborted();
+          if (!linked) return false;
+          await requireSessionAuthorization({ ...scopedDeps, db: tx }, grant, {
+            sessionId: authority.sessionId,
+            operation: "session.read",
+            surface: "http"
+          });
+          signal?.throwIfAborted();
+          return true;
+        });
+      });
+    } catch {
+      return false;
+    }
+  };
+}
+
+// src/http/websocket-upgrade-dispatch.ts
+function dispatchApiWebSocketUpgrade(request, server, routes, localBrowserBoundary) {
+  const route = routes.find((candidate) => candidate.handles(request));
+  if (!route) return { handled: false };
+  const rejection = localBrowserBoundary?.rejection(request);
+  if (rejection) return { handled: true, response: localBrowserBoundaryResponse(rejection) };
+  return { handled: true, response: route.upgrade(request, server) };
+}
+
 // src/editable-artifact-production.ts
-import { createHash as createHash4, randomUUID } from "crypto";
+import { createHash as createHash5, randomUUID as randomUUID3 } from "crypto";
 import {
   editableArtifactMaterializerCapabilitiesForRuntime
 } from "@opengeni/artifact-tool/runtime/materializer";
 import {
   EditableArtifactDurableExportService,
   EditableArtifactAgentApplication,
+  EDITABLE_ARTIFACT_EXPORT_FORMATS,
   EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES,
   EditableArtifactCompactionPipeline,
   EditableArtifactGenesisPipeline,
@@ -1286,8 +2363,9 @@ import {
   PostgresEditableArtifactStore,
   listEditableArtifactIdsForSession,
   touchEditableArtifactSessionLink,
+  recordNativeDocumentInspection,
   dbSql,
-  withRlsContext
+  withRlsContext as withRlsContext2
 } from "@opengeni/db";
 import { PostgresEditableArtifactDurableExportStore } from "@opengeni/db/editable-artifact-durable-export";
 import {
@@ -1351,7 +2429,7 @@ async function requireFlushBarrier(connection) {
 }
 
 // src/editable-artifact-native-kernel.ts
-import { createHash } from "crypto";
+import { createHash as createHash2 } from "crypto";
 import { pathToFileURL } from "url";
 import {
   createNativeArtifactSession,
@@ -1475,7 +2553,7 @@ var NativeEditableArtifactKernelAdapter = class {
         canonicalChunks: fixedChunks(snapshot, input.signal),
         canonicalByteSize: snapshot.byteLength,
         canonicalContentHash: editableArtifactContentHash(
-          `sha256:${createHash("sha256").update(snapshot).digest("hex")}`
+          `sha256:${createHash2("sha256").update(snapshot).digest("hex")}`
         ),
         stateHash: editableArtifactStateHash(session.stateHash()),
         coveredHeadSequence: 0,
@@ -1522,7 +2600,7 @@ var NativeEditableArtifactKernelAdapter = class {
         canonicalChunks: fixedChunks(canonical, input.signal),
         canonicalByteSize: canonical.byteLength,
         canonicalContentHash: editableArtifactContentHash(
-          `sha256:${createHash("sha256").update(canonical).digest("hex")}`
+          `sha256:${createHash2("sha256").update(canonical).digest("hex")}`
         ),
         stateHash: editableArtifactStateHash(session.stateHash()),
         coveredHeadSequence: input.state.artifact.headSequence,
@@ -1569,7 +2647,7 @@ var NativeEditableArtifactKernelAdapter = class {
       const stateHash = editableArtifactStateHash(session.stateHash());
       if (stateHash !== expected.stateHash) throw new Error("Snapshot state hash mismatch");
       const canonicalContentHash = editableArtifactContentHash(
-        `sha256:${createHash("sha256").update(canonical).digest("hex")}`
+        `sha256:${createHash2("sha256").update(canonical).digest("hex")}`
       );
       if (session.modality === "spreadsheet") {
         const coveredCausalFrontier = domainFrontier(session.frontier());
@@ -1785,7 +2863,7 @@ async function readVerifiedSnapshot(objects, snapshot, signal) {
       snapshot.byteSize,
       signal
     );
-    const contentHash = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+    const contentHash = `sha256:${createHash2("sha256").update(bytes).digest("hex")}`;
     if (contentHash !== snapshot.contentHash) throw new Error("Snapshot content hash mismatch");
     await object.assertUnchanged(signal);
     return bytes;
@@ -1821,7 +2899,7 @@ async function* fixedChunks(bytes, signal) {
   }
 }
 function namespaceForArtifact(artifactId) {
-  const digest = createHash("sha256").update(artifactId).digest();
+  const digest = createHash2("sha256").update(artifactId).digest();
   let value = 0n;
   for (let index = 0; index < 8; index += 1) value = value << 8n | BigInt(digest[index]);
   return value === 0n ? 1n : value;
@@ -1845,7 +2923,7 @@ function throwIfAborted(signal) {
 }
 
 // src/editable-artifact-office-import.ts
-import { createHash as createHash2 } from "crypto";
+import { createHash as createHash3 } from "crypto";
 import {
   ArtifactOfficeSourceUnsupportedError,
   prepareArtifactOfficeImport
@@ -2011,7 +3089,7 @@ async function readVerifiedWorkspaceFile(storage, file, signal) {
     throw new EditableArtifactOfficeImportError("source_changed");
   }
   const bytes = new Uint8Array(file.sizeBytes);
-  const digest = createHash2("sha256");
+  const digest = createHash3("sha256");
   for (let start = 0; start < file.sizeBytes; start += MAX_BOUNDED_OBJECT_CHUNK_BYTES) {
     throwIfAborted2(signal);
     const end = Math.min(file.sizeBytes, start + MAX_BOUNDED_OBJECT_CHUNK_BYTES) - 1;
@@ -2072,7 +3150,7 @@ function throwIfAborted2(signal) {
 }
 
 // src/editable-artifact-workspace-files.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 import { completeFileUpload, prepareGeneratedWorkspaceFile } from "@opengeni/db";
 import { retryWhileMissing as retryWhileMissing2 } from "@opengeni/storage";
 var UPLOAD_INTENT_TTL_MS = 60 * 6e4;
@@ -2208,7 +3286,7 @@ function plainSha256(value) {
   return match[1];
 }
 function deterministicUuid(seed) {
-  const bytes = createHash3("sha256").update(seed, "utf8").digest().subarray(0, 16);
+  const bytes = createHash4("sha256").update(seed, "utf8").digest().subarray(0, 16);
   bytes[6] = (bytes[6] ?? 0) & 15 | 80;
   bytes[8] = (bytes[8] ?? 0) & 63 | 128;
   const hex = bytes.toString("hex");
@@ -2297,6 +3375,11 @@ async function createStandaloneEditableArtifactApplication(input) {
       touch: async ({ scope, sessionId, artifactId }) => await touchEditableArtifactSessionLink(input.db, scope, sessionId, artifactId)
     }),
     inspector: kernel,
+    recordInspection: async (inspection) => {
+      if (inspection.actor.kind !== "agent")
+        throw new Error("Inspection proof requires an agent attempt");
+      return recordNativeDocumentInspection(input.db, { ...inspection, actor: inspection.actor });
+    },
     officeImports,
     workspaceFiles: new EditableArtifactWorkspaceFileAdapter({
       db: input.db,
@@ -2355,7 +3438,7 @@ var PostgresEditableArtifactAuthorization = class {
   }
   async authorize(request) {
     const actor = request.actor;
-    const rows = await withRlsContext(
+    const rows = await withRlsContext2(
       this.db,
       request.scope,
       async (tx) => rawRows(
@@ -2433,12 +3516,12 @@ var PollingEditableArtifactAuthorizationInvalidations = class {
 };
 var RandomEditableArtifactStableIds = class {
   next(_kind) {
-    return randomUUID().replaceAll("-", "");
+    return randomUUID3().replaceAll("-", "");
   }
 };
 var RandomEditableArtifactDurableExportIds = class {
   next(_kind) {
-    return randomUUID().replaceAll("-", "");
+    return randomUUID3().replaceAll("-", "");
   }
 };
 function materializationProfiles(capabilities) {
@@ -2448,8 +3531,9 @@ function materializationProfiles(capabilities) {
   }
   const codecVersion = capabilities.codecVersions["opengeni.xlsx"];
   return Object.freeze({
+    supportedFormats: EDITABLE_ARTIFACT_EXPORT_FORMATS,
     async resolve(input) {
-      if (input.modality !== "spreadsheet" || input.format !== "xlsx" || Object.keys(input.options).length !== 0) {
+      if (input.modality !== "spreadsheet" || input.format !== "xlsx" || !EDITABLE_ARTIFACT_EXPORT_FORMATS[input.modality].includes(input.format) || Object.keys(input.options).length !== 0) {
         return null;
       }
       return Object.freeze({
@@ -2478,7 +3562,7 @@ function snapshotBytesPort(objects) {
           throw new Error("Editable artifact snapshot content type mismatch");
         }
         const bytes = new Uint8Array(snapshot.byteSize);
-        const digest = createHash4("sha256");
+        const digest = createHash5("sha256");
         let offset = 0;
         for await (const chunk of object.chunks({
           chunkBytes: MAX_BOUNDED_OBJECT_CHUNK_BYTES2
@@ -2509,7 +3593,8 @@ function rawRows(result) {
 }
 
 // src/fatal-process-boundary.ts
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
+import { isDatabaseConnectionLoss } from "@opengeni/db";
 var API_FATAL_FLUSH_TIMEOUT_MS = 1e3;
 var API_FATAL_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
 var FATAL_ERROR_CODES = {
@@ -2520,19 +3605,69 @@ var FATAL_ERROR_CODES = {
 function installApiFatalProcessBoundary(options = {}) {
   const runtimeProcess = options.process ?? defaultProcessBoundary();
   const flushTimeoutMs = options.flushTimeoutMs ?? API_FATAL_FLUSH_TIMEOUT_MS;
-  const correlationId = options.correlationId ?? (() => `api-fatal.${randomUUID2()}`);
+  const correlationId = options.correlationId ?? (() => `api-fatal.${randomUUID4()}`);
   const fallbackLog = options.fallbackLog ?? ((message) => console.error(message));
+  const isRecoverableRejection = options.isRecoverableRejection ?? isDatabaseConnectionLoss;
   let observability = options.observability;
   let phase = "startup";
   let reporting = false;
+  const recover = (reason) => {
+    if (phase !== "running" || reporting) return false;
+    let recoverable = false;
+    try {
+      recoverable = isRecoverableRejection(reason);
+    } catch {
+      return false;
+    }
+    if (!recoverable) return false;
+    const attributes = {
+      errorClass: "ApiRecoveredRejection",
+      errorCode: "api_unhandled_database_connection_loss",
+      origin: "api",
+      reasonKind: apiFatalReasonKind(reason)
+    };
+    try {
+      if (observability?.warn) {
+        observability.warn(
+          "Opengeni API recovered an unhandled database connection loss",
+          attributes
+        );
+      } else {
+        safeFallbackLog(
+          fallbackLog,
+          "Opengeni API recovered an unhandled database connection loss (api_unhandled_database_connection_loss)"
+        );
+      }
+      observability?.incrementCounter?.({
+        name: "opengeni_api_recovered_rejections_total",
+        help: "Unhandled rejections the API survived because they only reported a lost database connection.",
+        labels: { code: "api_unhandled_database_connection_loss" }
+      });
+    } catch {
+    }
+    return true;
+  };
   const report = async (event, reason) => {
     if (reporting) return;
     reporting = true;
     const diagnostic = apiFatalDiagnostic(event, phase, reason, correlationId);
-    const message = apiFatalMessage(diagnostic);
+    let message = apiFatalMessage(diagnostic);
     const activeObservability = observability;
     try {
       if (activeObservability) {
+        try {
+          const diagnosticId = activeObservability.recordFailureDiagnostic?.({
+            code: FATAL_ERROR_CODES[event],
+            stage: phase,
+            retryDecision: "not_retryable",
+            error: reason
+          });
+          if (diagnosticId) {
+            diagnostic.correlationId = diagnosticId;
+            message = apiFatalMessage(diagnostic);
+          }
+        } catch {
+        }
         let logged = false;
         try {
           activeObservability.error(message, diagnostic);
@@ -2556,6 +3691,7 @@ function installApiFatalProcessBoundary(options = {}) {
     }
   };
   const onUnhandledRejection = (reason) => {
+    if (recover(reason)) return;
     void report("unhandled_rejection", reason);
   };
   const onUncaughtException = (reason) => {
@@ -2608,7 +3744,7 @@ function apiFatalReasonKind(reason) {
   }
 }
 function apiFatalMessage(diagnostic) {
-  return `OpenGeni API fatal process failure (${diagnostic.errorCode}; phase=${diagnostic.phase}; reason_kind=${diagnostic.reasonKind}; correlation_id=${diagnostic.correlationId})`;
+  return `Opengeni API fatal process failure (${diagnostic.errorCode}; phase=${diagnostic.phase}; reason_kind=${diagnostic.reasonKind}; correlation_id=${diagnostic.correlationId})`;
 }
 async function flushWithin(observability, timeoutMs) {
   let flush;
@@ -2682,6 +3818,26 @@ async function createTemporalWorkflowClient(settings, db) {
     connection,
     namespace: settings.temporalNamespace
   });
+  const scheduledTasks = createTemporalScheduleSynchronizer({
+    db,
+    withDeadline: (deadline, work) => temporal.withDeadline(deadline, work),
+    upsert: async (task) => {
+      const options = temporalScheduleOptions(task, settings.temporalTaskQueue);
+      try {
+        await temporal.schedule.getHandle(task.temporalScheduleId).update(() => temporalScheduleUpdateOptions(options));
+      } catch (error) {
+        if (!shouldCreateScheduleAfterUpdateError(error)) throw error;
+        await temporal.schedule.create(options);
+      }
+    },
+    remove: async (temporalScheduleId) => {
+      try {
+        await temporal.schedule.getHandle(temporalScheduleId).delete();
+      } catch (error) {
+        if (!(error instanceof ScheduleNotFoundError)) throw error;
+      }
+    }
+  });
   const client = {
     triggerAutomationRun: async ({ accountId, workspaceId, runId }) => {
       try {
@@ -2725,7 +3881,13 @@ async function createTemporalWorkflowClient(settings, db) {
       });
     },
     requestSessionWorkflowWakeDispatch: async () => {
-      await temporal.schedule.getHandle(SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID).trigger(ScheduleOverlapPolicy.BUFFER_ONE);
+      await temporal.workflow.signalWithStart(SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE, {
+        taskQueue: settings.temporalTaskQueue,
+        workflowId: SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_ID,
+        workflowIdReusePolicy: "ALLOW_DUPLICATE",
+        args: [],
+        signal: SESSION_WORKFLOW_WAKE_DISPATCH_REQUESTED_SIGNAL
+      });
     },
     signalCodexCapacity: async ({
       accountId,
@@ -2775,41 +3937,14 @@ async function createTemporalWorkflowClient(settings, db) {
         wakeRevision: workflowWakeRevision
       });
     },
-    syncScheduledTask: async ({ task }) => {
-      const schedule = temporal.schedule.getHandle(task.temporalScheduleId);
-      if (task.schedule.type === "manual") {
-        try {
-          await schedule.delete();
-        } catch (error) {
-          if (!(error instanceof ScheduleNotFoundError)) throw error;
-        }
-        return;
-      }
-      const options = temporalScheduleOptions(task, settings.temporalTaskQueue);
-      try {
-        await schedule.update(() => temporalScheduleUpdateOptions(options));
-      } catch (error) {
-        if (!shouldCreateScheduleAfterUpdateError(error)) {
-          throw error;
-        }
-        await temporal.schedule.create(options);
-      }
-    },
-    deleteScheduledTaskSchedule: async ({ temporalScheduleId }) => {
-      try {
-        await temporal.withDeadline(Date.now() + 5e3, async () => {
-          await temporal.schedule.getHandle(temporalScheduleId).delete();
-        });
-      } catch (error) {
-        if (error instanceof ScheduleNotFoundError) return;
-        throw error;
-      }
-    },
+    syncScheduledTask: async ({ task, onFailure }) => scheduledTasks.sync(task, onFailure),
+    deleteScheduledTaskSchedule: async ({ temporalScheduleId }) => scheduledTasks.remove(temporalScheduleId),
     triggerScheduledTask: async ({
       task,
       agentRunUsageIdempotencyKey,
       triggerWorkflowId,
       initiator,
+      credentialRestriction,
       triggerType = "manual"
     }) => {
       const workflowId = triggerWorkflowId;
@@ -2825,7 +3960,8 @@ async function createTemporalWorkflowClient(settings, db) {
               taskId: task.id,
               triggerType,
               agentRunUsageIdempotencyKey,
-              initiator
+              initiator,
+              ...credentialRestriction ? { credentialRestriction } : {}
             }
           ]
         });
@@ -2839,7 +3975,7 @@ async function createTemporalWorkflowClient(settings, db) {
     startRigVerification: async ({ workspaceId, changeId, versionId, workflowId }) => {
       const targetId = changeId ?? versionId;
       if (!targetId) {
-        throw new Error("rig verification requires changeId or versionId");
+        throw new Error("sandbox environment verification requires changeId or versionId");
       }
       try {
         await temporal.workflow.start("rigVerificationWorkflow", {
@@ -2887,7 +4023,7 @@ async function startApi(options = {}) {
   const observability = options.observability ?? createObservability(settings, { component: "api" });
   const searchPath = dbSearchPath(settings);
   const dbClient = createDb(settings.databaseUrl, {
-    max: 32,
+    max: settings.apiDatabasePoolMax,
     ...searchPath ? { searchPath } : {},
     rlsStrategy: settings.rlsStrategy
   });
@@ -2898,8 +4034,7 @@ async function startApi(options = {}) {
   const databasePosture = {
     rlsStrategy: settings.rlsStrategy,
     expectedRole: settings.runtimeDatabaseRole,
-    targetSchema: settings.dbSchema.trim() || "public",
-    organizationTenancyCanonicalActivationEnabled: settings.organizationTenancyCanonicalActivationEnabled
+    targetSchema: settings.dbSchema.trim() || "public"
   };
   const controlPlaneAuth = resolveNatsControlPlaneAuth(settings);
   try {
@@ -2912,14 +4047,14 @@ async function startApi(options = {}) {
     await retryStartupDependency(
       "PostgreSQL runtime posture",
       () => assertRuntimeDatabasePosture(dbClient.db, databasePosture),
-      { ...retryOptions, onRetry }
+      { ...retryOptions, onRetry, shouldRetry: isRetryableRuntimeDatabaseStartupError }
     );
     const resolvedCatalog = await retryStartupDependency(
       "model catalog",
       () => resolveCatalogSettings(dbClient.db, settings),
       { ...retryOptions, onRetry }
     );
-    observability.info("OpenGeni model catalog resolved", {
+    observability.info("Opengeni model catalog resolved", {
       catalogSource: resolvedCatalog.source,
       catalogVersion: resolvedCatalog.version
     });
@@ -2928,7 +4063,7 @@ async function startApi(options = {}) {
       () => createNatsEventBus(
         settings.natsUrl,
         controlPlaneAuth ? { user: controlPlaneAuth.user, pass: controlPlaneAuth.password } : void 0,
-        { logger: observabilityEventLogger(observability) }
+        observabilityEventBusOptions(observability)
       ),
       {
         ...retryOptions,
@@ -2949,7 +4084,7 @@ async function startApi(options = {}) {
   }
   if (!bus || !workflowClient) {
     await dbClient.close();
-    throw new Error("OpenGeni API startup dependencies were not initialized");
+    throw new Error("Opengeni API startup dependencies were not initialized");
   }
   const objectStorage = createObjectStorage(settings);
   let editableArtifactComposition;
@@ -2967,7 +4102,6 @@ async function startApi(options = {}) {
   }
   const { app, routeDeps } = createAppComposition({
     settings,
-    connectionCredentials: createNativeRemoteMcpCredentialsPort(settings, dbClient.db),
     db: dbClient.db,
     bus,
     workflowClient: workflowClient.client,
@@ -2990,21 +4124,29 @@ async function startApi(options = {}) {
       behavior: "http_and_websocket_fail_closed"
     });
   }
-  const artifactWebSockets = new EditableArtifactWebSocketTransport(routeDeps.editableArtifacts);
+  const artifactWebSockets = new EditableArtifactWebSocketTransport(
+    routeDeps.editableArtifacts,
+    editableArtifactSourceSessionAuthorizer(routeDeps)
+  );
   const interactionFrameProxies = new InteractionFrameProxyTransport(
     resolveFirstPartyDelegationSecret(settings)
   );
+  const localBrowserBoundary = createLocalBrowserBoundary(settings, {
+    warn: (message, attributes) => observability.warn(message, attributes)
+  });
+  const webSocketUpgrades = [interactionFrameProxies, artifactWebSockets];
   const server = Bun.serve({
     hostname: settings.apiHost,
     port: settings.apiPort,
     idleTimeout: 255,
     fetch: (request, bunServer) => {
-      if (interactionFrameProxies.handles(request)) {
-        return interactionFrameProxies.upgrade(request, bunServer);
-      }
-      if (artifactWebSockets.handles(request)) {
-        return artifactWebSockets.upgrade(request, bunServer);
-      }
+      const upgrade = dispatchApiWebSocketUpgrade(
+        request,
+        bunServer,
+        webSocketUpgrades,
+        localBrowserBoundary
+      );
+      if (upgrade.handled) return upgrade.response;
       return app.fetch(
         request,
         apiRequestBindingsForTransportPeer(bunServer.requestIP(request)?.address)
@@ -3019,8 +4161,19 @@ async function startApi(options = {}) {
       close: (socket) => socket.data.transportClosed()
     }
   });
+  const metricsServer = startApiMetricsListener(settings, observability);
   const stopSlackInteractionPump = settings.slackSigningSecret ? startSlackInteractionPump(routeDeps) : void 0;
   const stopMemorySlackPublicationPump = startMemorySlackPublicationPump(routeDeps);
+  const stopWorkspaceWebhookDispatchPump = startWorkspaceWebhookDispatchPump({
+    db: dbClient.db,
+    settings,
+    observability
+  });
+  const stopNativePushDispatchPump = startNativePushDispatchPump({
+    db: dbClient.db,
+    settings,
+    observability
+  });
   const stopTemporalScheduleCleanupPump = startTemporalScheduleCleanupPump({
     db: dbClient.db,
     cleanupConnectorAuthorization: async (claim) => await cleanupScheduledTaskConnectorAuthorization(routeDeps, claim),
@@ -3029,6 +4182,12 @@ async function startApi(options = {}) {
     },
     observability
   });
+  const stopScheduledTaskLifecyclePump = startScheduledTaskLifecyclePump({
+    db: dbClient.db,
+    sync: (task) => workflowClient.client.syncScheduledTask({ task }),
+    bus,
+    observability
+  });
   let stopMetricsIngestion;
   let stopHelloIngestion;
   let authCalloutResponder;
@@ -3036,14 +4195,20 @@ async function startApi(options = {}) {
     stopMetricsIngestion = startMetricsIngestion({
       db: dbClient.db,
       bus,
-      observability
+      observability,
+      agentUpdates: createAutomaticAgentUpdater({
+        db: dbClient.db,
+        bus,
+        settings,
+        observability
+      })
     });
     stopHelloIngestion = startHelloIngestion({
       db: dbClient.db,
       bus,
       observability
     });
-    observability.info("OpenGeni machine-metrics + hello ingestion consumers started", {});
+    observability.info("Opengeni machine-metrics + hello ingestion consumers started", {});
     const callout = resolveNatsCalloutConfig(settings);
     if (callout) {
       try {
@@ -3052,7 +4217,7 @@ async function startApi(options = {}) {
           settings.natsUrl
         );
       } catch {
-        observability.error("OpenGeni NATS auth-callout responder failed to start", {
+        observability.error("Opengeni NATS auth-callout responder failed to start", {
           errorClass: "NatsAuthCalloutOperationError",
           errorCode: "nats_auth_callout_start_failed",
           origin: "api"
@@ -3060,24 +4225,30 @@ async function startApi(options = {}) {
       }
     } else {
       observability.warn(
-        "OpenGeni selfhosted enabled but the NATS auth-callout plane is not configured; selfhosted agents cannot connect",
+        "Opengeni selfhosted enabled but the NATS auth-callout plane is not configured; selfhosted agents cannot connect",
         {}
       );
     }
   }
-  observability.info("OpenGeni API listening", {
+  observability.info("Opengeni API listening", {
     host: settings.apiHost,
-    port: settings.apiPort
+    port: settings.apiPort,
+    ...metricsServer ? { metricsPort: settings.apiMetricsPort } : {}
   });
   return {
     server,
     close: async () => {
       server.stop(true);
+      metricsServer?.stop(true);
       stopSlackInteractionPump?.();
       await stopMemorySlackPublicationPump();
       stopMetricsIngestion?.();
       stopHelloIngestion?.();
       await stopTemporalScheduleCleanupPump();
+      await stopScheduledTaskLifecyclePump();
+      await stopWorkspaceWebhookDispatchPump();
+      await stopNativePushDispatchPump();
+      await routeDeps.userPresence?.close().catch(() => void 0);
       await Promise.allSettled([
         Promise.resolve(editableArtifactComposition?.close()),
         authCalloutResponder?.close(),