@opengeni/worker-bundle 0.27.3 → 0.28.1-canary.0

package/dist/{activities-turn-V7J34ZOF.js → activities-turn-FOIZYY56.js}

@@ -86,7 +86,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-C54VDT6I.js";
+} from "./chunk-AKP6BKM2.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -3550,6 +3550,7 @@ function createTurnContext(input) {
 // src/activities/agent-turn/finalization.ts
 import {
   commitSessionAttemptQuiescence,
+  listPendingSessionTurns,
   recordCodexAccountUsageWithWakeTargets,
   releaseCodexCredentialLease,
   releaseXaiCredentialLease,
@@ -3713,6 +3714,50 @@ async function readCaptureRepository(svc, root) {
   }
 }
 var loggedStorageNullOnce = false;
+async function captureWhileIdle(input) {
+  if (input.signal?.aborted) return;
+  const controller = new AbortController();
+  const signal = input.signal ? AbortSignal.any([input.signal, controller.signal]) : controller.signal;
+  let checking = false;
+  let stopped = false;
+  const check = async () => {
+    if (checking || stopped || signal.aborted) return;
+    checking = true;
+    try {
+      let timer2;
+      let onAbort;
+      try {
+        const pending = await Promise.race([
+          input.hasPendingWork(),
+          new Promise((resolve) => {
+            onAbort = () => resolve(true);
+            signal.addEventListener("abort", onAbort, { once: true });
+            timer2 = setTimeout(() => resolve(true), 1e3);
+          })
+        ]);
+        if (pending) controller.abort();
+      } finally {
+        clearTimeout(timer2);
+        if (onAbort) signal.removeEventListener("abort", onAbort);
+      }
+    } catch {
+      controller.abort();
+    } finally {
+      checking = false;
+    }
+  };
+  await check();
+  if (signal.aborted) return;
+  const timer = setInterval(() => void check(), 250);
+  timer.unref?.();
+  try {
+    await input.capture(signal);
+  } finally {
+    stopped = true;
+    clearInterval(timer);
+    controller.abort();
+  }
+}
 async function captureWorkspaceRevision(input) {
   const { observability } = input;
   const stage = { value: "preflight" };
@@ -3755,13 +3800,23 @@ async function captureWorkspaceRevision(input) {
     name: "opengeni_workspace_captures_inflight",
     help: "Current workspace-capture operations still resident in this worker process."
   });
+  const ownership = { keys: /* @__PURE__ */ new Set(), retain: false };
   const capture = runCapture(
     input,
     { ...input, objectStorage: input.objectStorage },
     startedAt,
     controller.signal,
-    stage
-  ).finally(() => {
+    stage,
+    ownership
+  ).finally(async () => {
+    if (!ownership.retain && ownership.keys.size > 0) {
+      await safeDelete(
+        input.objectStorage,
+        [...ownership.keys],
+        observability,
+        new AbortController().signal
+      );
+    }
     observability.incrementGauge({
       name: "opengeni_workspace_captures_inflight",
       help: "Current workspace-capture operations still resident in this worker process.",
@@ -3788,13 +3843,17 @@ async function captureWorkspaceRevision(input) {
       });
       return;
     }
-    observability.warn("workspace capture failed \u2014 turn outcome unaffected", {
-      "opengeni.session_id": input.sessionId,
-      "opengeni.turn_id": input.turnId ?? "",
-      "error.message": error instanceof Error ? error.message : String(error),
-      "workspace_capture.duration_ms": Date.now() - startedAt,
-      "workspace_capture.stage": stage.value
-    });
+    const reason = controller.signal.aborted ? "deadline_exceeded" : isBoxExitingError(error) ? "sandbox_exited" : "operation_failed";
+    observability.warn(
+      `workspace capture failed \u2014 stage=${stage.value} reason=${reason} durationMs=${Date.now() - startedAt}; review cache not updated`,
+      {
+        "opengeni.session_id": input.sessionId,
+        "opengeni.turn_id": input.turnId ?? "",
+        "error.message": error instanceof Error ? error.message : String(error),
+        "workspace_capture.duration_ms": Date.now() - startedAt,
+        "workspace_capture.stage": stage.value
+      }
+    );
     observability.incrementCounter({
       name: "opengeni_workspace_capture_total",
       labels: { result: "failed" }
@@ -3805,7 +3864,8 @@ async function captureWorkspaceRevision(input) {
     controller.abort();
   }
 }
-async function runCapture(input, ctx, startedAt, signal, stage) {
+async function runCapture(input, ctx, startedAt, signal, stage, ownership) {
+  const ownedKeys = ownership.keys;
   const { observability } = input;
   const storage = ctx.objectStorage;
   const keepN = input.keepLatest ?? KEEP_LATEST_REVISIONS;
@@ -3892,6 +3952,13 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
   }
   const files = [];
   const blobKeys = /* @__PURE__ */ new Set();
+  const captureId = crypto.randomUUID();
+  const retainedRefs = retainedCaptureBlobRefs(
+    input.workspaceId,
+    input.sessionId,
+    prev?.blobKeys ?? []
+  );
+  const storedKeys = new Set(retainedRefs.values());
   let totalBytes = 0;
   let tooLargeCount = 0;
   let binaryCount = 0;
@@ -3921,6 +3988,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
       });
       throwIfCaptureAborted(signal);
     } catch (error) {
+      if (signal.aborted) throw error;
       const boxExiting = classifyCaptureEntryError(error);
       if (boxExiting) throw boxExiting;
       continue;
@@ -3942,7 +4010,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
     }
     const bytes = Buffer.from(read.content, "base64");
     const hash = sha256(bytes);
-    const contentRef = blobKey(input.workspaceId, input.sessionId, hash);
+    const contentRef = retainedRefs.get(hash) ?? blobKey(input.workspaceId, input.sessionId, `${captureId}/${hash}`);
     if (read.isBinary) binaryCount += 1;
     if (!blobKeys.has(contentRef)) {
       totalBytes += bytes.byteLength;
@@ -3959,6 +4027,17 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
       }
     }
     blobKeys.add(contentRef);
+    if (!storedKeys.has(contentRef)) {
+      stage.value = "content_upload";
+      ownedKeys.add(contentRef);
+      await storage.putObject({
+        key: contentRef,
+        contentType: "application/octet-stream",
+        body: bytes
+      });
+      throwIfCaptureAborted(signal);
+      storedKeys.add(contentRef);
+    }
     files.push({
       // baseHash (git HEAD blob sha) is intentionally null in M1: the wake-on-edit
       // flush guard (M3/C2) compares live content against the after-image `hash`,
@@ -3975,7 +4054,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
       deleted: false
     });
   }
-  let fingerprint = changeFingerprint(repos, files);
+  const fingerprint = changeFingerprint(repos, files);
   if (prev && prev.stats.fingerprint === fingerprint) {
     observability.incrementCounter({
       name: "opengeni_workspace_capture_total",
@@ -3986,102 +4065,9 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
   stage.value = "tree_index";
   const tree = await buildTreeIndex(svc, startedAt, signal);
   throwIfCaptureAborted(signal);
-  const turnKey = input.turnId;
+  const turnKey = `${input.turnId}/${captureId}`;
   const treeKey = `workspace-captures/${input.workspaceId}/${input.sessionId}/trees/${turnKey}.json`;
   const manifestKey = `workspace-captures/${input.workspaceId}/${input.sessionId}/manifests/${turnKey}.json`;
-  const uploadedKeys = /* @__PURE__ */ new Set();
-  blobKeys.clear();
-  totalBytes = 0;
-  let refreshedFiles = 0;
-  const omittedFiles = /* @__PURE__ */ new Set();
-  for (const file of files) {
-    stage.value = "content_upload";
-    throwIfCaptureAborted(signal);
-    if (file.deleted || file.tooLarge || !file.contentRef || !file.hash) {
-      continue;
-    }
-    let reread;
-    try {
-      reread = await svc.fsRead({
-        path: file.path,
-        encoding: "base64",
-        maxBytes: PER_FILE_CONTENT_GUARD_BYTES
-      });
-      throwIfCaptureAborted(signal);
-    } catch (error) {
-      if (signal.aborted) throw error;
-      const boxExiting = classifyCaptureEntryError(error);
-      if (boxExiting) throw boxExiting;
-      omittedFiles.add(file.path);
-      refreshedFiles += 1;
-      continue;
-    }
-    if (reread.truncated) {
-      file.hash = null;
-      file.contentRef = null;
-      file.sizeBytes = reread.sizeBytes;
-      file.isBinary = reread.isBinary;
-      file.tooLarge = true;
-      refreshedFiles += 1;
-      continue;
-    }
-    const bytes = Buffer.from(reread.content, "base64");
-    const hash = sha256(bytes);
-    const contentRef = blobKey(input.workspaceId, input.sessionId, hash);
-    if (hash !== file.hash || bytes.byteLength !== file.sizeBytes || reread.isBinary !== file.isBinary) {
-      file.hash = hash;
-      file.contentRef = contentRef;
-      file.sizeBytes = bytes.byteLength;
-      file.isBinary = reread.isBinary;
-      refreshedFiles += 1;
-    }
-    if (!blobKeys.has(contentRef)) {
-      totalBytes += bytes.byteLength;
-      if (totalBytes > WHOLE_CAPTURE_GUARD_BYTES) {
-        observability.warn("workspace capture skipped \u2014 whole-capture guard tripped", {
-          "opengeni.session_id": input.sessionId,
-          "workspace_capture.total_bytes": totalBytes
-        });
-        observability.incrementCounter({
-          name: "opengeni_workspace_capture_total",
-          labels: { result: "guard_tripped" }
-        });
-        return;
-      }
-    }
-    blobKeys.add(contentRef);
-    if (!uploadedKeys.has(contentRef)) {
-      await storage.putObject({
-        key: contentRef,
-        contentType: "application/octet-stream",
-        body: bytes
-      });
-      throwIfCaptureAborted(signal);
-      uploadedKeys.add(contentRef);
-    }
-  }
-  if (omittedFiles.size > 0) {
-    for (let index = files.length - 1; index >= 0; index -= 1) {
-      const file = files[index];
-      if (file && omittedFiles.has(file.path)) files.splice(index, 1);
-    }
-  }
-  if (refreshedFiles > 0) {
-    observability.incrementCounter({
-      name: "opengeni_workspace_capture_files_refreshed_total",
-      amount: refreshedFiles
-    });
-  }
-  tooLargeCount = files.filter((file) => file.tooLarge).length;
-  binaryCount = files.filter((file) => !file.deleted && file.isBinary).length;
-  fingerprint = changeFingerprint(repos, files);
-  if (prev && prev.stats.fingerprint === fingerprint) {
-    observability.incrementCounter({
-      name: "opengeni_workspace_capture_total",
-      labels: { result: "skipped_empty" }
-    });
-    return;
-  }
   const capturedAt = /* @__PURE__ */ new Date();
   const stats = {
     repoCount: repos.length,
@@ -4118,11 +4104,13 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
     })
   );
   stage.value = "tree_upload";
+  ownedKeys.add(treeKey);
   await storage.putObject({ key: treeKey, contentType: "application/json", body: treeBytes });
   throwIfCaptureAborted(signal);
   stats.durationMs = Date.now() - startedAt;
   const manifestBytes = utf8(JSON.stringify(manifest));
   stage.value = "manifest_upload";
+  ownedKeys.add(manifestKey);
   await storage.putObject({
     key: manifestKey,
     contentType: "application/json",
@@ -4131,6 +4119,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
   throwIfCaptureAborted(signal);
   const sizeBytes = totalBytes + treeBytes.byteLength + manifestBytes.byteLength;
   stage.value = "database_commit";
+  ownership.retain = true;
   const inserted = await insertWorkspaceCapture(input.db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -4147,6 +4136,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
     stats,
     capturedAt
   });
+  ownership.retain = inserted !== null;
   if (process.env.OPENGENI_TEST_SCENARIO === "sandbox") {
     console.log(
       `[sandbox-e2e] capture commit inserted=${Boolean(inserted)} revision=${revision} epoch=${input.leaseEpoch} group=${input.sandboxGroupId}`
@@ -4164,6 +4154,7 @@ async function runCapture(input, ctx, startedAt, signal, stage) {
   if (input.publish) {
     await input.publish(inserted.events).catch(() => void 0);
   }
+  stage.value = "garbage_collection";
   let gcDeleted = 0;
   try {
     throwIfCaptureAborted(signal);
@@ -4323,6 +4314,16 @@ function utf8(s) {
 function blobKey(workspaceId, sessionId, sha256Hex) {
   return `workspace-captures/${workspaceId}/${sessionId}/blobs/${sha256Hex}`;
 }
+function retainedCaptureBlobRefs(workspaceId, sessionId, latestKeys) {
+  const prefix = blobKey(workspaceId, sessionId, "");
+  const refs = /* @__PURE__ */ new Map();
+  for (const key of latestKeys) {
+    if (!key.startsWith(prefix)) continue;
+    const match = /^(?:[0-9a-f-]{36}\/)?([0-9a-f]{64})$/.exec(key.slice(prefix.length));
+    if (match?.[1]) refs.set(match[1], key);
+  }
+  return refs;
+}
 async function safeDelete(storage, keys, observability, signal) {
   for (const key of keys) {
     throwIfCaptureAborted(signal);
@@ -4692,39 +4693,49 @@ async function finalizeTurnAttempt(deps) {
       cancellationRequested: finalizerSignal?.aborted === true,
       deadlineRotationRequested: sandboxState.deadlineRotationRequested
     });
-    if (runTurnEndPersistence && attempt.turnId && sandboxState.resolvedSandbox && sandboxState.setupBoxSession && sandboxState.sandboxGroupId) {
+    if (settings.workspaceCaptureEnabled && runTurnEndPersistence && attempt.turnId && sandboxState.resolvedSandbox && sandboxState.setupBoxSession && sandboxState.sandboxGroupId) {
       sandboxState.turnEndCaptureInProgress = true;
-      if (sandboxState.snapshotInFlight) {
-        await waitForWarmSnapshot(
-          sandboxState.snapshotInFlight,
-          settings.sandboxSnapshotTimeoutMs,
-          finalizerSignal
-        );
-      }
-      const captureEstablished = sandboxState.resolvedSandbox.established;
-      await captureWorkspaceRevision({
-        db,
-        objectStorage,
-        settings,
-        publish: async (events) => {
-          await publishDurableSessionEvents(bus, input.workspaceId, input.sessionId, events);
-        },
-        session: sandboxState.setupBoxSession,
-        openReadSession: async () => await openFreshWorkspaceCaptureSession({
-          backendId: captureEstablished.backendId,
-          client: captureEstablished.client,
-          session: sandboxState.setupBoxSession,
-          expectedInstanceId: captureEstablished.instanceId
-        }),
-        leaseEpoch: sandboxState.resolvedSandbox.leaseEpoch,
-        sandboxGroupId: sandboxState.sandboxGroupId,
-        accountId: input.accountId,
-        workspaceId: input.workspaceId,
-        sessionId: input.sessionId,
-        turnId: attempt.turnId,
-        attemptId: input.attemptId,
-        observability,
-        ...finalizerSignal ? { signal: finalizerSignal } : {}
+      const captureSandbox = sandboxState.resolvedSandbox;
+      const captureSession = sandboxState.setupBoxSession;
+      const captureGroupId = sandboxState.sandboxGroupId;
+      const captureTurnId = attempt.turnId;
+      await captureWhileIdle({
+        ...finalizerSignal ? { signal: finalizerSignal } : {},
+        hasPendingWork: async () => (await listPendingSessionTurns(db, input.workspaceId, input.sessionId)).some(
+          (turn) => turn.id !== captureTurnId
+        ),
+        capture: async (signal) => {
+          if (sandboxState.snapshotInFlight) {
+            await waitForWarmSnapshot(
+              sandboxState.snapshotInFlight,
+              settings.sandboxSnapshotTimeoutMs,
+              signal
+            );
+          }
+          if (signal.aborted) return;
+          await captureWorkspaceRevision({
+            db,
+            objectStorage,
+            settings,
+            publish: async (events) => publishDurableSessionEvents(bus, input.workspaceId, input.sessionId, events),
+            session: captureSession,
+            openReadSession: async () => openFreshWorkspaceCaptureSession({
+              backendId: captureSandbox.established.backendId,
+              client: captureSandbox.established.client,
+              session: captureSession,
+              expectedInstanceId: captureSandbox.established.instanceId
+            }),
+            leaseEpoch: captureSandbox.leaseEpoch,
+            sandboxGroupId: captureGroupId,
+            accountId: input.accountId,
+            workspaceId: input.workspaceId,
+            sessionId: input.sessionId,
+            turnId: captureTurnId,
+            attemptId: input.attemptId,
+            observability,
+            signal
+          });
+        }
       });
     }
     eventing.toolPreparationClosing = true;
@@ -14287,6 +14298,8 @@ async function prepareRunCredentials(deps) {
 import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
 import {
   beginConnectorActionExecution,
+  getExternalLinkTurnAuthorization,
+  getSessionTurnForAttempt as getSessionTurnForAttempt2,
   getWorkspaceVideoGenerationPolicy,
   listSkillDescriptors as listSkillDescriptors2,
   completeConnectorActionExecution,
@@ -14922,6 +14935,8 @@ function driveQuery(value) {
 import {
   buildConnectionTokenResolver,
   buildHostConnectionTokenResolver,
+  getSessionTurnForAttempt,
+  authorizeDirectHostMcpUse,
   resolveAcceptedConnectionUse,
   sessionTenancyProductActivated
 } from "@opengeni/db";
@@ -14929,7 +14944,10 @@ import { recordTenancyCompatibilityLaneUse } from "@opengeni/observability";
 var OPENGENI_CONNECTION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu;
 function connectionTokenResolverForTurn(input) {
   const hostResolver = input.connectionCredentials?.mcpCredentials;
-  const baseResolver = hostResolver ? buildHostConnectionTokenResolver(hostResolver, {
+  const readHostTurn = input.getHostTurnForAttempt ?? getSessionTurnForAttempt;
+  const hostDb = input.db;
+  const nativeResolver = buildConnectionTokenResolver(input.db, input.settings);
+  const configuredResolver = hostResolver ? buildHostConnectionTokenResolver(hostResolver, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
     sessionId: input.sessionId,
@@ -14939,8 +14957,25 @@ function connectionTokenResolverForTurn(input) {
     executionGeneration: input.turn.executionGeneration,
     initiator: input.turn.initiator,
     initiatorContext: input.turn.initiatorContext,
-    surface: "model"
-  }) : buildConnectionTokenResolver(input.db, input.settings);
+    surface: "model",
+    // 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.
+    authorizeDurableBinding: (request) => authorizeDirectHostMcpUse(hostDb, request),
+    authorizeExecution: async (request) => {
+      if (request.connectionRef.authoritySource !== "host" && (!request.connectionRef.connectionId || OPENGENI_CONNECTION_ID_PATTERN.test(request.connectionRef.connectionId)))
+        return true;
+      if (!request.attemptId) return false;
+      const current = await readHostTurn(
+        hostDb,
+        request.workspaceId,
+        request.sessionId,
+        request.attemptId
+      );
+      return current !== null && current.id === request.turnId && current.executionGeneration === request.executionGeneration;
+    }
+  }) : nativeResolver;
+  const baseResolver = (request) => input.connectionCredentials?.mcpAuthoritySource === "host" && request.connectionRef.authoritySource !== "host" ? nativeResolver(request) : configuredResolver(request);
   return async (request) => {
     if (request.connectionRef.authoritySource === "host") {
       if (hostResolver) return await baseResolver(request);
@@ -14956,7 +14991,7 @@ function connectionTokenResolverForTurn(input) {
         ...request.connectionRef.selectedResources ? { selectedResources: request.connectionRef.selectedResources } : {}
       };
     }
-    if (hostResolver && request.connectionRef.connectionId && !OPENGENI_CONNECTION_ID_PATTERN.test(request.connectionRef.connectionId)) {
+    if (hostResolver && input.connectionCredentials?.mcpAuthoritySource !== "host" && request.connectionRef.connectionId && !OPENGENI_CONNECTION_ID_PATTERN.test(request.connectionRef.connectionId)) {
       try {
         return await baseResolver(request);
       } catch {
@@ -16063,10 +16098,14 @@ import {
   resolveCatalogSettings as resolveCatalogSettings2,
   resolveWorkspaceModelSelection,
   withFrozenPersonalConnectionDelegations,
-  resolveSessionToolPolicy
+  resolveSessionToolPolicy,
+  hasPermission as hasPermission2
 } from "@opengeni/core";
 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
+} from "@opengeni/contracts";
 
 // src/activities/agent-turn/turn-sandbox-access.ts
 async function resolveTurnSandboxAccess(sandboxState, sdkOwnedSandboxSession, unavailableMessage) {
@@ -16189,10 +16228,9 @@ import {
 
 // src/activities/agent-turn/skill-read.ts
 import {
-  assertSkillRelativePath,
+  listSkillPaths,
   PORTABLE_SKILL_MAX_FILES,
   readSkillFiles,
-  SKILL_READ_MAX_OUTPUT_BYTES,
   SKILL_READ_MAX_PATHS
 } from "@opengeni/runtime/skill-library";
 var SKILL_READ_TOOL_NAME = "skill_read";
@@ -16239,7 +16277,7 @@ function createSkillReadAttemptToolDefinition(input) {
       const loaded = await input.load(args.skill);
       const metadata = "files" in loaded ? loaded : null;
       const files = metadata ? metadata.files : loaded;
-      const selected = args.listFiles === true ? listSkillPaths(files) : readSkillFiles(files, args.paths);
+      const selected = args.listFiles === true ? listSkillPaths(files, PORTABLE_SKILL_MAX_FILES) : readSkillFiles(files, args.paths);
       const output = {
         ...metadata ? {
           skillId: metadata.skillId,
@@ -16257,22 +16295,6 @@ function createSkillReadAttemptToolDefinition(input) {
     }
   };
 }
-function listSkillPaths(files) {
-  if (files.length > PORTABLE_SKILL_MAX_FILES) {
-    throw new Error(`Skill inventory exceeds ${PORTABLE_SKILL_MAX_FILES} files.`);
-  }
-  const seen = /* @__PURE__ */ new Set();
-  for (const { path } of files) {
-    assertSkillRelativePath(path);
-    if (seen.has(path)) throw new Error(`Duplicate stored Skill path: ${path}`);
-    seen.add(path);
-  }
-  const result = { paths: [...seen].sort() };
-  if (Buffer.byteLength(JSON.stringify(result), "utf8") > SKILL_READ_MAX_OUTPUT_BYTES) {
-    throw new Error("Skill inventory exceeds the read output limit.");
-  }
-  return result;
-}
 
 // src/activities/agent-turn/skill-search.ts
 import { PublicSkillSearchError } from "@opengeni/core";
@@ -16494,7 +16516,7 @@ function createSkillInstallAttemptToolDefinition(input) {
 // src/activities/agent-turn/skill-transfer.ts
 import { posix } from "path";
 import {
-  assertSkillRelativePath as assertSkillRelativePath2,
+  assertSkillRelativePath,
   buildPortableSkillArtifact as buildPortableSkillArtifact2,
   PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES3,
   PORTABLE_SKILL_MAX_FILE_BYTES,
@@ -16518,7 +16540,7 @@ function guardSkillFilesystem(fs, authority) {
   };
 }
 async function checkoutSkillDirectory(fs, directory, files) {
-  assertSkillRelativePath2(directory);
+  assertSkillRelativePath(directory);
   const artifact = buildPortableSkillArtifact2(files);
   const parent = posix.dirname(directory);
   if (parent !== ".") await fs.fsMkdir({ path: parent, recursive: true });
@@ -16538,7 +16560,7 @@ async function checkoutSkillDirectory(fs, directory, files) {
   return { directory, fileCount: artifact.files.length };
 }
 async function readSkillDirectory(fs, directory) {
-  assertSkillRelativePath2(directory);
+  assertSkillRelativePath(directory);
   const pending = [directory];
   const seen = new Set(pending);
   const files = [];
@@ -16559,7 +16581,7 @@ async function readSkillDirectory(fs, directory) {
       throw new Error(`Skill directory listing is incomplete: ${current}`);
     }
     for (const entry of listing.root.children) {
-      assertSkillRelativePath2(entry.path);
+      assertSkillRelativePath(entry.path);
       if (posix.dirname(entry.path) !== current || posix.basename(entry.path) !== entry.name) {
         throw new Error("Skill directory listing returned a path outside the requested directory.");
       }
@@ -17218,6 +17240,19 @@ async function prepareTurnToolRuntime(deps) {
       }
     };
   })() : void 0;
+  const linkedAuthority = await getExternalLinkTurnAuthorization(
+    db,
+    {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId
+    },
+    turn.id
+  );
+  if (linkedAuthority && !linkedAuthority.authorized)
+    throw new Error("Native identity link was revoked");
+  const effectiveFirstPartyPermissions = linkedAuthority ? (session.firstPartyMcpPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2).filter(
+    (permission) => hasPermission2(linkedAuthority.permissions, permission)
+  ) : session.firstPartyMcpPermissions;
   const selectedFirstPartyMcpTools = allowedFirstPartyMcpToolsForSession(
     runSettings,
     session.firstPartyMcpTools
@@ -17229,11 +17264,17 @@ async function prepareTurnToolRuntime(deps) {
       title: session.title,
       titleSource: session.titleSource,
       firstPartyMcpTools: selectedFirstPartyMcpTools,
-      firstPartyMcpPermissions: session.firstPartyMcpPermissions
+      firstPartyMcpPermissions: effectiveFirstPartyPermissions
     }),
     parallelGenerationAvailable: typeof runtime.generateSessionTitle === "function"
   });
-  const googleDrivePublicationAllowed = selectedFirstPartyMcpTools.includes("editable_artifact_export") && selectedFirstPartyMcpTools.includes("editable_artifact_export_status") && (!session.firstPartyMcpPermissions?.length || session.firstPartyMcpPermissions.includes("artifacts:read") && session.firstPartyMcpPermissions.includes("artifacts:publish"));
+  const googleDrivePublicationAllowed = selectedFirstPartyMcpTools.includes("editable_artifact_export") && selectedFirstPartyMcpTools.includes("editable_artifact_export_status") && hasPermission2(
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
+    "artifacts:read"
+  ) && hasPermission2(
+    [...effectiveFirstPartyPermissions ?? DEFAULT_FIRST_PARTY_MCP_PERMISSIONS2],
+    "artifacts:publish"
+  );
   const googleDriveConnectorBindings = googleDrivePublicationTool && googleDrivePublicationTarget && googleDrivePublicationAllowed ? [
     {
       modelName: googleDrivePublicationTool.modelName,
@@ -17448,7 +17489,7 @@ async function prepareTurnToolRuntime(deps) {
         attemptId: input.attemptId,
         executionGeneration: attempt.executionGeneration
       },
-      ...session.firstPartyMcpPermissions?.length ? { permissions: session.firstPartyMcpPermissions } : {},
+      ...effectiveFirstPartyPermissions ? { permissions: effectiveFirstPartyPermissions } : {},
       selectedTools: selectedFirstPartyMcpTools,
       subjectId: "worker:first-party-mcp",
       subjectLabel: "OpenGeni worker",
@@ -17529,6 +17570,18 @@ async function prepareTurnToolRuntime(deps) {
         ...credentialSubjectId ? { credentialSubjectId } : {},
         ...codexAppsAuth ? { codexAppsAuth } : {},
         resolveCredential,
+        ...linkedAuthority ? {
+          authorizeAttemptExecution: async () => {
+            const current = await getSessionTurnForAttempt2(
+              db,
+              input.workspaceId,
+              input.sessionId,
+              input.attemptId
+            );
+            if (!current || current.id !== turn.id || current.executionGeneration !== attempt.executionGeneration)
+              throw new Error("The linked agent attempt is no longer authorized");
+          }
+        } : {},
         onAuthNeeded: publishToolAuthNeeded,
         materializeConnectorAttachments,
         refreshOwnedCommand: async (commandId) => {
@@ -17555,7 +17608,7 @@ async function prepareTurnToolRuntime(deps) {
         },
         // Manager-style sessions carry a creation-validated permission set
         // for their first-party MCP token; null keeps the fixed default.
-        ...session.firstPartyMcpPermissions?.length ? { firstPartyPermissions: session.firstPartyMcpPermissions } : {},
+        ...effectiveFirstPartyPermissions ? { firstPartyPermissions: effectiveFirstPartyPermissions } : {},
         firstPartyTools: titleToolPlan.remoteFirstPartyMcpTools,
         nestedAgentDepth: session.nestedAgentDepth,
         effectiveMaxNestedAgentDepth: session.effectiveMaxNestedAgentDepth,
@@ -17823,7 +17876,9 @@ import {
   getXaiSessionAccountPin as getXaiSessionAccountPin2,
   setXaiSessionAccountPin as setXaiSessionAccountPin2,
   getWorkspaceVideoGenerationPolicy as getWorkspaceVideoGenerationPolicy2,
-  loadWorkspaceVercelAiGatewayCredentialLease
+  loadWorkspaceVercelAiGatewayCredentialLease,
+  getExternalLinkTurnAuthorization as getExternalLinkTurnAuthorization2,
+  getSessionTurnForAttempt as getSessionTurnForAttempt3
 } from "@opengeni/db";
 import {
   formatSkillCatalog
@@ -19372,11 +19427,33 @@ async function buildTurnAgent(deps) {
     outcome: "completed",
     durationSeconds: (performance.now() - postToolPreparationStartedAt) / 1e3
   });
+  const linkedToolAuthority = await getExternalLinkTurnAuthorization2(
+    db,
+    {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId
+    },
+    turn.id
+  );
+  if (linkedToolAuthority && !linkedToolAuthority.authorized)
+    throw new Error("Native identity link was revoked");
   const agent = (() => {
     const agentConstructionStartedAt = performance.now();
     let agentConstructionOutcome = "completed";
     try {
       return runtime.buildAgent(eventing.modelRunSettings, runtimeResources, {
+        ...linkedToolAuthority ? {
+          authorizeAttemptExecution: async () => {
+            const current = await getSessionTurnForAttempt3(
+              db,
+              input.workspaceId,
+              input.sessionId,
+              input.attemptId
+            );
+            if (!current || current.id !== turn.id || current.executionGeneration !== turn.executionGeneration)
+              throw new Error("The linked agent attempt is no longer authorized");
+          }
+        } : {},
         ...preparedTools.inputWaitYield ? { inputWaitYield: preparedTools.inputWaitYield } : {},
         reasoningEffort: turn.reasoningEffort,
         latencyMode: turnExecutionPolicy.latencyMode,
@@ -19463,7 +19540,6 @@ async function buildTurnAgent(deps) {
         ),
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
         skillCatalog: deps.skillCatalog,
-        serverSkillReading: true,
         ...!structuredWorkspacePolicyActive && workspaceAgentInstructions ? { instructionsTemplate: workspaceAgentInstructions } : {},
         ...workspaceGovernance ? { workspaceGovernance } : {},
         ...workspaceMemory ? { workspaceMemory } : {},
@@ -21970,4 +22046,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-V7J34ZOF.js.map
+//# sourceMappingURL=activities-turn-FOIZYY56.js.map