@opengeni/worker-bundle 0.27.0-canary.1 → 0.27.2-canary.1

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

@@ -23,6 +23,7 @@ import {
   compactionFailureReason,
   compactionFailureReasonFromError,
   computeIdleDelayMs,
+  createModelHistoryAttachmentProjector,
   createRuntimeBatcher,
   createSharedActivityServices,
   createTurnSandboxProvisioner,
@@ -44,6 +45,7 @@ import {
   persistOrSignalSessionAttemptQuiescence,
   postClaimDatabaseRecoveryFailure,
   preClaimAdmissionFailure,
+  projectRejectedProviderArtifacts,
   providerRecoveryCountAfterModelRequestPhase,
   providerRecoveryCountFromMetadata,
   providerRecoveryExhaustedFailure,
@@ -53,7 +55,6 @@ import {
   refreshExhaustedXaiQuota,
   releaseTurnSandboxAfterWriterDrain,
   requireAgentStreamFinalOutput,
-  resolveWorkspaceInstalledSkillRuntime,
   resolveWorkspacePackRuntime,
   resumeBoxForTurn,
   rigProviderImageSourceImage,
@@ -75,6 +76,7 @@ import {
   startActivityHeartbeat,
   throwIfTurnOperationCancelled,
   turnFinalizerCancellationSignal,
+  turnInput,
   turnOperationCancellationFailure,
   unavailableMcpOperationalContext,
   validateIncidentTelemetrySystemUpdateAuthority,
@@ -84,7 +86,7 @@ import {
   withFirstPartyTools,
   wrapLazyTurnBoxWithRouting,
   wrapTurnBoxWithRouting
-} from "./chunk-7LS42PHP.js";
+} from "./chunk-C54VDT6I.js";
 import {
   StreamTimingMetrics,
   makeMachineOpObserver,
@@ -110,7 +112,7 @@ import {
   recordTurnWorkerPreparationTotal,
   runtimeMetricsHooksForObservability,
   turnLifecycleMetricsFor
-} from "./chunk-D4ZEFOYH.js";
+} from "./chunk-BARTLVBK.js";
 
 // src/activities-turn.ts
 import { createProductionAgentRuntime, summarizeForCompaction as summarizeForCompaction2 } from "@opengeni/runtime";
@@ -168,9 +170,6 @@ function summarizeCompanyBrainContributions(receipt) {
   }
   return Object.freeze([...bySource.values()].map((summary) => Object.freeze(summary)));
 }
-function modelVisibleCompanyBrainSkillActivations(sandboxBackend, skillActivations) {
-  return sandboxBackend === "none" ? [] : skillActivations;
-}
 function buildCompanyBrainContributionReceipt(input) {
   const contributions = [];
   for (const entry of input.instructionPolicy.entries) {
@@ -195,7 +194,7 @@ function buildCompanyBrainContributionReceipt(input) {
       })
     );
   }
-  for (const descriptor of input.preferences?.descriptors ?? []) {
+  for (const descriptor of input.skillCatalogText !== void 0 ? [] : input.preferences?.descriptors ?? []) {
     contributions.push(
       contribution({
         category: "skill_guide_descriptor",
@@ -228,7 +227,17 @@ function buildCompanyBrainContributionReceipt(input) {
       })
     );
   }
-  for (const descriptor of composeRuntimeSkills(input.skillActivations).configuredDescriptors) {
+  if (input.skillCatalogText)
+    contributions.push(
+      contribution({
+        category: "skill_guide_descriptor",
+        source: "runtime_skill_catalog",
+        inclusionReason: "authorized_skill_descriptor",
+        authorityScope: "workspace",
+        text: input.skillCatalogText
+      })
+    );
+  for (const descriptor of input.skillCatalogText !== void 0 ? [] : composeRuntimeSkills(input.skillActivations).configuredDescriptors) {
     contributions.push(
       contribution({
         category: "skill_guide_descriptor",
@@ -6809,7 +6818,7 @@ import { serviceTierForLatencyMode } from "@opengeni/config";
 // src/activities/context-compaction.ts
 import {
   applyContextCompaction,
-  getActiveSessionHistoryItemsPaged as getActiveSessionHistoryItemsPaged3,
+  getActiveSessionHistoryItemsPaged as getActiveSessionHistoryItemsPaged2,
   recordSkippedContextCompaction,
   recordStartedContextCompaction
 } from "@opengeni/db";
@@ -6830,463 +6839,6 @@ import {
   summarizeForCompaction
 } from "@opengeni/runtime";
 import { contextInputBudgetTokens } from "@opengeni/config";
-
-// src/activities/run-input.ts
-import {
-  MODEL_ATTACHMENT_REFS_FIELD,
-  FileResourceRef,
-  resourceMountPath as resourceMountPath2
-} from "@opengeni/contracts";
-import { createHash as createHash8 } from "crypto";
-import {
-  getActiveSessionHistoryItemsPaged as getActiveSessionHistoryItemsPaged2,
-  getFilesForSubject as getFilesForSubject2,
-  getSandboxSessionEnvelope,
-  listSessionSystemUpdatesForTurn,
-  listTurnOpenSuffixToolCalls
-} from "@opengeni/db";
-import {
-  projectHistoryForProvider,
-  projectRejectedProviderArtifactsFromSerializedRunState,
-  projectRejectedReasoningArtifact,
-  hasOpaqueProviderArtifact
-} from "@opengeni/runtime";
-function projectRejectedProviderArtifacts(rows) {
-  const out = [];
-  for (const row of rows) {
-    if (!row.providerArtifactInvalidatedAt) {
-      out.push(row.item);
-      continue;
-    }
-    const type = typeof row.item.type === "string" ? row.item.type : void 0;
-    if (type === "reasoning") {
-      out.push(projectRejectedReasoningArtifact(row.item));
-      continue;
-    }
-    if (type === "compaction") {
-      continue;
-    }
-    out.push(row.item);
-  }
-  return out;
-}
-async function measureHistoryPreparationPhase(options, phase, operation) {
-  const startedAt = performance.now();
-  let outcome = "completed";
-  try {
-    return await operation();
-  } catch (error) {
-    outcome = "failed";
-    throw error;
-  } finally {
-    try {
-      options.onPreparationPhase?.({
-        phase,
-        outcome,
-        durationSeconds: (performance.now() - startedAt) / 1e3
-      });
-    } catch {
-    }
-  }
-}
-var MAX_INLINE_MODEL_ATTACHMENT_BYTES = 20 * 1024 * 1024;
-var MODEL_IMAGE_CONTENT_TYPES = /* @__PURE__ */ new Set(["image/gif", "image/jpeg", "image/png", "image/webp"]);
-var MODEL_FILE_CONTENT_TYPES = /* @__PURE__ */ new Set([
-  "application/json",
-  "application/pdf",
-  "application/x-yaml",
-  "application/yaml"
-]);
-var BLOCKED_TEXT_CONTENT_TYPES = /* @__PURE__ */ new Set([
-  "text/css",
-  "text/html",
-  "text/javascript",
-  "text/xml"
-]);
-function safeErrorType(error) {
-  if (!(error instanceof Error)) return typeof error;
-  const name = error.name.trim();
-  return /^[A-Za-z][A-Za-z0-9_.-]{0,63}$/.test(name) ? name : "Error";
-}
-function modelAttachmentDescriptor(contentType) {
-  const normalized = contentType.toLowerCase().split(";", 1)[0]?.trim() ?? "";
-  if (MODEL_IMAGE_CONTENT_TYPES.has(normalized)) {
-    return { kind: "image", contentType: normalized };
-  }
-  if (MODEL_FILE_CONTENT_TYPES.has(normalized) || normalized.startsWith("text/") && !BLOCKED_TEXT_CONTENT_TYPES.has(normalized)) {
-    return { kind: "file", contentType: normalized };
-  }
-  return null;
-}
-async function modelAttachmentContentForFiles(files, readFileBytes) {
-  const selected = [];
-  let remainingBytes = MAX_INLINE_MODEL_ATTACHMENT_BYTES;
-  for (const file of files) {
-    const descriptor = modelAttachmentDescriptor(file.contentType);
-    const checksum = file.sha256?.trim().toLowerCase() ?? "";
-    if (file.status !== "ready" || !descriptor || descriptor.kind !== "image" || file.sizeBytes > remainingBytes || !/^[a-f0-9]{64}$/.test(checksum)) {
-      continue;
-    }
-    selected.push({ file, descriptor, checksum });
-    remainingBytes -= file.sizeBytes;
-  }
-  const attachments = new Array(selected.length);
-  let cursor = 0;
-  const worker = async () => {
-    while (cursor < selected.length) {
-      const index = cursor++;
-      const { file, descriptor, checksum } = selected[index];
-      try {
-        const bytes = await readFileBytes(file);
-        if (bytes.byteLength !== file.sizeBytes) {
-          console.error("model attachment bytes did not match finalized metadata", {
-            fileId: file.id,
-            expectedSizeBytes: file.sizeBytes,
-            actualSizeBytes: bytes.byteLength
-          });
-          continue;
-        }
-        if (createHash8("sha256").update(bytes).digest("hex") !== checksum) {
-          console.error("model attachment checksum did not match finalized metadata", {
-            fileId: file.id
-          });
-          continue;
-        }
-        attachments[index] = {
-          kind: descriptor.kind,
-          fileId: file.id,
-          filename: file.safeFilename,
-          contentType: descriptor.contentType,
-          dataUrl: `data:${descriptor.contentType};base64,${Buffer.from(bytes).toString("base64")}`
-        };
-      } catch (error) {
-        console.error("model attachment content read failed; retaining sandbox path fallback", {
-          fileId: file.id,
-          errorType: safeErrorType(error)
-        });
-      }
-    }
-  };
-  await Promise.all(
-    Array.from({ length: Math.min(8, selected.length) }, async () => await worker())
-  );
-  return attachments.filter(
-    (attachment) => attachment !== void 0
-  );
-}
-function attachmentRefsFromItem(item) {
-  const raw = item[MODEL_ATTACHMENT_REFS_FIELD];
-  if (!Array.isArray(raw)) return [];
-  const refs = [];
-  for (const candidate of raw) {
-    const parsed = FileResourceRef.safeParse(candidate);
-    if (parsed.success) refs.push(parsed.data);
-  }
-  return refs;
-}
-function attachmentReceiptText(ref, file) {
-  if (!file) {
-    return `[Earlier attachment: fileId=${ref.fileId}; mountDirectory=${resourceMountPath2(ref)}. Use the existing file there, or call files__files_get_download_url with this fileId and download it with the shell.]`;
-  }
-  const path = sandboxFilePath(ref, file);
-  return `[Attachment: ${file.safeFilename}; fileId=${file.id}; type=${file.contentType}; bytes=${file.sizeBytes}; path=${path}. If the local path is absent, call files__files_get_download_url with this fileId and download it with the shell.]`;
-}
-function createModelHistoryAttachmentProjector(policy, readFileBytes) {
-  const contentById = /* @__PURE__ */ new Map();
-  const attemptedContentIds = /* @__PURE__ */ new Set();
-  return async (items, options = {}) => {
-    const currentFileById = new Map((options.inlineFiles ?? []).map((file) => [file.id, file]));
-    const refsByIndex = /* @__PURE__ */ new Map();
-    const orderedFileIds = [];
-    const seenFileIds = /* @__PURE__ */ new Set();
-    for (let index = 0; index < items.length; index += 1) {
-      const refs = attachmentRefsFromItem(items[index]);
-      if (refs.length === 0) continue;
-      refsByIndex.set(index, refs);
-      for (const ref of refs) {
-        if (seenFileIds.has(ref.fileId)) continue;
-        seenFileIds.add(ref.fileId);
-        orderedFileIds.push(ref.fileId);
-      }
-    }
-    if (refsByIndex.size === 0) return items;
-    if (readFileBytes) {
-      const readable = [...orderedFileIds].reverse().map((id) => currentFileById.get(id)).filter((file) => {
-        if (!file || attemptedContentIds.has(file.id)) return false;
-        const descriptor = modelAttachmentDescriptor(file.contentType);
-        return Boolean(descriptor && descriptor.kind === "image" && policy.supportsImageInput);
-      });
-      for (const file of readable) attemptedContentIds.add(file.id);
-      const content = await modelAttachmentContentForFiles(readable, readFileBytes);
-      for (const attachment of content) contentById.set(attachment.fileId, attachment);
-    }
-    const projected = [...items];
-    for (const [index, refs] of refsByIndex) {
-      const original = items[index];
-      const existingContent = Array.isArray(original.content) ? [...original.content] : [{ type: "input_text", text: String(original.content ?? "") }];
-      const attachmentParts = refs.flatMap((ref) => {
-        const currentFile = currentFileById.get(ref.fileId);
-        const attachment = currentFile ? contentById.get(ref.fileId) : void 0;
-        const receipt = {
-          type: "input_text",
-          text: attachmentReceiptText(ref, currentFile)
-        };
-        if (!attachment || attachment.kind !== "image") {
-          return [receipt];
-        }
-        return [receipt, { type: "input_image", image: attachment.dataUrl }];
-      });
-      const clone = {
-        ...original,
-        content: [...existingContent, ...attachmentParts]
-      };
-      delete clone[MODEL_ATTACHMENT_REFS_FIELD];
-      projected[index] = clone;
-    }
-    return projected;
-  };
-}
-function withCurrentUserAttachmentRefs(historyItems, refs) {
-  if (refs.length === 0) return historyItems;
-  for (let index = historyItems.length - 1; index >= 0; index -= 1) {
-    const item = historyItems[index];
-    if (item.type !== "message" || item.role !== "user") continue;
-    const existing = attachmentRefsFromItem(item);
-    const existingIds = new Set(existing.map((ref) => ref.fileId));
-    const additions = refs.filter((ref) => !existingIds.has(ref.fileId));
-    if (additions.length === 0) return historyItems;
-    const projected = [...historyItems];
-    projected[index] = { ...item, [MODEL_ATTACHMENT_REFS_FIELD]: [...existing, ...additions] };
-    return projected;
-  }
-  return historyItems;
-}
-async function turnInput(db, runtime, agent, trigger, options) {
-  if (!trigger) {
-    throw new Error("Missing trigger event");
-  }
-  const updates = await measureHistoryPreparationPhase(
-    options,
-    "system_update_load",
-    async () => await listSessionSystemUpdatesForTurn(
-      db,
-      trigger.workspaceId,
-      trigger.sessionId,
-      options.turnId
-    )
-  );
-  if (updates.some((update) => !update.deliveredHistoryItemId)) {
-    throw new Error("Delivered internal update has no durable model-memory batch");
-  }
-  const internalContext = joinInternalContext(
-    options.recovering ? [
-      "[OpenGeni inference recovery]",
-      "Continue the same inference from durable conversation and sandbox state. A previous execution stopped before it could finish. Do not repeat completed side effects; inspect actual state when uncertain."
-    ].join("\n") : void 0,
-    options.unavailableSandboxFilesNote,
-    options.runCredentialsNote,
-    options.mcpAvailabilityNote
-  );
-  if (trigger.type === "user.message") {
-    const payload = trigger.payload;
-    const hasAnnotations = Array.isArray(payload.annotations) && payload.annotations.length > 0;
-    if (typeof payload.text !== "string" || payload.text.trim().length === 0 && !hasAnnotations) {
-      throw new Error("user.message payload is missing text and annotations");
-    }
-    const resources = Array.isArray(payload.resources) ? payload.resources : [];
-    const fileAttachments = await measureHistoryPreparationPhase(
-      options,
-      "current_attachment_resolution",
-      async () => await resolveUserMessageFileAttachments(
-        db,
-        options.fileAuthority.accountId,
-        trigger.workspaceId,
-        options.fileAuthority.subjectId,
-        resources
-      )
-    );
-    const attachmentContext = userMessageAttachmentsContext(fileAttachments);
-    return await messageInput(
-      db,
-      runtime,
-      agent,
-      trigger,
-      void 0,
-      joinInternalContext(internalContext, attachmentContext),
-      fileAttachments,
-      options.providerApi,
-      options.projectCanonicalHistory,
-      options.materializeModelHistory,
-      options.projectModelHistory,
-      options.loadActiveHistory,
-      options
-    );
-  }
-  if (trigger.type === "system.update.delivered") {
-    if (updates.length === 0) {
-      throw new Error("Internal update inference has no delivered updates");
-    }
-    return await messageInput(
-      db,
-      runtime,
-      agent,
-      trigger,
-      void 0,
-      internalContext,
-      [],
-      options.providerApi,
-      options.projectCanonicalHistory,
-      options.materializeModelHistory,
-      options.projectModelHistory,
-      options.loadActiveHistory,
-      options
-    );
-  }
-  if (trigger.type === "user.approvalDecision" || trigger.type === "user.humanInputResponse") {
-    return await openSuffixMessageInput(db, runtime, agent, trigger, internalContext, options);
-  }
-  throw new Error(`Unsupported trigger event type: ${trigger.type}`);
-}
-function joinInternalContext(...parts) {
-  const content = parts.map((part) => part?.trim()).filter((part) => Boolean(part));
-  return content.length > 0 ? content.join("\n\n") : void 0;
-}
-async function openSuffixMessageInput(db, runtime, agent, trigger, internalContext, options) {
-  const suffixRows = await listTurnOpenSuffixToolCalls(
-    db,
-    trigger.workspaceId,
-    trigger.sessionId,
-    options.turnId
-  );
-  if (suffixRows.length === 0) {
-    throw new Error("Open suffix resume has no interruption rows");
-  }
-  if (suffixRows.some((row) => row.resultItem == null)) {
-    throw new Error("Open suffix resume still has unresolved members");
-  }
-  return await messageInput(
-    db,
-    runtime,
-    agent,
-    trigger,
-    void 0,
-    internalContext,
-    [],
-    options.providerApi,
-    options.projectCanonicalHistory,
-    options.materializeModelHistory,
-    options.projectModelHistory,
-    options.loadActiveHistory,
-    options
-  );
-}
-async function messageInput(db, runtime, agent, trigger, text, internalContext, currentAttachments = [], providerApi = "responses", projectCanonicalHistory, materializeModelHistory, projectModelHistory, loadActiveHistory = getActiveSessionHistoryItemsPaged2, preparationOptions = {}) {
-  const currentAttachmentRefs = currentAttachments.map((attachment) => attachment.resource);
-  const [stored, envelope] = await Promise.all([
-    measureHistoryPreparationPhase(
-      preparationOptions,
-      "durable_history_load",
-      async () => loadActiveHistory(db, trigger.workspaceId, trigger.sessionId)
-    ),
-    measureHistoryPreparationPhase(
-      preparationOptions,
-      "sandbox_envelope_load",
-      async () => getSandboxSessionEnvelope(db, trigger.workspaceId, trigger.sessionId)
-    )
-  ]);
-  const canonicalView = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "canonical_projection",
-    async () => {
-      const active = projectRejectedProviderArtifacts(stored);
-      return projectCanonicalHistory ? await projectCanonicalHistory(active) : active;
-    }
-  );
-  const providerView = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "provider_projection",
-    () => projectHistoryForProvider(canonicalView, providerApi)
-  );
-  const referencedHistory = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "attachment_ref_projection",
-    () => withCurrentUserAttachmentRefs(providerView, currentAttachmentRefs)
-  );
-  const materializedHistory = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "screenshot_materialization",
-    async () => materializeModelHistory ? await materializeModelHistory(referencedHistory) : referencedHistory
-  );
-  const historyItems = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "model_attachment_projection",
-    async () => projectModelHistory ? await projectModelHistory(materializedHistory, {
-      inlineFiles: currentAttachments.map((attachment) => attachment.file)
-    }) : materializedHistory
-  );
-  const prepared = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "runtime_input_assembly",
-    async () => await runtime.prepareInput(agent, {
-      kind: "message",
-      ...text ? { text } : {},
-      ...internalContext ? { internalContext } : {},
-      historyItems,
-      sandboxEnvelope: envelope,
-      ...projectModelHistory ? { modelInputAlreadyProjected: true } : {}
-    })
-  );
-  const providerArtifactCandidates = await measureHistoryPreparationPhase(
-    preparationOptions,
-    "artifact_candidate_scan",
-    () => {
-      const preparedItems = Array.isArray(prepared.input) ? new Set(prepared.input) : /* @__PURE__ */ new Set();
-      return {
-        knownHistoryItemIds: stored.map((row) => row.id),
-        historyItemIds: stored.filter(
-          (row) => row.providerArtifactInvalidatedAt === null && hasOpaqueProviderArtifact(row.item) && preparedItems.has(row.item)
-        ).map((row) => row.id)
-      };
-    }
-  );
-  return {
-    input: prepared,
-    persistedHistoryCount: prepared.persistedHistoryCount,
-    providerArtifactCandidates
-  };
-}
-async function resolveUserMessageFileAttachments(db, accountId, workspaceId, subjectId, resources) {
-  const fileResources = resources.filter(
-    (resource) => resource.kind === "file"
-  );
-  if (fileResources.length === 0) return [];
-  const files = await getFilesForSubject2(db, {
-    accountId,
-    workspaceId,
-    subjectId,
-    fileIds: fileResources.map((resource) => resource.fileId)
-  });
-  const fileById = new Map(files.map((file) => [file.id, file]));
-  return fileResources.map((resource) => {
-    const file = fileById.get(resource.fileId);
-    if (!file) throw new Error(`File not found: ${resource.fileId}`);
-    return { resource, file };
-  });
-}
-function userMessageAttachmentsContext(attachments) {
-  const attachedFiles = attachments.map(
-    ({ resource, file }) => `- ${file.filename} (${file.contentType}, ${file.sizeBytes} bytes): ${sandboxFilePath(resource, file)}`
-  );
-  if (attachedFiles.length === 0) {
-    return void 0;
-  }
-  return ["Attached files are available in the sandbox:", ...attachedFiles].join("\n");
-}
-function sandboxFilePath(resource, file) {
-  return `${resourceMountPath2(resource)}/${file.safeFilename}`;
-}
-
-// src/activities/context-compaction.ts
 async function maybeCompactContext(db, settings, scope, lastInputTokens, summarize = (s, m) => summarizeForCompaction(s, m, {
   maxOutputTokens: SUMMARY_BUFFER_TOKENS
 }), options = {}) {
@@ -7307,7 +6859,7 @@ async function maybeCompactContext(db, settings, scope, lastInputTokens, summari
       };
     }
   }
-  const active = await getActiveSessionHistoryItemsPaged3(db, scope.workspaceId, scope.sessionId);
+  const active = await getActiveSessionHistoryItemsPaged2(db, scope.workspaceId, scope.sessionId);
   if (active.length === 0) {
     let requestConsumed = false;
     if (options.clearRequestedCompaction) {
@@ -7460,7 +7012,12 @@ async function compactContextRemoteV2(db, settings, scope, canonicalItems, items
     rewrittenToolOutputs = retry.rewrittenToolOutputs;
     compactionItem = await options.requestRemoteCompactionV2(settings, retry.input);
   }
-  const replacementHistory = buildRemoteV2ReplacementHistory(canonicalItems, compactionItem);
+  const retainedTokens = await retentionTokenCounts(canonicalItems, projectForWire);
+  const replacementHistory = buildRemoteV2ReplacementHistory(
+    canonicalItems,
+    compactionItem,
+    (item) => retainedTokens.get(item) ?? estimateTokens([item])
+  );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const tailItem = replacementHistory.at(-1);
@@ -7510,7 +7067,12 @@ async function compactContextPortable(db, settings, scope, canonicalItems, items
   const estimatedTokensBefore = estimateTokens(items);
   const summarized = await summarizeWithCodexOverflowTrimming(summarize, settings, items);
   const summaryBody = summarized.summaryBody;
-  const replacementHistory = buildCompactionReplacementHistory(canonicalItems, summaryBody);
+  const retainedTokens = await retentionTokenCounts(canonicalItems, projectForWire);
+  const replacementHistory = buildCompactionReplacementHistory(
+    canonicalItems,
+    summaryBody,
+    (item) => retainedTokens.get(item) ?? estimateTokens([item])
+  );
   const estimatedTokensAfter = estimateTokens(await projectForWire(replacementHistory));
   const replacementFingerprint = compactionReplacementFingerprint(replacementHistory);
   const previousReplacementFingerprint = latestCompactionReplacementFingerprint(canonicalItems);
@@ -7609,6 +7171,15 @@ function isExactContextLengthExceeded(error, seen = /* @__PURE__ */ new WeakSet(
   }
   return isExactContextLengthExceeded(record5.cause, seen) || isExactContextLengthExceeded(record5.error, seen) || isExactContextLengthExceeded(record5.diagnostics, seen);
 }
+async function retentionTokenCounts(items, project) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.role === "user" || item.role === "developer") {
+      counts.set(item, estimateTokens(await project([item])));
+    }
+  }
+  return counts;
+}
 
 // src/activities/open-suffix-resume.ts
 import {
@@ -7619,7 +7190,7 @@ import {
   appendSessionHistoryItems as appendSessionHistoryItems2,
   getActiveSessionHistoryItems,
   interruptedToolCallResult,
-  listTurnOpenSuffixToolCalls as listTurnOpenSuffixToolCalls2,
+  listTurnOpenSuffixToolCalls,
   nextSessionHistoryPosition,
   recordPendingSessionToolCallResult
 } from "@opengeni/db";
@@ -7770,7 +7341,7 @@ async function settleOpenSuffixResumeIfNeeded(input) {
   if (input.trigger.type !== "user.approvalDecision" && input.trigger.type !== "user.humanInputResponse") {
     return { action: "continue" };
   }
-  const rows = await listTurnOpenSuffixToolCalls2(
+  const rows = await listTurnOpenSuffixToolCalls(
     input.db,
     input.workspaceId,
     input.sessionId,
@@ -7816,7 +7387,7 @@ async function settleOpenSuffixResumeIfNeeded(input) {
     }
     if (!recorded.recorded) {
       const latest = resolveOpenSuffixResumeTarget(
-        await listTurnOpenSuffixToolCalls2(
+        await listTurnOpenSuffixToolCalls(
           input.db,
           input.workspaceId,
           input.sessionId,
@@ -7868,7 +7439,7 @@ async function settleOpenSuffixResumeIfNeeded(input) {
       return { action: "cancelled" };
     }
   }
-  const remaining = (await listTurnOpenSuffixToolCalls2(input.db, input.workspaceId, input.sessionId, input.turnId)).filter((row) => row.resultItem == null);
+  const remaining = (await listTurnOpenSuffixToolCalls(input.db, input.workspaceId, input.sessionId, input.turnId)).filter((row) => row.resultItem == null);
   if (remaining.length === 0) {
     return { action: "continue" };
   }
@@ -9577,7 +9148,7 @@ async function runTurnStreamAttempt(deps) {
 import {
   applySessionTurnSettlement,
   claimSessionWorkForAttempt,
-  getSessionEvent as getSessionEvent3,
+  getSessionEvent as getSessionEvent2,
   getHumanInputResumeForEvent as getHumanInputResumeForEvent2,
   getInteractionInterventionResumeForEvent,
   installOrReadTurnExecutionPolicyForAttempt,
@@ -9934,7 +9505,7 @@ async function claimTurnAttempt(deps) {
   billingState.countsTowardTokenCap = billingIdentity.countsTowardTokenCap;
   billingState.isCodexTurn = billingIdentity.codexSubscription;
   billingState.isXaiTurn = billingIdentity.xaiSubscription;
-  const trigger = await getSessionEvent3(db, input.workspaceId, attempt.triggerEventId);
+  const trigger = await getSessionEvent2(db, input.workspaceId, attempt.triggerEventId);
   if (!trigger) {
     throw new Error(`Trigger event not found: ${attempt.triggerEventId}`);
   }
@@ -10990,10 +10561,11 @@ async function selectCodexTurnCapacity(deps) {
 import {
   materializeRigVersionForAttempt,
   getWorkspaceModelPolicy,
+  getFilesForSubject as getFilesForSubject2,
   getWorkspace as getWorkspace2,
   resolveCompanyBrainContextSelection,
   getGeneratedVideoArtifact,
-  listSessionSystemUpdatesForTurn as listSessionSystemUpdatesForTurn2,
+  listSessionSystemUpdatesForTurn,
   getOrCreateCompanyProfileSnapshot,
   getOrCreatePreferenceRegistrySnapshot,
   getOrCreateWorkspaceInstructionPolicySnapshot,
@@ -11001,7 +10573,7 @@ import {
   resolveSessionAttemptPersonalResources
 } from "@opengeni/db";
 import {
-  projectHistoryForProvider as projectHistoryForProvider2,
+  projectHistoryForProvider,
   restoreGenericDispatchHistoryItems,
   projectModelInputForCapabilities,
   hasActiveWorkspaceInstructionPolicy,
@@ -11034,7 +10606,7 @@ import {
   prepareImageGenerationOperation,
   resetImageGenerationOperationBeforeProviderDispatch
 } from "@opengeni/db";
-import { createHash as createHash9 } from "crypto";
+import { createHash as createHash8 } from "crypto";
 var ImageGenerationOutcomeUnknownError = class extends Error {
   constructor(operationId) {
     super(
@@ -11247,7 +10819,7 @@ async function recoverCompletedImage(input, identity) {
   return retainedGeneratedImageFromArtifact(recovered).receipt;
 }
 function digest(prefix, ...values) {
-  const hash = createHash9("sha256").update(prefix);
+  const hash = createHash8("sha256").update(prefix);
   for (const value of values) hash.update(value).update("\0");
   return hash.digest("hex");
 }
@@ -11358,13 +10930,11 @@ async function prepareGovernanceAndModel(deps) {
   };
   const [
     packRuntime,
-    installedSkillRuntime,
     rigMaterialization,
     [workspace, companyProfileSnapshot, instructionPolicySnapshot, preferenceSnapshot],
     workspaceModelPolicy
   ] = await Promise.all([
     resolveWorkspacePackRuntime(db, input.workspaceId),
-    resolveWorkspaceInstalledSkillRuntime(db, input.workspaceId),
     session.rigId && session.rigVersionId ? (async () => await materializeRigVersionForAttempt(db, {
       accountId: input.accountId,
       workspaceId: input.workspaceId,
@@ -11403,12 +10973,13 @@ async function prepareGovernanceAndModel(deps) {
       preferences: preferenceSnapshot
     },
     {
-      includeCompanyProfile: companyProfileIncluded
+      includeCompanyProfile: companyProfileIncluded,
+      sharedSkillReader: true
     }
   );
   const structuredWorkspacePolicyActive = hasActiveWorkspaceInstructionPolicy(instructionPolicySnapshot);
   const workspaceMemory = contextSelection.workspaceMemory;
-  const buildCompanyBrainContributionReceiptFor = (skillActivations) => buildCompanyBrainContributionReceipt({
+  const buildCompanyBrainContributionReceiptFor = (skillCatalogText) => buildCompanyBrainContributionReceipt({
     contextSelectionReceiptId: contextSelection.receipt.id,
     attemptId: input.attemptId,
     turnId: turn.id,
@@ -11420,11 +10991,12 @@ async function prepareGovernanceAndModel(deps) {
     companyProfile: companyProfileSnapshot,
     companyProfileIncluded,
     workspaceMemory,
-    skillActivations
+    skillActivations: [],
+    skillCatalogText
   });
   try {
     eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
-      buildCompanyBrainContributionReceiptFor([])
+      buildCompanyBrainContributionReceiptFor("")
     );
   } catch {
   }
@@ -11475,7 +11047,13 @@ async function prepareGovernanceAndModel(deps) {
       );
       if (!object) throw new Error("attachment object is missing");
       return object.bytes;
-    } : void 0
+    } : void 0,
+    (fileIds) => getFilesForSubject2(db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: fileAuthoritySubjectId,
+      fileIds
+    })
   );
   const modelHistoryProjector = async (items, projectionOptions) => projectModelInputForCapabilities(
     await attachmentProjector(items, projectionOptions),
@@ -11486,7 +11064,7 @@ async function prepareGovernanceAndModel(deps) {
     return projectGeneratedImageHistoryForModel(items);
   };
   const compactionModelHistoryProjector = async (items) => await modelHistoryProjector(
-    projectHistoryForProvider2(
+    projectHistoryForProvider(
       await generatedImageHistoryProjector(restoreGenericDispatchHistoryItems(items)),
       providerApi
     )
@@ -11507,7 +11085,7 @@ async function prepareGovernanceAndModel(deps) {
       }
     }
   }
-  for (const update of await listSessionSystemUpdatesForTurn2(
+  for (const update of await listSessionSystemUpdatesForTurn(
     db,
     input.workspaceId,
     input.sessionId,
@@ -11537,7 +11115,6 @@ async function prepareGovernanceAndModel(deps) {
     ok: {
       runtimePreparationStartedAt,
       packRuntime,
-      installedSkillRuntime,
       rigVersion,
       rigName,
       agentHumanInputEnabled,
@@ -14710,6 +14287,8 @@ async function prepareRunCredentials(deps) {
 import { getWorkspaceConnectionModelRestrictions } from "@opengeni/db";
 import {
   beginConnectorActionExecution,
+  getWorkspaceVideoGenerationPolicy,
+  listSkillDescriptors as listSkillDescriptors2,
   completeConnectorActionExecution,
   getScheduledVariableSetExpectedGenerationForAttempt,
   getWorkspaceModelPolicy as getWorkspaceModelPolicy2,
@@ -14734,7 +14313,7 @@ import {
 } from "@opengeni/runtime";
 
 // src/activities/google-drive-publication.ts
-import { createHash as createHash10 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 import {
   GOOGLE_DRIVE_FILE_SCOPE,
   GOOGLE_DRIVE_FULL_SCOPE,
@@ -14834,7 +14413,7 @@ function googleDrivePublicationConnectorCall(target, rawRequest, approvalId) {
         sourceSha256: request.file.sha256
       },
       canonicalReceipt: { ...request.file },
-      idempotencyKeyDigest: createHash10("sha256").update(request.idempotencyKey, "utf8").digest("hex")
+      idempotencyKeyDigest: createHash9("sha256").update(request.idempotencyKey, "utf8").digest("hex")
     }
   };
 }
@@ -15022,7 +14601,7 @@ async function executeGoogleDrivePublication(input, ports = defaultPorts) {
   );
   if (!object) throw new Error("Editable artifact export object is missing");
   const bytes = object.bytes;
-  if (bytes.byteLength !== request.file.sizeBytes || createHash10("sha256").update(bytes).digest("hex") !== request.file.sha256) {
+  if (bytes.byteLength !== request.file.sizeBytes || createHash9("sha256").update(bytes).digest("hex") !== request.file.sha256) {
     throw new Error("Editable artifact export bytes failed verification");
   }
   const authorizedFetch = async (url, init) => {
@@ -15104,7 +14683,7 @@ function assertPublicationConnection(input, connection) {
   }
 }
 function publicationActorReplicaId(identity) {
-  const value = createHash10("sha256").update(
+  const value = createHash9("sha256").update(
     `google-drive-publication:${identity.sessionId}:${identity.turnId}:${identity.attemptId}:${identity.executionGeneration}`,
     "utf8"
   ).digest("hex").slice(0, 16);
@@ -15149,7 +14728,7 @@ function officeFormat(modality, contentType) {
   return expected.format;
 }
 function deterministicUuid(seed) {
-  const bytes = createHash10("sha256").update(seed, "utf8").digest().subarray(0, 16);
+  const bytes = createHash9("sha256").update(seed, "utf8").digest().subarray(0, 16);
   bytes[6] = (bytes[6] ?? 0) & 15 | 80;
   bytes[8] = (bytes[8] ?? 0) & 63 | 128;
   const hex = bytes.toString("hex");
@@ -15287,7 +14866,7 @@ function driveReceipt(input, file, replayed) {
   });
 }
 function publicationOperationKey(input) {
-  return createHash10("sha256").update(
+  return createHash9("sha256").update(
     JSON.stringify({
       workspaceId: input.workspaceId,
       connectionId: input.connectionId,
@@ -15956,7 +15535,7 @@ function canWrite(permissions) {
 }
 
 // src/activities/connector-attachments.ts
-import { createHash as createHash11 } from "crypto";
+import { createHash as createHash10 } from "crypto";
 import {
   CONNECTOR_ATTACHMENT_RECEIPT_VERSION,
   ConnectorAttachmentReceiptEnvelope
@@ -15976,7 +15555,7 @@ var ConnectorAttachmentMaterializationError = class extends Error {
   }
 };
 function digestParts(...parts) {
-  const hash = createHash11("sha256");
+  const hash = createHash10("sha256");
   for (const part of parts) {
     const bytes = Buffer.from(part, "utf8");
     hash.update(String(bytes.byteLength));
@@ -16581,6 +16160,780 @@ function createListModelsAttemptToolDefinition(input) {
   };
 }
 
+// src/activities/agent-turn/skill-tools.ts
+import { createHash as createHash11 } from "crypto";
+import {
+  skillReviewHumanInput
+} from "@opengeni/contracts";
+import {
+  assertSkillReadAttempt,
+  skillReviewResolution,
+  installPortableSkill,
+  replayPortableSkillInstall,
+  listSkillDescriptors
+} from "@opengeni/db";
+import {
+  createGitHubSkillSourceClient,
+  createPublicSkillSearchClient,
+  portableSkillCapabilityId,
+  portableSkillPluginKey,
+  readSkill,
+  resolveSkillImport,
+  saveSkill
+} from "@opengeni/core";
+import {
+  buildPortableSkillArtifact as buildPortableSkillArtifact3,
+  loadSkillLibrarySkill,
+  skillLibraryRepositoryUrl
+} from "@opengeni/runtime/skill-library";
+
+// src/activities/agent-turn/skill-read.ts
+import {
+  assertSkillRelativePath,
+  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";
+function createSkillReadAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: SKILL_READ_TOOL_NAME },
+    modelName: SKILL_READ_TOOL_NAME,
+    codemodePath: ["opengeni", SKILL_READ_TOOL_NAME],
+    title: "Read Skill files",
+    description: "Read Skill text without starting a sandbox. Omit paths to read SKILL.md; provide relative paths to read exactly those files, never implicitly adding SKILL.md. Set listFiles:true without paths to list relative paths and available revision identity only, with no file bodies. Use an id or name from the Skill index or skill_search. Management tools are lazy; when listed, opengeni-skills explains how to use them.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        skill: { type: "string", minLength: 1, maxLength: 512 },
+        listFiles: { type: "boolean" },
+        paths: {
+          type: "array",
+          minItems: 1,
+          maxItems: SKILL_READ_MAX_PATHS,
+          uniqueItems: true,
+          items: { type: "string", minLength: 1, maxLength: 1024 }
+        }
+      },
+      required: ["skill"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Read Skill files",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      if (typeof args.skill !== "string" || !args.skill || args.listFiles !== void 0 && typeof args.listFiles !== "boolean" || args.paths !== void 0 && (!Array.isArray(args.paths) || args.paths.some((path) => typeof path !== "string"))) {
+        throw new Error("skill_read requires a Skill identifier and optional relative paths.");
+      }
+      if (args.listFiles === true && args.paths !== void 0) {
+        throw new Error("skill_read listFiles:true cannot be combined with paths.");
+      }
+      await input.authorize();
+      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 output = {
+        ...metadata ? {
+          skillId: metadata.skillId,
+          revisionId: metadata.revisionId,
+          scopeVersion: metadata.scopeVersion,
+          ...metadata.installationVersion !== void 0 ? { installationVersion: metadata.installationVersion } : {}
+        } : {},
+        ...selected
+      };
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+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";
+import { listSkillLibraryEntries } from "@opengeni/runtime/skill-library";
+function createSkillSearchAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_search" },
+    modelName: "skill_search",
+    codemodePath: ["opengeni", "skill_search"],
+    title: "Search Skills",
+    description: "Find installed workspace Skills or available curated and public Skills. Returns identifiers and install sources, not file contents. Search never installs or starts a sandbox. Scope defaults to all; use installed to avoid external search.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        query: { type: "string", minLength: 2, maxLength: 200 },
+        scope: { type: "string", enum: ["installed", "catalog", "all"] },
+        limit: { type: "integer", minimum: 1, maximum: 20 }
+      },
+      required: ["query"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Search Skills",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const query = String(args.query).trim();
+      const scope = args.scope ?? "all";
+      const limit = typeof args.limit === "number" ? args.limit : 20;
+      const searchText = query.toLowerCase();
+      const matches = (entry) => `${entry.name}
+${entry.description}`.toLowerCase().includes(searchText);
+      const installed = scope === "catalog" ? [] : await input.listWorkspace();
+      const workspaceHits = installed.filter(matches).slice(0, limit).map((entry) => ({
+        ...entry,
+        source: entry.source ?? "workspace",
+        installed: !entry.source || entry.source === "workspace"
+      }));
+      const libraryHits = scope === "installed" ? [] : listSkillLibraryEntries().filter(matches).slice(0, limit).map((entry) => ({
+        id: `library:${entry.id}`,
+        name: entry.name,
+        description: entry.description,
+        source: "library",
+        libraryId: entry.id
+      }));
+      let publicResult = null;
+      let publicError = null;
+      if (scope !== "installed") {
+        try {
+          publicResult = await input.publicSearch.search({ query, limit });
+        } catch (error) {
+          if (!(error instanceof PublicSkillSearchError)) throw error;
+          publicError = {
+            source: "skills_sh",
+            code: error.code,
+            retryAfterSeconds: error.retryAfterSeconds
+          };
+        }
+      }
+      const output = {
+        workspace: workspaceHits,
+        library: libraryHits,
+        public: publicResult?.items.map((entry) => ({ ...entry })) ?? [],
+        // A provider outage is not an empty search. Keep local results useful
+        // and expose partial failure explicitly, without leaking network details.
+        partial: publicError !== null,
+        errors: publicError ? [publicError] : []
+      };
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+
+// src/activities/agent-turn/skill-save.ts
+import {
+  applySkillFileChanges,
+  buildPortableSkillArtifact,
+  PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES2
+} from "@opengeni/runtime/skill-library";
+function createSkillSaveAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_save" },
+    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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operationId: { type: "string", format: "uuid" },
+        skillId: { type: "string", format: "uuid" },
+        expectedRevisionId: { type: ["string", "null"], format: "uuid" },
+        expectedScopeVersion: { type: "integer", minimum: 0 },
+        files: {
+          type: "array",
+          maxItems: PORTABLE_SKILL_MAX_FILES2,
+          items: {
+            type: "object",
+            properties: {
+              path: { type: "string", minLength: 1, maxLength: 1024 },
+              content: { type: "string" }
+            },
+            required: ["path", "content"],
+            additionalProperties: false
+          }
+        },
+        deletions: {
+          type: "array",
+          maxItems: PORTABLE_SKILL_MAX_FILES2,
+          uniqueItems: true,
+          items: { type: "string", minLength: 1, maxLength: 1024 }
+        },
+        reason: { type: "string", minLength: 1, maxLength: 2e3 }
+      },
+      required: [
+        "operationId",
+        "skillId",
+        "expectedRevisionId",
+        "expectedScopeVersion",
+        "files",
+        "reason"
+      ],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Save Skill text",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const skillId = args.skillId;
+      const expectedRevisionId = args.expectedRevisionId;
+      const current = expectedRevisionId === null ? null : await input.load(skillId, expectedRevisionId);
+      if (current && current.revisionId !== expectedRevisionId) {
+        throw new Error("Skill edit base did not match the requested revision.");
+      }
+      const files = applySkillFileChanges(
+        current?.files ?? [],
+        args.files,
+        args.deletions ?? []
+      );
+      const artifact = buildPortableSkillArtifact(files);
+      const output = await input.save({
+        operationId: args.operationId,
+        skillId,
+        expectedRevisionId,
+        expectedScopeVersion: args.expectedScopeVersion,
+        files: artifact.files,
+        reason: args.reason
+      });
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+
+// src/activities/agent-turn/skill-install.ts
+function createSkillInstallAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_install" },
+    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.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operationId: { type: "string", format: "uuid" },
+        source: { type: "string", minLength: 1, maxLength: 2048 },
+        expectedInstallationVersion: { type: "integer", minimum: 0 },
+        reason: { type: "string", minLength: 1, maxLength: 2e3 }
+      },
+      required: ["operationId", "source", "reason"],
+      additionalProperties: false
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: true
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const output = await input.install({
+        operationId: args.operationId,
+        source: args.source,
+        ...args.expectedInstallationVersion !== void 0 ? { expectedInstallationVersion: args.expectedInstallationVersion } : {},
+        reason: args.reason
+      });
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+
+// src/activities/agent-turn/skill-transfer.ts
+import { posix } from "path";
+import {
+  assertSkillRelativePath as assertSkillRelativePath2,
+  buildPortableSkillArtifact as buildPortableSkillArtifact2,
+  PORTABLE_SKILL_MAX_FILES as PORTABLE_SKILL_MAX_FILES3,
+  PORTABLE_SKILL_MAX_FILE_BYTES,
+  PORTABLE_SKILL_MAX_TOTAL_BYTES
+} from "@opengeni/runtime/skill-library";
+var maxTraversalEntries = 1024;
+function guardSkillFilesystem(fs, authority) {
+  const read = (operation) => {
+    authority.assertActive();
+    return operation();
+  };
+  const write = (operation) => {
+    authority.assertActive();
+    return authority.runMutation(() => read(operation));
+  };
+  return {
+    fsList: (request) => read(() => fs.fsList(request)),
+    fsRead: (request) => read(() => fs.fsRead(request)),
+    fsWrite: (request) => write(() => fs.fsWrite(request)),
+    fsMkdir: (request) => write(() => fs.fsMkdir(request))
+  };
+}
+async function checkoutSkillDirectory(fs, directory, files) {
+  assertSkillRelativePath2(directory);
+  const artifact = buildPortableSkillArtifact2(files);
+  const parent = posix.dirname(directory);
+  if (parent !== ".") await fs.fsMkdir({ path: parent, recursive: true });
+  await fs.fsMkdir({ path: directory, recursive: false });
+  for (const file of artifact.files) {
+    const result = await fs.fsWrite({
+      path: `${directory}/${file.path}`,
+      content: file.content,
+      encoding: "utf8",
+      overwrite: false,
+      createParents: true
+    });
+    if (result.sizeBytes !== new TextEncoder().encode(file.content).byteLength) {
+      throw new Error(`Skill checkout wrote an unexpected byte count: ${file.path}`);
+    }
+  }
+  return { directory, fileCount: artifact.files.length };
+}
+async function readSkillDirectory(fs, directory) {
+  assertSkillRelativePath2(directory);
+  const pending = [directory];
+  const seen = new Set(pending);
+  const files = [];
+  let entries = 0;
+  let totalBytes = 0;
+  while (pending.length) {
+    const current = pending.shift();
+    const listing = await fs.fsList({
+      path: current,
+      depth: 1,
+      maxEntries: maxTraversalEntries + 1,
+      includeHidden: true
+    });
+    if (listing.root.type !== "dir" || listing.root.path !== current) {
+      throw new Error(`Expected a real Skill directory: ${current}`);
+    }
+    if (listing.truncated || listing.root.truncated || !listing.root.children) {
+      throw new Error(`Skill directory listing is incomplete: ${current}`);
+    }
+    for (const entry of listing.root.children) {
+      assertSkillRelativePath2(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.");
+      }
+      if (seen.has(entry.path)) throw new Error(`Duplicate Skill directory entry: ${entry.path}`);
+      seen.add(entry.path);
+      if (++entries > maxTraversalEntries) throw new Error("Skill directory has too many entries.");
+      if (entry.type === "dir") {
+        pending.push(entry.path);
+        continue;
+      }
+      if (entry.type !== "file") throw new Error(`Unsupported Skill file type: ${entry.path}`);
+      if (files.length >= PORTABLE_SKILL_MAX_FILES3) throw new Error("Skill has too many files.");
+      if (entry.sizeBytes !== null && entry.sizeBytes > PORTABLE_SKILL_MAX_FILE_BYTES) {
+        throw new Error(`Skill file exceeds the size limit: ${entry.path}`);
+      }
+      const read = await fs.fsRead({
+        path: entry.path,
+        encoding: "base64",
+        maxBytes: PORTABLE_SKILL_MAX_FILE_BYTES + 1
+      });
+      if (read.truncated || read.sizeBytes > PORTABLE_SKILL_MAX_FILE_BYTES) {
+        throw new Error(`Skill file exceeds the size limit: ${entry.path}`);
+      }
+      if (read.encoding !== "base64" || read.path !== entry.path) {
+        throw new Error(`Invalid Skill file read response: ${entry.path}`);
+      }
+      const bytes = Buffer.from(read.content, "base64");
+      if (bytes.byteLength !== read.sizeBytes) {
+        throw new Error(`Invalid Skill file byte count: ${entry.path}`);
+      }
+      totalBytes += bytes.byteLength;
+      if (totalBytes > PORTABLE_SKILL_MAX_TOTAL_BYTES)
+        throw new Error("Skill exceeds the total size limit.");
+      let content;
+      try {
+        content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+      } catch {
+        throw new Error(`Skill file is not valid UTF-8 text: ${entry.path}`);
+      }
+      files.push({ path: entry.path.slice(directory.length + 1), content });
+    }
+  }
+  return buildPortableSkillArtifact2(files);
+}
+
+// src/activities/agent-turn/skill-checkout.ts
+function createSkillCheckoutAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_checkout" },
+    modelName: "skill_checkout",
+    codemodePath: ["opengeni", "skill_checkout"],
+    title: "Check out Skill files",
+    description: "Copy a Skill to a fresh sandbox-relative directory for execution or larger edits. Starts the sandbox if needed. Never overwrites an existing directory and does not publish changes. Retain the returned revision and scope version for skill_publish. Use skill_read for ordinary reading without a sandbox.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        skill: { type: "string", minLength: 1, maxLength: 512 },
+        directory: { type: "string", minLength: 1, maxLength: 1024 }
+      },
+      required: ["skill", "directory"],
+      additionalProperties: false
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const skill = await input.load(args.skill);
+      const copied = await checkoutSkillDirectory(
+        await input.filesystem(),
+        args.directory,
+        skill.files
+      );
+      const output = {
+        ...copied,
+        skillId: skill.skillId,
+        revisionId: skill.revisionId,
+        scopeVersion: skill.scopeVersion
+      };
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+function createSkillPublishAttemptToolDefinition(input) {
+  return {
+    identity: { serverId: "opengeni", toolName: "skill_publish" },
+    modelName: "skill_publish",
+    codemodePath: ["opengeni", "skill_publish"],
+    title: "Publish Skill directory",
+    description: "Save a complete sandbox Skill directory through the same Learning-controlled service as skill_save. Reads UTF-8 text files directly; do not serialize the directory into arguments. Files missing from the directory are removed from the new revision. Supply the checkout revision and scope version; stale edits are refused. The result reports whether the change is live or pending approval.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        operationId: { type: "string", format: "uuid" },
+        skillId: { type: "string", format: "uuid" },
+        expectedRevisionId: { type: ["string", "null"], format: "uuid" },
+        expectedScopeVersion: { type: "integer", minimum: 0 },
+        directory: { type: "string", minLength: 1, maxLength: 1024 },
+        reason: { type: "string", minLength: 1, maxLength: 2e3 }
+      },
+      required: [
+        "operationId",
+        "skillId",
+        "expectedRevisionId",
+        "expectedScopeVersion",
+        "directory",
+        "reason"
+      ],
+      additionalProperties: false
+    },
+    annotations: {
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    source: "opengeni",
+    approval: "none",
+    execute: async (args) => {
+      await input.authorize();
+      const artifact = await readSkillDirectory(await input.filesystem(), args.directory);
+      const output = await input.save({
+        operationId: args.operationId,
+        skillId: args.skillId,
+        expectedRevisionId: args.expectedRevisionId,
+        expectedScopeVersion: args.expectedScopeVersion,
+        files: artifact.files,
+        reason: args.reason
+      });
+      return {
+        isError: false,
+        content: [{ type: "text", text: JSON.stringify(output) }],
+        structuredContent: output
+      };
+    }
+  };
+}
+
+// src/activities/agent-turn/skill-tools.ts
+function createWorkspaceSkillTools(input) {
+  const context = {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...input.subjectId ? { subjectId: input.subjectId } : {}
+  };
+  const authorize = () => assertSkillReadAttempt(input.db, { ...context, actor: input.actor });
+  const selected = new Map(input.selected.map((entry) => [entry.id, entry.artifact]));
+  const list = async () => (await listSkillDescriptors(input.db, context)).filter(
+    (entry) => entry.activationMode === "workspace_managed"
+  );
+  const load = async (identifier) => {
+    const exact = selected.get(identifier);
+    if (exact) return exact.files;
+    const descriptors = await list();
+    const exactWorkspace = descriptors.find((entry) => entry.id === identifier);
+    const matches = exactWorkspace ? [exactWorkspace] : descriptors.filter((entry) => entry.title === identifier || entry.stableKey === identifier);
+    const selectedMatches = [...selected.entries()].filter(
+      ([, artifact]) => artifact.name === identifier
+    );
+    if (!exactWorkspace && matches.length + selectedMatches.length > 1)
+      throw new Error(
+        "Multiple Skills match that name. Use the Skill id from the index or search."
+      );
+    if (!matches.length && selectedMatches.length === 1) return selectedMatches[0][1].files;
+    const match = matches[0];
+    if (!match) throw new Error("Skill is not available in this session.");
+    const record5 = await readSkill(input.db, context, match.id);
+    if (!record5 || record5.status !== "active" || !record5.activeRevisionId || record5.revisionId !== record5.activeRevisionId)
+      throw new Error("Skill is no longer active. Search again for current Skills.");
+    return {
+      skillId: record5.id,
+      revisionId: record5.activeRevisionId,
+      scopeVersion: record5.scopeVersion,
+      ...match.installationVersion !== null ? { installationVersion: match.installationVersion } : {},
+      files: record5.files
+    };
+  };
+  const withConfirmation = 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) } : {}
+    };
+  };
+  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(
+      await saveSkill(input.db, {
+        ...context,
+        ...request,
+        actor: input.actor,
+        files: [...artifact.files],
+        stableKey: base?.stableKey ?? `authored-${request.skillId.replaceAll("-", "")}`
+      })
+    );
+  };
+  return [
+    createSkillReadAttemptToolDefinition({ authorize, load }),
+    createSkillSearchAttemptToolDefinition({
+      authorize,
+      listWorkspace: async () => [
+        ...(await list()).map((entry) => ({
+          id: entry.id,
+          name: entry.title,
+          description: entry.description,
+          revisionId: entry.revisionId,
+          scopeVersion: entry.scopeVersion,
+          ...entry.installationVersion !== null ? { installationVersion: entry.installationVersion } : {}
+        })),
+        ...input.selected.map((entry) => ({
+          id: entry.id,
+          name: entry.artifact.name,
+          description: entry.artifact.description || entry.artifact.name,
+          source: entry.id.startsWith("builtin:") ? "builtin" : entry.id.startsWith("session:") ? "session" : "pack"
+        }))
+      ],
+      publicSearch: createPublicSkillSearchClient(input.settings)
+    }),
+    createSkillSaveAttemptToolDefinition({
+      authorize,
+      save,
+      load: async (skillId, revisionId) => {
+        const record5 = await readSkill(input.db, context, skillId, revisionId);
+        if (!record5?.revisionId) throw new Error("Skill edit base is unavailable.");
+        return { revisionId: record5.revisionId, files: record5.files };
+      }
+    }),
+    createSkillInstallAttemptToolDefinition({
+      authorize,
+      install: async (request) => {
+        const requestIdentity = {
+          operation: "skill_install",
+          source: request.source,
+          expectedInstallationVersion: request.expectedInstallationVersion ?? null,
+          reason: request.reason,
+          owner: "direct"
+        };
+        const replay = await replayPortableSkillInstall(input.db, {
+          ...context,
+          actor: input.actor,
+          operationId: request.operationId,
+          requestIdentity
+        });
+        if (replay) return withConfirmation(replay.skillReceipt);
+        let source;
+        if (request.source.startsWith("library:")) {
+          const loaded = loadSkillLibrarySkill(request.source.slice("library:".length));
+          source = {
+            capabilityId: `skill:${loaded.entry.id}`,
+            pluginKey: `skill/library/${loaded.entry.id}`,
+            source: "library",
+            sourceUrl: loaded.entry.sourceUrl,
+            repositoryUrl: skillLibraryRepositoryUrl(loaded.entry.sourceUrl),
+            version: loaded.entry.version,
+            sourceCommit: loaded.entry.sourceCommit,
+            sourcePath: loaded.entry.relativePath,
+            name: loaded.entry.name,
+            description: loaded.entry.description,
+            contentSha256: loaded.entry.contentSha256,
+            totalBytes: loaded.skill.files.reduce(
+              (total, file) => total + Buffer.byteLength(file.content),
+              0
+            ),
+            files: fileMetadata(loaded.skill.files),
+            provenance: "platform",
+            sourceProvenance: loaded.entry.provenance,
+            category: loaded.entry.category,
+            tags: [...loaded.entry.tags],
+            license: loaded.entry.license
+          };
+        } else {
+          const resolved = await resolveSkillImport(
+            request.source,
+            createGitHubSkillSourceClient(input.settings)
+          );
+          source = {
+            capabilityId: portableSkillCapabilityId(resolved.preview),
+            pluginKey: portableSkillPluginKey(resolved.preview),
+            source: resolved.preview.source,
+            sourceUrl: resolved.preview.sourceUrl,
+            repositoryUrl: resolved.preview.repositoryUrl,
+            version: resolved.preview.sourceCommit,
+            sourceCommit: resolved.preview.sourceCommit,
+            sourcePath: resolved.preview.sourcePath,
+            name: resolved.preview.name,
+            description: resolved.preview.description,
+            contentSha256: resolved.preview.contentSha256,
+            totalBytes: resolved.preview.totalBytes,
+            files: fileMetadata(resolved.files)
+          };
+        }
+        const installed = await installPortableSkill(input.db, {
+          ...context,
+          ...source,
+          subjectId: `service:skill-attempt:${input.actor.attemptId}`,
+          skillActor: input.actor,
+          skillOperationId: request.operationId,
+          skillRequestIdentity: requestIdentity,
+          ...request.expectedInstallationVersion !== void 0 ? {
+            expectedInstallationVersion: request.expectedInstallationVersion
+          } : {}
+        });
+        return withConfirmation(installed.skillReceipt);
+      }
+    }),
+    createSkillCheckoutAttemptToolDefinition({
+      authorize,
+      filesystem: input.filesystem,
+      load: async (skill) => {
+        const content = await load(skill);
+        if (!("files" in content))
+          return { skillId: skill, revisionId: null, scopeVersion: null, files: content };
+        return content;
+      }
+    }),
+    createSkillPublishAttemptToolDefinition({ authorize, filesystem: input.filesystem, save })
+  ];
+}
+function fileMetadata(files) {
+  return files.map((file) => ({
+    ...file,
+    byteSize: Buffer.byteLength(file.content),
+    contentSha256: createHash11("sha256").update(file.content, "utf8").digest("hex")
+  }));
+}
+
+// src/activities/agent-turn/skill-selection.ts
+import { loadNativeToolSkillArtifacts } from "@opengeni/runtime";
+import { loadSkillManagementSkill } from "@opengeni/runtime/skill-library";
+function configuredBundledSkillNames(context) {
+  const tools = new Set(context.firstPartyTools);
+  const artifacts = () => tools.has("editable_artifact_list") && tools.has("editable_artifact_get");
+  const definitions = [
+    { name: "opengeni-skills", include: () => true },
+    { name: "opengeni-projects", include: () => true },
+    { name: "opengeni-documents", include: artifacts },
+    { name: "opengeni-spreadsheets", include: artifacts },
+    { name: "opengeni-presentations", include: artifacts },
+    {
+      name: "opengeni-sites",
+      include: () => tools.has("artifacts_create") && tools.has("artifacts_publish")
+    },
+    { name: "opengeni-video-generation", include: () => context.videoGenerationEnabled }
+  ];
+  return definitions.filter(
+    (definition) => definition.include() && (context.bundledSkillIds === void 0 || context.bundledSkillIds.includes(`builtin:${definition.name}`))
+  ).map((definition) => definition.name);
+}
+function loadConfiguredBundledSkills(context) {
+  const names = new Set(configuredBundledSkillNames(context));
+  const artifacts = loadNativeToolSkillArtifacts({
+    projects: names.has("opengeni-projects"),
+    editableArtifacts: [
+      "opengeni-documents",
+      "opengeni-spreadsheets",
+      "opengeni-presentations"
+    ].some((name) => names.has(name)),
+    sites: names.has("opengeni-sites"),
+    videoGeneration: names.has("opengeni-video-generation")
+  });
+  return [...artifacts, ...names.has("opengeni-skills") ? [loadSkillManagementSkill()] : []].filter((artifact) => names.has(artifact.name)).map((artifact) => ({ id: `builtin:${artifact.name}`, artifact }));
+}
+
 // src/activities/agent-turn/tool-environment.ts
 async function prepareTurnToolPolicy(deps) {
   const {
@@ -16907,7 +17260,82 @@ async function prepareTurnToolRuntime(deps) {
       outcome
     })
   };
+  const skillConfiguration = await getWorkspaceVideoGenerationPolicy(db, input.workspaceId);
+  const bundledSkills = loadConfiguredBundledSkills({
+    bundledSkillIds: session.bundledSkillIds,
+    firstPartyTools: selectedFirstPartyMcpTools,
+    videoGenerationEnabled: skillConfiguration.defaultModelId !== null && skillConfiguration.enabledModelIds.length > 0
+  });
+  const selectedSkills = [
+    ...bundledSkills,
+    ...deps.selectedSkillActivations.map((entry) => ({ id: entry.id, artifact: entry.artifact })),
+    ...session.skills.map((skill) => ({
+      id: `session:${session.id}:${skill.name}`,
+      artifact: skill
+    }))
+  ];
+  const sharedSkillDescriptors = await listSkillDescriptors2(db, {
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...deps.fileAuthoritySubjectId ? { subjectId: deps.fileAuthoritySubjectId } : {}
+  });
+  const skillCatalog = [
+    ...sharedSkillDescriptors.filter((entry) => entry.activationMode === "workspace_managed").map((entry) => ({
+      id: entry.id,
+      name: entry.title,
+      description: entry.description
+    })),
+    ...selectedSkills.map((entry) => ({
+      id: entry.id,
+      name: entry.artifact.name,
+      description: entry.artifact.description || entry.artifact.name
+    }))
+  ];
+  const skillTools = createWorkspaceSkillTools({
+    db,
+    settings: runSettings,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    ...deps.fileAuthoritySubjectId ? { subjectId: deps.fileAuthoritySubjectId } : {},
+    actor: {
+      kind: "agent",
+      sessionId: input.sessionId,
+      turnId: turn.id,
+      attemptId: input.attemptId,
+      executionGeneration: attempt.executionGeneration
+    },
+    selected: selectedSkills,
+    filesystem: async () => {
+      throwIfWorkerShuttingDown();
+      throwIfTurnCancelled();
+      const access = await resolveTurnSandboxAccess(
+        sandboxState,
+        media.sdkOwnedSandboxSession,
+        "Skill checkout/publish requires a sandbox or Connected Machine."
+      );
+      const machineRoot = sandboxState.machinePrimarySession?.workspaceRoot;
+      const runAs = sandboxRunAs4(runSettings);
+      const channel = new SandboxChannelAService3({
+        session: access.session,
+        workspaceRoot: machineRoot ?? "/workspace",
+        ...machineRoot ? { providerPathMode: "workspace-relative" } : {},
+        leaseEpoch: access.leaseEpoch,
+        emit: async (events) => {
+          await eventing.publish?.(events, true);
+        },
+        ...runAs ? { runAs } : {}
+      });
+      return guardSkillFilesystem(channel, {
+        assertActive: () => {
+          throwIfWorkerShuttingDown();
+          throwIfTurnCancelled();
+        },
+        runMutation: async (mutation) => access.sandbox && !routingOn ? runWorkspaceMutationForSandbox(access.sandbox, "skillCheckout", mutation) : mutation()
+      });
+    }
+  });
   const attemptToolDefinitions = [
+    ...skillTools,
     createListModelsAttemptToolDefinition({
       currentModelId: turnExecutionPolicy.productModelId,
       load: async () => {
@@ -17196,7 +17624,11 @@ async function prepareTurnToolRuntime(deps) {
     connectorActionPolicy,
     generateSessionTitleInParallel: titleToolPlan.generateTitleInParallel,
     postToolPreparationStartedAt,
-    preparationIndependentToolNames: titleToolPlan.preparationIndependentToolNames
+    preparationIndependentToolNames: [
+      ...titleToolPlan.preparationIndependentToolNames,
+      "skill_read"
+    ],
+    skillCatalog
   };
 }
 
@@ -17390,9 +17822,12 @@ import {
   resolveXaiProviderAccountAuthoritySnapshotForAcceptance,
   getXaiSessionAccountPin as getXaiSessionAccountPin2,
   setXaiSessionAccountPin as setXaiSessionAccountPin2,
-  getWorkspaceVideoGenerationPolicy,
+  getWorkspaceVideoGenerationPolicy as getWorkspaceVideoGenerationPolicy2,
   loadWorkspaceVercelAiGatewayCredentialLease
 } from "@opengeni/db";
+import {
+  formatSkillCatalog
+} from "@opengeni/runtime";
 import {
   serviceTierForLatencyMode as serviceTierForLatencyMode2,
   environmentsEncryptionKeyBytes as environmentsEncryptionKeyBytes3,
@@ -18590,8 +19025,6 @@ async function buildTurnAgent(deps) {
     workspaceMemory,
     rigVersion,
     rigName,
-    packRuntime,
-    installedSkillRuntime,
     buildCompanyBrainContributionReceiptFor,
     promptCacheKey,
     workspaceVariableSet,
@@ -18774,7 +19207,7 @@ async function buildTurnAgent(deps) {
       }
     };
   })();
-  const videoGenerationPolicy = await getWorkspaceVideoGenerationPolicy(db, input.workspaceId);
+  const videoGenerationPolicy = await getWorkspaceVideoGenerationPolicy2(db, input.workspaceId);
   const videoGenerationEnabled = videoGenerationPolicy.defaultModelId !== null && videoGenerationPolicy.enabledModelIds.length > 0;
   let videoGenerationCredential = null;
   if (objectStorage && videoGenerationEnabled) {
@@ -18925,30 +19358,10 @@ async function buildTurnAgent(deps) {
     turnExecutionPolicy.latencyMode
   );
   const approvedToolCallId = approvedConnectorActionCallId(trigger);
-  const runtimeSkillActivations = [
-    ...installedSkillRuntime.activations,
-    ...packRuntime.skillActivations,
-    ...session.skills.map((skill) => ({
-      source: "session",
-      id: `session:${session.id}:${skill.name}`,
-      artifact: {
-        name: skill.name,
-        description: skill.description ?? null,
-        files: skill.files.map((file) => ({
-          path: file.path,
-          content: file.content
-        }))
-      },
-      reason: "attached to session"
-    }))
-  ];
-  const modelVisibleRuntimeSkillActivations = modelVisibleCompanyBrainSkillActivations(
-    eventing.modelRunSettings.sandboxBackend,
-    runtimeSkillActivations
-  );
+  const modelVisibleSkillCatalogText = formatSkillCatalog(deps.skillCatalog);
   try {
     eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
-      buildCompanyBrainContributionReceiptFor(modelVisibleRuntimeSkillActivations)
+      buildCompanyBrainContributionReceiptFor(modelVisibleSkillCatalogText)
     );
   } catch {
   }
@@ -19049,7 +19462,8 @@ async function buildTurnAgent(deps) {
           }
         ),
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
-        ...runtimeSkillActivations.length > 0 ? { skillActivations: runtimeSkillActivations } : {},
+        skillCatalog: deps.skillCatalog,
+        serverSkillReading: true,
         ...!structuredWorkspacePolicyActive && workspaceAgentInstructions ? { instructionsTemplate: workspaceAgentInstructions } : {},
         ...workspaceGovernance ? { workspaceGovernance } : {},
         ...workspaceMemory ? { workspaceMemory } : {},
@@ -19105,7 +19519,7 @@ async function buildTurnAgent(deps) {
   }
   return {
     agent,
-    modelVisibleRuntimeSkillActivations,
+    modelVisibleSkillCatalogText,
     postAgentPreparationStartedAt
   };
 }
@@ -19431,7 +19845,6 @@ function createRunAgentTurnActivity(services) {
       const {
         runtimePreparationStartedAt,
         packRuntime,
-        installedSkillRuntime,
         rigVersion,
         rigName,
         agentHumanInputEnabled,
@@ -20002,6 +20415,7 @@ function createRunAgentTurnActivity(services) {
         ).values()
       ];
       const toolRuntime = await prepareTurnToolRuntime({
+        selectedSkillActivations: packRuntime.skillActivations,
         input,
         catalogSourceSettings,
         db,
@@ -20048,6 +20462,7 @@ function createRunAgentTurnActivity(services) {
         preparationIndependentToolNames
       } = toolRuntime;
       const builtAgent = await buildTurnAgent({
+        skillCatalog: toolRuntime.skillCatalog,
         input,
         db,
         runtime,
@@ -20082,8 +20497,6 @@ function createRunAgentTurnActivity(services) {
         workspaceMemory,
         rigVersion,
         rigName,
-        packRuntime,
-        installedSkillRuntime,
         buildCompanyBrainContributionReceiptFor,
         promptCacheKey,
         workspaceVariableSet,
@@ -20105,7 +20518,7 @@ function createRunAgentTurnActivity(services) {
         postToolPreparationStartedAt,
         codexContext
       });
-      const { agent, modelVisibleRuntimeSkillActivations, postAgentPreparationStartedAt } = builtAgent;
+      const { agent, modelVisibleSkillCatalogText, postAgentPreparationStartedAt } = builtAgent;
       await bindLazySandboxProvisioner({
         ...sandboxRoute,
         input,
@@ -20159,7 +20572,7 @@ function createRunAgentTurnActivity(services) {
         companyBrainContributionReceiptRecorded = true;
         try {
           const companyBrainContributionReceipt = buildCompanyBrainContributionReceiptFor(
-            modelVisibleRuntimeSkillActivations
+            modelVisibleSkillCatalogText
           );
           eventing.companyBrainContextContributions = summarizeCompanyBrainContributions(
             companyBrainContributionReceipt
@@ -21557,4 +21970,4 @@ export {
   createTurnActivities,
   createTurnActivitiesFromServices
 };
-//# sourceMappingURL=activities-turn-57AOUNYN.js.map
+//# sourceMappingURL=activities-turn-V7J34ZOF.js.map