@opengeni/api-router 4.0.0 → 4.1.0-canary.35855175602001

package/src/mcp/server.ts

@@ -9,6 +9,7 @@ import {
   setSessionChannel,
 } from "@opengeni/db";
 import { createHash, randomUUID } from "node:crypto";
+import { mintEnrollToken } from "../sandbox/enrollment";
 import { capabilityAccountReadiness } from "./capability-account-readiness";
 import {
   prepareWorkspaceArtifactUpload,
@@ -280,6 +281,8 @@ import {
   boundRigDetailMcp,
   SESSION_EVENT_MCP_MAX_BYTES,
 } from "./session-view";
+import { completeChildReadSequences } from "./child-read-evidence";
+import { acknowledgeConsumedChildEvents } from "@opengeni/db";
 import {
   SESSION_WAIT_COMPLETION_EVENT_TYPES,
   SESSION_WAIT_DEFAULT_SECONDS,
@@ -1709,7 +1712,7 @@ function registerSandboxFileArtifactTool(
     "sandbox_file_publish",
     {
       description:
-        "Publish one exact file from this session's /workspace into durable workspace storage. Use this before presenting a ZIP, CSV, JSON, Markdown, HTML, PDF, Office file, or other sandbox output as downloadable. Returns a permanent, authenticated artifact receipt; never invent or expose a sandbox: URL as the durable result.",
+        "Publish one exact file from this session's /workspace into durable workspace storage. Use this before presenting a video, ZIP, CSV, JSON, Markdown, HTML, PDF, Office file, or other sandbox output as downloadable. Present the returned artifact.artifactId as [Open file](artifact:<artifactId>), or ![Preview](artifact:<artifactId>) for inline image/video/audio/PDF previews. Replace <artifactId> with the exact returned ID and use a descriptive label. Never expose a sandbox: URL as the durable result.",
       inputSchema: {
         path: z4.string().min(1).max(4_096),
       },
@@ -3780,7 +3783,7 @@ function registerFleetTools(
     "sandbox_provision",
     {
       description:
-        "Provision a new sandbox for the fleet. kind=selfhosted returns device-flow enrollment instructions to share with a HUMAN (install the agent + enroll their machine with loud whole-machine consent — the agent cannot self-consent). kind=modal creates a named Modal sandbox record, but it is NOT yet attachable as a swap target: routing a session onto a second Modal box is not supported yet, so sandbox_swap to its id is rejected. Use the session's own box (the default) or attach a Connected Machine instead.",
+        "Provision a new sandbox for the fleet. kind=selfhosted returns interactive device-flow instructions for a human to approve. For authorized headless enrollment, use connected_machine_enroll_token when available instead. kind=modal creates a named Modal sandbox record, but it is NOT yet attachable as a swap target: routing a session onto a second Modal box is not supported yet, so sandbox_swap to its id is rejected. Use the session's own box (the default) or attach a Connected Machine instead.",
       inputSchema: {
         kind: z4.enum(["selfhosted", "modal"]),
         name: z4.string().min(1).max(120).optional(),
@@ -3796,11 +3799,11 @@ function registerFleetTools(
   );
 }
 
-// Workspace-admin/operator surface for removing a connected machine. This is
+// Enrollment-management surface for creating tokens and removing machines. This is
 // deliberately separate from the session-scoped fleet tools: a worker can list,
 // attach, or run on a machine only with session authority, while removal requires
-// the explicit high-trust enrollments:manage permission and never accepts a
-// sandbox id. A Modal record therefore cannot be removed through this operation.
+// the explicit enrollments:manage permission. Removal accepts enrollment ids,
+// never sandbox ids; a Modal record cannot be removed through this operation.
 function registerConnectedMachineTools(
   server: McpServer,
   deps: ApiRouteDeps,
@@ -3808,11 +3811,40 @@ function registerConnectedMachineTools(
   sessionId: string | null,
   json: JsonResult,
 ): void {
+  server.registerTool(
+    "connected_machine_enroll_token",
+    {
+      description:
+        "Create a short-lived Connected Machine enrollment token for this workspace using existing enrollments:manage authority. Returns the token, expiry and Unix/PowerShell install commands. Run the appropriate command on the intended machine through an already-authorized execution path, then verify it with sandboxes_list. No separate device approval is required. Screen control is optional and defaults off. The token grants whole-machine access on enrollment; do not put it in public code or unrelated logs. Existing machine connections are preserved.",
+      inputSchema: { allowScreenControl: z4.boolean().optional() },
+    },
+    async ({ allowScreenControl }) => {
+      if (sessionId) {
+        await authorizeFirstPartySession(deps, grant, sessionId, "session.first_party_mcp.call");
+      }
+      const minted = await mintEnrollToken(deps, {
+        accountId: grant.accountId,
+        workspaceId: grant.workspaceId,
+        allowScreenControl: allowScreenControl ?? false,
+      });
+      if (!minted) throw new Error("enrollment credential plane is not configured");
+      const base = (deps.settings.publicBaseUrl ?? "https://app.opengeni.ai").replace(/\/+$/, "");
+      const unixQuote = (value: string) => `'${value.replaceAll("'", "'\\''")}'`;
+      const windowsQuote = (value: string) => `'${value.replaceAll("'", "''")}'`;
+      return json({
+        ...minted,
+        workspaceId: grant.workspaceId,
+        allowScreenControl: allowScreenControl ?? false,
+        installCommandUnix: `curl -fsSL ${unixQuote(`${base}/install.sh`)} | OPENGENI_API_URL=${unixQuote(base)} OPENGENI_ENROLL_TOKEN=${unixQuote(minted.token)} sh`,
+        installCommandWindows: `$env:OPENGENI_API_URL=${windowsQuote(base)}; $env:OPENGENI_ENROLL_TOKEN=${windowsQuote(minted.token)}; irm ${windowsQuote(`${base}/install.ps1`)} | iex`,
+      });
+    },
+  );
   server.registerTool(
     "connected_machine_remove",
     {
       description:
-        "Remove one enrolled self-hosted machine while it is offline. Access is revoked, future heartbeat/reconnect credentials are rejected, and session, route, lease, archive, and audit history is retained. Idle dependent sessions are detached atomically; machine-home sessions become compute-less (backend none) until another sandbox is selected. Active turns, live leases, and recovery work remain fail-closed blockers whose typed outcome explains what must settle before retrying. Pass the enrollmentId from the Machines surface, never a Modal sandbox id. Reconnecting later requires a fresh human-approved device-flow enrollment.",
+        "Remove one enrolled self-hosted machine while it is offline. Access is revoked, future heartbeat/reconnect credentials are rejected, and session, route, lease, archive, and audit history is retained. Idle dependent sessions are detached atomically; machine-home sessions become compute-less (backend none) until another sandbox is selected. Active turns, live leases, and recovery work remain fail-closed blockers whose typed outcome explains what must settle before retrying. Pass the enrollmentId from the Machines surface, never a Modal sandbox id. Reconnecting later requires fresh enrollment through device approval or an authorized enrollment token.",
       inputSchema: {
         enrollmentId: z4.string().uuid(),
         expectedUpdatedAt: z4.string().datetime({ offset: true }).optional(),
@@ -4221,6 +4253,24 @@ function registerWorkspaceOrchestrationTools(
   sessionCreateVisible: boolean,
   json: JsonResult,
 ): void {
+  const acknowledgeReads = async (children: { sessionId: string; sequences: number[] }[]) => {
+    if (
+      !callerSessionId ||
+      !exactAgentAttemptClaims(grant) ||
+      !children.some((child) => child.sequences.length > 0)
+    )
+      return;
+    // Never use grant.subjectId, session creator, or the latest queue human.
+    // Reauthorize after the bounded read, including after a blocking wait.
+    const actor = await requireLiveAgentAttemptAuthorization(deps.db, grant, callerSessionId);
+    if (!actor.initiatingHumanSubjectId) return;
+    await acknowledgeConsumedChildEvents(deps.db, {
+      workspaceId: grant.workspaceId,
+      sessionId: callerSessionId,
+      subjectId: actor.initiatingHumanSubjectId,
+      children,
+    });
+  };
   if (can("sessions:read")) {
     server.registerTool(
       "sessions_list",
@@ -4572,31 +4622,31 @@ function registerWorkspaceOrchestrationTools(
         if (view !== "debug" && !auditRequested) {
           const { readSessionEventView } = await import("./session-event-view");
           const { listSessionEventSlices } = await import("@opengeni/db/session-event-slices");
-          return json(
-            await readSessionEventView(
-              {
+          const page = await readSessionEventView(
+            {
+              sessionId,
+              view,
+              cursor,
+              callId,
+              includeArguments,
+              includeOutput,
+              after,
+              before,
+              direction: requestedDirection,
+              limit,
+            },
+            (options) =>
+              listSessionEventSlices(
+                deps.db,
+                grant.workspaceId,
                 sessionId,
-                view,
-                cursor,
-                callId,
-                includeArguments,
-                includeOutput,
-                after,
-                before,
-                direction: requestedDirection,
-                limit,
-              },
-              (options) =>
-                listSessionEventSlices(
-                  deps.db,
-                  grant.workspaceId,
-                  sessionId,
-                  options,
-                  (legacyOptions) =>
-                    listSessionEventPage(deps.db, grant.workspaceId, sessionId, legacyOptions),
-                ),
-            ),
+                options,
+                (legacyOptions) =>
+                  listSessionEventPage(deps.db, grant.workspaceId, sessionId, legacyOptions),
+              ),
           );
+          await acknowledgeReads([{ sessionId, sequences: completeChildReadSequences(page) }]);
+          return json(page);
         }
         if (
           cursor !== undefined ||
@@ -4640,33 +4690,48 @@ function registerWorkspaceOrchestrationTools(
         });
         if (requestedResultMode === "compact") {
           const event = dbPage.events[0];
-          return json(
-            event
-              ? boundSessionEventCompactResult(
-                  compactSessionEventResult(
-                    event,
-                    latestClass!,
-                    dbPage.coveredSequence ?? {
-                      first: event.sequence,
-                      last: event.sequence,
-                    },
-                  ),
-                )
-              : null,
-          );
+          const result = event
+            ? boundSessionEventCompactResult(
+                compactSessionEventResult(
+                  event,
+                  latestClass!,
+                  dbPage.coveredSequence ?? {
+                    first: event.sequence,
+                    last: event.sequence,
+                  },
+                ),
+              )
+            : null;
+          if (
+            result &&
+            ["turn.completed", "agent.message.completed"].includes(result.type) &&
+            !result.truncation.truncated &&
+            dbPage.fullPayloadsExact
+          ) {
+            await acknowledgeReads([{ sessionId, sequences: [result.sequence] }]);
+          }
+          return json(result);
         }
-        return json(
-          boundSessionEventMcpPage({
-            events: dbPage.events,
-            mode,
-            payloadMode,
-            direction,
-            sourceHasMore: dbPage.hasMore,
-            sourceTruncatedBy: dbPage.truncatedBy,
-            after: after ?? 0,
-            before: before ?? null,
-          }),
-        );
+        const page = boundSessionEventMcpPage({
+          events: dbPage.events,
+          mode,
+          payloadMode,
+          direction,
+          sourceHasMore: dbPage.hasMore,
+          sourceTruncatedBy: dbPage.truncatedBy,
+          after: after ?? 0,
+          before: before ?? null,
+        });
+        if (
+          payloadMode === "full" &&
+          dbPage.fullPayloadsExact &&
+          !page.truncation?.reasons.includes("model_payload")
+        ) {
+          await acknowledgeReads([
+            { sessionId, sequences: page.events.map((event) => event.sequence) },
+          ]);
+        }
+        return json(page);
       },
     );
 
@@ -4721,56 +4786,65 @@ function registerWorkspaceOrchestrationTools(
         // (tests) may pass no extra at all.
         const signal: AbortSignal | undefined = extra?.signal;
         const workspaceId = grant.workspaceId;
+        const incompleteWaitEvents = new Set<string>();
         // A NATS subscription is live fanout only; the durable session_events
         // read below is the authority. Bun.serve idleTimeout (255 s) and the
         // 60 s MCP client request timeout both exceed the 50 s cap.
-        return json(
-          await waitForSessionChanges({
-            targets,
-            ownSessionId,
-            maxWaitMs: (maxWaitSeconds ?? SESSION_WAIT_DEFAULT_SECONDS) * 1_000,
-            targetEventTypes,
-            targetEventMatches:
-              waitFor === "completion" ? sessionWaitCompletionEventMatches : undefined,
-            signal,
-            source: {
-              reauthorizeTargets: async (sessionIds) => {
-                for (const targetSessionId of sessionIds) {
-                  await authorizeFirstPartySession(
-                    deps,
-                    grant,
-                    targetSessionId,
-                    "session.events.read",
-                  );
-                }
-              },
-              readTargetEvents: async (target) => {
-                const page = await listSessionEventPage(deps.db, workspaceId, target.sessionId, {
-                  after: target.afterSequence,
-                  direction: "after",
-                  limit: SESSION_WAIT_EVENTS_PER_TARGET,
-                  payloadMode: "full",
-                  includeTypes: targetEventTypes,
-                  maxBytes: SESSION_EVENT_MCP_MAX_BYTES * 4,
-                });
-                return { events: page.events, hasMore: page.hasMore };
-              },
-              readOwnPendingUpdateKinds:
-                ownSessionId === null
-                  ? null
-                  : async () =>
-                      (
-                        await listOutstandingSessionSystemUpdates(
-                          deps.db,
-                          workspaceId,
-                          ownSessionId,
-                        )
-                      ).map((update) => update.kind),
-              subscribe: (targetSessionId, onEvents) =>
-                deps.bus.subscribe(workspaceId, targetSessionId, onEvents),
+        const result = await waitForSessionChanges({
+          targets,
+          ownSessionId,
+          maxWaitMs: (maxWaitSeconds ?? SESSION_WAIT_DEFAULT_SECONDS) * 1_000,
+          targetEventTypes,
+          targetEventMatches:
+            waitFor === "completion" ? sessionWaitCompletionEventMatches : undefined,
+          signal,
+          source: {
+            reauthorizeTargets: async (sessionIds) => {
+              for (const targetSessionId of sessionIds) {
+                await authorizeFirstPartySession(
+                  deps,
+                  grant,
+                  targetSessionId,
+                  "session.events.read",
+                );
+              }
             },
-          }),
-        );
+            readTargetEvents: async (target) => {
+              const page = await listSessionEventPage(deps.db, workspaceId, target.sessionId, {
+                after: target.afterSequence,
+                direction: "after",
+                limit: SESSION_WAIT_EVENTS_PER_TARGET,
+                payloadMode: "full",
+                includeTypes: targetEventTypes,
+                maxBytes: SESSION_EVENT_MCP_MAX_BYTES * 4,
+              });
+              if (!page.fullPayloadsExact) {
+                for (const event of page.events) incompleteWaitEvents.add(event.id);
+              }
+              return { events: page.events, hasMore: page.hasMore };
+            },
+            readOwnPendingUpdateKinds:
+              ownSessionId === null
+                ? null
+                : async () =>
+                    (
+                      await listOutstandingSessionSystemUpdates(deps.db, workspaceId, ownSessionId)
+                    ).map((update) => update.kind),
+            subscribe: (targetSessionId, onEvents) =>
+              deps.bus.subscribe(workspaceId, targetSessionId, onEvents),
+          },
+        });
+        if (!result.aborted && !result.truncated) {
+          await acknowledgeReads(
+            result.changed.map((target) => ({
+              sessionId: target.sessionId,
+              sequences: target.events
+                .filter((event) => event.contentComplete && !incompleteWaitEvents.has(event.id))
+                .map((event) => event.sequence),
+            })),
+          );
+        }
+        return json(result);
       },
     );
 

package/src/mcp/session-wait.ts

@@ -164,6 +164,8 @@ export function sessionWaitSemanticClass(type: SessionEventType): SessionEventSe
 export type SessionWaitTarget = { sessionId: string; afterSequence: number };
 
 export type SessionWaitEventSummary = {
+  /** True only when every semantic result field survived all projections. */
+  contentComplete?: boolean;
   id: string;
   sequence: number;
   type: SessionEventType;
@@ -521,6 +523,20 @@ export function summarizeSessionWaitEvent(
   } else if (typeof compact.result === "string" && compact.result !== compact.text) {
     summary.result = clampSummaryString(compact.result, textChars);
   }
+  // Other wait summaries may omit actionable fields (e.g. human-input
+  // questions); absence of a truncation marker is not proof of full content.
+  summary.contentComplete =
+    ["turn.completed", "agent.message.completed"].includes(event.type) &&
+    !compact.truncation.truncated &&
+    text === compact.text &&
+    JSON.stringify(failure) === JSON.stringify(compact.failure) &&
+    (compact.output === null ||
+      compact.output === compact.text ||
+      JSON.stringify(compact.output) === JSON.stringify(summary.result)) &&
+    (compact.result === null ||
+      compact.result === undefined ||
+      compact.result === compact.text ||
+      JSON.stringify(summary.result) === JSON.stringify(compact.result));
   return summary;
 }
 
@@ -570,6 +586,7 @@ export function boundSessionWaitResult(
       ...target,
       events: target.events.map((event) => ({
         ...event,
+        contentComplete: false,
         text: event.text === null ? null : clampSummaryString(event.text, textChars),
         ...(typeof event.result === "string"
           ? { result: clampSummaryString(event.result, textChars) }

package/src/routes/codex.ts

@@ -7,14 +7,18 @@
 // is added to isAuthExempt. Secrets never leave the server: status/usage read the
 // decrypted token only to call the codex backend; the token is never returned.
 
-import { environmentsEncryptionKeyBytes, productLabelForModelId } from "@opengeni/config";
+import {
+  environmentsEncryptionKeyBytes,
+  configuredModels,
+  getSettings,
+  withCodexCatalogProvider,
+  type Settings,
+} from "@opengeni/config";
 import {
   accessTokenExpiry,
   buildCodexUsageWindowFromCache,
   CODEX_CLIENT_VERSION,
-  CODEX_FALLBACK_MODEL_SLUGS,
   CODEX_FIVE_HOUR_WINDOW_SECONDS,
-  CODEX_MODEL_ID_PREFIX,
   CODEX_PROVIDER_ID,
   CODEX_WEEKLY_WINDOW_SECONDS,
   CodexDeviceError,
@@ -193,20 +197,22 @@ function codexUsageJson(payload: CodexUsagePayload): {
   return { status: payload.status, usage: payload };
 }
 
-export function codexModelsForPicker(): Array<{
+export function codexModelsForPicker(settings: Settings = getSettings()): Array<{
   id: string;
   label: string;
   provider: string;
   providerLabel: string;
   api: "responses";
 }> {
-  return CODEX_FALLBACK_MODEL_SLUGS.map((slug) => ({
-    id: `${CODEX_MODEL_ID_PREFIX}${slug}`,
-    label: productLabelForModelId(slug),
-    provider: CODEX_PROVIDER_ID,
-    providerLabel: CODEX_PROVIDER_LABEL,
-    api: "responses" as const,
-  }));
+  return configuredModels(withCodexCatalogProvider(settings))
+    .filter((model) => model.providerId === CODEX_PROVIDER_ID)
+    .map((model) => ({
+      id: model.id,
+      label: model.label,
+      provider: CODEX_PROVIDER_ID,
+      providerLabel: CODEX_PROVIDER_LABEL,
+      api: "responses" as const,
+    }));
 }
 import { createSignedState, readSignedState } from "@opengeni/github";
 import {
@@ -214,6 +220,7 @@ import {
   hasPermission,
   requireAccessGrant,
   requireCanonicalLocalAccountAdministrator,
+  resolveCatalogSettings,
   type ApiRouteDeps,
 } from "@opengeni/core";
 import type { Context, Hono } from "hono";
@@ -1284,7 +1291,7 @@ export function registerCodexRoutes(app: Hono, deps: ApiRouteDeps): void {
       now: new Date(),
     });
     let valid = false;
-    const models = codexModelsForPicker();
+    const models = codexModelsForPicker((await resolveCatalogSettings(db, settings)).settings);
     let catalogError: string | null = null;
     try {
       const cred = status?.credentialId

package/src/routes/skill-content.ts

@@ -1,8 +1,8 @@
 import { z } from "zod";
 import type { Context, Hono } from "hono";
 import { HTTPException } from "hono/http-exception";
-import { SkillFile, type SkillWriteReceipt } from "@opengeni/contracts";
-import { readSkillRemovalScope } from "@opengeni/db";
+import { SkillFile, SKILL_MAX_FILES, type SkillWriteReceipt } from "@opengeni/contracts";
+import { getSessionForSubject, readSkillRemovalScope } from "@opengeni/db";
 import {
   approveSkill,
   rejectSkill,
@@ -27,8 +27,8 @@ const saveRequest = z
     expectedScopeVersion: z.number().int().nonnegative(),
     scope: scopeSchema.default("workspace"),
     stableKey: z.string().min(1).max(96),
-    files: z.array(SkillFile).max(128),
-    deletions: z.array(z.string().min(1).max(512)).max(128).default([]),
+    files: z.array(SkillFile).max(SKILL_MAX_FILES),
+    deletions: z.array(z.string().min(1).max(512)).max(SKILL_MAX_FILES).default([]),
     reason: z.string().min(1).max(2000),
   })
   .strict();
@@ -66,9 +66,20 @@ export function registerSkillContentRoutes(app: Hono, deps: ApiRouteDeps): void
       .object({
         limit: z.coerce.number().int().min(1).max(250).default(100),
         cursor: z.string().max(2048).optional(),
+        sessionId: z.uuid().optional(),
       })
       .safeParse(c.req.query());
     if (!query.success) throw new HTTPException(422, { message: "Invalid Skill list query" });
+    if (query.data.sessionId) {
+      await requireAccessGrant(c, deps, workspaceId, "sessions:read");
+      const session = await getSessionForSubject(
+        deps.db,
+        workspaceId,
+        query.data.sessionId,
+        grant.subjectId,
+      );
+      if (!session) throw new HTTPException(404, { message: "Session not found" });
+    }
     let after: { stableKey: string; id: string } | undefined;
     if (query.data.cursor !== undefined) {
       try {
@@ -83,7 +94,12 @@ export function registerSkillContentRoutes(app: Hono, deps: ApiRouteDeps): void
     const rows = await listSkills(
       deps.db,
       { accountId: grant.accountId, workspaceId, subjectId: grant.subjectId },
-      { limit: query.data.limit + 1, metadataOnly: true, ...(after ? { after } : {}) },
+      {
+        limit: query.data.limit + 1,
+        metadataOnly: true,
+        ...(after ? { after } : {}),
+        ...(query.data.sessionId ? { sessionId: query.data.sessionId } : {}),
+      },
     );
     const page = rows.slice(0, query.data.limit);
     const last = page.at(-1);

package/src/sandbox/machines.ts

@@ -33,7 +33,7 @@ import {
   type MachineMetricsRow,
 } from "@opengeni/db";
 import { MachineView, MetricSample, type MachinesResponse } from "@opengeni/contracts";
-import { managedSessionGroupBackend } from "@opengeni/core";
+import { managedSessionGroupBackend, sessionGroupMachinePresentation } from "@opengeni/core";
 import { selfhostedHeartbeatLiveness } from "@opengeni/runtime/sandbox";
 
 export type MachinesServices = {
@@ -258,23 +258,24 @@ export async function listMachines(
   if (session && groupBackend) {
     const groupActive = activeSandboxId === null;
     const groupLease = await readLease(db, workspaceId, session.sandboxGroupId);
+    const presentation = sessionGroupMachinePresentation(groupBackend);
+    const localHost = groupBackend === "local";
     machines.push(
       MachineView.parse({
         sandboxId: session.sandboxGroupId,
         enrollmentId: null,
-        name: "session sandbox",
-        kind: groupBackend === "opensandbox" ? "opensandbox" : "modal",
+        name: presentation.name,
+        kind: presentation.kind,
         state: "online",
         active: groupActive,
         isSessionGroup: true,
         workspaceGeneration: groupLease?.workspaceGeneration ?? null,
         archiveGeneration: groupLease?.archiveGeneration ?? null,
         archiveComplete: groupLease?.archiveComplete ?? false,
-        // The Modal group box is a cloud Linux box; its precise OS/arch is not
-        // surfaced as a metric, so the dashboard shows the canonical linux/x86_64.
-        os: "linux",
-        arch: "x86_64",
-        hasDisplay: false,
+        // A local sandbox is this machine. Other managed providers run a Linux box.
+        os: localHost ? process.platform : "linux",
+        arch: localHost ? process.arch : "x86_64",
+        hasDisplay: localHost,
         desktopUnavailableReason: null,
         allowScreenControl: false,
         sharedSessionCount: 1,

package/src/sandbox-file-artifacts.ts

@@ -295,6 +295,14 @@ export function sandboxFileContentType(filename: string): string {
       ".jpg": "image/jpeg",
       ".json": "application/json",
       ".md": "text/markdown",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".ogv": "video/ogg",
+      ".mp3": "audio/mpeg",
+      ".m4a": "audio/mp4",
+      ".ogg": "audio/ogg",
+      ".wav": "audio/wav",
+      ".flac": "audio/flac",
       ".pdf": "application/pdf",
       ".png": "image/png",
       ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
@@ -314,7 +322,13 @@ export function sandboxArtifactIdentity(input: {
   sha256: string;
 }): { fileId: string; uploadId: string } {
   const digest = createHash("sha256")
-    .update("opengeni-sandbox-file-artifact-v1\0")
+    // Newly classified media must not collide with old binary-typed publications.
+    // Preserve the v1 identity for every previously supported format.
+    .update(
+      /^(audio|video)\//.test(sandboxFileContentType(input.path))
+        ? "opengeni-sandbox-media-artifact-v1\0"
+        : "opengeni-sandbox-file-artifact-v1\0",
+    )
     .update(input.workspaceId)
     .update("\0")
     .update(input.sessionId)

package/src/site-uploads.ts

@@ -1,5 +1,6 @@
 import { WorkspaceArtifactSourceBundle, type AccessGrant } from "@opengeni/contracts";
 import type { ApiRouteDeps, ObjectStorageDependency } from "@opengeni/core";
+import { retryWhileMissing } from "@opengeni/storage";
 import {
   createWorkspaceArtifactUpload,
   getWorkspaceArtifactUpload,
@@ -19,10 +20,15 @@ export async function validateSiteSource(storage: Storage, key: string, sizeByte
       "Editable source JSON must be at most 64 MiB. Exclude dependencies and build output; HTML has a separate storage limit.",
     );
   }
-  const content = await storage.getObjectBytes(key);
+  const content = await retryWhileMissing(() => storage.getObjectBytes(key));
+  if (!content) {
+    throw new WorkspaceArtifactOperationError(
+      "Site source is not available yet. Retry publication with the same upload.",
+    );
+  }
   try {
     WorkspaceArtifactSourceBundle.parse(
-      JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(content!.bytes)),
+      JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(content.bytes)),
     );
   } catch {
     throw new WorkspaceArtifactOperationError(
@@ -129,13 +135,22 @@ async function freeze(
     }
     decoder.decode();
   }
-  await storage.putObjectStreamIfAbsent({
+  const created = await storage.putObjectStreamIfAbsent({
     key: to,
     contentType,
     byteSize: head.ContentLength,
     chunks: chunks(),
   });
-  return (await storage.headObject(to))!.ContentLength!;
+  // A successful conditional PUT is the receipt. A following visibility miss
+  // cannot invalidate it. Only a conflict needs the existing winner's metadata.
+  if (created) return head.ContentLength;
+  const stored = await retryWhileMissing(() => storage.headObject!(to));
+  if (!stored || stored.ContentLength === undefined) {
+    throw new WorkspaceArtifactOperationError(
+      "Frozen Site upload is unavailable. Retry publication with the same upload.",
+    );
+  }
+  return stored.ContentLength;
 }
 type Input = Partial<Parameters<typeof prepareWorkspaceArtifactContent>[2]> & { uploadId?: string };
 export async function prepareWorkspaceArtifactPublication(