@opengeni/worker-bundle 1.0.0-canary.1 → 1.0.0

package/src/activities/parent-wake.ts

@@ -1,13 +1,17 @@
+import { getSessionParentClaudeProviderAccountAuthority } from "@opengeni/db";
 import type { Settings } from "@opengeni/config";
 import type { Session, SessionGoal, SessionSystemUpdatePayload } from "@opengeni/contracts";
 import {
   getSession,
   getSessionGoal,
   getSessionParentPersonalConnectionDelegations,
+  getSessionParentMcpAccountBindings,
   getSessionParentXaiProviderAccountAuthority,
   addSessionSystemUpdateWithSourceMutation,
   claimPendingSessionSystemUpdateOutbox,
   claimPendingSessionWorkflowWakes,
+  repairPendingChildTerminalResultWakes,
+  type ChildTerminalWakeRepairCursor,
   childRequiresActionDedupeKey,
   getSessionSystemUpdateOutboxByDedupeKey,
   getOrCreateSessionSystemUpdateOutbox,
@@ -38,8 +42,11 @@ export type ReconcileParentSystemUpdateOverrides = Partial<{
 
 export type ReconcileSessionWorkflowWakeOverrides = Partial<{
   claimPendingSessionWorkflowWakes: typeof claimPendingSessionWorkflowWakes;
+  repairPendingChildTerminalResultWakes: typeof repairPendingChildTerminalResultWakes;
 }>;
 
+const childTerminalRepairCursors = new WeakMap<Database, ChildTerminalWakeRepairCursor>();
+
 export type ReconcileAutomaticSessionTitleFanoutOverrides = Partial<{
   claimAutomaticSessionTitleFanout: typeof claimAutomaticSessionTitleFanout;
   markAutomaticSessionTitleFanoutDelivered: typeof markAutomaticSessionTitleFanoutDelivered;
@@ -63,23 +70,30 @@ export async function notifyParentOfChildIdle(
       return;
     }
     const goal = await getSessionGoal(svc.db, workspaceId, childSessionId);
-    // Sacred user pause: if the MANAGER's own goal was paused by the user, the
-    // wake must not tell it to "resume it now" — that instruction is exactly
-    // what re-arms the loop the user just stopped. Suppress the resume nudge and
-    // tell the agent to stay paused. Paired with the goal_set reactivation
-    // guard so a nudge that slips through still cannot revive the goal.
     const clientEventId = `child-completion:${childSessionId}:${episodeKey}`;
+    // The idle settlement committed this row with the child's frozen final
+    // answer. This adds the goal facts; the upsert keeps the frozen content.
     const payload = childCompletionPayload(child, goal);
     const personalConnectionDelegations = await getSessionParentPersonalConnectionDelegations(
       svc.db,
       workspaceId,
       childSessionId,
     );
+    const mcpAccountBindings = await getSessionParentMcpAccountBindings(
+      svc.db,
+      workspaceId,
+      childSessionId,
+    );
     const xaiAuthority = await getSessionParentXaiProviderAccountAuthority(
       svc.db,
       workspaceId,
       childSessionId,
     );
+    const claudeAuthority = await getSessionParentClaudeProviderAccountAuthority(
+      svc.db,
+      workspaceId,
+      childSessionId,
+    );
     const outbox = await getOrCreateSessionSystemUpdateOutbox(svc.db, {
       accountId: child.accountId,
       workspaceId,
@@ -92,12 +106,17 @@ export async function notifyParentOfChildIdle(
       summary: childCompletionSummary(child, goal, "idle"),
       payload,
       lineage: {
+        ...(claudeAuthority.subjectId
+          ? { claudeAuthoritySubjectId: claudeAuthority.subjectId }
+          : {}),
         childSessionId: child.id,
         parentSessionId: child.parentSessionId,
         ...(xaiAuthority.subjectId ? { xaiAuthoritySubjectId: xaiAuthority.subjectId } : {}),
       },
       personalConnectionDelegations,
+      mcpAccountBindings,
       xaiProviderAccountAuthoritySnapshot: xaiAuthority.snapshot,
+      claudeProviderAccountAuthoritySnapshot: claudeAuthority.snapshot,
     });
     if (outbox.status === "delivered") {
       return;
@@ -214,7 +233,9 @@ async function deliverParentSystemUpdateOutbox(
         summary: outbox.summary,
         lineage: outbox.lineage,
         personalConnectionDelegations: outbox.personalConnectionDelegations,
+        mcpAccountBindings: outbox.mcpAccountBindings,
         xaiProviderAccountAuthoritySnapshot: outbox.xaiProviderAccountAuthoritySnapshot,
+        claudeProviderAccountAuthoritySnapshot: outbox.claudeProviderAccountAuthoritySnapshot,
       },
       async (tx) => {
         await markSessionSystemUpdateOutboxDeliveredInTransaction(tx, outbox);
@@ -370,6 +391,22 @@ export async function reconcilePendingSessionWorkflowWakes(
       pendingAdmissionBlockers: {},
     };
   }
+  const repairChildren =
+    overrides.repairPendingChildTerminalResultWakes ?? repairPendingChildTerminalResultWakes;
+  const inventory = await repairChildren(
+    svc.db,
+    Math.min(100, limit),
+    childTerminalRepairCursors.get(svc.db) ?? null,
+  );
+  if (inventory.cursor) childTerminalRepairCursors.set(svc.db, inventory.cursor);
+  else childTerminalRepairCursors.delete(svc.db);
+  if (inventory.failed > 0) {
+    svc.observability.error("Pending child-result wake repair failed", {
+      examined: inventory.examined,
+      registered: inventory.registered,
+      failed: inventory.failed,
+    });
+  }
   const repairs = await claimPendingSessionWorkflowWakesFn(svc.db, limit);
   let signaled = 0;
   let pendingAdmission = 0;
@@ -457,11 +494,10 @@ function childCompletionPayload(
 }
 
 /**
- * The worker-specific lines for one child (what happened + its goal), WITHOUT
- * the trailing "what to do next" instruction. Kept separate so N child
- * completions can be coalesced into one internal-update inference: the DB layer
- * stores each child's summary and rebuilds a single numbered digest with one
- * shared trailing instruction instead of running N model calls.
+ * The short status line for one child (what happened + its goal). It is also
+ * the timeline preview, so it carries no instructions: the parent reads the
+ * child's answer from the typed payload, and the operational contract says how
+ * to use it. N completions coalesce into one internal-update inference.
  */
 export function childCompletionSummary(
   child: Session,
@@ -495,14 +531,3 @@ export function childCompletionSummary(
   }
   return lines.join("\n");
 }
-
-/**
- * The single trailing instruction appended to a child-completion (or digest)
- * inference. Suppresses the "resume it now" nudge when the manager's own goal
- * was paused by the user (paired with the goal_set reactivation guard).
- */
-export function childCompletionTrailing(parentGoalUserPaused: boolean): string {
-  return parentGoalUserPaused
-    ? "Read each worker's session events/notebook output for its result. This session was paused by the user — do NOT resume or replace your goal; summarize the result for the user and remain paused."
-    : "Read each worker's session events/notebook output for its result, then continue. If your own goal was paused awaiting these workers, resume it now.";
-}

package/src/activities/retained-screenshots.ts

@@ -6,13 +6,16 @@ import {
   COMPUTER_SCREENSHOT_WORKSPACE_QUOTA_BYTES,
   RetainedArtifactMetadataSchema,
   retainedScreenshotReferenceFromFile,
+  retainedSessionScreenshotKindFromObjectKey,
   type RetainedArtifactMetadata,
   type RetainedArtifactReference,
   type RetainedOutputUnavailableReason,
+  type RetainedSessionScreenshotKind,
 } from "@opengeni/contracts";
 import {
   RetainedScreenshotQuotaExceededError,
   getRetainedScreenshotArtifact,
+  getRetainedScreenshotArtifactForToolCall,
   isDatabasePersistenceFailure,
   isSessionEventPersistenceError,
   prepareRetainedScreenshotArtifact,
@@ -209,14 +212,26 @@ export function toolOutputContainsInlineImage(output: unknown): boolean {
       return (
         (record.type === "input_image" &&
           sdkImageSourceContainsInlineImage(record.image ?? record.image_url ?? record.imageUrl)) ||
-        (record.type === "image" && decodeInlineMcpImage(record.data, record.mimeType) !== null)
+        (record.type === "image" && isDeclaredInlineMcpImage(record))
       );
     });
   }
   if (!output || typeof output !== "object") return false;
   const record = output as Record<string, unknown>;
   if (Array.isArray(record.content)) return toolOutputContainsInlineImage(record.content);
-  return record.type === "image" && sdkImageSourceContainsInlineImage(record.image);
+  return (
+    record.type === "image" &&
+    (sdkImageSourceContainsInlineImage(record.image) || isDeclaredInlineMcpImage(record))
+  );
+}
+
+/** Detect image-bearing MCP blocks even when decoding rejects oversized or malformed bytes. */
+function isDeclaredInlineMcpImage(record: Record<string, unknown>): boolean {
+  return (
+    typeof record.data === "string" &&
+    typeof record.mimeType === "string" &&
+    record.mimeType.toLowerCase().startsWith("image/")
+  );
 }
 
 function decodeInlineMcpImage(
@@ -520,9 +535,14 @@ export function retainedScreenshotIdentity(input: {
   attemptId: string;
   toolCallId: string;
   toolOutputId: string;
+  kind?: RetainedSessionScreenshotKind | undefined;
 }): { artifactId: string; settlementKey: string } {
   const settlementKey = createHash("sha256")
-    .update("opengeni:computer-screenshot:v1\0")
+    .update(
+      input.kind === "browser_screenshot"
+        ? "opengeni:browser-screenshot:v1\0"
+        : "opengeni:computer-screenshot:v1\0",
+    )
     .update(input.sessionId)
     .update("\0")
     .update(input.turnId)
@@ -551,12 +571,13 @@ export function unavailableRetainedSessionImage(input: {
   toolCallId: string;
   toolOutputId: string;
   reason: RetainedOutputUnavailableReason;
+  kind?: RetainedSessionScreenshotKind | undefined;
 }): RetainedArtifactMetadata {
   const identity = retainedScreenshotIdentity(input);
   return unavailable(identity.artifactId, input.reason);
 }
 
-export async function retainComputerScreenshot(input: {
+export async function retainSessionScreenshot(input: {
   db: Database;
   objectStorage: ObjectStorage | null;
   accountId: string;
@@ -565,6 +586,7 @@ export async function retainComputerScreenshot(input: {
   turnId: string;
   attemptId: string;
   output: TypedScreenshotToolOutput;
+  kind?: RetainedSessionScreenshotKind | undefined;
   now?: Date;
   retentionMs?: number;
   workspaceQuotaBytes?: number;
@@ -575,6 +597,7 @@ export async function retainComputerScreenshot(input: {
     attemptId: input.attemptId,
     toolCallId: input.output.callId,
     toolOutputId: input.output.toolOutputId,
+    kind: input.kind,
   });
   let screenshot: ValidatedSessionImage;
   try {
@@ -594,7 +617,8 @@ export async function retainComputerScreenshot(input: {
   const retentionExpiresAt = new Date(
     now.getTime() + (input.retentionMs ?? COMPUTER_SCREENSHOT_RETENTION_MS),
   );
-  const objectKey = `workspaces/${input.workspaceId}/files/${identity.artifactId}/retained/session-image.${screenshot.extension}`;
+  const objectName = input.kind === "browser_screenshot" ? "browser-screenshot" : "session-image";
+  const objectKey = `workspaces/${input.workspaceId}/files/${identity.artifactId}/retained/${objectName}.${screenshot.extension}`;
   let prepared: RetainedScreenshotArtifact;
   try {
     prepared = (
@@ -697,6 +721,9 @@ export async function retainComputerScreenshot(input: {
   }
 }
 
+/** Existing computer callers keep their stable entry point. */
+export const retainComputerScreenshot = retainSessionScreenshot;
+
 /** Replace only new screenshot bytes with a compact receipt before first persistence. */
 export function compactRetainedScreenshotHistory(
   history: Array<Record<string, unknown>>,
@@ -874,6 +901,26 @@ async function materializeRetainedScreenshotHistoryWithCache(
   cache: Map<string, string>,
 ): Promise<Array<Record<string, unknown>>> {
   const now = input.now ?? new Date();
+  const receiptForMarker = async (
+    marker: unknown,
+    callId: string | null,
+  ): Promise<RetainedArtifactMetadata | null> => {
+    if (!isRetainedImageMarker(marker)) return null;
+    const receipt = retainedReceipt(marker.artifact);
+    if (receipt) return receipt;
+    // Older canonical history could truncate the artifact UUID and reason as
+    // ordinary text. Recover only from this exact session and an unambiguous
+    // tool call; otherwise fail before constructing a malformed model image.
+    if (!callId) throw new Error("Retained screenshot receipt has no tool call identity");
+    const artifact = await getRetainedScreenshotArtifactForToolCall(
+      input.db,
+      input.workspaceId,
+      input.sessionId,
+      callId,
+    );
+    if (!artifact) throw new Error("Retained screenshot receipt cannot be recovered");
+    return reference(artifact);
+  };
   const dataUrlForReceipt = async (receipt: RetainedArtifactMetadata): Promise<string> => {
     let dataUrl = cache.get(receipt.artifactId);
     if (!dataUrl) {
@@ -921,8 +968,12 @@ async function materializeRetainedScreenshotHistoryWithCache(
     }
     return dataUrl;
   };
-  const materializeEntry = async (entry: unknown): Promise<unknown> => {
-    const receipt = retainedReceiptFromImageContent(entry);
+  const materializeEntry = async (entry: unknown, callId: string | null): Promise<unknown> => {
+    const image =
+      entry && typeof entry === "object" && !Array.isArray(entry)
+        ? (entry as Record<string, unknown>).image
+        : null;
+    const receipt = await receiptForMarker(image, callId);
     if (!receipt) return entry;
     const dataUrl = await dataUrlForReceipt(receipt);
     return { ...(entry as Record<string, unknown>), image: dataUrl };
@@ -930,7 +981,8 @@ async function materializeRetainedScreenshotHistoryWithCache(
 
   const materialized: Array<Record<string, unknown>> = [];
   for (const item of input.history) {
-    const directReceipt = retainedReceiptFromDirectOutput(item.output);
+    const callId = historyCallId(item);
+    const directReceipt = await receiptForMarker(item.output, callId);
     if (directReceipt) {
       materialized.push({
         ...item,
@@ -954,7 +1006,7 @@ async function materializeRetainedScreenshotHistoryWithCache(
     let changed = false;
     const output: unknown[] = [];
     for (const entry of outputEntries) {
-      const next = await materializeEntry(entry);
+      const next = await materializeEntry(entry, callId);
       changed ||= next !== entry;
       output.push(next);
     }
@@ -1059,12 +1111,15 @@ function reference(artifact: RetainedScreenshotArtifact): RetainedArtifactRefere
   if (!artifact.sessionId) {
     throw new Error(`Ready retained screenshot is detached: ${artifact.artifactId}`);
   }
+  const kind = retainedSessionScreenshotKindFromObjectKey(artifact.file.objectKey);
+  if (!kind) throw new Error(`Ready retained screenshot has unknown key: ${artifact.artifactId}`);
   const value = retainedScreenshotReferenceFromFile({
     ...artifact.file,
     sessionId: artifact.sessionId,
     width: artifact.width,
     height: artifact.height,
     expiresAt: artifact.retentionExpiresAt.toISOString(),
+    kind,
   });
   if (!value)
     throw new Error(`Ready retained screenshot receipt is invalid: ${artifact.artifactId}`);
@@ -1110,6 +1165,18 @@ function retainedReceiptFromImageContent(entry: unknown): RetainedArtifactMetada
   return retainedReceipt(marker.artifact);
 }
 
+function isRetainedImageMarker(value: unknown): value is {
+  type: "retained_artifact";
+  artifact: unknown;
+} {
+  return Boolean(
+    value &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    (value as Record<string, unknown>).type === RETAINED_IMAGE_MARKER,
+  );
+}
+
 function retainedReceiptFromDirectOutput(output: unknown): RetainedArtifactMetadata | null {
   if (!output || typeof output !== "object" || Array.isArray(output)) return null;
   const marker = output as Record<string, unknown>;
@@ -1120,7 +1187,11 @@ function retainedReceiptFromDirectOutput(output: unknown): RetainedArtifactMetad
 function retainedReceipt(value: unknown): RetainedArtifactMetadata | null {
   const parsed = RetainedArtifactMetadataSchema.safeParse(value);
   if (!parsed.success) return null;
-  return parsed.data.available && parsed.data.kind !== "computer_screenshot" ? null : parsed.data;
+  return parsed.data.available &&
+    parsed.data.kind !== "computer_screenshot" &&
+    parsed.data.kind !== "browser_screenshot"
+    ? null
+    : parsed.data;
 }
 
 function isInlineImageContent(entry: unknown): boolean {
@@ -1130,7 +1201,7 @@ function isInlineImageContent(entry: unknown): boolean {
     (record.type === "input_image" &&
       typeof record.image === "string" &&
       record.image.startsWith("data:image/")) ||
-    (record.type === "image" && decodeInlineMcpImage(record.data, record.mimeType) !== null)
+    (record.type === "image" && isDeclaredInlineMcpImage(record))
   );
 }
 

package/src/activities/rig-verification.ts

@@ -60,7 +60,6 @@ import {
 import type { Context } from "@temporalio/activity";
 import type { ControlActivityServices } from "./types";
 import { rigProviderImageSourceImage } from "./sandbox-images";
-import { resolveWorkspacePackRuntime, type WorkspacePackRuntime } from "./packs";
 import { currentActivityContext } from "./streaming";
 
 type RigSetupHook = typeof import("@opengeni/runtime").runRigSetupHook;
@@ -175,7 +174,7 @@ const RIG_VERIFICATION_HEARTBEAT_MIN_INTERVAL_MS = 250;
 // lease-holder fiction or manual recovery.
 export const RIG_VERIFICATION_OWNER_TTL_MS = 20 * 60_000;
 export const RIG_VERIFICATION_OWNERS_DISABLED_MESSAGE =
-  "Rig verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
+  "Sandbox Environment verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
 const RIG_VERIFICATION_HOLDER_TOUCH_INTERVAL_MS = 10_000;
 const RIG_VERIFICATION_RELEASE_GRACE_MS = 1;
 
@@ -187,7 +186,7 @@ export class RigVerificationActivityDeadlineError extends Error {
     readonly cleanupReserveMs: number,
   ) {
     super(
-      `Rig verification activity-local deadline reached with ${cleanupReserveMs}ms reserved for cleanup before the ${startToCloseTimeoutMs}ms Temporal start-to-close timeout`,
+      `Sandbox Environment verification activity-local deadline reached with ${cleanupReserveMs}ms reserved for cleanup before the ${startToCloseTimeoutMs}ms Temporal start-to-close timeout`,
     );
   }
 }
@@ -223,7 +222,9 @@ export function createRigVerificationActivityLifecycle(
   const temporalSignal = context?.cancellationSignal;
   const forwardTemporalCancellation = (): void => {
     if (!controller.signal.aborted) {
-      controller.abort(temporalSignal?.reason ?? new Error("Rig verification cancelled"));
+      controller.abort(
+        temporalSignal?.reason ?? new Error("Sandbox Environment verification cancelled"),
+      );
     }
   };
   if (temporalSignal?.aborted) {
@@ -308,7 +309,7 @@ export function createRigVerificationActivityLifecycle(
 }
 
 function abortReason(signal: AbortSignal): unknown {
-  return signal.reason ?? new Error("Rig verification cancelled");
+  return signal.reason ?? new Error("Sandbox Environment verification cancelled");
 }
 
 function throwIfAborted(signal: AbortSignal): void {
@@ -433,7 +434,9 @@ export class RigVerificationLeaseUnavailableError extends Error {
     readonly sandboxGroupId: string,
     readonly role: "attached" | "blocked" | "rearmed" | "fenced",
   ) {
-    super(`Rig verification requires a new clean sandbox, but lease ${sandboxGroupId} was ${role}`);
+    super(
+      `Sandbox Environment verification requires a new clean sandbox, but lease ${sandboxGroupId} was ${role}`,
+    );
   }
 }
 
@@ -490,7 +493,7 @@ export async function runWithOwnedRigVerificationSandbox<T>(
   let establishmentPromise: Promise<EstablishedSandboxSession> | null = null;
 
   const warnCleanupTimeout = (operation: string, instanceId: string | null): void => {
-    input.observability.warn("rig verifier: ownership cleanup timed out", {
+    input.observability.warn("sandbox environment verifier: ownership cleanup timed out", {
       holderId,
       instanceId,
       operation,
@@ -504,7 +507,7 @@ export async function runWithOwnedRigVerificationSandbox<T>(
     instanceId: string | null,
     error: unknown,
   ): void => {
-    input.observability.warn("rig verifier: ownership cleanup failed", {
+    input.observability.warn("sandbox environment verifier: ownership cleanup failed", {
       holderId,
       instanceId,
       operation,
@@ -643,11 +646,14 @@ export async function runWithOwnedRigVerificationSandbox<T>(
               );
             } catch (error) {
               if (!signal.aborted) {
-                input.observability.warn("rig verifier: Modal ownership tag failed", {
-                  holderId,
-                  instanceId: created.instanceId,
-                  error: error instanceof Error ? error.message : String(error),
-                });
+                input.observability.warn(
+                  "sandbox environment verifier: Modal ownership tag failed",
+                  {
+                    holderId,
+                    instanceId: created.instanceId,
+                    error: error instanceof Error ? error.message : String(error),
+                  },
+                );
               }
             }
           }
@@ -913,10 +919,12 @@ function rigProviderImageContentMarker(
   markerRoot = "/var/opengeni",
 ): { marker: string; normalizedRoot: string } {
   if (!/^sha256:[0-9a-f]{64}$/u.test(contentHash)) {
-    throw new Error("Rig provider image content marker requires a canonical SHA-256 value");
+    throw new Error(
+      "Sandbox Environment provider image content marker requires a canonical SHA-256 value",
+    );
   }
   if (!/^\/[A-Za-z0-9._/-]+$/u.test(markerRoot)) {
-    throw new Error("Rig provider image marker root must be a safe absolute path");
+    throw new Error("Sandbox Environment provider image marker root must be a safe absolute path");
   }
   const normalizedRoot = markerRoot.replace(/\/+$/u, "") || "/";
   const marker = `${normalizedRoot === "/" ? "" : normalizedRoot}/rig-setup-content-${contentHash.slice("sha256:".length)}.done`;
@@ -978,7 +986,9 @@ export async function verifyRigProviderImageColdBoot(
         runContext.commandRunner,
       );
       if (markerResult.exitCode !== 0) {
-        throw new Error("built provider image is missing its exact rig-content marker");
+        throw new Error(
+          "built provider image is missing its exact sandbox environment-content marker",
+        );
       }
       for (const check of rigPlatformChecksForSettings(input.settings)) {
         const result = await runCommand(
@@ -1083,7 +1093,7 @@ export async function buildVerifiedRigProviderImage(input: {
         error: {
           code: "provider_image_content_conflict",
           message:
-            "this exact rig version already records a provider image for different effective content; mint and verify a new version",
+            "this exact sandbox environment version already records a provider image for different effective content; mint and verify a new version",
           retryable: false,
         },
       };
@@ -1276,13 +1286,10 @@ export async function buildVerifiedRigProviderImage(input: {
 
 export function settingsForRigVerification(
   settings: ControlActivityServices["settings"],
-  packRuntime: WorkspacePackRuntime,
   rigImage: string | null,
 ): ControlActivityServices["settings"] {
   // Rig verification must prove setup and provider-image materialization on
-  // the deployment-owned platform base. Legacy Pack and historical Rig image
-  // values are intentionally ignored here.
-  void packRuntime;
+  // the deployment-owned platform base. Historical Rig image values are ignored.
   void rigImage;
   return settings;
 }
@@ -1294,18 +1301,18 @@ async function loadChangeTarget(
 ): Promise<{ rig: Rig; baseVersion: RigVersion; change: RigChange }> {
   const change = await getRigChange(db, workspaceId, changeId);
   if (!change) {
-    throw new Error(`Rig change not found: ${changeId}`);
+    throw new Error(`Sandbox Environment change not found: ${changeId}`);
   }
   const rig = await getRig(db, workspaceId, change.rigId);
   if (!rig) {
-    throw new Error(`Rig not found for change: ${change.rigId}`);
+    throw new Error(`Sandbox Environment not found for change: ${change.rigId}`);
   }
   if (!change.baseVersionId) {
-    throw new Error(`Rig change ${change.id} has no base version`);
+    throw new Error(`Sandbox Environment change ${change.id} has no base version`);
   }
   const baseVersion = await getRigVersionById(db, workspaceId, change.baseVersionId);
   if (!baseVersion || baseVersion.rigId !== rig.id) {
-    throw new Error(`Base rig version not found: ${change.baseVersionId}`);
+    throw new Error(`Base sandbox environment version not found: ${change.baseVersionId}`);
   }
   return { rig, baseVersion, change };
 }
@@ -1317,11 +1324,11 @@ async function loadVersionTarget(
 ): Promise<{ rig: Rig; version: RigVersion }> {
   const version = await getRigVersionById(db, workspaceId, versionId);
   if (!version) {
-    throw new Error(`Rig version not found: ${versionId}`);
+    throw new Error(`Sandbox Environment version not found: ${versionId}`);
   }
   const rig = await getRig(db, workspaceId, version.rigId);
   if (!rig) {
-    throw new Error(`Rig not found for version: ${version.rigId}`);
+    throw new Error(`Sandbox Environment not found for version: ${version.rigId}`);
   }
   return { rig, version };
 }
@@ -1373,12 +1380,7 @@ export function createRigVerificationActivities(services: () => Promise<ControlA
             change,
             candidateVersion,
           );
-          const packRuntime = await resolveWorkspacePackRuntime(db, input.workspaceId);
-          const runSettings = settingsForRigVerification(
-            settings,
-            packRuntime,
-            candidateVersion.image,
-          );
+          const runSettings = settingsForRigVerification(settings, candidateVersion.image);
           const providerImageContentHash = rigProviderImageContentHash({
             backend: runSettings.sandboxBackend,
             sourceImage: rigProviderImageSourceImage(runSettings, runSettings.sandboxBackend),
@@ -1452,7 +1454,7 @@ export function createRigVerificationActivities(services: () => Promise<ControlA
               );
               if (markerResult.exitCode !== 0) {
                 throw new Error(
-                  `Failed to seal rig provider image content marker: ${markerResult.output.slice(-2000)}`,
+                  `Failed to seal sandbox environment provider image content marker: ${markerResult.output.slice(-2000)}`,
                 );
               }
               const platformCheckResults = await runRigChecks(
@@ -1572,8 +1574,7 @@ export function createRigVerificationActivities(services: () => Promise<ControlA
           metadata: { versionId: version.id },
         });
         try {
-          const packRuntime = await resolveWorkspacePackRuntime(db, input.workspaceId);
-          const runSettings = settingsForRigVerification(settings, packRuntime, version.image);
+          const runSettings = settingsForRigVerification(settings, version.image);
           const providerImageContentHash = rigProviderImageContentHash({
             backend: runSettings.sandboxBackend,
             sourceImage: rigProviderImageSourceImage(runSettings, runSettings.sandboxBackend),
@@ -1615,7 +1616,7 @@ export function createRigVerificationActivities(services: () => Promise<ControlA
               );
               if (markerResult.exitCode !== 0) {
                 throw new Error(
-                  `Failed to seal rig provider image content marker: ${markerResult.output.slice(-2000)}`,
+                  `Failed to seal sandbox environment provider image content marker: ${markerResult.output.slice(-2000)}`,
                 );
               }
               const platformCheckResults = await runRigChecks(

package/src/activities/run-credential-renewal.ts

@@ -28,6 +28,18 @@ export type RunCredentialRenewalOptions = {
   }) => void;
 };
 
+export function runCredentialRenewalExpiry(
+  material: NormalizedRunCredentialMaterial | null,
+): Date | null {
+  const expiries = [
+    ...(material?.expiresAt ? [material.expiresAt.getTime()] : []),
+    ...(material?.mcp ?? []).flatMap((entry) =>
+      entry.expiresAt ? [Date.parse(entry.expiresAt)] : [],
+    ),
+  ];
+  return expiries.length ? new Date(Math.min(...expiries)) : null;
+}
+
 export function nextRunCredentialRenewalDelay(expiresAt: Date | null, nowMs = Date.now()): number {
   return nextExpiringMaterialRenewalDelay(
     expiresAt,
@@ -52,7 +64,7 @@ export function startRunCredentialRenewalLoop(
     initialExpiresAt: options.initialExpiresAt,
     resolve: options.resolve,
     write: options.write,
-    expiresAt: (material) => material?.expiresAt ?? null,
+    expiresAt: runCredentialRenewalExpiry,
     publicErrorClass: "RunCredentialRenewalOperationError",
     policy: {
       defaultRefreshMs: RUN_CREDENTIAL_DEFAULT_REFRESH_MS,