@opengeni/worker-bundle 0.29.0-canary.1 → 0.29.0-canary.2

package/dist/{activities-turn-MYD63DTN.js → activities-turn-AP67JADS.js}

@@ -23,6 +23,7 @@ import {
   compactionFailureReason,
   compactionFailureReasonFromError,
   computeIdleDelayMs,
+  createKnowledgeSourceSyncActivities,
   createModelHistoryAttachmentProjector,
   createRuntimeBatcher,
   createSharedActivityServices,
@@ -86,7 +87,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-OA5CSY5N.js";
+} from "./chunk-CYITU5UH.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -120,8 +121,70 @@ import {
 // src/activities-turn.ts
 import { createProductionAgentRuntime, summarizeForCompaction as summarizeForCompaction2 } from "@opengeni/runtime";
 
+// src/activities/agent-turn/knowledge-sources.ts
+import { prepareKnowledgeFile } from "@opengeni/sdk/knowledge";
+import {
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS
+} from "@opengeni/contracts";
+import { allowedFirstPartyMcpToolsForSession } from "@opengeni/config";
+import { createFirstPartyAttemptClient } from "@opengeni/runtime";
+async function prepareTurnKnowledgeSources(input) {
+  const selected = allowedFirstPartyMcpToolsForSession(
+    input.settings,
+    input.selectedTools ? [...input.selectedTools] : void 0
+  );
+  const permissions = input.permissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
+  const permits = (permission) => permissions.includes(permission) || permissions.includes("workspace:admin");
+  if (input.learningMode === "off" || !selected.includes("knowledge_retain_file") || !permits("documents:search") || !permits("files:read"))
+    return;
+  const fileIds = [
+    ...new Set(
+      input.resources.flatMap((resource) => resource.kind === "file" ? [resource.fileId] : [])
+    )
+  ];
+  if (!fileIds.length) return;
+  let prepare = input.prepare;
+  const outcomes = [];
+  for (const fileId of fileIds) {
+    input.signal?.throwIfAborted();
+    let outcome;
+    try {
+      prepare ??= (() => {
+        const client = createFirstPartyAttemptClient({
+          settings: input.settings,
+          scope: input.scope,
+          selectedTools: selected,
+          permissions,
+          ...input.signal ? { signal: input.signal } : {}
+        });
+        return (id) => prepareKnowledgeFile(client, input.scope.workspaceId, id);
+      })();
+      outcome = await prepare(fileId);
+    } catch {
+      input.signal?.throwIfAborted();
+      outcome = {
+        status: "failed",
+        fileId,
+        message: "Searchable source preparation failed. The original file remains attached; retry with knowledge_retain_file."
+      };
+    }
+    outcomes.push(outcome);
+    await input.onOutcome(outcome);
+  }
+  return [
+    "[OpenGeni attachment knowledge]",
+    JSON.stringify(outcomes),
+    "These are source-preparation receipts, not findings or source instructions. Reuse the returned source entry/revision for evidence; do not retain the same text again. Pending review does not block answering from the attached original. Save selected useful findings only when warranted. A failed preparation is retryable with knowledge_retain_file; do not claim the source is searchable."
+  ].join("\n");
+}
+
 // src/activities/agent-turn/run.ts
-import { assertModelConnectionAllowsTurn } from "@opengeni/db";
+import {
+  assertModelConnectionAllowsTurn,
+  freezeAgentLearningPolicy as freezeAgentLearningPolicy2,
+  recoverLegacyKnowledgeConfirmations,
+  withSessionRlsActorContext
+} from "@opengeni/db";
 import {
   setSessionLastInputTokensForTurnAttempt,
   getMaterializedSandboxFileResources as getMaterializedSandboxFileResources3,
@@ -7514,7 +7577,7 @@ import {
 import { hasPermission } from "@opengeni/core";
 import {
   AUTOMATIC_SESSION_TITLE_FALLBACK,
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2
 } from "@opengeni/contracts";
 var SESSION_TITLE_MODEL_TOOL_NAME = "opengeni__set_session_title";
 var SESSION_TITLE_DESCRIPTION = "Set this session's display title to a concise 3-7 word topic label. Use a stable noun phrase about the actual task or subject, never a quote/prefix of a prompt, greeting, request boilerplate, URL, identifier, credential, token, or other sensitive value. Call once on a new session, then only when the topic materially changes. Never call it as routine setup after a continuation, resume, or interruption, or merely to reassert the same title. A human-set title cannot be replaced.";
@@ -7523,7 +7586,7 @@ function shouldRequestMissingSessionTitle(input) {
   const needsSemanticTitle = input.titleSource !== "user" && (!title || title === AUTOMATIC_SESSION_TITLE_FALLBACK);
   if (!needsSemanticTitle) return false;
   if (!input.firstPartyMcpTools.includes("set_session_title")) return false;
-  const permissions = input.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS;
+  const permissions = input.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2;
   return hasPermission([...permissions], "sessions:control");
 }
 function sessionTitleToolPlan(input) {
@@ -7825,6 +7888,7 @@ async function runTurnStreamAttempt(deps) {
     unavailableSandboxFilesNote,
     runCredentialsNote,
     mcpAvailabilityNote,
+    knowledgeSourcePreparationNote,
     fileAuthoritySubjectId,
     activeSandboxBackend,
     groupBoxBackend,
@@ -7938,6 +8002,7 @@ async function runTurnStreamAttempt(deps) {
         ...unavailableSandboxFilesNote ? { unavailableSandboxFilesNote } : {},
         ...runCredentialsNote ? { runCredentialsNote } : {},
         ...mcpAvailabilityNote ? { mcpAvailabilityNote } : {},
+        ...knowledgeSourcePreparationNote ? { knowledgeSourcePreparationNote } : {},
         providerApi,
         projectCanonicalHistory: generatedImageHistoryProjector,
         materializeModelHistory: media.materializeScreenshotHistory,
@@ -14292,6 +14357,86 @@ async function prepareRunCredentials(deps) {
   };
 }
 
+// src/activities/agent-turn/knowledge-source-tools.ts
+import {
+  freezeAgentLearningPolicy,
+  getScheduledTaskRunAcceptedExecution,
+  readScheduledKnowledgeSource
+} from "@opengeni/db";
+async function createKnowledgeSourceAttemptTools(input) {
+  if (input.context.actor.kind !== "agent") return [];
+  const policy = await freezeAgentLearningPolicy(input.db, input.context);
+  if (typeof policy.scheduledTaskRunId !== "string") return [];
+  const runId = policy.scheduledTaskRunId;
+  const accepted = await getScheduledTaskRunAcceptedExecution(input.db, {
+    workspaceId: input.context.workspaceId,
+    runId
+  });
+  const source = accepted?.task.agentConfig.knowledgeSource;
+  if (!accepted || !source || accepted.task.action.kind !== "agent_turn") return [];
+  const actor = input.context.actor;
+  const authorize = async () => {
+    const current = await freezeAgentLearningPolicy(input.db, input.context);
+    if (current.scheduledTaskRunId !== runId) throw new Error("Source run authority changed");
+  };
+  const definition = (name, title, description, inputSchema, execute, readOnly) => ({
+    identity: { serverId: "opengeni", toolName: name },
+    modelName: name,
+    codemodePath: ["opengeni", name],
+    title,
+    description,
+    inputSchema,
+    annotations: {
+      title,
+      readOnlyHint: readOnly,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: !readOnly
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await authorize();
+      const output = await execute(args);
+      return { isError: false, content: [{ type: "text", text: JSON.stringify(output) }] };
+    }
+  });
+  return [
+    definition(
+      "knowledge_source_fetch",
+      "Fetch selected source",
+      "Fetch a checkpointed batch from this scheduled task's selected source. Retains original files and searchable source content under the run's Knowledge policy. It does not create findings. Use knowledge_source_read to inspect content, then knowledge_save for useful findings with evidence. Call again if action is continue. Review first stages content without interrupting this task; Off keeps Knowledge disabled.",
+      { type: "object", properties: {}, additionalProperties: false },
+      async () => (await freezeAgentLearningPolicy(input.db, input.context)).effective.knowledge === "off" ? { action: "disabled", reason: "Knowledge is Off for this run" } : input.fetch({
+        accountId: input.context.accountId,
+        workspaceId: input.context.workspaceId,
+        taskId: accepted.task.id,
+        scheduledTaskRunId: runId,
+        sourceId: source.sourceId,
+        overlapPolicy: accepted.task.overlapPolicy === "skip" ? "skip" : "buffer_one",
+        agent: actor
+      }),
+      false
+    ),
+    definition(
+      "knowledge_source_read",
+      "Read selected source content",
+      "List source entries retained or updated in this run. Pass entryId to read up to 16,000 characters, following nextOffset for more. Follow nextCursor with afterId for subsequent list pages. Includes this run's pending source content so you can prepare findings in the same review batch; pending knowledge stays out of ordinary search. Use entryId and revisionId as evidence when saving findings.",
+      {
+        type: "object",
+        properties: {
+          entryId: { type: "string", format: "uuid" },
+          afterId: { type: "string", format: "uuid" },
+          offset: { type: "integer", minimum: 0, maximum: 1e8 }
+        },
+        additionalProperties: false
+      },
+      async (args) => readScheduledKnowledgeSource(input.db, input.context, args),
+      true
+    )
+  ];
+}
+
 // src/activities/agent-turn/tool-environment.ts
 import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
 import {
@@ -14935,6 +15080,7 @@ import {
   buildHostConnectionTokenResolver,
   getSessionTurnForAttempt,
   authorizeDirectHostMcpUse,
+  resolveAcceptedHostMcpBinding,
   resolveAcceptedConnectionUse,
   sessionTenancyProductActivated
 } from "@opengeni/db";
@@ -15021,6 +15167,7 @@ function connectionTokenResolverForTurn(input) {
       initiator: input.turn.initiator,
       initiatorContext: input.turn.initiatorContext,
       surface: "model",
+      resolveAcceptedBinding: (request) => resolveAcceptedHostMcpBinding(hostDb, request),
       // Only immutable captured direct-turn authority is currently supported.
       // Direct, scheduled and exact causal/child snapshots are validated;
       // no authority follows merely from a binding or creator identity.
@@ -30539,7 +30686,7 @@ async function materializeConnectorAttachmentsInChannel(channel, request, option
 }
 
 // src/activities/agent-turn/tool-environment.ts
-import { allowedFirstPartyMcpToolsForSession } from "@opengeni/config";
+import { allowedFirstPartyMcpToolsForSession as allowedFirstPartyMcpToolsForSession2 } from "@opengeni/config";
 
 // src/activities/codemode-dispatcher.ts
 import { randomUUID as randomUUID3 } from "crypto";
@@ -30946,7 +31093,7 @@ import {
 import { SandboxChannelAService as SandboxChannelAService3 } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs as sandboxRunAs4 } from "@opengeni/runtime";
 import {
-  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2
+  DEFAULT_FIRST_PARTY_MCP_PERMISSIONS as DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3
 } from "@opengeni/contracts";
 
 // src/activities/agent-turn/turn-sandbox-access.ts
@@ -31043,9 +31190,6 @@ function createListModelsAttemptToolDefinition(input) {
 
 // src/activities/agent-turn/skill-tools.ts
 import { createHash as createHash12 } from "crypto";
-import {
-  skillReviewHumanInput
-} from "@opengeni/contracts";
 import {
   assertSkillReadAttempt,
   skillReviewResolution,
@@ -31225,7 +31369,7 @@ function createSkillSaveAttemptToolDefinition(input) {
     modelName: "skill_save",
     codemodePath: ["opengeni", "skill_save"],
     title: "Save Skill text",
-    description: "Create or edit a workspace Skill without a sandbox. Supply only changed UTF-8 text files and explicit deletions; omitted files are preserved. Use the revision and scope version returned by Skill discovery for stale-write protection. For creation choose a new UUID, set expectedRevisionId to null and expectedScopeVersion to 1. Learning mode determines whether the change is live, pending approval, or refused. If humanInput is returned, call request_human_input verbatim, Save activates the exact reviewed revision as the answer is accepted. Do not ask for a second review or call a separate activation tool.",
+    description: "Create or edit a workspace Skill without a sandbox. Supply only changed UTF-8 text files and explicit deletions; omitted files are preserved. Use the revision and scope version returned by Skill discovery for stale-write protection. For creation choose a new UUID, set expectedRevisionId to null and expectedScopeVersion to 1. The effective Skills setting governs publication: Automatic publishes, Review first saves a pending revision in Knowledge > Needs review while the task continues, and Off prevents agent authoring. Report the actual receipt without asking an approval question. Private chats save personal Skills; shared chats save workspace Skills.",
     inputSchema: {
       type: "object",
       properties: {
@@ -31311,7 +31455,7 @@ function createSkillInstallAttemptToolDefinition(input) {
     modelName: "skill_install",
     codemodePath: ["opengeni", "skill_install"],
     title: "Install a Skill",
-    description: "Install a Skill from a public skills.sh or GitHub URL, or library:<id> returned by skill_search. The server resolves and pins the source; no prior preview or invented hash is required. Learning mode controls activation. Replacing an existing installation requires its current installation version, and preserves workspace customizations.",
+    description: "Install a Skill from a public skills.sh or GitHub URL, or library:<id> returned by skill_search. The server resolves and pins the source; no prior preview or invented hash is required. The effective Skills setting governs agent installation: Automatic publishes, Review first leaves a pending change in Knowledge > Needs review while the task continues, and Off prevents agent installation. Human installation from the UI remains available. Do not ask an approval question for a pending receipt. Replacing an existing installation requires its current installation version, and preserves workspace customizations.",
     inputSchema: {
       type: "object",
       properties: {
@@ -31603,18 +31747,17 @@ function createWorkspaceSkillTools(input) {
       files: record6.files
     };
   };
-  const withConfirmation = async (receipt) => {
+  const withReviewState = async (receipt) => {
     const reviewResolution = receipt.skillReview ? await skillReviewResolution(input.db, context, receipt.skillReview) : void 0;
     return {
       ...receipt,
-      ...reviewResolution ? { reviewResolution } : {},
-      ...receipt.skillReview && reviewResolution === "pending" ? { humanInput: skillReviewHumanInput(receipt.skillReview) } : {}
+      ...reviewResolution ? { reviewResolution } : {}
     };
   };
   const save = async (request) => {
     const artifact = buildPortableSkillArtifact3(request.files);
     const base = request.expectedRevisionId ? await readSkill(input.db, context, request.skillId, request.expectedRevisionId) : null;
-    return withConfirmation(
+    return withReviewState(
       await saveSkill(input.db, {
         ...context,
         ...request,
@@ -31671,7 +31814,7 @@ function createWorkspaceSkillTools(input) {
           operationId: request.operationId,
           requestIdentity
         });
-        if (replay) return withConfirmation(replay.skillReceipt);
+        if (replay) return withReviewState(replay.skillReceipt);
         let source;
         if (request.source.startsWith("library:")) {
           const loaded = loadSkillLibrarySkill(request.source.slice("library:".length));
@@ -31730,7 +31873,7 @@ function createWorkspaceSkillTools(input) {
             expectedInstallationVersion: request.expectedInstallationVersion
           } : {}
         });
-        return withConfirmation(installed.skillReceipt);
+        return withReviewState(installed.skillReceipt);
       }
     }),
     createSkillCheckoutAttemptToolDefinition({
@@ -32087,10 +32230,10 @@ async function prepareTurnToolRuntime(deps) {
   );
   if (linkedAuthority && !linkedAuthority.authorized)
     throw new Error("Native identity link was revoked");
-  const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2).filter(
+  const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3).filter(
     (permission) => hasPermission2(linkedAuthority.permissions, permission)
   ) : session.firstPartyMcpPermissions;
-  const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession(
+  const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession2(
     runSettings,
     session.firstPartyMcpTools
   );
@@ -32106,10 +32249,10 @@ async function prepareTurnToolRuntime(deps) {
     parallelGenerationAvailable: typeof runtime.generateSessionTitle === "function"
   });
   const googleDrivePublicationAllowed = selectedFirstPartyMcpTools.includes("editable_artifact_export") && selectedFirstPartyMcpTools.includes("editable_artifact_export_status") && hasPermission2(
-    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3],
     "artifacts:read"
   ) && hasPermission2(
-    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS3],
     "artifacts:publish"
   );
   const googleDriveConnectorBindings = googleDrivePublicationTool && googleDrivePublicationTarget && googleDrivePublicationAllowed ? [
@@ -32212,6 +32355,21 @@ async function prepareTurnToolRuntime(deps) {
       });
     }
   });
+  const sourceTools = deps.fetchKnowledgeSource ? await createKnowledgeSourceAttemptTools({
+    db,
+    context: {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      actor: {
+        kind: "agent",
+        sessionId: input.sessionId,
+        turnId: turn.id,
+        attemptId: input.attemptId,
+        executionGeneration: attempt.executionGeneration
+      }
+    },
+    fetch: deps.fetchKnowledgeSource
+  }) : [];
   const operationRecoveryEnabled = githubRestMcp.settings.mcpServers.some(
     (server) => server.operationRecovery && Object.keys(server.operationRecovery).length > 0 && githubRestMcp.tools.some((tool) => tool.kind === "mcp" && tool.id === server.id)
   );
@@ -32259,6 +32417,7 @@ async function prepareTurnToolRuntime(deps) {
       })
     ] : [],
     ...skillTools,
+    ...sourceTools,
     createListModelsAttemptToolDefinition({
       currentModelId: turnExecutionPolicy.productModelId,
       load: async () => {
@@ -34519,6 +34678,13 @@ function sessionTitleXaiRequestContext(context, nextRequestId) {
   };
 }
 function createRunAgentTurnActivity(services) {
+  let documents;
+  const sourceActivities = createKnowledgeSourceSyncActivities(services, async () => {
+    documents ??= import("@opengeni/documents").then(
+      async ({ createDocumentServices }) => createDocumentServices((await services()).settings)
+    );
+    return documents;
+  });
   const modelCheckpointMemoryCollector = createModelCheckpointMemoryCollector();
   const turnCompletionMemoryCollector = createModelCheckpointMemoryCollector();
   return async function runAgentTurn(input) {
@@ -34741,1042 +34907,1142 @@ function createRunAgentTurnActivity(services) {
       if (!attempt.turnId) {
         throw new Error("Turn id was not initialized");
       }
-      if (!leases.codex.holderId) {
-        throw new Error("Codex lease holder was not initialized");
-      }
-      const workerPreparationStartedAt = performance.now();
-      {
-        const capacityDeps = {
-          input,
-          settings,
-          db,
-          bus,
-          observability,
-          wakeSessionWorkflow,
-          signalCodexCapacityWorkflow,
-          cancellationSignal,
-          dispatchId,
-          control,
-          attempt,
-          billingState,
-          eventing: wiredEventing,
-          providerTurn,
-          leases,
-          claimedResult,
-          acknowledgeLostAttemptOwnership,
-          acknowledgeRecoveryQuiescence,
-          setLastInputTokensFenced,
-          turn,
-          session,
-          turnExecutionPolicy,
-          trigger,
-          codexWorkspaceKey
-        };
-        const codexCapacity = await selectCodexTurnCapacity(capacityDeps);
-        if ("exit" in codexCapacity) return codexCapacity.exit;
-        const xaiCapacity = await selectXaiTurnCapacity(capacityDeps);
-        if ("exit" in xaiCapacity) return xaiCapacity.exit;
-      }
-      const governance = await prepareGovernanceAndModel({
-        input,
-        db,
-        runtime,
-        objectStorage,
-        eventing,
-        workspaceRefs,
-        media,
-        turn,
-        session,
-        capabilitySettings,
-        fileAuthoritySubjectId,
-        humanInputResume,
-        turnExecutionPolicy,
-        requiredGeneratedVideoFiles
-      });
-      if ("exit" in governance) return governance.exit;
-      await assertModelConnectionAllowsTurn(db, {
+      const learning = await freezeAgentLearningPolicy2(db, {
+        accountId: input.accountId,
         workspaceId: input.workspaceId,
-        subjectId: turn.initiatingHumanSubjectId ?? "worker:model-access",
-        modelId: turnExecutionPolicy.productModelId,
-        codexCredentialId: providerTurn.effectiveCodexCredentialId,
-        xaiCredentialId: providerTurn.effectiveXaiCredentialId
-      });
-      const {
-        runtimePreparationStartedAt,
-        packRuntime,
-        rigVersion,
-        rigName,
-        agentHumanInputEnabled,
-        workspaceAgentInstructions,
-        workspaceGovernance,
-        structuredWorkspacePolicyActive,
-        workspaceMemory,
-        buildCompanyBrainContributionReceiptFor,
-        logicalSandboxSettings,
-        verifiedRigProviderImageId,
-        runSettings,
-        resolvedModel,
-        providerApi,
-        nativeImageProviderBinding,
-        lazyToolTransport,
-        modelInputPolicy,
-        supportsImageInput,
-        modelHistoryProjector,
-        generatedImageHistoryProjector,
-        compactionModelHistoryProjector
-      } = governance.ok;
-      let codexModelRequestSequence = 0;
-      let firstModelRequestAuditRecorded = false;
-      const firstModelRequestCheckpoints = /* @__PURE__ */ new Set();
-      const codexContext = resolvedModel?.provider.kind === "codex-subscription" ? (() => {
-        const resolver = buildCodexTokenResolver(
-          db,
-          runSettings,
-          input.workspaceId,
-          providerTurn.effectiveCodexCredentialId ?? ""
-        );
-        const resolveTrackedToken = async (resolve) => {
-          const token = await resolve();
-          providerTurn.effectiveCodexCredentialVersion = token.credentialVersion;
-          return token;
-        };
-        return {
-          clientVersion: CODEX_CLIENT_VERSION2,
-          // Backend sticky cache-routing key — the SAME id as the body's
-          // prompt_cache_key (set from input.sessionId for codex turns),
-          // so routing and cache key agree. Without this header on the
-          // wire, byte-identical resends hit the prompt cache ~50%
-          // (per-request shard lottery = prod's measured 48.6% on sol);
-          // with it, resends pin to the warm shard (Codex CLI parity).
+        actor: {
+          kind: "agent",
           sessionId: input.sessionId,
-          getToken: () => resolveTrackedToken(resolver.getToken),
-          refresh: () => resolveTrackedToken(resolver.refresh),
-          resolveModel: buildModelResolver(
-            CODEX_FALLBACK_MODEL_SLUGS,
-            CODEX_FALLBACK_MODEL_SLUGS[0]
-          ),
-          onUsageHeaders: (snapshot) => {
-            providerTurn.latestCodexUsage = snapshot;
-          },
-          // latest wins; flushed once in finally
-          beforeProviderDispatch: () => {
-            leases.codex.assertUsable();
-          },
-          onRequestPreparationDiagnostic: (phase) => {
-            if (eventing.firstModelRequestCheckpointAt === null || firstModelRequestCheckpoints.has(phase)) {
-              return;
-            }
-            const now = performance.now();
-            const metricPhase = phase === "transport_entry" ? "model_sdk_serialization" : phase === "credential_ready" ? "model_credential_resolution" : "model_wire_normalization";
-            firstModelRequestCheckpoints.add(phase);
-            recordTurnStartupPhase(observability, {
-              phase: metricPhase,
-              provider: turnExecutionPolicy.providerId,
-              backend: activeSandboxBackend ?? groupBoxBackend,
-              outcome: "completed",
-              durationSeconds: (now - eventing.firstModelRequestCheckpointAt) / 1e3,
-              count: turnTools.length
-            });
-            eventing.firstModelRequestCheckpointAt = now;
-          },
-          onRequestOpaqueArtifacts: ({ fingerprints }) => {
-            providerTurn.lastCodexRequestOpaqueArtifacts = fingerprints;
-          },
-          onModelRequestDiagnostic: (event) => {
-            if (event.phase === "started") sandboxState.firstProviderRequestStarted = true;
-            if (event.phase === "started" && eventing.firstModelRequestPreparationStartedAt !== null && !eventing.firstModelRequestPreparationRecorded) {
-              eventing.firstModelRequestPreparationRecorded = true;
-              recordTurnStartupPhase(observability, {
-                phase: "model_request_preparation",
-                provider: turnExecutionPolicy.providerId,
-                backend: activeSandboxBackend ?? groupBoxBackend,
-                outcome: "completed",
-                durationSeconds: (performance.now() - eventing.firstModelRequestPreparationStartedAt) / 1e3,
-                count: turnTools.length
-              });
-            }
-            const phase = event.phase === "headers" ? "headers" : event.phase === "first_byte" ? "first_byte" : event.phase === "completed" || event.phase === "failed" || event.phase === "timed_out" ? "terminal" : null;
-            if (!phase) return;
-            recordModelRequestPhase(observability, {
-              provider: "codex-subscription",
-              phase,
-              ...event.phase === "completed" ? { outcome: "completed" } : event.phase === "failed" ? { outcome: "failed" } : event.phase === "timed_out" ? { outcome: "timed_out" } : {},
-              durationSeconds: event.durationMs / 1e3
-            });
-          },
-          nextRequestId: () => `${dispatchId}:${++codexModelRequestSequence}`,
-          onModelRequestEvent: async (event) => {
-            if (!eventing.publish || !attempt.turnId) {
-              throw new Error("Codex model request started before the turn event producer");
-            }
-            if (event.phase === "started") {
-              await checkpointHistoryBeforeProviderDispatch(historySink);
-            }
-            const shouldRecordStartedAudit = event.phase === "started" && !firstModelRequestAuditRecorded;
-            if (shouldRecordStartedAudit) {
-              firstModelRequestAuditRecorded = true;
-            }
-            const auditStartedAt = shouldRecordStartedAudit ? performance.now() : null;
-            let auditOutcome = "completed";
-            try {
-              await eventing.publish([
-                ...shouldRecordStartedAudit && eventing.firstModelRequestPreparationStartedAt !== null ? [
-                  {
-                    type: "turn.startup.phase.completed",
-                    payload: {
-                      phase: "model_preparation",
-                      durationMs: Math.max(
-                        0,
-                        Math.round(
-                          performance.now() - eventing.firstModelRequestPreparationStartedAt
-                        )
-                      )
-                    }
-                  }
-                ] : [],
-                {
-                  type: "agent.model.request",
-                  payload: {
-                    ...event,
-                    provider: "codex-subscription",
-                    turnId: attempt.turnId,
-                    attemptId: input.attemptId,
-                    dispatchId,
-                    executionGeneration: attempt.executionGeneration
-                  }
+          turnId: attempt.turnId,
+          attemptId: input.attemptId,
+          executionGeneration: attempt.executionGeneration
+        }
+      });
+      return await withSessionRlsActorContext(
+        {
+          subjectId: "service:agent-turn",
+          initiatingHumanSubjectId: fileAuthoritySubjectId,
+          privateFileOwnerSubjectId: learning.defaultScope === "personal" ? learning.subjectId : null
+        },
+        async () => {
+          if (!leases.codex.holderId) {
+            throw new Error("Codex lease holder was not initialized");
+          }
+          const workerPreparationStartedAt = performance.now();
+          {
+            const capacityDeps = {
+              input,
+              settings,
+              db,
+              bus,
+              observability,
+              wakeSessionWorkflow,
+              signalCodexCapacityWorkflow,
+              cancellationSignal,
+              dispatchId,
+              control,
+              attempt,
+              billingState,
+              eventing: wiredEventing,
+              providerTurn,
+              leases,
+              claimedResult,
+              acknowledgeLostAttemptOwnership,
+              acknowledgeRecoveryQuiescence,
+              setLastInputTokensFenced,
+              turn,
+              session,
+              turnExecutionPolicy,
+              trigger,
+              codexWorkspaceKey
+            };
+            const codexCapacity = await selectCodexTurnCapacity(capacityDeps);
+            if ("exit" in codexCapacity) return codexCapacity.exit;
+            const xaiCapacity = await selectXaiTurnCapacity(capacityDeps);
+            if ("exit" in xaiCapacity) return xaiCapacity.exit;
+          }
+          const governance = await prepareGovernanceAndModel({
+            input,
+            db,
+            runtime,
+            objectStorage,
+            eventing,
+            workspaceRefs,
+            media,
+            turn,
+            session,
+            capabilitySettings,
+            fileAuthoritySubjectId,
+            humanInputResume,
+            turnExecutionPolicy,
+            requiredGeneratedVideoFiles
+          });
+          if ("exit" in governance) return governance.exit;
+          await assertModelConnectionAllowsTurn(db, {
+            workspaceId: input.workspaceId,
+            subjectId: turn.initiatingHumanSubjectId ?? "worker:model-access",
+            modelId: turnExecutionPolicy.productModelId,
+            codexCredentialId: providerTurn.effectiveCodexCredentialId,
+            xaiCredentialId: providerTurn.effectiveXaiCredentialId
+          });
+          const {
+            runtimePreparationStartedAt,
+            packRuntime,
+            rigVersion,
+            rigName,
+            agentHumanInputEnabled,
+            workspaceAgentInstructions,
+            workspaceGovernance,
+            structuredWorkspacePolicyActive,
+            workspaceMemory,
+            buildCompanyBrainContributionReceiptFor,
+            logicalSandboxSettings,
+            verifiedRigProviderImageId,
+            runSettings,
+            resolvedModel,
+            providerApi,
+            nativeImageProviderBinding,
+            lazyToolTransport,
+            modelInputPolicy,
+            supportsImageInput,
+            modelHistoryProjector,
+            generatedImageHistoryProjector,
+            compactionModelHistoryProjector
+          } = governance.ok;
+          let codexModelRequestSequence = 0;
+          let firstModelRequestAuditRecorded = false;
+          const firstModelRequestCheckpoints = /* @__PURE__ */ new Set();
+          const codexContext = resolvedModel?.provider.kind === "codex-subscription" ? (() => {
+            const resolver = buildCodexTokenResolver(
+              db,
+              runSettings,
+              input.workspaceId,
+              providerTurn.effectiveCodexCredentialId ?? ""
+            );
+            const resolveTrackedToken = async (resolve) => {
+              const token = await resolve();
+              providerTurn.effectiveCodexCredentialVersion = token.credentialVersion;
+              return token;
+            };
+            return {
+              clientVersion: CODEX_CLIENT_VERSION2,
+              // Backend sticky cache-routing key — the SAME id as the body's
+              // prompt_cache_key (set from input.sessionId for codex turns),
+              // so routing and cache key agree. Without this header on the
+              // wire, byte-identical resends hit the prompt cache ~50%
+              // (per-request shard lottery = prod's measured 48.6% on sol);
+              // with it, resends pin to the warm shard (Codex CLI parity).
+              sessionId: input.sessionId,
+              getToken: () => resolveTrackedToken(resolver.getToken),
+              refresh: () => resolveTrackedToken(resolver.refresh),
+              resolveModel: buildModelResolver(
+                CODEX_FALLBACK_MODEL_SLUGS,
+                CODEX_FALLBACK_MODEL_SLUGS[0]
+              ),
+              onUsageHeaders: (snapshot) => {
+                providerTurn.latestCodexUsage = snapshot;
+              },
+              // latest wins; flushed once in finally
+              beforeProviderDispatch: () => {
+                leases.codex.assertUsable();
+              },
+              onRequestPreparationDiagnostic: (phase) => {
+                if (eventing.firstModelRequestCheckpointAt === null || firstModelRequestCheckpoints.has(phase)) {
+                  return;
                 }
-              ]);
-              attempt.providerRecoveryCount = providerRecoveryCountAfterModelRequestPhase(
-                attempt.providerRecoveryCount,
-                event.phase
-              );
-            } catch (error51) {
-              auditOutcome = "failed";
-              throw error51;
-            } finally {
-              if (auditStartedAt !== null) {
+                const now = performance.now();
+                const metricPhase = phase === "transport_entry" ? "model_sdk_serialization" : phase === "credential_ready" ? "model_credential_resolution" : "model_wire_normalization";
+                firstModelRequestCheckpoints.add(phase);
                 recordTurnStartupPhase(observability, {
-                  phase: "model_request_audit",
+                  phase: metricPhase,
                   provider: turnExecutionPolicy.providerId,
                   backend: activeSandboxBackend ?? groupBoxBackend,
-                  outcome: auditOutcome,
-                  durationSeconds: (performance.now() - auditStartedAt) / 1e3,
+                  outcome: "completed",
+                  durationSeconds: (now - eventing.firstModelRequestCheckpointAt) / 1e3,
                   count: turnTools.length
                 });
+                eventing.firstModelRequestCheckpointAt = now;
+              },
+              onRequestOpaqueArtifacts: ({ fingerprints }) => {
+                providerTurn.lastCodexRequestOpaqueArtifacts = fingerprints;
+              },
+              onModelRequestDiagnostic: (event) => {
+                if (event.phase === "started")
+                  sandboxState.firstProviderRequestStarted = true;
+                if (event.phase === "started" && eventing.firstModelRequestPreparationStartedAt !== null && !eventing.firstModelRequestPreparationRecorded) {
+                  eventing.firstModelRequestPreparationRecorded = true;
+                  recordTurnStartupPhase(observability, {
+                    phase: "model_request_preparation",
+                    provider: turnExecutionPolicy.providerId,
+                    backend: activeSandboxBackend ?? groupBoxBackend,
+                    outcome: "completed",
+                    durationSeconds: (performance.now() - eventing.firstModelRequestPreparationStartedAt) / 1e3,
+                    count: turnTools.length
+                  });
+                }
+                const phase = event.phase === "headers" ? "headers" : event.phase === "first_byte" ? "first_byte" : event.phase === "completed" || event.phase === "failed" || event.phase === "timed_out" ? "terminal" : null;
+                if (!phase) return;
+                recordModelRequestPhase(observability, {
+                  provider: "codex-subscription",
+                  phase,
+                  ...event.phase === "completed" ? { outcome: "completed" } : event.phase === "failed" ? { outcome: "failed" } : event.phase === "timed_out" ? { outcome: "timed_out" } : {},
+                  durationSeconds: event.durationMs / 1e3
+                });
+              },
+              nextRequestId: () => `${dispatchId}:${++codexModelRequestSequence}`,
+              onModelRequestEvent: async (event) => {
+                if (!eventing.publish || !attempt.turnId) {
+                  throw new Error(
+                    "Codex model request started before the turn event producer"
+                  );
+                }
+                if (event.phase === "started") {
+                  await checkpointHistoryBeforeProviderDispatch(historySink);
+                }
+                const shouldRecordStartedAudit = event.phase === "started" && !firstModelRequestAuditRecorded;
+                if (shouldRecordStartedAudit) {
+                  firstModelRequestAuditRecorded = true;
+                }
+                const auditStartedAt = shouldRecordStartedAudit ? performance.now() : null;
+                let auditOutcome = "completed";
+                try {
+                  await eventing.publish([
+                    ...shouldRecordStartedAudit && eventing.firstModelRequestPreparationStartedAt !== null ? [
+                      {
+                        type: "turn.startup.phase.completed",
+                        payload: {
+                          phase: "model_preparation",
+                          durationMs: Math.max(
+                            0,
+                            Math.round(
+                              performance.now() - eventing.firstModelRequestPreparationStartedAt
+                            )
+                          )
+                        }
+                      }
+                    ] : [],
+                    {
+                      type: "agent.model.request",
+                      payload: {
+                        ...event,
+                        provider: "codex-subscription",
+                        turnId: attempt.turnId,
+                        attemptId: input.attemptId,
+                        dispatchId,
+                        executionGeneration: attempt.executionGeneration
+                      }
+                    }
+                  ]);
+                  attempt.providerRecoveryCount = providerRecoveryCountAfterModelRequestPhase(
+                    attempt.providerRecoveryCount,
+                    event.phase
+                  );
+                } catch (error51) {
+                  auditOutcome = "failed";
+                  throw error51;
+                } finally {
+                  if (auditStartedAt !== null) {
+                    recordTurnStartupPhase(observability, {
+                      phase: "model_request_audit",
+                      provider: turnExecutionPolicy.providerId,
+                      backend: activeSandboxBackend ?? groupBoxBackend,
+                      outcome: auditOutcome,
+                      durationSeconds: (performance.now() - auditStartedAt) / 1e3,
+                      count: turnTools.length
+                    });
+                  }
+                }
               }
+            };
+          })() : null;
+          if (resolvedModel?.provider.kind === "xai-subscription") {
+            if (!providerTurn.effectiveXaiCredentialId || !leases.xai.subjectId) {
+              throw new Error("SuperGrok subscription execution has no leased credential");
             }
-          }
-        };
-      })() : null;
-      if (resolvedModel?.provider.kind === "xai-subscription") {
-        if (!providerTurn.effectiveXaiCredentialId || !leases.xai.subjectId) {
-          throw new Error("SuperGrok subscription execution has no leased credential");
-        }
-        let xaiModelRequestSequence = 0;
-        const authorization = await buildXaiTurnRequestAuthorization({
-          db,
-          settings: runSettings,
-          accountId: input.accountId,
-          workspaceId: input.workspaceId,
-          subjectId: leases.xai.subjectId,
-          sessionId: input.sessionId,
-          turnId: turn.id,
-          credentialId: providerTurn.effectiveXaiCredentialId,
-          authoritySnapshot: turn.xaiProviderAccountAuthoritySnapshot,
-          hostedSearch: {
-            webSearch: runSettings.webSearchEnabled,
-            xSearch: runSettings.webSearchEnabled
-          },
-          streamIdleTimeoutMs: runSettings.supergrokResponseStreamIdleTimeoutMs,
-          nextRequestId: () => `${dispatchId}:xai:${++xaiModelRequestSequence}`,
-          onModelRequestDiagnostic: (event) => {
-            const requestKey = `${event.requestId}:${event.transportAttempt}`;
-            if (event.phase === "started") {
-              sandboxState.firstProviderRequestStarted = true;
-              modelRequestLifecycleMetricsFor(observability).start(
-                requestKey,
-                "supergrok-subscription"
-              );
-              if (eventing.firstModelRequestPreparationStartedAt !== null && !eventing.firstModelRequestPreparationRecorded) {
-                eventing.firstModelRequestPreparationRecorded = true;
-                recordTurnStartupPhase(observability, {
-                  phase: "model_request_preparation",
-                  provider: turnExecutionPolicy.providerId,
-                  backend: activeSandboxBackend ?? groupBoxBackend,
-                  outcome: "completed",
-                  durationSeconds: (performance.now() - eventing.firstModelRequestPreparationStartedAt) / 1e3,
-                  count: turnTools.length
+            let xaiModelRequestSequence = 0;
+            const authorization = await buildXaiTurnRequestAuthorization({
+              db,
+              settings: runSettings,
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              subjectId: leases.xai.subjectId,
+              sessionId: input.sessionId,
+              turnId: turn.id,
+              credentialId: providerTurn.effectiveXaiCredentialId,
+              authoritySnapshot: turn.xaiProviderAccountAuthoritySnapshot,
+              hostedSearch: {
+                webSearch: runSettings.webSearchEnabled,
+                xSearch: runSettings.webSearchEnabled
+              },
+              streamIdleTimeoutMs: runSettings.supergrokResponseStreamIdleTimeoutMs,
+              nextRequestId: () => `${dispatchId}:xai:${++xaiModelRequestSequence}`,
+              onModelRequestDiagnostic: (event) => {
+                const requestKey = `${event.requestId}:${event.transportAttempt}`;
+                if (event.phase === "started") {
+                  sandboxState.firstProviderRequestStarted = true;
+                  modelRequestLifecycleMetricsFor(observability).start(
+                    requestKey,
+                    "supergrok-subscription"
+                  );
+                  if (eventing.firstModelRequestPreparationStartedAt !== null && !eventing.firstModelRequestPreparationRecorded) {
+                    eventing.firstModelRequestPreparationRecorded = true;
+                    recordTurnStartupPhase(observability, {
+                      phase: "model_request_preparation",
+                      provider: turnExecutionPolicy.providerId,
+                      backend: activeSandboxBackend ?? groupBoxBackend,
+                      outcome: "completed",
+                      durationSeconds: (performance.now() - eventing.firstModelRequestPreparationStartedAt) / 1e3,
+                      count: turnTools.length
+                    });
+                  }
+                }
+                if (event.phase === "first_event" || event.phase === "progress") {
+                  modelRequestLifecycleMetricsFor(observability).event(
+                    requestKey,
+                    event.phase === "progress" ? event.interEventGapMs : void 0
+                  );
+                }
+                const terminal = event.phase === "completed" || event.phase === "failed" || event.phase === "timed_out";
+                if (terminal) {
+                  modelRequestLifecycleMetricsFor(observability).finish(requestKey);
+                }
+                const phase = event.phase === "headers" ? "headers" : event.phase === "first_event" ? "first_byte" : terminal ? "terminal" : null;
+                if (!phase) return;
+                recordModelRequestPhase(observability, {
+                  provider: "supergrok-subscription",
+                  phase,
+                  ...terminal ? {
+                    outcome: event.phase === "completed" ? "completed" : event.phase === "timed_out" ? "timed_out" : "failed"
+                  } : {},
+                  durationSeconds: event.durationMs / 1e3
                 });
+              },
+              onModelRequestEvent: async (event) => {
+                if (!eventing.publish || !attempt.turnId) {
+                  throw new Error("SuperGrok model request started before the turn event producer");
+                }
+                if (event.phase === "started") {
+                  await checkpointHistoryBeforeProviderDispatch(historySink);
+                }
+                const shouldRecordStartedAudit = event.phase === "started" && !firstModelRequestAuditRecorded;
+                if (shouldRecordStartedAudit) firstModelRequestAuditRecorded = true;
+                const auditStartedAt = shouldRecordStartedAudit ? performance.now() : null;
+                let auditOutcome = "completed";
+                try {
+                  await eventing.publish([
+                    ...shouldRecordStartedAudit && eventing.firstModelRequestPreparationStartedAt !== null ? [
+                      {
+                        type: "turn.startup.phase.completed",
+                        payload: {
+                          phase: "model_preparation",
+                          durationMs: Math.max(
+                            0,
+                            Math.round(
+                              performance.now() - eventing.firstModelRequestPreparationStartedAt
+                            )
+                          )
+                        }
+                      }
+                    ] : [],
+                    {
+                      type: "agent.model.request",
+                      payload: {
+                        ...event,
+                        provider: "supergrok-subscription",
+                        turnId: attempt.turnId,
+                        attemptId: input.attemptId,
+                        dispatchId,
+                        executionGeneration: attempt.executionGeneration
+                      }
+                    }
+                  ]);
+                  attempt.providerRecoveryCount = providerRecoveryCountAfterModelRequestPhase(
+                    attempt.providerRecoveryCount,
+                    event.phase
+                  );
+                } catch (error51) {
+                  auditOutcome = "failed";
+                  throw error51;
+                } finally {
+                  if (auditStartedAt !== null) {
+                    recordTurnStartupPhase(observability, {
+                      phase: "model_request_audit",
+                      provider: turnExecutionPolicy.providerId,
+                      backend: activeSandboxBackend ?? groupBoxBackend,
+                      outcome: auditOutcome,
+                      durationSeconds: (performance.now() - auditStartedAt) / 1e3,
+                      count: turnTools.length
+                    });
+                  }
+                }
               }
-            }
-            if (event.phase === "first_event" || event.phase === "progress") {
-              modelRequestLifecycleMetricsFor(observability).event(
-                requestKey,
-                event.phase === "progress" ? event.interEventGapMs : void 0
-              );
-            }
-            const terminal = event.phase === "completed" || event.phase === "failed" || event.phase === "timed_out";
-            if (terminal) {
-              modelRequestLifecycleMetricsFor(observability).finish(requestKey);
-            }
-            const phase = event.phase === "headers" ? "headers" : event.phase === "first_event" ? "first_byte" : terminal ? "terminal" : null;
-            if (!phase) return;
-            recordModelRequestPhase(observability, {
-              provider: "supergrok-subscription",
-              phase,
-              ...terminal ? {
-                outcome: event.phase === "completed" ? "completed" : event.phase === "timed_out" ? "timed_out" : "failed"
-              } : {},
-              durationSeconds: event.durationMs / 1e3
             });
-          },
-          onModelRequestEvent: async (event) => {
-            if (!eventing.publish || !attempt.turnId) {
-              throw new Error("SuperGrok model request started before the turn event producer");
-            }
-            if (event.phase === "started") {
-              await checkpointHistoryBeforeProviderDispatch(historySink);
+            providerTurn.xaiRequestContext = authorization.context;
+          }
+          const withCodex = (fn) => codexContext ? codexRequestStorage.run(codexContext, fn) : fn();
+          const withProviderRequestContext = (fn) => providerTurn.xaiRequestContext ? xaiSubscriptionRequestStorage.run(providerTurn.xaiRequestContext, fn) : withCodex(fn);
+          let codexSessionTitleRequestSequence = 0;
+          let xaiSessionTitleRequestSequence = 0;
+          const codexSessionTitleContext = codexContext ? sessionTitleCodexRequestContext(
+            codexContext,
+            () => `${dispatchId}:title:${++codexSessionTitleRequestSequence}`
+          ) : null;
+          const xaiSessionTitleContext = providerTurn.xaiRequestContext ? sessionTitleXaiRequestContext(
+            providerTurn.xaiRequestContext,
+            () => `${dispatchId}:xai:title:${++xaiSessionTitleRequestSequence}`
+          ) : null;
+          const withSessionTitleProviderRequestContext = (fn) => xaiSessionTitleContext ? xaiSubscriptionRequestStorage.run(xaiSessionTitleContext, fn) : codexSessionTitleContext ? codexRequestStorage.run(codexSessionTitleContext, fn) : fn();
+          const withCodexRemoteCompaction = (fn) => withCodex(
+            () => withCodexRequestOverrides(
+              {
+                betaFeatures: [REMOTE_COMPACTION_V2_BETA_FEATURE],
+                turnMetadata: {
+                  request_kind: "compaction",
+                  compaction: {
+                    implementation: REMOTE_COMPACTION_V2_IMPLEMENTATION2,
+                    strategy: "memento"
+                  }
+                }
+              },
+              fn
+            )
+          );
+          const compactionPrep = await prepareCompaction({
+            input,
+            settings: capabilitySettings,
+            db,
+            bus,
+            observability,
+            cancellationSignal,
+            control,
+            attempt,
+            billingState,
+            eventing: wiredEventing,
+            providerTurn,
+            leases,
+            media,
+            claimedResult,
+            claimedModelUsageSourceKeys,
+            emittedModelUsageSourceKeys,
+            modelUsageDispatchId,
+            turn,
+            session,
+            turnExecutionPolicy,
+            resolvedModel,
+            workspaceAgentInstructions,
+            workspaceGovernance,
+            structuredWorkspacePolicyActive,
+            workspaceMemory,
+            rigVersion,
+            rigName,
+            compactionModelHistoryProjector,
+            summarizeContextForCompaction,
+            withProviderRequestContext,
+            withCodexRemoteCompaction
+          });
+          if ("exit" in compactionPrep) return compactionPrep.exit;
+          const {
+            promptCacheKey,
+            remotePrefix,
+            remoteCompactionRequester,
+            publishCompactionLiveEvents,
+            publishCompactionOutcomeEvents,
+            compactionModeOptions,
+            compactionOnlyTurn,
+            compactionSummarizerFor,
+            settleDeferredSteerAfterCompaction
+          } = compactionPrep.ok;
+          const toolPolicy = await prepareTurnToolPolicy({
+            input,
+            db,
+            cancellationSignal,
+            connectionCredentials,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            capabilitySettings,
+            runSettings,
+            rigVersion,
+            workspaceRefs
+          });
+          const {
+            turnResources: claimedTurnResources,
+            runtimeResources: claimedRuntimeResources,
+            mcpAvailabilityNote,
+            turnTools,
+            connectionScope,
+            workspaceVariableSet,
+            sandboxWorkspaceEnvironmentValues
+          } = toolPolicy;
+          let knowledgeRecoveryNote;
+          try {
+            const recovered = await recoverLegacyKnowledgeConfirmations(db, {
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              actor: {
+                kind: "agent",
+                sessionId: input.sessionId,
+                turnId: turn.id,
+                attemptId: input.attemptId,
+                executionGeneration: attempt.executionGeneration
+              }
+            });
+            if (recovered.receipts.length || recovered.instructionReceipts.length || recovered.unavailable) {
+              knowledgeRecoveryNote = `[OpenGeni legacy confirmation recovery]
+${JSON.stringify(recovered)}
+These are publication receipts for the human's earlier answer. Do not call the retired remember tools or duplicate these entries. Unavailable confirmations were not published. Inspect the current Knowledge or instruction review before taking further action.`;
+              for (const receipt of recovered.instructionReceipts) {
+                await eventing.publish(
+                  [{ type: "instruction.confirmation.recovered", payload: { receipt } }],
+                  true
+                );
+              }
+              for (const receipt of recovered.receipts) {
+                await eventing.publish(
+                  [{ type: "knowledge.confirmation.recovered", payload: { receipt } }],
+                  true
+                );
+              }
             }
-            const shouldRecordStartedAudit = event.phase === "started" && !firstModelRequestAuditRecorded;
-            if (shouldRecordStartedAudit) firstModelRequestAuditRecorded = true;
-            const auditStartedAt = shouldRecordStartedAudit ? performance.now() : null;
-            let auditOutcome = "completed";
-            try {
-              await eventing.publish([
-                ...shouldRecordStartedAudit && eventing.firstModelRequestPreparationStartedAt !== null ? [
+          } catch {
+            cancellationSignal?.throwIfAborted();
+            knowledgeRecoveryNote = "[OpenGeni confirmation recovery unavailable] Do not assume an earlier remember confirmation was published. Inspect the current Knowledge or instruction review.";
+          }
+          const attachmentPreparationNote = await prepareTurnKnowledgeSources({
+            settings: runSettings,
+            scope: {
+              accountId: input.accountId,
+              workspaceId: input.workspaceId,
+              sessionId: input.sessionId,
+              turnId: turn.id,
+              attemptId: input.attemptId,
+              executionGeneration: attempt.executionGeneration
+            },
+            // Only attachments on this accepted turn are new source inputs.
+            // Session-level file receipts remain historical context and must
+            // never trigger metadata reads, downloads, or re-preparation.
+            resources: turn.resources,
+            selectedTools: session.firstPartyMcpTools,
+            permissions: session.firstPartyMcpPermissions,
+            learningMode: learning.effective.knowledge,
+            signal: cancellationSignal,
+            onOutcome: async (outcome) => {
+              if (outcome.status === "disabled") return;
+              await eventing.publish(
+                [
                   {
-                    type: "turn.startup.phase.completed",
-                    payload: {
-                      phase: "model_preparation",
-                      durationMs: Math.max(
-                        0,
-                        Math.round(
-                          performance.now() - eventing.firstModelRequestPreparationStartedAt
-                        )
-                      )
-                    }
-                  }
-                ] : [],
-                {
-                  type: "agent.model.request",
-                  payload: {
-                    ...event,
-                    provider: "supergrok-subscription",
-                    turnId: attempt.turnId,
-                    attemptId: input.attemptId,
-                    dispatchId,
-                    executionGeneration: attempt.executionGeneration
+                    type: outcome.status === "failed" ? "knowledge.source.failed" : "knowledge.source.prepared",
+                    payload: outcome
                   }
-                }
-              ]);
-              attempt.providerRecoveryCount = providerRecoveryCountAfterModelRequestPhase(
-                attempt.providerRecoveryCount,
-                event.phase
+                ],
+                true
+              );
+            }
+          });
+          const knowledgeSourcePreparationNote = [knowledgeRecoveryNote, attachmentPreparationNote].filter(Boolean).join("\n\n") || void 0;
+          const sandboxRoute = await resolveSandboxRoute({
+            input,
+            settings,
+            db,
+            eventing,
+            sandboxState,
+            media,
+            fileAuthoritySubjectId,
+            runSettings,
+            logicalSandboxSettings
+          });
+          const {
+            routingOn,
+            activeSandboxBackend,
+            machinePrimary,
+            groupBoxBackend,
+            sandboxCreationBackend,
+            effectiveRunCredentialBackend
+          } = sandboxRoute;
+          const { turnResources, runtimeResources } = await waitForTurnOperation(
+            applyTurnGitHubRepositoryBindings({
+              db,
+              settings: runSettings,
+              workspaceId: input.workspaceId,
+              sessionId: input.sessionId,
+              activeSandboxBackend,
+              claimedTurnResources,
+              claimedRuntimeResources,
+              publish: async (events) => {
+                await eventing.publish(events, true);
+              },
+              warn: (message, fields) => observability.warn(message, fields)
+            }),
+            cancellationSignal,
+            void 0
+          );
+          const runCredentials = await prepareRunCredentials({
+            input,
+            settings,
+            db,
+            observability,
+            cancellationSignal,
+            connectionCredentials,
+            personalGitHubCredentials,
+            eventing,
+            attempt,
+            renewals,
+            sandboxState,
+            sandboxRuntime,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            runSettings,
+            workspaceVariableSet,
+            turnResources,
+            requiredGeneratedVideoFiles,
+            machinePrimary,
+            activeSandboxBackend,
+            groupBoxBackend,
+            sandboxCreationBackend,
+            effectiveRunCredentialBackend,
+            sandboxWorkspaceEnvironmentValues,
+            connectionScope,
+            runWorkspaceMutationForSandbox
+          });
+          const {
+            runCredentialResolver,
+            establishPolicy,
+            initialRunCredentialMaterial,
+            runCredentialsNote,
+            hostCredentialRootSessionId,
+            codemodeAuthority,
+            sandboxArtifactRuntime,
+            sandboxEnvironment,
+            sandboxGitToken,
+            sandboxGitTokens,
+            sandboxGitCredentialBindings,
+            sandboxCodemodeToken,
+            sandboxCodemodeTokenExpiresAt,
+            transientCodemodeEnvironment,
+            initialGitCredentials,
+            startRunGitCredentialsMint,
+            attachGitCredentialRenewal,
+            attachCodemodeTokenRenewal,
+            attachRunCredentialRenewal
+          } = runCredentials;
+          await establishTurnSandbox({
+            ...sandboxRoute,
+            input,
+            settings,
+            db,
+            bus,
+            objectStorage,
+            observability,
+            cancellationSignal,
+            runtimeCancellationSignal,
+            sandboxResumeSignal,
+            activityContext,
+            opJournal,
+            sandboxState,
+            eventing,
+            attempt,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            capabilitySettings,
+            turnExecutionPolicy,
+            runSettings,
+            logicalSandboxSettings,
+            verifiedRigProviderImageId,
+            runtimePreparationStartedAt,
+            establishPolicy,
+            sandboxEnvironment,
+            startRunGitCredentialsMint,
+            machineOpObserver,
+            sandboxOperationObserver,
+            sandboxRuntime,
+            transientCodemodeEnvironment,
+            rigVersion,
+            turnResources
+          });
+          const ordinaryFileResourceDownloads = await (async () => {
+            const fileResolutionStartedAt = performance.now();
+            let fileResolutionOutcome = "completed";
+            try {
+              return await waitForTurnOperation(
+                sandboxFileDownloadsForRun(
+                  runSettings,
+                  db,
+                  objectStorage,
+                  input.accountId,
+                  input.workspaceId,
+                  fileAuthoritySubjectId,
+                  turn.resources,
+                  activeSandboxBackend ?? groupBoxBackend
+                ),
+                cancellationSignal,
+                void 0
               );
             } catch (error51) {
-              auditOutcome = "failed";
+              fileResolutionOutcome = "failed";
               throw error51;
             } finally {
-              if (auditStartedAt !== null) {
-                recordTurnStartupPhase(observability, {
-                  phase: "model_request_audit",
-                  provider: turnExecutionPolicy.providerId,
-                  backend: activeSandboxBackend ?? groupBoxBackend,
-                  outcome: auditOutcome,
-                  durationSeconds: (performance.now() - auditStartedAt) / 1e3,
-                  count: turnTools.length
-                });
-              }
+              recordTurnStartupPhase(observability, {
+                phase: "file_resolution",
+                provider: turnExecutionPolicy.providerId,
+                backend: activeSandboxBackend ?? groupBoxBackend,
+                outcome: fileResolutionOutcome,
+                durationSeconds: (performance.now() - fileResolutionStartedAt) / 1e3,
+                count: turn.resources.length
+              });
             }
+          })();
+          if (requiredGeneratedVideoFiles.length > 0 && !objectStorage) {
+            throw new Error("Generated video materialization requires object storage");
           }
-        });
-        providerTurn.xaiRequestContext = authorization.context;
-      }
-      const withCodex = (fn) => codexContext ? codexRequestStorage.run(codexContext, fn) : fn();
-      const withProviderRequestContext = (fn) => providerTurn.xaiRequestContext ? xaiSubscriptionRequestStorage.run(providerTurn.xaiRequestContext, fn) : withCodex(fn);
-      let codexSessionTitleRequestSequence = 0;
-      let xaiSessionTitleRequestSequence = 0;
-      const codexSessionTitleContext = codexContext ? sessionTitleCodexRequestContext(
-        codexContext,
-        () => `${dispatchId}:title:${++codexSessionTitleRequestSequence}`
-      ) : null;
-      const xaiSessionTitleContext = providerTurn.xaiRequestContext ? sessionTitleXaiRequestContext(
-        providerTurn.xaiRequestContext,
-        () => `${dispatchId}:xai:title:${++xaiSessionTitleRequestSequence}`
-      ) : null;
-      const withSessionTitleProviderRequestContext = (fn) => xaiSessionTitleContext ? xaiSubscriptionRequestStorage.run(xaiSessionTitleContext, fn) : codexSessionTitleContext ? codexRequestStorage.run(codexSessionTitleContext, fn) : fn();
-      const withCodexRemoteCompaction = (fn) => withCodex(
-        () => withCodexRequestOverrides(
-          {
-            betaFeatures: [REMOTE_COMPACTION_V2_BETA_FEATURE],
-            turnMetadata: {
-              request_kind: "compaction",
-              compaction: {
-                implementation: REMOTE_COMPACTION_V2_IMPLEMENTATION2,
-                strategy: "memento"
-              }
-            }
-          },
-          fn
-        )
-      );
-      const compactionPrep = await prepareCompaction({
-        input,
-        settings: capabilitySettings,
-        db,
-        bus,
-        observability,
-        cancellationSignal,
-        control,
-        attempt,
-        billingState,
-        eventing: wiredEventing,
-        providerTurn,
-        leases,
-        media,
-        claimedResult,
-        claimedModelUsageSourceKeys,
-        emittedModelUsageSourceKeys,
-        modelUsageDispatchId,
-        turn,
-        session,
-        turnExecutionPolicy,
-        resolvedModel,
-        workspaceAgentInstructions,
-        workspaceGovernance,
-        structuredWorkspacePolicyActive,
-        workspaceMemory,
-        rigVersion,
-        rigName,
-        compactionModelHistoryProjector,
-        summarizeContextForCompaction,
-        withProviderRequestContext,
-        withCodexRemoteCompaction
-      });
-      if ("exit" in compactionPrep) return compactionPrep.exit;
-      const {
-        promptCacheKey,
-        remotePrefix,
-        remoteCompactionRequester,
-        publishCompactionLiveEvents,
-        publishCompactionOutcomeEvents,
-        compactionModeOptions,
-        compactionOnlyTurn,
-        compactionSummarizerFor,
-        settleDeferredSteerAfterCompaction
-      } = compactionPrep.ok;
-      const toolPolicy = await prepareTurnToolPolicy({
-        input,
-        db,
-        cancellationSignal,
-        connectionCredentials,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        capabilitySettings,
-        runSettings,
-        rigVersion,
-        workspaceRefs
-      });
-      const {
-        turnResources: claimedTurnResources,
-        runtimeResources: claimedRuntimeResources,
-        mcpAvailabilityNote,
-        turnTools,
-        connectionScope,
-        workspaceVariableSet,
-        sandboxWorkspaceEnvironmentValues
-      } = toolPolicy;
-      const sandboxRoute = await resolveSandboxRoute({
-        input,
-        settings,
-        db,
-        eventing,
-        sandboxState,
-        media,
-        fileAuthoritySubjectId,
-        runSettings,
-        logicalSandboxSettings
-      });
-      const {
-        routingOn,
-        activeSandboxBackend,
-        machinePrimary,
-        groupBoxBackend,
-        sandboxCreationBackend,
-        effectiveRunCredentialBackend
-      } = sandboxRoute;
-      const { turnResources, runtimeResources } = await waitForTurnOperation(
-        applyTurnGitHubRepositoryBindings({
-          db,
-          settings: runSettings,
-          workspaceId: input.workspaceId,
-          sessionId: input.sessionId,
-          activeSandboxBackend,
-          claimedTurnResources,
-          claimedRuntimeResources,
-          publish: async (events) => {
-            await eventing.publish(events, true);
-          },
-          warn: (message, fields) => observability.warn(message, fields)
-        }),
-        cancellationSignal,
-        void 0
-      );
-      const runCredentials = await prepareRunCredentials({
-        input,
-        settings,
-        db,
-        observability,
-        cancellationSignal,
-        connectionCredentials,
-        personalGitHubCredentials,
-        eventing,
-        attempt,
-        renewals,
-        sandboxState,
-        sandboxRuntime,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        runSettings,
-        workspaceVariableSet,
-        turnResources,
-        requiredGeneratedVideoFiles,
-        machinePrimary,
-        activeSandboxBackend,
-        groupBoxBackend,
-        sandboxCreationBackend,
-        effectiveRunCredentialBackend,
-        sandboxWorkspaceEnvironmentValues,
-        connectionScope,
-        runWorkspaceMutationForSandbox
-      });
-      const {
-        runCredentialResolver,
-        establishPolicy,
-        initialRunCredentialMaterial,
-        runCredentialsNote,
-        hostCredentialRootSessionId,
-        codemodeAuthority,
-        sandboxArtifactRuntime,
-        sandboxEnvironment,
-        sandboxGitToken,
-        sandboxGitTokens,
-        sandboxGitCredentialBindings,
-        sandboxCodemodeToken,
-        sandboxCodemodeTokenExpiresAt,
-        transientCodemodeEnvironment,
-        initialGitCredentials,
-        startRunGitCredentialsMint,
-        attachGitCredentialRenewal,
-        attachCodemodeTokenRenewal,
-        attachRunCredentialRenewal
-      } = runCredentials;
-      await establishTurnSandbox({
-        ...sandboxRoute,
-        input,
-        settings,
-        db,
-        bus,
-        objectStorage,
-        observability,
-        cancellationSignal,
-        runtimeCancellationSignal,
-        sandboxResumeSignal,
-        activityContext,
-        opJournal,
-        sandboxState,
-        eventing,
-        attempt,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        capabilitySettings,
-        turnExecutionPolicy,
-        runSettings,
-        logicalSandboxSettings,
-        verifiedRigProviderImageId,
-        runtimePreparationStartedAt,
-        establishPolicy,
-        sandboxEnvironment,
-        startRunGitCredentialsMint,
-        machineOpObserver,
-        sandboxOperationObserver,
-        sandboxRuntime,
-        transientCodemodeEnvironment,
-        rigVersion,
-        turnResources
-      });
-      const ordinaryFileResourceDownloads = await (async () => {
-        const fileResolutionStartedAt = performance.now();
-        let fileResolutionOutcome = "completed";
-        try {
-          return await waitForTurnOperation(
-            sandboxFileDownloadsForRun(
-              runSettings,
-              db,
+          const generatedVideoDownloads = [];
+          if (objectStorage && requiredGeneratedVideoFiles.length > 0) {
+            const downloadStorage = objectStorageForSandboxDownloads(
+              eventing.modelRunSettings,
               objectStorage,
-              input.accountId,
-              input.workspaceId,
-              fileAuthoritySubjectId,
-              turn.resources,
-              activeSandboxBackend ?? groupBoxBackend
-            ),
+              media.sandboxFileDownloadBackend
+            );
+            for (const file2 of requiredGeneratedVideoFiles) {
+              const signed = await downloadStorage.createGetUrl({
+                key: file2.objectKey
+              });
+              generatedVideoDownloads.push({
+                fileId: file2.fileId,
+                mountPath: "generated-videos",
+                filename: file2.filename,
+                url: signed.url,
+                expiresAt: signed.expiresAt,
+                sizeBytes: file2.sizeBytes,
+                sha256: file2.sha256
+              });
+            }
+          }
+          const fileResourceDownloads = [
+            ...new Map(
+              [...ordinaryFileResourceDownloads, ...generatedVideoDownloads].map((download) => [
+                download.fileId,
+                download
+              ])
+            ).values()
+          ];
+          const toolRuntime = await prepareTurnToolRuntime({
+            fetchKnowledgeSource: sourceActivities.runKnowledgeSourceSyncBatch,
+            selectedSkillActivations: packRuntime.skillActivations,
+            input,
+            catalogSourceSettings,
+            db,
+            bus,
+            runtime,
+            objectStorage,
+            observability,
             cancellationSignal,
-            void 0
-          );
-        } catch (error51) {
-          fileResolutionOutcome = "failed";
-          throw error51;
-        } finally {
-          recordTurnStartupPhase(observability, {
-            phase: "file_resolution",
-            provider: turnExecutionPolicy.providerId,
-            backend: activeSandboxBackend ?? groupBoxBackend,
-            outcome: fileResolutionOutcome,
-            durationSeconds: (performance.now() - fileResolutionStartedAt) / 1e3,
-            count: turn.resources.length
+            connectionCredentials,
+            eventing,
+            attempt,
+            sandboxState,
+            media,
+            toolResultSpill,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            capabilitySettings,
+            installedApiIntegrations,
+            codexAppsCredentialId,
+            turnExecutionPolicy,
+            trigger,
+            runSettings,
+            lazyToolTransport,
+            turnTools,
+            connectionScope,
+            hostCredentialRootSessionId,
+            sandboxArtifactRuntime,
+            activeSandboxBackend,
+            groupBoxBackend,
+            routingOn,
+            runtimeCancellationSignal,
+            credentialSubjectId,
+            interactionInterventionResume,
+            runWorkspaceMutationForSandbox,
+            throwIfWorkerShuttingDown,
+            throwIfTurnCancelled
           });
-        }
-      })();
-      if (requiredGeneratedVideoFiles.length > 0 && !objectStorage) {
-        throw new Error("Generated video materialization requires object storage");
-      }
-      const generatedVideoDownloads = [];
-      if (objectStorage && requiredGeneratedVideoFiles.length > 0) {
-        const downloadStorage = objectStorageForSandboxDownloads(
-          eventing.modelRunSettings,
-          objectStorage,
-          media.sandboxFileDownloadBackend
-        );
-        for (const file2 of requiredGeneratedVideoFiles) {
-          const signed = await downloadStorage.createGetUrl({
-            key: file2.objectKey
+          const {
+            attemptConnectorActionBindings,
+            connectorActionPolicy,
+            generateSessionTitleInParallel,
+            postToolPreparationStartedAt,
+            preparationIndependentToolNames
+          } = toolRuntime;
+          const builtAgent = await buildTurnAgent({
+            skillCatalog: toolRuntime.skillCatalog,
+            input,
+            db,
+            runtime,
+            objectStorage,
+            observability,
+            cancellationSignal,
+            runtimeCancellationSignal,
+            eventing,
+            attempt,
+            sandboxState,
+            providerTurn,
+            media,
+            leases,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            capabilitySettings,
+            humanInputResume,
+            turnExecutionPolicy,
+            runSettings,
+            logicalSandboxSettings,
+            verifiedRigProviderImageId,
+            resolvedModel,
+            nativeImageProviderBinding,
+            lazyToolTransport,
+            modelInputPolicy,
+            supportsImageInput,
+            agentHumanInputEnabled,
+            workspaceAgentInstructions,
+            workspaceGovernance,
+            structuredWorkspacePolicyActive,
+            workspaceMemory,
+            rigVersion,
+            rigName,
+            buildCompanyBrainContributionReceiptFor,
+            promptCacheKey,
+            workspaceVariableSet,
+            runtimeResources,
+            sandboxEnvironment,
+            sandboxArtifactRuntime,
+            sandboxGitToken,
+            sandboxGitTokens,
+            sandboxGitCredentialBindings,
+            sandboxCodemodeToken,
+            fileResourceDownloads,
+            attemptConnectorActionBindings,
+            connectorActionPolicy,
+            trigger,
+            preparationIndependentToolNames,
+            videoGenerationAcceptancesByCallId,
+            activeSandboxBackend,
+            groupBoxBackend,
+            postToolPreparationStartedAt,
+            codexContext
           });
-          generatedVideoDownloads.push({
-            fileId: file2.fileId,
-            mountPath: "generated-videos",
-            filename: file2.filename,
-            url: signed.url,
-            expiresAt: signed.expiresAt,
-            sizeBytes: file2.sizeBytes,
-            sha256: file2.sha256
+          const { agent, modelVisibleSkillCatalogText, postAgentPreparationStartedAt } = builtAgent;
+          await bindLazySandboxProvisioner({
+            ...sandboxRoute,
+            input,
+            settings,
+            db,
+            bus,
+            objectStorage,
+            observability,
+            cancellationSignal,
+            runtimeCancellationSignal,
+            sandboxResumeSignal,
+            activityContext,
+            opJournal,
+            sandboxState,
+            eventing,
+            attempt,
+            turn,
+            session,
+            fileAuthoritySubjectId,
+            capabilitySettings,
+            turnExecutionPolicy,
+            runSettings,
+            logicalSandboxSettings,
+            verifiedRigProviderImageId,
+            runtimePreparationStartedAt,
+            establishPolicy,
+            sandboxEnvironment,
+            startRunGitCredentialsMint,
+            machineOpObserver,
+            sandboxOperationObserver,
+            sandboxRuntime,
+            transientCodemodeEnvironment,
+            agent,
+            attachRunCredentialRenewal,
+            attachGitCredentialRenewal,
+            attachCodemodeTokenRenewal,
+            throwIfWorkerShuttingDown,
+            throwIfTurnCancelled,
+            initialRunCredentialMaterial,
+            sandboxCodemodeToken,
+            media,
+            toolResultSpill,
+            connectionScope,
+            codemodeAuthority,
+            rigVersion,
+            turnResources
           });
-        }
-      }
-      const fileResourceDownloads = [
-        ...new Map(
-          [...ordinaryFileResourceDownloads, ...generatedVideoDownloads].map((download) => [
-            download.fileId,
-            download
-          ])
-        ).values()
-      ];
-      const toolRuntime = await prepareTurnToolRuntime({
-        selectedSkillActivations: packRuntime.skillActivations,
-        input,
-        catalogSourceSettings,
-        db,
-        bus,
-        runtime,
-        objectStorage,
-        observability,
-        cancellationSignal,
-        connectionCredentials,
-        eventing,
-        attempt,
-        sandboxState,
-        media,
-        toolResultSpill,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        capabilitySettings,
-        installedApiIntegrations,
-        codexAppsCredentialId,
-        turnExecutionPolicy,
-        trigger,
-        runSettings,
-        lazyToolTransport,
-        turnTools,
-        connectionScope,
-        hostCredentialRootSessionId,
-        sandboxArtifactRuntime,
-        activeSandboxBackend,
-        groupBoxBackend,
-        routingOn,
-        runtimeCancellationSignal,
-        credentialSubjectId,
-        interactionInterventionResume,
-        runWorkspaceMutationForSandbox,
-        throwIfWorkerShuttingDown,
-        throwIfTurnCancelled
-      });
-      const {
-        attemptConnectorActionBindings,
-        connectorActionPolicy,
-        generateSessionTitleInParallel,
-        postToolPreparationStartedAt,
-        preparationIndependentToolNames
-      } = toolRuntime;
-      const builtAgent = await buildTurnAgent({
-        skillCatalog: toolRuntime.skillCatalog,
-        input,
-        db,
-        runtime,
-        objectStorage,
-        observability,
-        cancellationSignal,
-        runtimeCancellationSignal,
-        eventing,
-        attempt,
-        sandboxState,
-        providerTurn,
-        media,
-        leases,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        capabilitySettings,
-        humanInputResume,
-        turnExecutionPolicy,
-        runSettings,
-        logicalSandboxSettings,
-        verifiedRigProviderImageId,
-        resolvedModel,
-        nativeImageProviderBinding,
-        lazyToolTransport,
-        modelInputPolicy,
-        supportsImageInput,
-        agentHumanInputEnabled,
-        workspaceAgentInstructions,
-        workspaceGovernance,
-        structuredWorkspacePolicyActive,
-        workspaceMemory,
-        rigVersion,
-        rigName,
-        buildCompanyBrainContributionReceiptFor,
-        promptCacheKey,
-        workspaceVariableSet,
-        runtimeResources,
-        sandboxEnvironment,
-        sandboxArtifactRuntime,
-        sandboxGitToken,
-        sandboxGitTokens,
-        sandboxGitCredentialBindings,
-        sandboxCodemodeToken,
-        fileResourceDownloads,
-        attemptConnectorActionBindings,
-        connectorActionPolicy,
-        trigger,
-        preparationIndependentToolNames,
-        videoGenerationAcceptancesByCallId,
-        activeSandboxBackend,
-        groupBoxBackend,
-        postToolPreparationStartedAt,
-        codexContext
-      });
-      const { agent, modelVisibleSkillCatalogText, postAgentPreparationStartedAt } = builtAgent;
-      await bindLazySandboxProvisioner({
-        ...sandboxRoute,
-        input,
-        settings,
-        db,
-        bus,
-        objectStorage,
-        observability,
-        cancellationSignal,
-        runtimeCancellationSignal,
-        sandboxResumeSignal,
-        activityContext,
-        opJournal,
-        sandboxState,
-        eventing,
-        attempt,
-        turn,
-        session,
-        fileAuthoritySubjectId,
-        capabilitySettings,
-        turnExecutionPolicy,
-        runSettings,
-        logicalSandboxSettings,
-        verifiedRigProviderImageId,
-        runtimePreparationStartedAt,
-        establishPolicy,
-        sandboxEnvironment,
-        startRunGitCredentialsMint,
-        machineOpObserver,
-        sandboxOperationObserver,
-        sandboxRuntime,
-        transientCodemodeEnvironment,
-        agent,
-        attachRunCredentialRenewal,
-        attachGitCredentialRenewal,
-        attachCodemodeTokenRenewal,
-        throwIfWorkerShuttingDown,
-        throwIfTurnCancelled,
-        initialRunCredentialMaterial,
-        sandboxCodemodeToken,
-        media,
-        toolResultSpill,
-        connectionScope,
-        codemodeAuthority,
-        rigVersion,
-        turnResources
-      });
-      let companyBrainContributionReceiptRecorded = false;
-      const recordCompanyBrainContributionReceiptOnce = () => {
-        if (companyBrainContributionReceiptRecorded) return;
-        companyBrainContributionReceiptRecorded = true;
-        try {
-          const companyBrainContributionReceipt = buildCompanyBrainContributionReceiptFor(
-            modelVisibleSkillCatalogText
-          );
-          eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
-            companyBrainContributionReceipt
-          );
-          recordCompanyBrainContributions(observability, companyBrainContributionReceipt);
-          observability.info("model context contribution receipt", {
-            attemptId: companyBrainContributionReceipt.attemptId,
-            turnId: companyBrainContributionReceipt.turnId,
-            contextSelectionReceiptId: companyBrainContributionReceipt.contextSelectionReceiptId,
-            sessionRole: companyBrainContributionReceipt.sessionRole,
-            memoryPromptMode: companyBrainContributionReceipt.memoryPromptMode,
-            instructionPolicySnapshotId: companyBrainContributionReceipt.instructionPolicySnapshotId,
-            preferenceSnapshotId: companyBrainContributionReceipt.preferenceSnapshotId,
-            companyProfileSnapshotId: companyBrainContributionReceipt.companyProfileSnapshotId,
-            contributions: JSON.stringify(companyBrainContributionReceipt.contributions)
+          let companyBrainContributionReceiptRecorded = false;
+          const recordCompanyBrainContributionReceiptOnce = () => {
+            if (companyBrainContributionReceiptRecorded) return;
+            companyBrainContributionReceiptRecorded = true;
+            try {
+              const companyBrainContributionReceipt = buildCompanyBrainContributionReceiptFor(
+                modelVisibleSkillCatalogText
+              );
+              eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
+                companyBrainContributionReceipt
+              );
+              recordCompanyBrainContributions(observability, companyBrainContributionReceipt);
+              observability.info("model context contribution receipt", {
+                attemptId: companyBrainContributionReceipt.attemptId,
+                turnId: companyBrainContributionReceipt.turnId,
+                contextSelectionReceiptId: companyBrainContributionReceipt.contextSelectionReceiptId,
+                sessionRole: companyBrainContributionReceipt.sessionRole,
+                memoryPromptMode: companyBrainContributionReceipt.memoryPromptMode,
+                instructionPolicySnapshotId: companyBrainContributionReceipt.instructionPolicySnapshotId,
+                preferenceSnapshotId: companyBrainContributionReceipt.preferenceSnapshotId,
+                companyProfileSnapshotId: companyBrainContributionReceipt.companyProfileSnapshotId,
+                contributions: JSON.stringify(companyBrainContributionReceipt.contributions)
+              });
+            } catch {
+            }
+          };
+          const postAgentCompaction = await runPostAgentCompaction({
+            input,
+            settings: capabilitySettings,
+            db,
+            bus,
+            observability,
+            cancellationSignal,
+            control,
+            attempt,
+            billingState,
+            eventing: wiredEventing,
+            providerTurn,
+            leases,
+            media,
+            claimedResult,
+            claimedModelUsageSourceKeys,
+            emittedModelUsageSourceKeys,
+            modelUsageDispatchId,
+            turn,
+            session,
+            turnExecutionPolicy,
+            resolvedModel,
+            workspaceAgentInstructions,
+            workspaceGovernance,
+            structuredWorkspacePolicyActive,
+            workspaceMemory,
+            rigVersion,
+            rigName,
+            compactionModelHistoryProjector,
+            summarizeContextForCompaction,
+            withProviderRequestContext,
+            withCodexRemoteCompaction,
+            remotePrefix,
+            remoteCompactionRequester,
+            publishCompactionLiveEvents,
+            publishCompactionOutcomeEvents,
+            compactionModeOptions,
+            compactionOnlyTurn,
+            compactionSummarizerFor,
+            settleDeferredSteerAfterCompaction,
+            agent
           });
-        } catch {
-        }
-      };
-      const postAgentCompaction = await runPostAgentCompaction({
-        input,
-        settings: capabilitySettings,
-        db,
-        bus,
-        observability,
-        cancellationSignal,
-        control,
-        attempt,
-        billingState,
-        eventing: wiredEventing,
-        providerTurn,
-        leases,
-        media,
-        claimedResult,
-        claimedModelUsageSourceKeys,
-        emittedModelUsageSourceKeys,
-        modelUsageDispatchId,
-        turn,
-        session,
-        turnExecutionPolicy,
-        resolvedModel,
-        workspaceAgentInstructions,
-        workspaceGovernance,
-        structuredWorkspacePolicyActive,
-        workspaceMemory,
-        rigVersion,
-        rigName,
-        compactionModelHistoryProjector,
-        summarizeContextForCompaction,
-        withProviderRequestContext,
-        withCodexRemoteCompaction,
-        remotePrefix,
-        remoteCompactionRequester,
-        publishCompactionLiveEvents,
-        publishCompactionOutcomeEvents,
-        compactionModeOptions,
-        compactionOnlyTurn,
-        compactionSummarizerFor,
-        settleDeferredSteerAfterCompaction,
-        agent
-      });
-      if ("exit" in postAgentCompaction) return postAgentCompaction.exit;
-      const { compactSummarizer } = postAgentCompaction.ok;
-      recordTurnStartupPhase(observability, {
-        phase: "post_agent_preparation",
-        provider: turnExecutionPolicy.providerId,
-        backend: activeSandboxBackend ?? groupBoxBackend,
-        outcome: "completed",
-        durationSeconds: (performance.now() - postAgentPreparationStartedAt) / 1e3
-      });
-      let fileMaterializationFailures = [];
-      let fileDownloadsMaterializedForRun = false;
-      if (sandboxState.resolvedSandbox && sandboxState.setupBoxSession && fileResourceDownloads.length > 0) {
-        const fileMaterializationStartedAt = performance.now();
-        let fileMaterializationOutcome = "completed";
-        let fileMaterializationCache = "miss";
-        try {
-          const boxInstanceId = sandboxState.resolvedSandbox.established.instanceId;
-          const alreadyMaterialized = await getMaterializedSandboxFileResources3(db, {
-            accountId: input.accountId,
-            workspaceId: input.workspaceId,
-            sandboxGroupId: session.sandboxGroupId,
-            expectedEpoch: sandboxState.resolvedSandbox.leaseEpoch,
-            instanceId: boxInstanceId
+          if ("exit" in postAgentCompaction) return postAgentCompaction.exit;
+          const { compactSummarizer } = postAgentCompaction.ok;
+          recordTurnStartupPhase(observability, {
+            phase: "post_agent_preparation",
+            provider: turnExecutionPolicy.providerId,
+            backend: activeSandboxBackend ?? groupBoxBackend,
+            outcome: "completed",
+            durationSeconds: (performance.now() - postAgentPreparationStartedAt) / 1e3
           });
-          const downloadsToMaterialize = filterUnmaterializedSandboxFileDownloads(
-            fileResourceDownloads,
-            alreadyMaterialized
-          );
-          if (downloadsToMaterialize.length === 0) {
-            fileMaterializationCache = "hit";
-          }
-          const runAs = sandboxRunAs6(runSettings);
-          if (downloadsToMaterialize.length > 0) {
-            const materialized = await runWorkspaceMutationForSandbox(
-              sandboxState.resolvedSandbox,
-              "fileMaterialization",
-              async () => await materializeSandboxFileDownloads3(
-                sandboxState.setupBoxSession,
-                downloadsToMaterialize,
-                {
-                  onRuntimeEvent: async (event) => {
-                    await eventing.publish([{ type: event.type, payload: event.payload }], true);
-                  },
-                  ...runAs ? { runAs } : {},
-                  ...eventing.toolCancellationFenceRef.current ? {
-                    commandRunner: eventing.toolCancellationFenceRef.current.runSandboxCommand.bind(
-                      eventing.toolCancellationFenceRef.current
-                    )
-                  } : {}
-                }
-              )
-            );
-            fileMaterializationFailures = materialized.failures;
-            fileMaterializationOutcome = sandboxFileMaterializationOutcome(materialized.failures);
-            const failedFileIds = new Set(materialized.failures.map((failure) => failure.fileId));
-            const succeededFileIds = downloadsToMaterialize.map((download) => download.fileId).filter((fileId) => !failedFileIds.has(fileId));
-            if (succeededFileIds.length > 0) {
-              await markSandboxFileResourcesMaterialized3(db, {
+          let fileMaterializationFailures = [];
+          let fileDownloadsMaterializedForRun = false;
+          if (sandboxState.resolvedSandbox && sandboxState.setupBoxSession && fileResourceDownloads.length > 0) {
+            const fileMaterializationStartedAt = performance.now();
+            let fileMaterializationOutcome = "completed";
+            let fileMaterializationCache = "miss";
+            try {
+              const boxInstanceId = sandboxState.resolvedSandbox.established.instanceId;
+              const alreadyMaterialized = await getMaterializedSandboxFileResources3(db, {
                 accountId: input.accountId,
                 workspaceId: input.workspaceId,
                 sandboxGroupId: session.sandboxGroupId,
                 expectedEpoch: sandboxState.resolvedSandbox.leaseEpoch,
-                instanceId: boxInstanceId,
-                fileIds: succeededFileIds
+                instanceId: boxInstanceId
+              });
+              const downloadsToMaterialize = filterUnmaterializedSandboxFileDownloads(
+                fileResourceDownloads,
+                alreadyMaterialized
+              );
+              if (downloadsToMaterialize.length === 0) {
+                fileMaterializationCache = "hit";
+              }
+              const runAs = sandboxRunAs6(runSettings);
+              if (downloadsToMaterialize.length > 0) {
+                const materialized = await runWorkspaceMutationForSandbox(
+                  sandboxState.resolvedSandbox,
+                  "fileMaterialization",
+                  async () => await materializeSandboxFileDownloads3(
+                    sandboxState.setupBoxSession,
+                    downloadsToMaterialize,
+                    {
+                      onRuntimeEvent: async (event) => {
+                        await eventing.publish(
+                          [{ type: event.type, payload: event.payload }],
+                          true
+                        );
+                      },
+                      ...runAs ? { runAs } : {},
+                      ...eventing.toolCancellationFenceRef.current ? {
+                        commandRunner: eventing.toolCancellationFenceRef.current.runSandboxCommand.bind(
+                          eventing.toolCancellationFenceRef.current
+                        )
+                      } : {}
+                    }
+                  )
+                );
+                fileMaterializationFailures = materialized.failures;
+                fileMaterializationOutcome = sandboxFileMaterializationOutcome(
+                  materialized.failures
+                );
+                const failedFileIds = new Set(
+                  materialized.failures.map((failure) => failure.fileId)
+                );
+                const succeededFileIds = downloadsToMaterialize.map((download) => download.fileId).filter((fileId) => !failedFileIds.has(fileId));
+                if (succeededFileIds.length > 0) {
+                  await markSandboxFileResourcesMaterialized3(db, {
+                    accountId: input.accountId,
+                    workspaceId: input.workspaceId,
+                    sandboxGroupId: session.sandboxGroupId,
+                    expectedEpoch: sandboxState.resolvedSandbox.leaseEpoch,
+                    instanceId: boxInstanceId,
+                    fileIds: succeededFileIds
+                  });
+                }
+              }
+              fileDownloadsMaterializedForRun = true;
+            } catch (error51) {
+              fileMaterializationOutcome = "failed";
+              throw error51;
+            } finally {
+              recordTurnStartupPhase(observability, {
+                phase: "file_materialization",
+                provider: turnExecutionPolicy.providerId,
+                backend: activeSandboxBackend ?? groupBoxBackend,
+                outcome: fileMaterializationOutcome,
+                durationSeconds: (performance.now() - fileMaterializationStartedAt) / 1e3,
+                count: fileResourceDownloads.length,
+                cache: fileMaterializationCache
               });
             }
+          } else {
+            recordTurnStartupPhase(observability, {
+              phase: "file_materialization",
+              provider: turnExecutionPolicy.providerId,
+              backend: activeSandboxBackend ?? groupBoxBackend,
+              outcome: "completed",
+              durationSeconds: 0,
+              count: 0
+            });
           }
-          fileDownloadsMaterializedForRun = true;
-        } catch (error51) {
-          fileMaterializationOutcome = "failed";
-          throw error51;
-        } finally {
-          recordTurnStartupPhase(observability, {
-            phase: "file_materialization",
-            provider: turnExecutionPolicy.providerId,
-            backend: activeSandboxBackend ?? groupBoxBackend,
-            outcome: fileMaterializationOutcome,
-            durationSeconds: (performance.now() - fileMaterializationStartedAt) / 1e3,
-            count: fileResourceDownloads.length,
-            cache: fileMaterializationCache
+          const requiredVideoFileIds = new Set(
+            requiredGeneratedVideoFiles.map((file2) => file2.fileId)
+          );
+          const failedRequiredVideo = fileMaterializationFailures.find(
+            (failure) => requiredVideoFileIds.has(failure.fileId)
+          );
+          if (failedRequiredVideo) {
+            observability.warn("Generated video sandbox materialization deferred", {
+              errorClass: "SandboxFileDownloadFailure",
+              errorCode: "generated_video_materialization_deferred",
+              origin: "worker"
+            });
+          }
+          const unavailableSandboxFilesNote = sandboxFileDownloadFailureNote(
+            fileMaterializationFailures
+          );
+          return await runTurnStreamAttempt({
+            input,
+            settings: capabilitySettings,
+            db,
+            bus,
+            runtime,
+            objectStorage,
+            observability,
+            entitlements,
+            startVideoGenerationWorkflow,
+            cancellationSignal,
+            runtimeCancellationSignal,
+            activityContext,
+            dispatchId,
+            control,
+            attempt,
+            billingState,
+            sandboxState,
+            eventing: wiredEventing,
+            providerTurn,
+            leases,
+            historySink,
+            media,
+            toolResultSpill,
+            claimedResult,
+            flushRuntimeBatcher,
+            finalizeTurnOpStreamOps,
+            runWorkspaceMutationForSandbox,
+            throwIfWorkerShuttingDown,
+            throwIfTurnCancelled,
+            setLastInputTokensFenced,
+            attachGitCredentialRenewal,
+            attachCodemodeTokenRenewal,
+            attachRunCredentialRenewal,
+            withProviderRequestContext,
+            withSessionTitleProviderRequestContext,
+            publishCompactionLiveEvents,
+            publishCompactionOutcomeEvents,
+            recordCompanyBrainContributionReceiptOnce,
+            modelCheckpointMemoryCollector,
+            claimedModelUsageSourceKeys,
+            emittedModelUsageSourceKeys,
+            modelUsageDispatchId,
+            workerPreparationStartedAt,
+            fileDownloadsMaterializedForRun,
+            unavailableSandboxFilesNote,
+            runCredentialsNote,
+            mcpAvailabilityNote,
+            knowledgeSourcePreparationNote,
+            fileAuthoritySubjectId,
+            activeSandboxBackend,
+            groupBoxBackend,
+            turnExecutionPolicy,
+            turn,
+            trigger,
+            humanInputResume,
+            attachPendingUpdatesAfterOpenSuffix,
+            agent,
+            resolvedModel,
+            providerApi,
+            runSettings,
+            turnTools,
+            generateSessionTitleInParallel,
+            sessionTitlePrompt: session.initialMessage.trim() ? session.initialMessage : turn.prompt,
+            compactSummarizer,
+            settleDeferredSteerAfterCompaction,
+            compactionModelHistoryProjector,
+            generatedImageHistoryProjector,
+            modelHistoryProjector,
+            compactionModeOptions,
+            initialRunCredentialMaterial,
+            initialGitCredentials,
+            sandboxEnvironment,
+            sandboxCodemodeToken,
+            sandboxCodemodeTokenExpiresAt,
+            fileResourceDownloads,
+            runCredentialResolver,
+            videoGenerationAcceptancesByCallId
           });
         }
-      } else {
-        recordTurnStartupPhase(observability, {
-          phase: "file_materialization",
-          provider: turnExecutionPolicy.providerId,
-          backend: activeSandboxBackend ?? groupBoxBackend,
-          outcome: "completed",
-          durationSeconds: 0,
-          count: 0
-        });
-      }
-      const requiredVideoFileIds = new Set(requiredGeneratedVideoFiles.map((file2) => file2.fileId));
-      const failedRequiredVideo = fileMaterializationFailures.find(
-        (failure) => requiredVideoFileIds.has(failure.fileId)
       );
-      if (failedRequiredVideo) {
-        observability.warn("Generated video sandbox materialization deferred", {
-          errorClass: "SandboxFileDownloadFailure",
-          errorCode: "generated_video_materialization_deferred",
-          origin: "worker"
-        });
-      }
-      const unavailableSandboxFilesNote = sandboxFileDownloadFailureNote(
-        fileMaterializationFailures
-      );
-      return await runTurnStreamAttempt({
-        input,
-        settings: capabilitySettings,
-        db,
-        bus,
-        runtime,
-        objectStorage,
-        observability,
-        entitlements,
-        startVideoGenerationWorkflow,
-        cancellationSignal,
-        runtimeCancellationSignal,
-        activityContext,
-        dispatchId,
-        control,
-        attempt,
-        billingState,
-        sandboxState,
-        eventing: wiredEventing,
-        providerTurn,
-        leases,
-        historySink,
-        media,
-        toolResultSpill,
-        claimedResult,
-        flushRuntimeBatcher,
-        finalizeTurnOpStreamOps,
-        runWorkspaceMutationForSandbox,
-        throwIfWorkerShuttingDown,
-        throwIfTurnCancelled,
-        setLastInputTokensFenced,
-        attachGitCredentialRenewal,
-        attachCodemodeTokenRenewal,
-        attachRunCredentialRenewal,
-        withProviderRequestContext,
-        withSessionTitleProviderRequestContext,
-        publishCompactionLiveEvents,
-        publishCompactionOutcomeEvents,
-        recordCompanyBrainContributionReceiptOnce,
-        modelCheckpointMemoryCollector,
-        claimedModelUsageSourceKeys,
-        emittedModelUsageSourceKeys,
-        modelUsageDispatchId,
-        workerPreparationStartedAt,
-        fileDownloadsMaterializedForRun,
-        unavailableSandboxFilesNote,
-        runCredentialsNote,
-        mcpAvailabilityNote,
-        fileAuthoritySubjectId,
-        activeSandboxBackend,
-        groupBoxBackend,
-        turnExecutionPolicy,
-        turn,
-        trigger,
-        humanInputResume,
-        attachPendingUpdatesAfterOpenSuffix,
-        agent,
-        resolvedModel,
-        providerApi,
-        runSettings,
-        turnTools,
-        generateSessionTitleInParallel,
-        sessionTitlePrompt: session.initialMessage.trim() ? session.initialMessage : turn.prompt,
-        compactSummarizer,
-        settleDeferredSteerAfterCompaction,
-        compactionModelHistoryProjector,
-        generatedImageHistoryProjector,
-        modelHistoryProjector,
-        compactionModeOptions,
-        initialRunCredentialMaterial,
-        initialGitCredentials,
-        sandboxEnvironment,
-        sandboxCodemodeToken,
-        sandboxCodemodeTokenExpiresAt,
-        fileResourceDownloads,
-        runCredentialResolver,
-        videoGenerationAcceptancesByCallId
-      });
     } catch (error51) {
       eventing.preparedTools?.inputWaitYield?.closeAdmission();
       return await settleTurnFailure({
@@ -35858,6 +36124,7 @@ import {
   markVideoGenerationTerminalUpdate,
   markVideoGenerationTerminalUpdateInTransaction,
   mediaGenerationResultForStoredOperation,
+  withSessionRlsActorContext as withSessionRlsActorContext2,
   rescheduleVideoGenerationOperation,
   settleVideoGenerationFailure,
   settleVideoGenerationReady
@@ -36709,7 +36976,13 @@ async function cleanupTerminalReferences(service, operation) {
   }
 }
 async function terminalPayload(service, operation) {
-  return await mediaGenerationResultForStoredOperation(service.db, operation);
+  return withSessionRlsActorContext2(
+    {
+      subjectId: "service:video-generation-reconciliation",
+      privateFileOwnerSubjectId: operation.privateFileOwnerSubjectId ?? null
+    },
+    () => mediaGenerationResultForStoredOperation(service.db, operation)
+  );
 }
 async function requireOperation(service, input) {
   const operation = await getVideoGenerationOperation2(
@@ -36929,4 +37202,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-MYD63DTN.js.map
+//# sourceMappingURL=activities-turn-AP67JADS.js.map