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

package/src/workflows/file-upload-reaper.ts

@@ -8,6 +8,7 @@ const reaperActivity = proxyActivities<
     | "maintainRetainedScreenshots"
     | "maintainBrowserStateArtifacts"
     | "recoverVideoGenerationWorkflows"
+    | "reconcileRecentModelCallFacts"
   >
 >({
   startToCloseTimeout: "5 minutes",
@@ -20,4 +21,5 @@ export async function fileUploadReaperWorkflow(): Promise<void> {
   await reaperActivity.maintainRetainedScreenshots();
   await reaperActivity.maintainBrowserStateArtifacts();
   await reaperActivity.recoverVideoGenerationWorkflows();
+  await reaperActivity.reconcileRecentModelCallFacts();
 }

package/src/workflows/scheduled-tasks.ts

@@ -7,6 +7,7 @@ import {
   WorkflowIdReusePolicy,
 } from "@temporalio/workflow";
 import type { TurnInitiator } from "@opengeni/contracts";
+import type { DispatchScheduledTaskRunInput } from "../activities/types";
 import { scheduledTaskActivity } from "./activities";
 import {
   knowledgeSourceSyncWake,
@@ -26,14 +27,38 @@ export type ScheduledTaskFireWorkflowInput = ScheduledTaskFireWorkflowBase &
         triggerType: "scheduled";
         agentRunUsageIdempotencyKey?: never;
         initiator?: never;
+        credentialRestriction?: never;
       }
     | {
         triggerType: "manual" | "initial" | "provider_event" | "retry" | "repair";
         agentRunUsageIdempotencyKey: string;
         initiator: TurnInitiator;
+        credentialRestriction?: "developer_setup";
       }
   );
 
+export function scheduledTaskDispatchInput(
+  input: ScheduledTaskFireWorkflowInput,
+  producerKey: string,
+): DispatchScheduledTaskRunInput {
+  const base = {
+    workspaceId: input.workspaceId,
+    taskId: input.taskId,
+    producerKey,
+  };
+  return input.triggerType !== "scheduled"
+    ? {
+        ...base,
+        triggerType: input.triggerType,
+        agentRunUsageIdempotencyKey: input.agentRunUsageIdempotencyKey,
+        initiator: input.initiator,
+        ...(input.credentialRestriction === "developer_setup"
+          ? { credentialRestriction: input.credentialRestriction }
+          : {}),
+      }
+    : { ...base, triggerType: "scheduled" };
+}
+
 export async function scheduledTaskFireWorkflow(
   input: ScheduledTaskFireWorkflowInput,
 ): Promise<void> {
@@ -47,20 +72,8 @@ export async function scheduledTaskFireWorkflow(
   ) {
     return;
   }
-  const base = {
-    workspaceId: input.workspaceId,
-    taskId: input.taskId,
-    producerKey: workflowInfo().workflowId,
-  };
   const result = await scheduledTaskActivity.dispatchScheduledTaskRun(
-    input.triggerType !== "scheduled"
-      ? {
-          ...base,
-          triggerType: input.triggerType,
-          agentRunUsageIdempotencyKey: input.agentRunUsageIdempotencyKey,
-          initiator: input.initiator,
-        }
-      : { ...base, triggerType: "scheduled" },
+    scheduledTaskDispatchInput(input, workflowInfo().workflowId),
   );
   if (result.action !== "knowledge_source_sync") return;
 

package/src/workflows/session.ts

@@ -58,6 +58,56 @@ const HUMAN_INPUT_EXPIRY_STALE_RETRY_MS = 1_000;
  */
 const ROTATION_IDLE_FLOOR_MS = 60_000; // 60s
 
+/**
+ * Provider capacity waits are shared: every waiter of one exhausted pool learns
+ * the same authoritative reset time, and one capacity mutation (for example the
+ * bounded refresh that verifies a quota reset) wakes every waiter at once, both
+ * as the typed capacity signal and as the generic durable workflow wake. Without
+ * spread, a reset resumes the whole backlog in the same few seconds and its
+ * turns stampede sandbox creation and the provider. Each workflow therefore
+ * delays its reconciliation by a bounded, replay-deterministic (Temporal-seeded
+ * `Math.random`) jitter: up to one minute past a scheduled reset timer and up to
+ * 30 seconds after a capacity or queue wake or an already-due waiter. A wake
+ * that lands inside a waiter's timer spread does not shorten it. The Postgres
+ * waiter stays authoritative; jitter only delays the same reconciliation
+ * activity and never creates queue rows, input, or inference. Interruptions are
+ * never delayed.
+ *
+ * The patch marker is not understood by workers built before it: rolling the
+ * worker image back past this change while a session has recorded the marker
+ * (it waited on capacity in its current run) fails that workflow's tasks as
+ * nondeterministic until a patched worker returns.
+ */
+export const CAPACITY_WAKE_JITTER_PATCH = "session-capacity-wake-jitter-v1";
+/**
+ * A scheduled run's approval timeout sleeps on a durable Temporal timer. A
+ * history recorded by a worker that ignored the deadline has no timer command
+ * there, so replay only arms it behind this marker.
+ */
+export const SCHEDULED_HUMAN_WAIT_TIMEOUT_PATCH = "session-scheduled-human-wait-timeout-v1";
+export const CAPACITY_TIMER_WAKE_JITTER_MAX_MS = 60_000;
+export const CAPACITY_WAKE_JITTER_MAX_MS = 30_000;
+
+/**
+ * Pure + exported so the bound is unit-testable without a workflow environment.
+ * `overrideMaxMs` is the test-only SessionWorkflowInput ceiling; it can only
+ * narrow the production bound.
+ */
+export function capacityWakeJitterMs(
+  kind: "timer" | "wake",
+  sample: number,
+  overrideMaxMs?: number,
+): number {
+  const productionMax =
+    kind === "timer" ? CAPACITY_TIMER_WAKE_JITTER_MAX_MS : CAPACITY_WAKE_JITTER_MAX_MS;
+  const max =
+    overrideMaxMs !== undefined && Number.isFinite(overrideMaxMs)
+      ? Math.min(productionMax, Math.max(0, Math.trunc(overrideMaxMs)))
+      : productionMax;
+  const unit = Number.isFinite(sample) ? Math.min(Math.max(sample, 0), 1 - Number.EPSILON) : 0;
+  return Math.floor(unit * max);
+}
+
 /**
  * How long the continuation loop must hold before re-admitting the next turn. 0 ⇒ no
  * hold (re-dispatch immediately — a rotation candidate is ready, or no idle delay was
@@ -229,7 +279,15 @@ export function preClaimFailureDetail(error: unknown): PreClaimFailureDetail | u
   ) {
     return undefined;
   }
-  const detail = cause.details?.[0] as { disposition?: unknown; code?: unknown } | undefined;
+  const detail = cause.details?.[0] as
+    | {
+        disposition?: unknown;
+        code?: unknown;
+        sqlState?: unknown;
+        reason?: unknown;
+        retryPolicy?: unknown;
+      }
+    | undefined;
   if (
     detail?.code !== "db_deadlock" &&
     detail?.code !== "db_serialization_failure" &&
@@ -239,6 +297,27 @@ export function preClaimFailureDetail(error: unknown): PreClaimFailureDetail | u
     return undefined;
   }
   const disposition = detail.disposition;
+  if (disposition === "blocked") {
+    if (
+      detail.code !== "db_failure" ||
+      detail.retryPolicy !== "explicit_recheck" ||
+      (detail.reason !== "database_claim_rejected" &&
+        detail.reason !== "initiator_membership_required" &&
+        detail.reason !== "personal_resource_grant_required") ||
+      !(
+        detail.sqlState === null ||
+        (typeof detail.sqlState === "string" && /^[0-9A-Z]{5}$/.test(detail.sqlState))
+      )
+    )
+      return undefined;
+    return {
+      disposition,
+      code: detail.code,
+      reason: detail.reason,
+      sqlState: detail.sqlState,
+      retryPolicy: "explicit_recheck",
+    };
+  }
   if (disposition !== "retryable" && disposition !== "permanent") return undefined;
   if (
     (detail.code === "db_deadlock" || detail.code === "db_serialization_failure") &&
@@ -286,6 +365,14 @@ export function postClaimDatabaseRecoveryDetail(
   const hasProviderRecoveryCount = detail.providerRecoveryCount !== undefined;
   const hasProviderFailureCode = detail.providerFailureCode !== undefined;
   if (
+    (detail.sandboxSetupOutcomeUnknown !== undefined &&
+      detail.sandboxSetupOutcomeUnknown !== true) ||
+    (detail.sandboxSetupRecoveryExhausted !== undefined &&
+      detail.sandboxSetupRecoveryExhausted !== true) ||
+    (detail.sandboxSetupOutcomeUnknown === true && detail.sandboxSetupRecoveryExhausted === true) ||
+    ((detail.sandboxSetupOutcomeUnknown === true ||
+      detail.sandboxSetupRecoveryExhausted === true) &&
+      hasProviderRecoveryCount) ||
     hasProviderRecoveryCount !== hasProviderFailureCode ||
     (hasProviderRecoveryCount &&
       (!Number.isSafeInteger(detail.providerRecoveryCount) ||
@@ -340,6 +427,9 @@ export type SessionWorkflowInput = {
   // Test-only override for the durable capacity-wait continue-as-new
   // backstop. Production uses CODEX_CAPACITY_CHECKS_PER_RUN_BACKSTOP.
   maxCapacityChecksPerRun?: number;
+  // Test-only ceiling for capacity-wake jitter (0 disables it) so real-server
+  // workflow tests stay fast. Production omits it and uses the bounds above.
+  capacityWakeJitterMaxMs?: number;
 };
 
 export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void> {
@@ -351,6 +441,7 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
   const preserveQuiescenceWake = patched("session-quiescence-reconciliation-wake-v1");
   const staleControlSignalIsOnlyWakeHint = patched("session-control-stale-wake-v1");
   const unclaimedAttemptRecovery = patched("session-unclaimed-attempt-recovery-v1");
+  let durableAdmissionBlocking = false;
   // PR #2208 changed a typed-cancelled result from a plain re-peek into a
   // recoverDispatch activity. Version that new command so histories which
   // already recorded the legacy re-peek remain deterministic on replay.
@@ -446,7 +537,14 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       const timerMs = Number.isFinite(parsedDeadline)
         ? Math.max(0, parsedDeadline - Date.now())
         : 0;
+      const observedCause = (): activities.ReconcileCodexCapacityWaitInput["cause"] =>
+        wakeups !== seenWakeups
+          ? "queue"
+          : capacityWakeups !== seenCapacityWakeups
+            ? "signal"
+            : "timer";
       let cause: activities.ReconcileCodexCapacityWaitInput["cause"] = "timer";
+      let spread = false;
       if (wakeups !== seenWakeups) {
         cause = "queue";
       } else if (capacityWakeups !== seenCapacityWakeups) {
@@ -462,12 +560,48 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
         if (interruptionWakeups !== seenInterruptionWakeups) {
           return;
         }
-        cause =
-          wakeups !== seenWakeups
-            ? "queue"
-            : capacityWakeups !== seenCapacityWakeups
-              ? "signal"
-              : "timer";
+        cause = observedCause();
+        // Histories recorded before the jitter replay without the marker and
+        // reconcile right at the deadline, exactly as they did.
+        if (cause === "timer" && patched(CAPACITY_WAKE_JITTER_PATCH)) {
+          // The shared reset deadline itself fired. The first waiter to
+          // reconcile usually refreshes usage and wakes every other waiter; a
+          // waiter already inside its own spread keeps it instead of starting a
+          // second, shorter one, so the backlog resumes across the whole window.
+          spread = true;
+          const timerJitterMs = capacityWakeJitterMs(
+            "timer",
+            Math.random(),
+            input.capacityWakeJitterMaxMs,
+          );
+          if (timerJitterMs > 0) {
+            await condition(() => interruptionWakeups !== seenInterruptionWakeups, timerJitterMs);
+            if (interruptionWakeups !== seenInterruptionWakeups) {
+              return;
+            }
+          }
+          cause = observedCause();
+        }
+      }
+      if (!spread && patched(CAPACITY_WAKE_JITTER_PATCH)) {
+        // One capacity mutation wakes every waiter of the pool at once (the typed
+        // capacity signal and the generic durable wake), and a fresh run after
+        // continue-as-new, restart, or Resume sees every unobserved wake as an
+        // already-due waiter. Spread those reconciliations too. A later wake
+        // does not cut the pause short (that would re-synchronize the herd); a
+        // queued prompt stays behind the blocked turn either way, so only an
+        // interruption (Pause/Steer/Cancel) wins immediately.
+        const wakeJitterMs = capacityWakeJitterMs(
+          "wake",
+          Math.random(),
+          input.capacityWakeJitterMaxMs,
+        );
+        if (wakeJitterMs > 0) {
+          await condition(() => interruptionWakeups !== seenInterruptionWakeups, wakeJitterMs);
+          if (interruptionWakeups !== seenInterruptionWakeups) {
+            return;
+          }
+        }
       }
       const reconcileInput = {
         accountId: input.accountId,
@@ -506,6 +640,9 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
           ...(input.maxCapacityChecksPerRun !== undefined
             ? { maxCapacityChecksPerRun: input.maxCapacityChecksPerRun }
             : {}),
+          ...(input.capacityWakeJitterMaxMs !== undefined
+            ? { capacityWakeJitterMaxMs: input.capacityWakeJitterMaxMs }
+            : {}),
         });
       }
       current = result;
@@ -552,6 +689,9 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
           ...(input.maxCapacityChecksPerRun !== undefined
             ? { maxCapacityChecksPerRun: input.maxCapacityChecksPerRun }
             : {}),
+          ...(input.capacityWakeJitterMaxMs !== undefined
+            ? { capacityWakeJitterMaxMs: input.capacityWakeJitterMaxMs }
+            : {}),
         });
       }
     }
@@ -561,10 +701,51 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
     const closeSignalVersion = signalVersion;
     const closeNonControlSignalVersion = nonControlSignalVersion;
     const workflowId = workflowInfo().workflowId;
+    // Re-evaluate at the changed command, not only workflow entry. A replay
+    // without the marker keeps its old shape; the next live admission cycle
+    // can activate this fix without waiting for continueAsNew.
+    durableAdmissionBlocking = patched("session-durable-admission-block-v1");
+    const safeObservation = patched("session-safe-control-observation-v1");
     const peek = await activity.peekSessionWork({
       workspaceId: input.workspaceId,
       sessionId: input.sessionId,
+      ...(durableAdmissionBlocking ? { includeAdmissionFence: true } : {}),
+      ...(safeObservation ? { observerAccountId: input.accountId } : {}),
     });
+    if (peek.kind === "unavailable" || peek.kind === "attempt-owned") {
+      if (
+        peek.kind === "attempt-owned" &&
+        "ownerActivityState" in peek &&
+        peek.ownerActivityState === "settled" &&
+        patched("session-settled-owner-recovery-v1")
+      ) {
+        const reconciliation = await activity.reconcileSettledSessionAttempt({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: peek.turnId,
+          attemptId: peek.attemptId,
+          executionGeneration: peek.executionGeneration,
+          // Continue-as-new observers carry no owner authority. Always use
+          // the DB-stored original run/activity, not this observer's run.
+          workflowId: peek.activityRef.workflowId,
+          workflowRunId: peek.activityRef.workflowRunId,
+          activityId: peek.activityRef.activityId,
+        });
+        if (reconciliation.action === "recovering") continue;
+        if (reconciliation.action === "exceeded") return;
+      }
+      // No terminal/idle projection and no successor dispatch. Restoration
+      // need not produce a wake, so retain the observer with a bounded timer
+      // instead of closing and stranding durable work. Signals interrupt the
+      // wait; continue-as-new above bounds history, never business execution.
+      await condition(() => signalVersion !== closeSignalVersion, "30s");
+      continue;
+    }
+    if (peek.kind === "admission-blocked") {
+      if (signalVersion !== closeSignalVersion || pendingQuiescenceProofs.size > 0) continue;
+      return;
+    }
     if (peek.kind === "interruption-pending") {
       const settlement = await activity.settleSessionInterruptions({
         accountId: input.accountId,
@@ -630,6 +811,7 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       const finalPeek = await activity.peekSessionWork({
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
+        ...(safeObservation ? { observerAccountId: input.accountId } : {}),
       });
       if (
         finalPeek.kind !== "sandbox-lifecycle-wait" ||
@@ -645,8 +827,13 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       const seenApprovalWakeups = approvalWakeups;
       const seenWakeups = wakeups;
       const seenInterruptionWakeups = interruptionWakeups;
+      const scheduledRunTimeout =
+        peek.scheduledRunTimeout && peek.expiresAt && patched(SCHEDULED_HUMAN_WAIT_TIMEOUT_PATCH)
+          ? peek.scheduledRunTimeout
+          : undefined;
       const timeoutMs =
-        (peek.humanInputRequestId || peek.interactionInterventionId) && peek.expiresAt
+        (peek.humanInputRequestId || peek.interactionInterventionId || scheduledRunTimeout) &&
+        peek.expiresAt
           ? humanInputDeadlineWaitMs(peek.expiresAt)
           : undefined;
       const wakeCondition = () =>
@@ -681,6 +868,20 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
         if (expiry.action === "stale") {
           await condition(wakeCondition, HUMAN_INPUT_EXPIRY_STALE_RETRY_MS);
         }
+      } else if (!woke && scheduledRunTimeout) {
+        // The scheduler answers for the unanswered person through the same
+        // acceptance boundary (a labelled system rejection/skip); the loop
+        // then re-peeks and resumes the turn like any decision.
+        const expiry = await activity.expireScheduledRunHumanWait({
+          accountId: input.accountId,
+          workspaceId: input.workspaceId,
+          sessionId: input.sessionId,
+          turnId: scheduledRunTimeout.turnId,
+          runId: scheduledRunTimeout.runId,
+        });
+        if (expiry.action === "stale") {
+          await condition(wakeCondition, HUMAN_INPUT_EXPIRY_STALE_RETRY_MS);
+        }
       }
       continue;
     }
@@ -695,8 +896,8 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       if (settlement.action !== "held") continue;
 
       // The durable outbox owns the long deadline. Keep this workflow run open
-      // only for the same bounded close-race window used by ordinary idle; any
-      // signal is a hint to re-peek PostgreSQL truth.
+      // for its bounded close-race window; unlike ordinary idle, this held-wait
+      // path is unchanged. Any signal is a hint to re-peek PostgreSQL truth.
       const seenWakeups = wakeups;
       const seenApprovalWakeups = approvalWakeups;
       const seenInterruptionWakeups = interruptionWakeups;
@@ -711,6 +912,7 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       const finalPeek = await activity.peekSessionWork({
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
+        ...(safeObservation ? { observerAccountId: input.accountId } : {}),
       });
       if (
         finalPeek.kind !== "input-wait" ||
@@ -749,20 +951,28 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       // idle-backoff goal keeps its durable obligation armed; the delayed
       // wake-outbox row at the pacing deadline or any producer signal restarts
       // the workflow. No Temporal timer is used for pacing.
-      const seenWakeups = wakeups;
-      const seenApprovalWakeups = approvalWakeups;
-      const seenInterruptionWakeups = interruptionWakeups;
-      const woke = await condition(
-        () =>
-          interruptionWakeups !== seenInterruptionWakeups ||
-          wakeups !== seenWakeups ||
-          approvalWakeups !== seenApprovalWakeups,
-        "5s",
-      );
-      if (woke) continue;
+      // Evaluate at the changed command so old recorded timers still replay,
+      // while the next live idle cycle can close without a grace period.
+      if (!patched("session-normal-idle-no-grace-v1")) {
+        const seenWakeups = wakeups;
+        const seenApprovalWakeups = approvalWakeups;
+        const seenInterruptionWakeups = interruptionWakeups;
+        const woke = await condition(
+          () =>
+            interruptionWakeups !== seenInterruptionWakeups ||
+            wakeups !== seenWakeups ||
+            approvalWakeups !== seenApprovalWakeups,
+          "5s",
+        );
+        if (woke) continue;
+      }
+      // Keep both the durable recheck and the transactional idle/parent-outbox
+      // fence. A signal accepted during this activity chain makes us loop;
+      // later work restarts the same session via durable signalWithStart.
       const finalPeek = await activity.peekSessionWork({
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
+        ...(safeObservation ? { observerAccountId: input.accountId } : {}),
       });
       if (finalPeek.kind !== "idle") continue;
       await activity.markSessionIdle({
@@ -779,7 +989,15 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
       peek.kind === "approval-pending"
         ? ({ kind: "approval", triggerEventId: peek.triggerEventId } as const)
         : ({ kind: "next" } as const);
-    if (!(await runTurn(input.accountId, input.workspaceId, input.sessionId, trigger))) {
+    if (
+      !(await runTurn(
+        input.accountId,
+        input.workspaceId,
+        input.sessionId,
+        trigger,
+        "admissionFence" in peek ? peek.admissionFence : undefined,
+      ))
+    ) {
       if (signalVersion !== closeSignalVersion) continue;
       return;
     }
@@ -790,6 +1008,7 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
     workspaceId: string,
     sessionId: string,
     trigger: activities.RunAgentTurnInput["trigger"],
+    admissionFence?: activities.FailSessionAttemptInput["admissionFence"],
   ): Promise<boolean> {
     const capacityWaitEntryBaseline = { wakeups, capacityWakeups };
     // Capture every admission-relevant signal before activity dispatch. A
@@ -1072,6 +1291,7 @@ export async function sessionWorkflow(input: SessionWorkflowInput): Promise<void
                   ? { preClaimFailureDisposition: admissionFailureDisposition }
                   : {}),
                 ...(admissionFailure ? { preClaimFailure: admissionFailure } : {}),
+                ...(durableAdmissionBlocking && admissionFence ? { admissionFence } : {}),
                 ...(postClaimDatabaseRecovery ? { postClaimDatabaseRecovery } : {}),
                 trigger,
                 error: workflowFailureMessage(outcome.error),

package/src/workflows.ts

@@ -28,6 +28,10 @@ export {
   sandboxReaperWorkflowV2,
 } from "./workflows/sandbox-reaper";
 export { fileUploadReaperWorkflow } from "./workflows/file-upload-reaper";
+export {
+  browserDeadlineCheckpointWorkflow,
+  browserDeadlineCheckpointSweepWorkflow,
+} from "./workflows/browser-deadline-checkpoint";
 export { siteAuthMaintenanceWorkflow } from "./workflows/site-auth-maintenance";
 export {
   videoGenerationWorkflow,

package/dist/activities/agent-turn/knowledge-sources.d.ts

@@ -1,20 +0,0 @@
-import { type FirstPartyMcpToolName, type Permission, type ResourceRef, type KnowledgeFilePreparationResult } from "@opengeni/contracts";
-import { type Settings } from "@opengeni/config";
-import { createFirstPartyAttemptClient } from "@opengeni/runtime";
-export type KnowledgeSourcePreparationOutcome = KnowledgeFilePreparationResult | {
-    status: "failed";
-    fileId: string;
-    message: string;
-};
-/** Accepted chat/schedule resources use ordinary agent authority and policy. */
-export declare function prepareTurnKnowledgeSources(input: {
-    settings: Settings;
-    scope: Parameters<typeof createFirstPartyAttemptClient>[0]["scope"];
-    resources: readonly ResourceRef[];
-    selectedTools?: readonly FirstPartyMcpToolName[] | undefined;
-    permissions?: readonly Permission[] | null | undefined;
-    learningMode: "automatic" | "review_first" | "off";
-    signal?: AbortSignal | undefined;
-    onOutcome: (outcome: KnowledgeSourcePreparationOutcome) => Promise<void>;
-    prepare?: (fileId: string) => Promise<KnowledgeFilePreparationResult>;
-}): Promise<string | undefined>;

package/dist/activities/packs.d.ts

@@ -1,55 +0,0 @@
-import { CapabilityPack } from "@opengeni/contracts";
-import { type Database } from "@opengeni/db";
-import { packInstallationUsesLegacyRuntime } from "@opengeni/core";
-import { type InstalledSkillActivation, type PackSkillActivation } from "@opengeni/runtime";
-export { resolveRigProviderImageSelection, rigProviderImageSourceImage, settingsWithPackSandboxImage, settingsWithRigImage, settingsWithRigProviderImage, } from "./sandbox-images.js";
-export { packInstallationUsesLegacyRuntime };
-/**
- * Legacy pack-scoped runtime compatibility. V2 Pack installations own ordinary
- * Skill components and select an explicit Rig; they contribute nothing here.
- */
-export type WorkspacePackRuntime = {
-    sandboxImage: string | null;
-    sandboxProviderImages: CapabilityPack["sandboxProviderImages"] | null;
-    skillActivations: PackSkillActivation[];
-};
-export type WorkspaceInstalledSkillRuntime = {
-    activations: InstalledSkillActivation[];
-};
-/**
- * Resolves only pre-V2 active Pack installations. A frozen manifest/digest is
- * the protocol marker for V2: inline Skills were migrated into the ordinary
- * Skill ledger and sandboxImage was resolved to selectedRigId during install,
- * so reading either field directly here would duplicate ownership and silently
- * override session compute.
- */
-export declare function resolveWorkspacePackRuntime(db: Database, workspaceId: string): Promise<WorkspacePackRuntime>;
-/**
- * Resolves every active immutable Skill through the normalized Plugin/Skill-
- * Facet ledger. The data layer has already filtered ineffective owner edges;
- * this boundary independently verifies exact files before runtime activation.
- */
-export declare function resolveWorkspaceInstalledSkillRuntime(db: Database, workspaceId: string): Promise<WorkspaceInstalledSkillRuntime>;
-/**
- * Pure pre-V2 compatibility rule for enabled Pack manifests. At most one
- * legacy Pack may declare a sandbox image, and legacy Skill names must be
- * unique. V2 rows never reach this function through runtime resolution.
- */
-export declare function workspacePackRuntimeFromPacks(packs: CapabilityPack[]): WorkspacePackRuntime;
-/**
- * Resolves the per-workspace agent persona override (the white-label surface).
- * Returns the workspace's stored template when set, else null to mean "use the
- * deployment default" (settings.agentInstructionsTemplate). The runtime always
- * injects the non-bypassable CORE regardless, so a null here keeps the
- * byte-identical default and a non-null value only restyles the persona.
- *
- * This is the workspace tier of the session > workspace > deployment-default
- * resolution; per-session overrides do not exist in this slice, so the worker
- * resolves workspace > default and passes the result as instructionsTemplate.
- */
-export declare function resolveWorkspaceAgentInstructions(db: Database, workspaceId: string): Promise<string | null>;
-/**
- * Applies a pack-declared sandbox image to run settings. With no pack image
- * the settings pass through untouched, so deployments without packs keep the
- * global OPENGENI_DOCKER_IMAGE / OPENGENI_MODAL_IMAGE_REF behavior exactly.
- */