@opengeni/api-router 0.30.1 → 1.0.0

package/dist/index.js

@@ -1,15 +1,26 @@
 import {
+  InteractionFrameProxyTransport,
   SlackBotProviderError,
+  apiRequestBindingsForTransportPeer,
+  cleanupScheduledTaskConnectorAuthorization,
   createAppComposition,
+  createLocalBrowserBoundary,
   createOpenGeniSlackBotInteractionClient,
+  localBrowserBoundaryResponse,
+  sql,
+  startApiMetricsListener,
   startSlackInteractionPump,
-  startTemporalScheduleCleanupPump
-} from "./chunk-2PQMSRCB.js";
+  startTemporalScheduleCleanupPump,
+  withAccessGrantSessionRlsContext
+} from "./chunk-6TZ5LG3O.js";
+import "./chunk-OGQDXVXY.js";
 
 // src/index.ts
+import { scheduledTaskKnowledgeSource } from "@opengeni/contracts";
 import {
   dbSearchPath,
   getSettings,
+  resolveFirstPartyDelegationSecret,
   resolveNatsCalloutConfig,
   resolveNatsControlPlaneAuth,
   retryStartupDependency,
@@ -18,15 +29,22 @@ import {
 } from "@opengeni/config";
 import {
   assertRuntimeDatabasePosture,
+  isRetryableRuntimeDatabaseStartupError,
   createDb,
   markSessionWorkflowWakeDelivered,
   runtimeDatabaseReadyCheck
 } from "@opengeni/db";
 import { createNatsEventBus } from "@opengeni/events";
-import { createObservability, logStartupDependencyRetry } from "@opengeni/observability";
+import {
+  createObservability,
+  logStartupDependencyRetry
+} from "@opengeni/observability";
 import { createObjectStorage } from "@opengeni/storage";
 import { isArtifactRuntimeConfigured } from "@opengeni/artifact-tool/runtime/development";
-import { SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID } from "@opengeni/core";
+import {
+  resolveCatalogSettings,
+  SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID
+} from "@opengeni/core";
 import {
   Connection,
   Client as TemporalClient,
@@ -36,6 +54,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)),
@@ -64,20 +91,45 @@ function eventAttributeValue(value) {
 }
 
 // src/sandbox/auth-callout.ts
+import { createHash } from "crypto";
+import { createLogThrottle } from "@opengeni/observability";
 import {
   resolveEnrollmentSigningSecret
 } from "@opengeni/config";
 import { verifyEnrollmentBearer } from "@opengeni/contracts";
-import { getEnrollment } from "@opengeni/db";
+import { claimEnrollmentConnection, getEnrollment } from "@opengeni/db";
 import {
   createResponderConnection,
   decodeAuthRequest,
   mintAuthResponse,
   mintUserJwt,
+  parseAgentConnectionName,
   workspaceAgentPermissions
 } from "@opengeni/events";
+
+// src/sandbox/connection-authority.ts
+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 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);
@@ -104,15 +156,23 @@ async function handleAuthorizationRequest(deps, requestBytes) {
   }
   const claims = await verifyEnrollmentBearer(secret, bearer);
   if (!claims) {
-    deps.observability?.warn?.("auth-callout: rejected an invalid enrollment bearer", {});
+    warnDenial(
+      deps,
+      rejectedBearerKey(bearer),
+      "invalid_bearer",
+      "auth-callout: rejected an invalid enrollment bearer"
+    );
     return deny("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
-    });
+    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("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}`) {
@@ -121,7 +181,32 @@ async function handleAuthorizationRequest(deps, requestBytes) {
   if (enrollment.credentialGeneration !== claims.credentialGeneration) {
     return deny("enrollment credential generation mismatch");
   }
-  const permissions = workspaceAgentPermissions(claims.workspaceId);
+  const connectionInstanceId = parseAgentConnectionName(decoded.name);
+  if (!connectionInstanceId) {
+    return deny("missing or invalid agent connection instance");
+  }
+  const claim = await claimEnrollmentConnection(deps.db, {
+    workspaceId: claims.workspaceId,
+    enrollmentId: claims.enrollmentId,
+    credentialGeneration: claims.credentialGeneration,
+    connectionInstanceId,
+    leaseMs: AGENT_CONNECTION_LEASE_MS
+  });
+  if (!claim.claimed) {
+    warnDenial(
+      deps,
+      `duplicate:${claims.workspaceId}:${claims.agentId}`,
+      "duplicate_runner",
+      "auth-callout: denied a duplicate live runner",
+      { workspaceId: claims.workspaceId, agentId: claims.agentId }
+    );
+    return deny("another runner instance currently owns this enrollment");
+  }
+  const permissions = workspaceAgentPermissions(
+    claims.workspaceId,
+    claims.agentId,
+    connectionInstanceId
+  );
   const nowSeconds = Math.floor(Date.now() / 1e3);
   const userJwt = mintUserJwt({
     userPublicKey: decoded.userNkey,
@@ -145,7 +230,8 @@ async function handleAuthorizationRequest(deps, requestBytes) {
   });
   deps.observability?.info?.("auth-callout: granted a workspace-scoped NATS credential", {
     workspaceId: claims.workspaceId,
-    agentId: claims.agentId
+    agentId: claims.agentId,
+    connectionGeneration: claim.connectionGeneration
   });
   return Buffer.from(response, "utf8");
 }
@@ -157,7 +243,7 @@ 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", {
@@ -170,35 +256,132 @@ async function startAuthCalloutResponder(deps, natsUrl) {
 import {
   clearEnrollmentWentOffline,
   disconnectAttachedBrowserDevices,
+  advanceEnrollmentAgentUpdate,
   getEnrollment as getEnrollment2,
+  getLiveEnrollmentConnection,
   ingestMachineMetricsSample,
   reconcileAttachedBrowserInventory,
+  releaseEnrollmentConnection,
+  renewEnrollmentConnection,
   sessionsWithActiveOpOnEnrollment,
   setEnrollmentDisplayState,
-  setEnrollmentOpStreamState,
-  setEnrollmentWentOffline,
-  touchEnrollmentLastSeen
+  setEnrollmentAgentRuntime,
+  setEnrollmentOpStreamState
 } from "@opengeni/db";
 import {
   AttachedBrowserInventorySnapshot as AttachedBrowserInventoryContract
 } from "@opengeni/contracts";
 import { appendAndPublishEvents } from "@opengeni/events";
+import { normalizeConnectedMachineWorkspaceRoot } from "@opengeni/runtime/sandbox";
 import {
   AgentEvent,
+  AgentUpdateStage,
   Arch,
   GoingOfflineReason,
   Hello,
   Os,
   goingOfflineReasonToJSON
 } from "@opengeni/agent-proto";
-var AGENT_EVENTS_SUBJECT = "agent.*.*.events";
-var AGENT_HELLO_SUBJECT = "agent.*.*.hello";
+var AGENT_EVENTS_SUBJECT = "agent.*.*.connection.*.events";
+var AGENT_HELLO_SUBJECT = "agent.*.*.connection.*.hello";
+function payloadIsHeartbeat(payload) {
+  try {
+    return AgentEvent.decode(payload).event?.$case === "heartbeat";
+  } catch {
+    return false;
+  }
+}
+function createAgentEventIngestionScheduler(handler, options = {}) {
+  const maxConcurrentSubjects = options.maxConcurrentSubjects ?? 32;
+  if (!Number.isSafeInteger(maxConcurrentSubjects) || maxConcurrentSubjects <= 0) {
+    throw new RangeError("maxConcurrentSubjects must be a positive safe integer");
+  }
+  const states = /* @__PURE__ */ new Map();
+  const readySubjects = [];
+  const idleWaiters = /* @__PURE__ */ new Set();
+  let accepting = true;
+  let activeSubjects = 0;
+  const resolveIdleWaiters = () => {
+    if (states.size !== 0) return;
+    for (const resolve of idleWaiters) resolve();
+    idleWaiters.clear();
+  };
+  async function drain(subject, state) {
+    while (true) {
+      const event = state.pending.shift();
+      if (!event) break;
+      try {
+        await handler(event.payload, event.subject);
+      } catch {
+      }
+    }
+    activeSubjects -= 1;
+    state.scheduled = false;
+    if (state.pending.length > 0) {
+      schedule(subject, state);
+    } else {
+      if (states.get(subject) === state) states.delete(subject);
+      resolveIdleWaiters();
+    }
+    pump();
+  }
+  function pump() {
+    while (activeSubjects < maxConcurrentSubjects) {
+      const next = readySubjects.shift();
+      if (!next) return;
+      if (states.get(next.subject) !== next.state || !next.state.scheduled) continue;
+      activeSubjects += 1;
+      void drain(next.subject, next.state);
+    }
+  }
+  function schedule(subject, state) {
+    if (state.scheduled) return;
+    state.scheduled = true;
+    readySubjects.push({ subject, state });
+    pump();
+  }
+  return {
+    enqueue(payload, subject) {
+      if (!accepting) return;
+      const heartbeat = payloadIsHeartbeat(payload);
+      let state = states.get(subject);
+      if (!state) {
+        state = { scheduled: false, pending: [] };
+        states.set(subject, state);
+      }
+      const queued = { payload, subject, heartbeat };
+      const lastIndex = state.pending.length - 1;
+      if (heartbeat && lastIndex >= 0 && state.pending[lastIndex].heartbeat) {
+        state.pending[lastIndex] = queued;
+        options.onHeartbeatCoalesced?.();
+      } else {
+        state.pending.push(queued);
+      }
+      schedule(subject, state);
+    },
+    async whenIdle() {
+      if (states.size === 0) return;
+      await new Promise((resolve) => idleWaiters.add(resolve));
+    },
+    close() {
+      accepting = false;
+      for (const state of states.values()) {
+        state.pending.length = 0;
+      }
+      resolveIdleWaiters();
+    }
+  };
+}
 function parseAgentSubject(subject, tail) {
   const parts = subject.split(".");
-  if (parts.length !== 4 || parts[0] !== "agent" || parts[3] !== tail) {
+  if (parts.length !== 6 || parts[0] !== "agent" || parts[3] !== "connection" || !parts[4] || parts[5] !== tail) {
     return null;
   }
-  return { workspaceId: parts[1], agentId: parts[2] };
+  return {
+    workspaceId: parts[1],
+    agentId: parts[2],
+    connectionInstanceId: parts[4]
+  };
 }
 function parseAgentEventSubject(subject) {
   return parseAgentSubject(subject, "events");
@@ -294,19 +477,10 @@ async function ingestAttachedBrowserInventory(db, input) {
     snapshot: wireAttachedBrowserInventoryToContract(input.inventory)
   });
 }
-async function ingestHeartbeat(db, input) {
-  const enrollment = await getEnrollment2(db, input.workspaceId, input.agentId);
-  if (!enrollment) {
-    return { ingested: false, seriesAppended: false };
-  }
+async function ingestHeartbeatMetrics(db, input) {
   const sample = wireSampleToDbSample(input.sample);
-  await touchEnrollmentLastSeen(db, {
-    accountId: enrollment.accountId,
-    workspaceId: input.workspaceId,
-    enrollmentId: input.agentId
-  });
   const result = await ingestMachineMetricsSample(db, {
-    accountId: enrollment.accountId,
+    accountId: input.accountId,
     workspaceId: input.workspaceId,
     enrollmentId: input.agentId,
     sample
@@ -356,17 +530,19 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
       labels: { reason }
     });
     try {
-      const enrollment = await getEnrollment2(db, ids.workspaceId, ids.agentId);
-      if (enrollment) {
-        await setEnrollmentWentOffline(db, {
-          accountId: enrollment.accountId,
+      const enrollment2 = await getEnrollment2(db, ids.workspaceId, ids.agentId);
+      if (enrollment2) {
+        const released = await releaseEnrollmentConnection(db, {
+          accountId: enrollment2.accountId,
           workspaceId: ids.workspaceId,
           enrollmentId: ids.agentId,
+          connectionInstanceId: ids.connectionInstanceId,
           reason
         });
+        if (!released.released) return;
         try {
           await disconnectAttachedBrowserDevices(db, {
-            accountId: enrollment.accountId,
+            accountId: enrollment2.accountId,
             workspaceId: ids.workspaceId,
             enrollmentId: ids.agentId
           });
@@ -408,10 +584,75 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
     }
     return;
   }
+  if (event.event?.$case === "agentUpdateProgress") {
+    const enrollment2 = await getEnrollment2(db, ids.workspaceId, ids.agentId).catch(() => null);
+    if (!enrollment2 || enrollment2.connectionInstanceId !== ids.connectionInstanceId) return;
+    const progress = event.event.agentUpdateProgress;
+    const status = (() => {
+      switch (progress.stage) {
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_ACCEPTED:
+          return "accepted";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_WAITING_FOR_IDLE:
+          return "waiting_for_idle";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_DOWNLOADING:
+          return "downloading";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_VERIFYING:
+          return "verifying";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_APPLYING:
+          return "applying";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_RESTARTING:
+          return "restarting";
+        case AgentUpdateStage.AGENT_UPDATE_STAGE_FAILED:
+          return "failed";
+        default:
+          return null;
+      }
+    })();
+    if (!status) return;
+    try {
+      await advanceEnrollmentAgentUpdate(db, {
+        accountId: enrollment2.accountId,
+        workspaceId: ids.workspaceId,
+        enrollmentId: ids.agentId,
+        connectionInstanceId: ids.connectionInstanceId,
+        connectionGeneration: enrollment2.connectionGeneration,
+        operationId: progress.operationId,
+        status,
+        expectedBinarySha256: /^[0-9a-f]{64}$/.test(progress.expectedBinarySha256) ? progress.expectedBinarySha256 : null,
+        errorCode: progress.errorCode || null,
+        retryable: progress.retryable,
+        rolledBack: progress.rolledBack
+      });
+    } catch (error) {
+      observability?.warn?.("Failed to ingest a machine self-update progress event", {
+        subject,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+    return;
+  }
   if (event.event?.$case !== "heartbeat") {
     return;
   }
   const heartbeat = event.event.heartbeat;
+  const enrollment = await getEnrollment2(db, ids.workspaceId, ids.agentId).catch(() => null);
+  if (!enrollment || enrollment.connectionInstanceId !== ids.connectionInstanceId) return;
+  try {
+    const renewed = await renewEnrollmentConnection(db, {
+      accountId: enrollment.accountId,
+      workspaceId: ids.workspaceId,
+      enrollmentId: ids.agentId,
+      connectionInstanceId: ids.connectionInstanceId,
+      leaseMs: AGENT_CONNECTION_LEASE_MS
+    });
+    if (!renewed.renewed) return;
+  } catch (error) {
+    observability?.warn?.("Failed to renew a machine connection heartbeat", {
+      subject,
+      error: error instanceof Error ? error.message : String(error)
+    });
+    return;
+  }
   if (heartbeat.attachedBrowserInventory) {
     try {
       await ingestAttachedBrowserInventory(db, {
@@ -426,10 +667,33 @@ 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;
+      if (enrollment.hasDisplay !== available || (enrollment.desktopUnavailableReason ?? null) !== reason || enrollment.agentCapabilities?.desktop !== available) {
+        await refreshEnrollmentDisplay(db, {
+          workspaceId: ids.workspaceId,
+          agentId: ids.agentId,
+          hasDisplay: available,
+          desktopUnavailableReason: reason,
+          runtimeDesktop: available,
+          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 {
-    await ingestHeartbeat(db, {
+    await ingestHeartbeatMetrics(db, {
+      accountId: enrollment.accountId,
       workspaceId: ids.workspaceId,
       agentId: ids.agentId,
       sample: metrics
@@ -442,10 +706,22 @@ async function handleAgentEventPayload(db, observability, payload, subject, bus)
   }
 }
 function startMetricsIngestion(deps) {
-  return deps.bus.subscribeAgentEvents(
-    AGENT_EVENTS_SUBJECT,
-    (payload, subject) => handleAgentEventPayload(deps.db, deps.observability, payload, subject, deps.bus)
+  const scheduler = createAgentEventIngestionScheduler(
+    (payload, subject) => handleAgentEventPayload(deps.db, deps.observability, payload, subject, deps.bus),
+    {
+      onHeartbeatCoalesced: () => deps.observability?.incrementCounter({
+        name: "opengeni_machine_heartbeat_coalesced_total",
+        help: "Connected Machine heartbeats collapsed while an exact runner event queue was busy."
+      })
+    }
   );
+  const unsubscribe = deps.bus.subscribeAgentEvents(AGENT_EVENTS_SUBJECT, (payload, subject) => {
+    scheduler.enqueue(payload, subject);
+  });
+  return () => {
+    unsubscribe();
+    scheduler.close();
+  };
 }
 function helloReportsDisplay(hello) {
   const caps = hello.capabilities;
@@ -464,13 +740,41 @@ function helloDesktopUnavailableReason(hello) {
 function helloReportsOpStream(hello) {
   return hello.capabilities?.opStream === true;
 }
+function helloRuntimeCapabilities(hello) {
+  const caps = hello.capabilities;
+  if (!caps) return {};
+  return {
+    exec: caps.exec === true,
+    filesystem: caps.filesystem === true,
+    git: caps.git === true,
+    pty: caps.pty === true,
+    desktop: caps.desktop === true,
+    opStream: caps.opStream === true,
+    browserBridge: caps.browserBridge === true,
+    operationResourcePolicy: caps.operationResourcePolicy === true,
+    operationCpuQuota: caps.operationCpuQuota === true,
+    transactionalFsWrite: caps.transactionalFsWrite === true
+  };
+}
+function helloCompletedUpdate(hello) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    hello.completedUpdateOperationId
+  ) || !/^(?:v)?\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(hello.completedUpdateTargetVersion) || !/^[0-9a-f]{64}$/.test(hello.completedUpdateBinarySha256)) {
+    return null;
+  }
+  return {
+    operationId: hello.completedUpdateOperationId,
+    targetVersion: hello.completedUpdateTargetVersion,
+    binarySha256: hello.completedUpdateBinarySha256
+  };
+}
 async function refreshEnrollmentDisplay(db, input) {
   const desktopUnavailableReason = input.desktopUnavailableReason ?? null;
   const enrollment = await getEnrollment2(db, input.workspaceId, input.agentId);
   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)) {
     return { updated: false };
   }
   return await setEnrollmentDisplayState(db, {
@@ -478,7 +782,9 @@ async function refreshEnrollmentDisplay(db, input) {
     workspaceId: input.workspaceId,
     enrollmentId: input.agentId,
     hasDisplay: input.hasDisplay,
-    desktopUnavailableReason
+    desktopUnavailableReason,
+    ...input.runtimeDesktop !== void 0 ? { runtimeDesktop: input.runtimeDesktop } : {},
+    ...input.connectionInstanceId ? { connectionInstanceId: input.connectionInstanceId } : {}
   });
 }
 async function refreshEnrollmentOpStream(db, input) {
@@ -493,7 +799,8 @@ async function refreshEnrollmentOpStream(db, input) {
     accountId: enrollment.accountId,
     workspaceId: input.workspaceId,
     enrollmentId: input.agentId,
-    opStream: input.opStream
+    opStream: input.opStream,
+    ...input.connectionInstanceId ? { connectionInstanceId: input.connectionInstanceId } : {}
   });
 }
 async function handleHelloPayload(db, observability, payload, subject, bus) {
@@ -511,17 +818,53 @@ async function handleHelloPayload(db, observability, payload, subject, bus) {
     });
     return;
   }
+  const authority = await getLiveEnrollmentConnection(db, ids.workspaceId, ids.agentId).catch(
+    () => null
+  );
+  if (!authority || authority.connectionInstanceId !== ids.connectionInstanceId) {
+    observability?.warn?.("Ignored a Hello from a superseded runner instance", {
+      workspaceId: ids.workspaceId,
+      agentId: ids.agentId
+    });
+    return;
+  }
+  let workspaceRoot;
+  if (hello.workspaceRoot.length > 0) {
+    try {
+      workspaceRoot = normalizeConnectedMachineWorkspaceRoot(hello.workspaceRoot, authority.os);
+    } catch (error) {
+      observability?.warn?.("Ignored an invalid Connected Machine workspace root", {
+        workspaceId: ids.workspaceId,
+        agentId: ids.agentId,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   try {
     await refreshEnrollmentDisplay(db, {
       workspaceId: ids.workspaceId,
       agentId: ids.agentId,
       hasDisplay: helloReportsDisplay(hello),
-      desktopUnavailableReason: helloDesktopUnavailableReason(hello)
+      desktopUnavailableReason: helloDesktopUnavailableReason(hello),
+      connectionInstanceId: ids.connectionInstanceId
     });
     await refreshEnrollmentOpStream(db, {
       workspaceId: ids.workspaceId,
       agentId: ids.agentId,
-      opStream: helloReportsOpStream(hello)
+      opStream: helloReportsOpStream(hello),
+      connectionInstanceId: ids.connectionInstanceId
+    });
+    await setEnrollmentAgentRuntime(db, {
+      accountId: authority.accountId,
+      workspaceId: ids.workspaceId,
+      enrollmentId: ids.agentId,
+      connectionInstanceId: ids.connectionInstanceId,
+      agentVersion: hello.agentVersion.trim() || null,
+      binarySha256: /^[0-9a-f]{64}$/.test(hello.binarySha256) ? hello.binarySha256 : null,
+      updateChannel: hello.updateChannel === "stable" || hello.updateChannel === "beta" ? hello.updateChannel : null,
+      capabilities: helloRuntimeCapabilities(hello),
+      ...workspaceRoot !== void 0 ? { workspaceRoot } : {},
+      completedUpdate: helloCompletedUpdate(hello)
     });
   } catch (error) {
     observability?.warn?.("Failed to refresh an enrollment's capabilities from a Hello", {
@@ -530,23 +873,21 @@ async function handleHelloPayload(db, observability, payload, subject, bus) {
     });
   }
   try {
-    const enrollment = await getEnrollment2(db, ids.workspaceId, ids.agentId);
-    if (enrollment) {
-      const { cleared } = await clearEnrollmentWentOffline(db, {
-        accountId: enrollment.accountId,
-        workspaceId: ids.workspaceId,
-        enrollmentId: ids.agentId
-      });
-      if (cleared && bus) {
-        await fanOutMachineLinkEvents(
-          db,
-          bus,
-          observability,
-          ids.workspaceId,
-          ids.agentId,
-          (activeTurnId) => [{ type: "machine.link.restored", turnId: activeTurnId, payload: {} }]
-        );
-      }
+    const { cleared } = await clearEnrollmentWentOffline(db, {
+      accountId: authority.accountId,
+      workspaceId: ids.workspaceId,
+      enrollmentId: ids.agentId,
+      connectionInstanceId: ids.connectionInstanceId
+    });
+    if (cleared && bus) {
+      await fanOutMachineLinkEvents(
+        db,
+        bus,
+        observability,
+        ids.workspaceId,
+        ids.agentId,
+        (activeTurnId) => [{ type: "machine.link.restored", turnId: activeTurnId, payload: {} }]
+      );
     }
   } catch (error) {
     observability?.warn?.("Failed to clear a machine going-offline marker on a Hello", {
@@ -733,6 +1074,195 @@ function escapeSlackText(value) {
   return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
+// 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/workspace-webhook-dispatch.ts
+import { randomUUID } 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,
+  maintainWorkspaceAllowances,
+  pruneOrganizationWebhookDeliveries,
+  pruneWorkspaceWebhookDeliveries,
+  settleOrganizationWebhookDelivery,
+  settleWorkspaceWebhookDelivery
+} from "@opengeni/db";
+import { pinnedFetch } from "@opengeni/network";
+var WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE = 32;
+var CLAIM_SECONDS = 60;
+var POLL_INTERVAL_MS = 2e3;
+var DELIVERY_TIMEOUT_MS = 1e4;
+var PRUNE_EVERY_TICKS = 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 drainWorkspaceWebhookDeliveries(deps) {
+  await maintainWorkspaceAllowances(deps.db);
+  const key = environmentsEncryptionKeyBytes(deps.settings);
+  if (!key) return { claimed: 0, delivered: 0, failed: 0 };
+  const claimId = randomUUID();
+  const claims = await claimWorkspaceWebhookDeliveries(deps.db, {
+    claimId,
+    limit: WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE,
+    claimSeconds: CLAIM_SECONDS
+  });
+  const organizationClaims = await claimOrganizationWebhookDeliveries(deps.db, {
+    claimId,
+    limit: WORKSPACE_WEBHOOK_DISPATCH_BATCH_SIZE,
+    claimSeconds: CLAIM_SECONDS
+  });
+  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_MS);
+  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_TICKS === 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,
@@ -741,13 +1271,14 @@ import {
   encodeEditableArtifactLiveServerWireFrame
 } from "@opengeni/core";
 var EDITABLE_ARTIFACT_LIVE_WEBSOCKET_PATH = "/v1/editable-artifacts/live";
-var EDITABLE_ARTIFACT_LIVE_WEBSOCKET_PROTOCOL = "opengeni-artifact-v1";
+var EDITABLE_ARTIFACT_LIVE_WEBSOCKET_PROTOCOL = "opengeni-artifact-v2";
 var EDITABLE_ARTIFACT_LIVE_WEBSOCKET_MAX_MESSAGE_BYTES = 8 * 1024 * 1024 + 64 * 1024;
 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),
@@ -771,7 +1302,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: {
@@ -782,8 +1316,9 @@ var EditableArtifactWebSocketTransport = class {
   }
 };
 var EditableArtifactWebSocketConnection = class {
-  constructor(application) {
+  constructor(application, authorizeSourceSession) {
     this.application = application;
+    this.authorizeSourceSession = authorizeSourceSession;
   }
   socket = null;
   session = null;
@@ -869,7 +1404,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");
@@ -976,14 +1512,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 randomUUID2 } 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,
@@ -999,7 +1642,6 @@ import {
   editableArtifactId
 } from "@opengeni/core/editable-artifacts";
 import {
-  EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION,
   EditableArtifactApplication,
   EditableArtifactCompatibilityError,
   EditableArtifactLiveServer,
@@ -1007,14 +1649,16 @@ import {
   SystemEditableArtifactLiveScheduler,
   WebCryptoEditableArtifactLiveTokens
 } from "@opengeni/core/editable-artifact-live";
+import { currentEditableArtifactCompatibility } from "@opengeni/contracts/editable-artifacts";
 import {
   PostgresEditableArtifactLiveReadStore,
   PostgresEditableArtifactLiveTicketStore,
   PostgresEditableArtifactStore,
   listEditableArtifactIdsForSession,
   touchEditableArtifactSessionLink,
+  recordNativeDocumentInspection,
   dbSql,
-  withRlsContext
+  withRlsContext as withRlsContext2
 } from "@opengeni/db";
 import { PostgresEditableArtifactDurableExportStore } from "@opengeni/db/editable-artifact-durable-export";
 import {
@@ -1078,7 +1722,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,
@@ -1093,6 +1737,13 @@ import {
 } from "@opengeni/contracts/editable-artifact-causal-frontier";
 import { decodeEditableArtifactSerializedCommit } from "@opengeni/contracts/editable-artifact-serialized-commit";
 import { decodeEditableArtifactMutationIntent } from "@opengeni/contracts/editable-artifacts";
+import {
+  COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+  DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION,
+  PRESENTATION_ARTIFACT_MODEL_SCHEMA_VERSION,
+  SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION,
+  SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION
+} from "@opengeni/contracts/editable-artifact-versions";
 import {
   MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES,
   causalFrontiersEqual,
@@ -1101,9 +1752,6 @@ import {
   editableArtifactReplicaId,
   editableArtifactStateHash
 } from "@opengeni/core";
-var MODEL_SCHEMA_VERSION = 1;
-var OPERATION_PROTOCOL_VERSION = 1;
-var CRDT_STATE_VERSION = 1;
 var SNAPSHOT_CHUNK_BYTES = 1024 * 1024;
 async function loadVerifiedNativeArtifactRuntimeBinding() {
   const location = await doctorConfiguredArtifactRuntime();
@@ -1136,7 +1784,7 @@ var NativeEditableArtifactKernelAdapter = class {
           modality: "spreadsheet",
           committedTransactionBytes,
           kernelVersion: this.runtime.buildIdentity,
-          modelSchemaVersion: MODEL_SCHEMA_VERSION
+          modelSchemaVersion: SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION
         });
       }
       if (session.modality !== request.modality) {
@@ -1148,7 +1796,7 @@ var NativeEditableArtifactKernelAdapter = class {
         nativeReceiptBytes,
         resultingStateHash: editableArtifactStateHash(session.stateHash()),
         kernelVersion: this.runtime.buildIdentity,
-        modelSchemaVersion: MODEL_SCHEMA_VERSION
+        modelSchemaVersion: modelSchemaVersionFor(request.modality)
       });
     } finally {
       session.dispose();
@@ -1198,11 +1846,11 @@ 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,
-        modelSchemaVersion: MODEL_SCHEMA_VERSION,
+        modelSchemaVersion: modelSchemaVersionFor(input.modality),
         kernelVersion: this.runtime.buildIdentity
       };
       if (session.modality === "spreadsheet") {
@@ -1210,8 +1858,8 @@ var NativeEditableArtifactKernelAdapter = class {
           ...common,
           modality: "spreadsheet",
           coveredCausalFrontier: domainFrontier(session.frontier()),
-          operationProtocolVersion: OPERATION_PROTOCOL_VERSION,
-          crdtStateVersion: CRDT_STATE_VERSION
+          operationProtocolVersion: COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+          crdtStateVersion: SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION
         });
       }
       return Object.freeze({
@@ -1245,11 +1893,11 @@ 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,
-        modelSchemaVersion: MODEL_SCHEMA_VERSION,
+        modelSchemaVersion: modelSchemaVersionFor(input.state.modality),
         kernelVersion: this.runtime.buildIdentity
       };
       if (session.modality === "spreadsheet") {
@@ -1258,8 +1906,8 @@ var NativeEditableArtifactKernelAdapter = class {
           ...common,
           modality: session.modality,
           coveredCausalFrontier: domainFrontier(session.frontier()),
-          operationProtocolVersion: OPERATION_PROTOCOL_VERSION,
-          crdtStateVersion: CRDT_STATE_VERSION
+          operationProtocolVersion: COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+          crdtStateVersion: SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION
         });
       }
       if (session.modality !== input.state.modality) throw new Error("Native modality mismatch");
@@ -1292,7 +1940,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());
@@ -1312,12 +1960,12 @@ var NativeEditableArtifactKernelAdapter = class {
           canonicalContentHash,
           coveredHeadSequence,
           stateHash,
-          modelSchemaVersion: MODEL_SCHEMA_VERSION,
+          modelSchemaVersion: SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION,
           kernelVersion: this.runtime.buildIdentity,
           fullCrdtStateVerified: true,
           coveredCausalFrontier,
-          operationProtocolVersion: OPERATION_PROTOCOL_VERSION,
-          crdtStateVersion: CRDT_STATE_VERSION,
+          operationProtocolVersion: COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+          crdtStateVersion: SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION,
           ...replayedTarget2 ? { replayedTarget: replayedTarget2 } : {}
         });
       }
@@ -1339,7 +1987,7 @@ var NativeEditableArtifactKernelAdapter = class {
         canonicalContentHash,
         coveredHeadSequence,
         stateHash,
-        modelSchemaVersion: MODEL_SCHEMA_VERSION,
+        modelSchemaVersion: modelSchemaVersionFor(session.modality),
         kernelVersion: this.runtime.buildIdentity,
         nativeRevision,
         ...replayedTarget ? { replayedTarget } : {}
@@ -1349,6 +1997,10 @@ var NativeEditableArtifactKernelAdapter = class {
     }
   }
 };
+function modelSchemaVersionFor(modality) {
+  if (modality === "spreadsheet") return SPREADSHEET_ARTIFACT_MODEL_SCHEMA_VERSION;
+  return modality === "document" ? DOCUMENT_ARTIFACT_MODEL_SCHEMA_VERSION : PRESENTATION_ARTIFACT_MODEL_SCHEMA_VERSION;
+}
 function assertRuntime(candidate, location) {
   if (typeof candidate !== "object" || candidate === null) {
     throw new Error("Verified artifact facade returned no runtime");
@@ -1504,7 +2156,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;
@@ -1540,7 +2192,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;
@@ -1564,7 +2216,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
@@ -1578,20 +2230,34 @@ import {
   editableArtifactStateHash as editableArtifactStateHash2,
   EditableArtifactOfficeImportError
 } from "@opengeni/core/editable-artifacts";
-import { getFile } from "@opengeni/db";
+import { requireLiveAgentAttemptAuthorization } from "@opengeni/core";
+import { getFilesForSubject } from "@opengeni/db";
 import {
-  MAX_BOUNDED_OBJECT_CHUNK_BYTES
+  MAX_BOUNDED_OBJECT_CHUNK_BYTES,
+  retryWhileMissing
 } from "@opengeni/storage";
 var SNAPSHOT_MIME = "application/vnd.opengeni.editable-artifact-snapshot";
 var EditableArtifactOfficeImportAdapter = class {
   constructor(dependencies) {
     this.dependencies = dependencies;
-    this.readFile = dependencies.readFile ?? getFile;
+    this.readFiles = dependencies.readFiles ?? getFilesForSubject;
+    this.resolveFileAuthoritySubjectId = dependencies.resolveFileAuthoritySubjectId ?? editableArtifactFileAuthoritySubjectId;
   }
-  readFile;
+  readFiles;
+  resolveFileAuthoritySubjectId;
   async prepare(input) {
     throwIfAborted2(input.signal);
-    const file = await this.readFile(this.dependencies.db, input.scope.workspaceId, input.fileId);
+    const subjectId = await this.resolveFileAuthoritySubjectId(
+      this.dependencies.db,
+      input.scope,
+      input.actor
+    );
+    const [file] = await this.readFiles(this.dependencies.db, {
+      accountId: input.scope.accountId,
+      workspaceId: input.scope.workspaceId,
+      subjectId,
+      fileIds: [input.fileId]
+    });
     if (!file || file.status !== "ready") {
       throw new EditableArtifactOfficeImportError("invalid_source");
     }
@@ -1699,29 +2365,74 @@ function officeFilenameMatches(filename, modality) {
 }
 async function readVerifiedWorkspaceFile(storage, file, signal) {
   throwIfAborted2(signal);
-  const before = await storage.headFile(file);
+  const before = await retryWhileMissing(async () => {
+    try {
+      return await storage.headFile(file);
+    } catch (error) {
+      if (typeof storage.fileExists === "function" && !await storage.fileExists(file)) {
+        return null;
+      }
+      throw error;
+    }
+  });
+  if (!before) {
+    throw new EditableArtifactOfficeImportError("source_changed");
+  }
   if (before.ContentLength !== file.sizeBytes || before.ContentType !== file.contentType || before.Metadata?.sha256 !== file.sha256 || typeof before.VersionToken !== "string" || before.VersionToken.length < 1) {
     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;
-    const chunk = await storage.getFileRange(file, { start, end });
+    const chunk = await retryWhileMissing(async () => storage.getFileRange(file, { start, end }));
     if (!chunk || chunk.byteLength !== end - start + 1) {
       throw new EditableArtifactOfficeImportError("source_changed");
     }
     bytes.set(chunk, start);
     digest.update(chunk);
   }
-  const after = await storage.headFile(file);
+  const after = await retryWhileMissing(async () => {
+    try {
+      return await storage.headFile(file);
+    } catch (error) {
+      if (typeof storage.fileExists === "function" && !await storage.fileExists(file)) {
+        return null;
+      }
+      throw error;
+    }
+  });
+  if (!after) {
+    throw new EditableArtifactOfficeImportError("source_changed");
+  }
   const sha256 = digest.digest("hex");
   if (after.ContentLength !== before.ContentLength || after.ContentType !== before.ContentType || after.Metadata?.sha256 !== before.Metadata?.sha256 || after.VersionToken !== before.VersionToken || sha256 !== file.sha256) {
     throw new EditableArtifactOfficeImportError("source_changed");
   }
   return bytes;
 }
+async function editableArtifactFileAuthoritySubjectId(db, scope, actor) {
+  if (actor.kind !== "agent") return actor.subjectId;
+  const authorization = await requireLiveAgentAttemptAuthorization(
+    db,
+    {
+      accountId: scope.accountId,
+      workspaceId: scope.workspaceId,
+      subjectId: actor.subjectId,
+      permissions: [],
+      principalKind: "agent_attempt",
+      metadata: {
+        sessionId: actor.sessionId,
+        turnId: actor.turnId,
+        attemptId: actor.attemptId,
+        executionGeneration: actor.generation
+      }
+    },
+    actor.sessionId
+  );
+  return authorization.initiatingHumanSubjectId;
+}
 async function* byteChunks(bytes) {
   for (let offset = 0; offset < bytes.byteLength; offset += MAX_BOUNDED_OBJECT_CHUNK_BYTES) {
     yield bytes.subarray(offset, offset + MAX_BOUNDED_OBJECT_CHUNK_BYTES);
@@ -1732,8 +2443,9 @@ 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;
 var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 var EditableArtifactWorkspaceFileAdapter = class {
@@ -1790,7 +2502,7 @@ var EditableArtifactWorkspaceFileAdapter = class {
         if (existing) {
           assertStoredExport(existing, download.byteSize, download.mimeType, sha256);
         } else {
-          await storage.putObjectStreamIfAbsent({
+          const created = await storage.putObjectStreamIfAbsent({
             key: objectKey,
             contentType: download.mimeType,
             chunks: download.chunks(input.signal ? { signal: input.signal } : {}),
@@ -1798,18 +2510,28 @@ var EditableArtifactWorkspaceFileAdapter = class {
             sha256,
             ...input.signal ? { signal: input.signal } : {}
           });
-          const stored = await storage.headObject(objectKey);
-          assertStoredExport(stored, download.byteSize, download.mimeType, sha256);
+          if (!created) {
+            await assertVisibleExport(
+              storage,
+              objectKey,
+              download.byteSize,
+              download.mimeType,
+              sha256,
+              input.signal
+            );
+          }
         }
         await download.assertUnchanged(input.signal);
         throwIfAborted3(input.signal);
         file = await this.completeFile(this.dependencies.db, input.scope.workspaceId, uploadId);
       } else {
-        assertStoredExport(
-          await storage.headObject(objectKey),
+        await assertVisibleExport(
+          storage,
+          objectKey,
           download.byteSize,
           download.mimeType,
-          sha256
+          sha256,
+          input.signal
         );
         await download.assertUnchanged(input.signal);
       }
@@ -1833,6 +2555,13 @@ var EditableArtifactWorkspaceFileAdapter = class {
     }
   }
 };
+async function assertVisibleExport(storage, objectKey, byteSize, contentType, sha256, signal) {
+  const head = await retryWhileMissing2(
+    async () => await storage.headObject(objectKey),
+    signal ? { signal } : {}
+  );
+  assertStoredExport(head, byteSize, contentType, sha256);
+}
 function assertStoredExport(head, byteSize, contentType, sha256) {
   if (!head || head.ContentLength !== byteSize || head.ContentType !== contentType || head.Metadata?.sha256 !== sha256 || typeof head.VersionToken !== "string" || head.VersionToken.length < 1) {
     throw new Error("Workspace export object differs from its durable materialization");
@@ -1850,7 +2579,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");
@@ -1939,6 +2668,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,
@@ -1964,7 +2698,8 @@ async function createStandaloneEditableArtifactApplication(input) {
   });
   const compatibility = Object.freeze({
     assertCompatible(request) {
-      if (request.protocolVersion !== EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION || request.modelSchemaVersion !== 1 || request.kernelVersion !== runtime.buildIdentity) {
+      const current = currentEditableArtifactCompatibility(request.artifact.modality);
+      if (request.modality !== request.artifact.modality || request.liveProtocolVersion !== current.liveProtocolVersion || request.modelSchemaVersion !== current.modelSchemaVersion || request.snapshotVersion !== current.snapshotVersion || request.commandProtocolVersion !== current.commandProtocolVersion || request.committedTransactionProtocolVersion !== current.committedTransactionProtocolVersion) {
         throw new EditableArtifactCompatibilityError();
       }
     }
@@ -1996,7 +2731,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(
@@ -2074,22 +2809,24 @@ var PollingEditableArtifactAuthorizationInvalidations = class {
 };
 var RandomEditableArtifactStableIds = class {
   next(_kind) {
-    return randomUUID().replaceAll("-", "");
+    return randomUUID2().replaceAll("-", "");
   }
 };
 var RandomEditableArtifactDurableExportIds = class {
   next(_kind) {
-    return randomUUID().replaceAll("-", "");
+    return randomUUID2().replaceAll("-", "");
   }
 };
 function materializationProfiles(capabilities) {
-  if (capabilities.protocol !== "OGAMC001" || capabilities.runtimeKind !== "native" || capabilities.maxOutputBytes !== EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES || capabilities.codecVersions["opengeni.xlsx"] === void 0 || !capabilities.supportedModelSchemaVersions.includes(1) || !capabilities.supportedOperationProtocolVersions.includes(1) || !capabilities.supportedSnapshotProtocolVersions.includes(1)) {
+  const spreadsheetCompatibility = currentEditableArtifactCompatibility("spreadsheet");
+  if (capabilities.protocol !== "OGAMC001" || capabilities.runtimeKind !== "native" || capabilities.maxOutputBytes !== EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES || capabilities.codecVersions["opengeni.xlsx"] === void 0 || capabilities.supportedModelSchemaVersions[0] !== spreadsheetCompatibility.modelSchemaVersion || capabilities.supportedOperationProtocolVersions[0] !== spreadsheetCompatibility.committedTransactionProtocolVersion || capabilities.supportedSnapshotProtocolVersions[0] !== spreadsheetCompatibility.snapshotVersion) {
     throw new Error("Verified artifact materializer profile is incompatible");
   }
   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({
@@ -2118,7 +2855,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
@@ -2148,6 +2885,169 @@ function rawRows(result) {
   throw new Error("Unsupported database execute result shape");
 }
 
+// src/fatal-process-boundary.ts
+import { randomUUID as randomUUID3 } from "crypto";
+var API_FATAL_FLUSH_TIMEOUT_MS = 1e3;
+var API_FATAL_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]{1,128}$/;
+var FATAL_ERROR_CODES = {
+  startup_failure: "api_startup_failed",
+  unhandled_rejection: "api_unhandled_rejection",
+  uncaught_exception: "api_uncaught_exception"
+};
+function installApiFatalProcessBoundary(options = {}) {
+  const runtimeProcess = options.process ?? defaultProcessBoundary();
+  const flushTimeoutMs = options.flushTimeoutMs ?? API_FATAL_FLUSH_TIMEOUT_MS;
+  const correlationId = options.correlationId ?? (() => `api-fatal.${randomUUID3()}`);
+  const fallbackLog = options.fallbackLog ?? ((message) => console.error(message));
+  let observability = options.observability;
+  let phase = "startup";
+  let reporting = false;
+  const report = async (event, reason) => {
+    if (reporting) return;
+    reporting = true;
+    const diagnostic = apiFatalDiagnostic(event, phase, reason, correlationId);
+    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);
+          logged = true;
+        } catch {
+        }
+        if (!logged) {
+          safeFallbackLog(fallbackLog, message);
+        }
+        try {
+          const span = activeObservability.startSpan("api.process.fatal", diagnostic);
+          span.end({ error: true });
+        } catch {
+        }
+        await flushWithin(activeObservability, flushTimeoutMs);
+      } else {
+        safeFallbackLog(fallbackLog, message);
+      }
+    } finally {
+      runtimeProcess.exit(1);
+    }
+  };
+  const onUnhandledRejection = (reason) => {
+    void report("unhandled_rejection", reason);
+  };
+  const onUncaughtException = (reason) => {
+    void report("uncaught_exception", reason);
+  };
+  runtimeProcess.on("unhandledRejection", onUnhandledRejection);
+  runtimeProcess.on("uncaughtException", onUncaughtException);
+  return {
+    attachObservability: (value) => {
+      observability = value;
+    },
+    markRunning: () => {
+      phase = "running";
+    },
+    reportStartupFailure: async (reason) => {
+      await report("startup_failure", reason);
+    },
+    dispose: () => {
+      runtimeProcess.off("unhandledRejection", onUnhandledRejection);
+      runtimeProcess.off("uncaughtException", onUncaughtException);
+    }
+  };
+}
+function apiFatalDiagnostic(event, phase, reason, correlationId) {
+  let safeCorrelationId = "api-fatal.fallback";
+  try {
+    const candidate = correlationId();
+    if (API_FATAL_CORRELATION_ID_PATTERN.test(candidate)) {
+      safeCorrelationId = candidate;
+    }
+  } catch {
+  }
+  return {
+    errorClass: "ApiFatalOperationError",
+    errorCode: FATAL_ERROR_CODES[event],
+    origin: "api",
+    phase,
+    reasonKind: apiFatalReasonKind(reason),
+    correlationId: safeCorrelationId
+  };
+}
+function apiFatalReasonKind(reason) {
+  if (reason === null) return "null";
+  const kind = typeof reason;
+  if (kind !== "object") return kind;
+  try {
+    return reason instanceof Error ? "error" : "object";
+  } catch {
+    return "object";
+  }
+}
+function apiFatalMessage(diagnostic) {
+  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;
+  try {
+    flush = Promise.resolve(observability.flush()).catch(() => void 0);
+  } catch {
+    return;
+  }
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return;
+  let timeout;
+  try {
+    await Promise.race([
+      flush,
+      new Promise((resolve) => {
+        timeout = setTimeout(resolve, timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout !== void 0) clearTimeout(timeout);
+  }
+}
+function safeFallbackLog(fallbackLog, message) {
+  try {
+    fallbackLog(message);
+  } catch {
+  }
+}
+function defaultProcessBoundary() {
+  return {
+    on: (event, listener) => {
+      if (event === "unhandledRejection") {
+        process.on("unhandledRejection", listener);
+      } else {
+        process.on("uncaughtException", listener);
+      }
+    },
+    off: (event, listener) => {
+      if (event === "unhandledRejection") {
+        process.off("unhandledRejection", listener);
+      } else {
+        process.off("uncaughtException", listener);
+      }
+    },
+    exit: (code) => {
+      process.exit(code);
+    }
+  };
+}
+
 // src/index.ts
 function isWorkflowAlreadyStarted(error) {
   return error instanceof WorkflowExecutionAlreadyStartedError;
@@ -2172,7 +3072,40 @@ 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 {
+        await temporal.workflow.start("automationRunWorkflow", {
+          taskQueue: settings.temporalTaskQueue,
+          workflowId: `automation-run:${runId}`,
+          workflowIdReusePolicy: "REJECT_DUPLICATE",
+          args: [{ accountId, workspaceId, runId }]
+        });
+      } catch (error) {
+        if (isWorkflowAlreadyStarted(error)) return;
+        throw error;
+      }
+    },
     signalUserMessage: async ({ eventId, workflowId }) => {
       await temporal.workflow.getHandle(workflowId).signal("userMessage", eventId);
     },
@@ -2182,7 +3115,8 @@ async function createTemporalWorkflowClient(settings, db) {
       sessionId,
       workflowId,
       wakeRevision,
-      interruptionRequested
+      interruptionRequested,
+      onSignalAccepted
     }) => {
       await temporal.workflow.signalWithStart("sessionWorkflow", {
         taskQueue: settings.temporalTaskQueue,
@@ -2191,7 +3125,8 @@ async function createTemporalWorkflowClient(settings, db) {
         args: [{ accountId, workspaceId, sessionId }],
         signal: interruptionRequested ? "sessionControl" : "queueChanged"
       });
-      await markSessionWorkflowWakeDelivered(db, {
+      onSignalAccepted?.();
+      return await markSessionWorkflowWakeDelivered(db, {
         accountId,
         workspaceId,
         sessionId,
@@ -2250,41 +3185,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;
@@ -2300,7 +3208,8 @@ async function createTemporalWorkflowClient(settings, db) {
               taskId: task.id,
               triggerType,
               agentRunUsageIdempotencyKey,
-              initiator
+              initiator,
+              ...credentialRestriction ? { credentialRestriction } : {}
             }
           ]
         });
@@ -2314,7 +3223,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", {
@@ -2357,11 +3266,12 @@ async function createTemporalWorkflowClient(settings, db) {
     }
   };
 }
-async function startApi() {
-  const settings = getSettings();
-  const observability = createObservability(settings, { component: "api" });
+async function startApi(options = {}) {
+  const settings = options.settings ?? getSettings();
+  const observability = options.observability ?? createObservability(settings, { component: "api" });
   const searchPath = dbSearchPath(settings);
   const dbClient = createDb(settings.databaseUrl, {
+    max: settings.apiDatabasePoolMax,
     ...searchPath ? { searchPath } : {},
     rlsStrategy: settings.rlsStrategy
   });
@@ -2372,21 +3282,37 @@ async function startApi() {
   const databasePosture = {
     rlsStrategy: settings.rlsStrategy,
     expectedRole: settings.runtimeDatabaseRole,
-    targetSchema: settings.dbSchema.trim() || "public"
+    targetSchema: settings.dbSchema.trim() || "public",
+    organizationTenancyCanonicalActivationEnabled: settings.organizationTenancyCanonicalActivationEnabled
   };
   const controlPlaneAuth = resolveNatsControlPlaneAuth(settings);
   try {
+    const { ensureModalRegistryImage } = await import("@opengeni/runtime/sandbox");
+    await retryStartupDependency(
+      "Modal private-registry image",
+      () => ensureModalRegistryImage(settings),
+      { ...retryOptions, onRetry }
+    );
     await retryStartupDependency(
       "PostgreSQL runtime posture",
       () => assertRuntimeDatabasePosture(dbClient.db, databasePosture),
+      { ...retryOptions, onRetry, shouldRetry: isRetryableRuntimeDatabaseStartupError }
+    );
+    const resolvedCatalog = await retryStartupDependency(
+      "model catalog",
+      () => resolveCatalogSettings(dbClient.db, settings),
       { ...retryOptions, onRetry }
     );
+    observability.info("OpenGeni model catalog resolved", {
+      catalogSource: resolvedCatalog.source,
+      catalogVersion: resolvedCatalog.version
+    });
     bus = await retryStartupDependency(
       "NATS",
       () => createNatsEventBus(
         settings.natsUrl,
         controlPlaneAuth ? { user: controlPlaneAuth.user, pass: controlPlaneAuth.password } : void 0,
-        { logger: observabilityEventLogger(observability) }
+        observabilityEventBusOptions(observability)
       ),
       {
         ...retryOptions,
@@ -2447,30 +3373,54 @@ async function startApi() {
       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 (artifactWebSockets.handles(request)) {
-        return artifactWebSockets.upgrade(request, bunServer);
-      }
-      return app.fetch(request);
+      const upgrade = dispatchApiWebSocketUpgrade(
+        request,
+        bunServer,
+        webSocketUpgrades,
+        localBrowserBoundary
+      );
+      if (upgrade.handled) return upgrade.response;
+      return app.fetch(
+        request,
+        apiRequestBindingsForTransportPeer(bunServer.requestIP(request)?.address)
+      );
     },
     websocket: {
       maxPayloadLength: EDITABLE_ARTIFACT_LIVE_WEBSOCKET_MAX_MESSAGE_BYTES,
       backpressureLimit: 16 * 1024 * 1024,
       closeOnBackpressureLimit: true,
-      open: (socket) => artifactWebSockets.websocket.open(socket),
-      message: (socket, message) => artifactWebSockets.websocket.message(socket, message),
-      close: (socket) => artifactWebSockets.websocket.close(socket)
+      open: (socket) => socket.data.attach(socket),
+      message: (socket, message) => socket.data.receive(message),
+      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 stopTemporalScheduleCleanupPump = startTemporalScheduleCleanupPump({
     db: dbClient.db,
+    cleanupConnectorAuthorization: async (claim) => await cleanupScheduledTaskConnectorAuthorization(routeDeps, claim),
     deleteSchedule: async (temporalScheduleId) => {
       await workflowClient.client.deleteScheduledTaskSchedule({ temporalScheduleId });
     },
@@ -2514,17 +3464,21 @@ async function startApi() {
   }
   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 stopWorkspaceWebhookDispatchPump();
+      await routeDeps.userPresence?.close().catch(() => void 0);
       await Promise.allSettled([
         Promise.resolve(editableArtifactComposition?.close()),
         authCalloutResponder?.close(),
@@ -2536,7 +3490,16 @@ async function startApi() {
   };
 }
 if (import.meta.main) {
-  await startApi();
+  const fatalBoundary = installApiFatalProcessBoundary();
+  try {
+    const settings = getSettings();
+    const observability = createObservability(settings, { component: "api" });
+    fatalBoundary.attachObservability(observability);
+    await startApi({ settings, observability });
+    fatalBoundary.markRunning();
+  } catch (error) {
+    await fatalBoundary.reportStartupFailure(error);
+  }
 }
 function temporalOverlapPolicy(policy) {
   if (policy === "skip") {
@@ -2641,7 +3604,7 @@ function temporalScheduleOptions(task, taskQueue) {
 }
 function scheduledTaskEffectivelyPaused(task) {
   if (task.status === "paused") return true;
-  if (task.action.kind !== "knowledge_source_sync") return false;
+  if (!scheduledTaskKnowledgeSource(task)) return false;
   const control = task.metadata.knowledgeSourceSync;
   if (!control || typeof control !== "object") return false;
   const record = control;