@opengeni/worker-bundle 1.0.1-canary.4 → 2.0.0-canary.35585322809001

package/dist/activities/agent-turn/codex.d.ts

@@ -24,7 +24,7 @@ export declare function acceptsPromptCacheKeyForTurn(resolvedModel: {
 export declare function refreshCappedCodexUsageRows(db: ActivityServices["db"], settings: Settings, workspaceId: string, accounts: Array<Pick<CodexAccountStatus, "id" | "status" | "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind">>, capacitySignals: {
     signalCodexCapacityWorkflow?: ActivityServices["signalCodexCapacityWorkflow"] | undefined;
     wakeSessionWorkflow: ActivityServices["wakeSessionWorkflow"];
-}): Promise<Array<Pick<CodexAccountStatus, "id" | "status" | "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind">>>;
+}, acceptedTurnId?: string): Promise<Array<Pick<CodexAccountStatus, "id" | "status" | "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind">>>;
 /**
  * True once the lifetime last confirmed by Postgres is no longer trustworthy.
  * A missing or malformed deadline fails closed for a holder that claims to be

package/dist/activities/agent-turn/compaction-prep.d.ts

@@ -1,4 +1,3 @@
-import { serializedToolsForRemoteCompaction } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
 import { maybeCompactContext } from "../context-compaction.js";
 import type { CompactionSummarizer, RemoteCompactionV2Requester } from "../context-compaction.js";
@@ -10,10 +9,7 @@ import type { ClaimTurnOk } from "./claim.js";
 import type { GovernanceModelOk } from "./governance-model.js";
 import type { AttemptIdentityState, BillingState, ClaimedResult, EventingState, ProviderTurnState, TurnControlState } from "./turn-context.js";
 export type RemoteCompactionPrefix = {
-    tools: Awaited<ReturnType<typeof serializedToolsForRemoteCompaction>>;
-    instructions: string;
-    toolsReady: boolean;
-    agent: Parameters<typeof serializedToolsForRemoteCompaction>[0] | null;
+    agent: ReturnType<ActivityServices["runtime"]["buildAgent"]> | null;
 };
 export type CompactionPrepDeps = {
     input: RunAgentTurnInput;

package/dist/activities/agent-turn/errors.d.ts

@@ -1,4 +1,4 @@
-import { type MaterializationVerificationDiagnostic } from "@opengeni/runtime";
+import { type CompactionProviderRejection, type MaterializationVerificationDiagnostic } from "@opengeni/runtime";
 import { type McpTransportRequestFailureDiagnostic } from "@opengeni/runtime/mcp-network";
 import { ApplicationFailure } from "@temporalio/activity";
 import type { CodexAccountStatus } from "@opengeni/db";
@@ -68,11 +68,9 @@ export declare function escapedMcpTimeoutRecoveryFailure(input: {
  * Convert the atomic claim transaction's failure into a small, stable
  * Temporal wire contract. The original error remains in activity diagnostics,
  * but SQL text, parameters, and arbitrary invariant messages never enter
- * workflow history. Every database failure is safe to re-read after backoff
- * because the claim transaction contains no model/tool effects. Database
- * constraints and authorization guards can also be repaired by a deployment or
- * authority refresh, so they must preserve pending work. Only a non-database
- * claim invariant is terminal.
+ * workflow history. Operational failures retry; other persistence rejections
+ * retain accepted work behind a durable explicit-recheck fence. Repeating the
+ * same rejected transaction without changed conditions is not recovery.
  */
 export declare function preClaimAdmissionFailure(error: unknown): ApplicationFailure;
 /**
@@ -148,7 +146,29 @@ export type SafeErrorDiagnostic = {
  */
 export declare function safeErrorDiagnostic(error: unknown): SafeErrorDiagnostic;
 export declare function safeErrorForTelemetry(error: unknown): Error;
+/**
+ * Guidance appended to a definitive provider rejection. Repeating the exact
+ * request cannot succeed, so the generic "send another message to retry"
+ * advice is wrong here: a new prompt re-sends the same rejected history.
+ */
+export declare const COMPACTION_PROVIDER_REJECTION_GUIDANCE = "The provider refused this exact request, so repeating it fails the same way until the conversation changes. If a new message fails again, start a new session.";
 export declare function compactionFailureReasonFromError(error: unknown): string;
+/**
+ * Exact `turn.failed` payload for a terminal compaction failure. A definitive
+ * provider rejection additionally carries its closed identifier record so the
+ * timeline, API consumers, and operators can name the rejected field without
+ * parsing the message.
+ */
+export declare function compactionFailureTurnEventPayload(error: unknown, overrides?: {
+    error?: string;
+}): {
+    error: string;
+    code: "context_compaction_failed";
+    retryable: false;
+    recovery: "user_message";
+    compacted: false;
+    providerRejection?: CompactionProviderRejection;
+};
 export declare function isCompactionSummaryFailure(error: unknown): boolean;
 export declare function shouldRecoverCompactionProviderFailure(error: unknown): boolean;
 export declare function classifyContextWindowOverflowError(error: unknown): {

package/dist/activities/agent-turn/governance-model.d.ts

@@ -1,7 +1,6 @@
 import { materializeRigVersionForAttempt } from "@opengeni/db";
 import { renderWorkspaceGovernanceContext, type OpenGeniRuntime } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
-import { resolveWorkspacePackRuntime } from "../packs.js";
 import { createModelHistoryAttachmentProjector } from "../run-input.js";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput, RunAgentTurnResult } from "../types.js";
 import { buildCompanyBrainContributionReceipt } from "../../model-context-contributions.js";
@@ -35,7 +34,6 @@ export type GovernanceModelDeps = {
 };
 export type GovernanceModelOk = {
     runtimePreparationStartedAt: number;
-    packRuntime: Awaited<ReturnType<typeof resolveWorkspacePackRuntime>>;
     rigVersion: NonNullable<Awaited<ReturnType<typeof materializeRigVersionForAttempt>>>["version"] | null;
     rigName: string | null;
     agentHumanInputEnabled: boolean;

package/dist/activities/agent-turn/recovery-warning.d.ts

@@ -0,0 +1,8 @@
+import { type Database } from "@opengeni/db";
+/** Opt-in belongs to this warning-aware worker implementation, not the DB
+ * client, role defaults or deployment configuration. Claim stamps it locally. */
+export declare const FILESYSTEM_DISCONTINUITY_PROTOCOL: 1;
+export declare function recoveryAwareSessionInstructions(db: Database, workspaceId: string, session: {
+    id: string;
+    instructions?: string | null;
+}): Promise<string>;

package/dist/activities/agent-turn/run-credentials.d.ts

@@ -54,7 +54,6 @@ export declare function prepareRunCredentials(deps: PrepareRunCredentialsDeps):
     initialRunCredentialMaterial: NormalizedRunCredentialMaterial | null;
     runCredentialsNote: string | undefined;
     authorizeGitHubTokenMint: GitHubTokenMintAuthorization;
-    hostCredentialRootSessionId: string | null;
     gitCredentialAuthority: import("../environment.js").GitCredentialAuthority | undefined;
     codemodeAuthority: {
         sessionId: string;

package/dist/activities/agent-turn/sandbox-establish.d.ts

@@ -4,7 +4,7 @@ import { type GitCredentialTokenWriterSession, type NormalizedRunCredentialMater
 import { type Settings } from "@opengeni/config";
 import { mergeResourceRefs } from "../common.js";
 import { type MintedRunGitCredentials, type SandboxCodemodeAuthority } from "../environment.js";
-import { rigProviderImageSourceImage } from "../packs.js";
+import { rigProviderImageSourceImage } from "../sandbox-images.js";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput } from "../types.js";
 import type { currentActivityContext } from "../streaming.js";
 import { type ResumedTurnSandbox } from "../../sandbox-resume.js";

package/dist/activities/agent-turn/sandbox-route.d.ts

@@ -109,15 +109,6 @@ export declare function reconcileActiveSandboxPointer(db: ActivityServices["db"]
     type: SessionEventType;
     payload: unknown;
 }>) => Promise<void> | void): Promise<LoadedActivePointer>;
-/**
- * Warm the Modal private-registry image for the image ref this turn actually
- * resolved, not only the deployment-global OPENGENI_MODAL_IMAGE_REF warmed at
- * worker boot. A provider-native modalImageId bypasses registry import and is
- * resolved by ModalImageSelector.fromId during create. Otherwise packs can
- * override `modalImageRef` per workspace/turn, so a private pack image must be
- * resolved before sandbox creation or Modal falls back to the unauthenticated
- * `fromTag` path.
- */
 export declare function ensureTurnModalRegistryImage(runSettings: Settings, sandboxCreationBackend: Settings["sandboxBackend"] | undefined, ensureRegistryImage?: (settings: Settings) => Promise<void>): Promise<void>;
 export declare const SANDBOX_ARTIFACT_RUNTIME_MANIFEST = "/opt/opengeni/artifact-runtime/installation.json";
 export declare const SANDBOX_ARTIFACT_TOOL_ENTRY = "/opt/opengeni/artifact-runtime/skill-facade-entry.mjs";
@@ -125,17 +116,6 @@ export type SandboxArtifactRuntimeAdmission = Readonly<{
     available: boolean;
     environment: Readonly<Record<string, string>>;
 }>;
-/**
- * Admit the optional native standalone-file runtime only for the deployment's
- * exact base sandbox image contract. A pack/rig image override is an
- * independent filesystem and therefore fails closed even when the deployment
- * base image is capable. Collaborative artifact skills are admitted separately
- * from the frozen canonical tool catalog.
- *
- * This keeps lazy provisioning intact: CI/release proves the image closure,
- * while a before-agent-start doctor verifies the actual box before any model
- * call. No speculative sandbox is created merely to populate the skill index.
- */
 export declare function sandboxArtifactRuntimeAdmission(deploymentSettings: Settings, runSettings: Settings, backend: Settings["sandboxBackend"] | undefined, options?: Readonly<{
     production?: boolean;
 }>): SandboxArtifactRuntimeAdmission;

package/dist/activities/agent-turn/sandbox-runtime.d.ts

@@ -40,7 +40,7 @@ export declare function createSandboxTurnRuntime(deps: SandboxTurnRuntimeDeps):
     onHomeSandboxRebound: (rebound: {
         established: EstablishedSandboxSession;
         leaseEpoch: number;
-    }) => void;
+    }) => Promise<void>;
     runWorkspaceMutationForSandbox: <T>(sandbox: ResumedTurnSandbox, operation: string, mutation: () => Promise<T>, observePhase?: (measurement: {
         phase: "admission" | "provider" | "settlement" | "snapshot_wait";
         outcome: "completed" | "failed";

package/dist/activities/agent-turn/skill-remove.d.ts

@@ -0,0 +1,14 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import { z } from "zod";
+import type { SkillWriteReceipt } from "@opengeni/contracts";
+export declare const SkillRemoveRequest: z.ZodObject<{
+    operationId: z.ZodUUID;
+    skillId: z.ZodUUID;
+    expectedRevisionId: z.ZodNullable<z.ZodUUID>;
+    expectedScopeVersion: z.ZodNumber;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare function createSkillRemoveAttemptToolDefinition(input: {
+    authorize: () => Promise<void>;
+    remove: (request: z.infer<typeof SkillRemoveRequest>) => Promise<SkillWriteReceipt>;
+}): AttemptToolDefinition;

package/dist/activities/agent-turn/skill-search.d.ts

@@ -7,7 +7,7 @@ export type WorkspaceSkillSearchEntry = Readonly<{
     revisionId?: string;
     scopeVersion?: number;
     installationVersion?: number;
-    source?: "workspace" | "builtin" | "session" | "pack";
+    source?: "workspace" | "builtin" | "session";
 }>;
 export declare function createSkillSearchAttemptToolDefinition(input: {
     authorize: () => Promise<void>;

package/dist/activities/agent-turn/stream-attempt.d.ts

@@ -82,6 +82,7 @@ export type TurnStreamAttemptDeps = {
     turn: {
         executionGeneration: number;
         model: string;
+        source?: string;
     };
     trigger: NonNullable<Awaited<ReturnType<typeof getSessionEvent>>>;
     humanInputResume: Awaited<ReturnType<typeof getHumanInputResumeForEvent>>;

package/dist/activities/agent-turn/tool-environment.d.ts

@@ -9,7 +9,6 @@ import type { GovernanceModelOk } from "./governance-model.js";
 import type { SandboxTurnRuntime } from "./sandbox-runtime.js";
 import type { sandboxArtifactRuntimeAdmission } from "./sandbox-route.js";
 import type { AttemptIdentityState, EventingState, SandboxRuntimeState, WorkspaceRefState } from "./turn-context.js";
-import type { RuntimeSkillActivation } from "@opengeni/runtime";
 export type PrepareTurnToolPolicyDeps = {
     input: RunAgentTurnInput;
     db: ActivityServices["db"];
@@ -25,7 +24,6 @@ export type PrepareTurnToolPolicyDeps = {
 };
 export type PrepareTurnToolRuntimeDeps = {
     fetchKnowledgeSource?: ((input: import("../types.js").RunKnowledgeSourceSyncBatchInput) => Promise<import("../types.js").RunKnowledgeSourceSyncBatchResult>) | undefined;
-    selectedSkillActivations: readonly RuntimeSkillActivation[];
     input: RunAgentTurnInput;
     catalogSourceSettings: Settings;
     db: ActivityServices["db"];
@@ -34,7 +32,6 @@ export type PrepareTurnToolRuntimeDeps = {
     objectStorage: ActivityServices["objectStorage"];
     observability: ActivityServices["observability"];
     cancellationSignal: AbortSignal | undefined;
-    connectionCredentials: ActivityServices["connectionCredentials"];
     eventing: EventingState;
     attempt: AttemptIdentityState;
     sandboxState: SandboxRuntimeState;
@@ -55,7 +52,6 @@ export type PrepareTurnToolRuntimeDeps = {
         accountId: string;
         workspaceId: string;
     };
-    hostCredentialRootSessionId: string | null;
     sandboxArtifactRuntime: ReturnType<typeof sandboxArtifactRuntimeAdmission>;
     activeSandboxBackend: Settings["sandboxBackend"] | undefined;
     groupBoxBackend: Settings["sandboxBackend"];

package/dist/activities/agent-turn/turn-sandbox-access.d.ts

@@ -7,6 +7,9 @@ export type ResolvedTurnSandboxAccess = Readonly<{
     session: ChannelASession;
     leaseEpoch: number;
 }>;
+/** The lazy wrapper remains the agent's owner even after provisioning fills
+ * resolvedSandbox with the raw provider handle for capture and release. */
+export declare function ownedTurnSandboxForAgent(sandboxState: TurnSandboxAccessState): import("@opengeni/runtime").EstablishedSandboxSession | undefined;
 /** Join the turn's canonical sandbox boundary and return its active routed session. */
 export declare function resolveTurnSandboxAccess(sandboxState: TurnSandboxAccessState, sdkOwnedSandboxSession: unknown, unavailableMessage: string): Promise<ResolvedTurnSandboxAccess>;
 export {};

package/dist/activities/codex-capacity.d.ts

@@ -17,7 +17,7 @@ export declare function signalCodexCapacityWakeTargets(services: CodexCapacitySi
 export declare function signalPendingCodexCapacityWakeTargets(services: CodexCapacitySignalServices & {
     db: ControlActivityServices["db"];
 }, workspaceId: string): Promise<void>;
-export declare function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnostic = never>(context: CodexCapacitySelectionContext<TPolicyScope, TUnavailableDiagnostic>): ReturnType<Parameters<typeof reconcileCodexCapacityWaitDb>[2]>;
+export declare function codexCapacityDecision<TPolicyScope = never, TUnavailableDiagnostic = never>(context: CodexCapacitySelectionContext<TPolicyScope, TUnavailableDiagnostic>, now?: Date): ReturnType<Parameters<typeof reconcileCodexCapacityWaitDb>[2]>;
 /**
  * Arm a durable Codex waiter and immediately re-evaluate it under the
  * allocator lock. A capacity mutation that commits just before the waiter is
@@ -28,6 +28,11 @@ export declare function codexCapacityDecision<TPolicyScope = never, TUnavailable
 export declare function armAndReconcileCodexCapacityWait(services: Pick<ControlActivityServices, "db" | "bus">, input: Parameters<typeof armCodexCapacityWait>[1], options?: {
     onArmed?: () => void;
 }): Promise<{
+    action: "stopped";
+    sessionStatus: "failed" | "queued";
+    waiter: import("@opengeni/db").CodexCapacityWait;
+    events: import("@opengeni/contracts").SessionEvent[];
+} | {
     action: "stale";
     waiter: import("@opengeni/db").CodexCapacityWait | null;
     events: import("@opengeni/contracts").SessionEvent[];

package/dist/activities/codex-rotation.d.ts

@@ -1,7 +1,7 @@
 import type { CodexAccountStatus, CodexCredentialLeaseSelectionContext, CodexLeaseAccountStatus, CodexPinSource } from "@opengeni/db";
 export type CodexRotationAccount = CodexAccountStatus | CodexLeaseAccountStatus;
 /** Capacity metadata worth an authoritative live read before/all through an idle. */
-export declare function codexAccountNeedsLiveCapacityRefresh(account: Pick<CodexAccountStatus, "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind">, now: Date): boolean;
+export declare function codexAccountNeedsLiveCapacityRefresh(account: Pick<CodexAccountStatus, "primaryUsedPercent" | "secondaryUsedPercent" | "exhaustedUntil" | "exhaustedKind">, _now: Date): boolean;
 export type CodexRotationStrategy = "most_remaining" | "round_robin" | "drain_then_next" | "sharded";
 /**
  * The ONE strategy rotation-enabled workspaces run: sticky-sharded. The legacy

package/dist/activities/context-compaction.d.ts

@@ -1,5 +1,5 @@
 import { type Database } from "@opengeni/db";
-import { type CompactionItem } from "@opengeni/runtime";
+import { type CompactionItem, type CompactionProviderRejection } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
 import type { SessionEvent } from "@opengeni/contracts";
 export type MaybeCompactResult = {
@@ -77,6 +77,12 @@ export declare function settleFailedContextCompactionLandmark(db: Database, scop
 }, options?: {
     clearRequestedCompaction?: boolean;
     publishLiveEvents?: (events: SessionEvent[]) => Promise<void>;
+    /**
+     * Closed identifier record of a definitive provider rejection. Carried on
+     * the visible `compaction.skipped` landmark so the timeline can name the
+     * rejected field instead of offering a retry that cannot succeed.
+     */
+    providerRejection?: CompactionProviderRejection | null;
 }): Promise<Extract<MaybeCompactResult, {
     compacted: false;
 }>>;

package/dist/activities/mcp-account-routes.d.ts

@@ -0,0 +1,22 @@
+import type { Settings } from "@opengeni/config";
+import type { McpConnectionAccountBinding, ToolRef, ToolAuthNeededPayload } from "@opengeni/contracts";
+import type { ApiIntegrationRuntime } from "@opengeni/db";
+export declare function accountRouteAuthNeededPayload(payload: ToolAuthNeededPayload, bindings: readonly McpConnectionAccountBinding[] | null | undefined): ToolAuthNeededPayload;
+/** Expand only after canonical tool-policy admission. Aliases are execution
+ * identities, never an alternate way to gain admission to a connector. */
+export declare function expandMcpAccountRoutes(input: {
+    settings: Settings;
+    tools: ToolRef[];
+    bindings: readonly McpConnectionAccountBinding[] | null | undefined;
+}): {
+    settings: Settings;
+    tools: ToolRef[];
+    accountLabels: ReadonlyMap<string, string>;
+};
+/** Each adapter closes over its own immutable credential ref and authority
+ * generation. Sharing a provider transport never shares a credential resolver. */
+export declare function expandApiIntegrationAccountRoutes(input: {
+    integrations: readonly ApiIntegrationRuntime[];
+    bindings: readonly McpConnectionAccountBinding[] | null | undefined;
+    tools: readonly ToolRef[];
+}): ApiIntegrationRuntime[];

package/dist/activities/mcp-credentials.d.ts

@@ -1,22 +1,21 @@
 import type { Settings } from "@opengeni/config";
-import type { ConnectionCredentialsPort } from "@opengeni/contracts";
-import { getSessionTurnForAttempt, resolveAcceptedConnectionUse, sessionTenancyProductActivated, type Database, type ResolveConnectionCredentialInput, type ResolveConnectionCredentialResult, type SessionTurnForExecution } from "@opengeni/db";
-import { type Observability } from "@opengeni/observability";
-export declare function connectionTokenResolverForTurn(input: {
+import { resolveAcceptedConnectionUse, type Database, type ResolveConnectionCredentialInput, type ResolveConnectionCredentialResult, type SessionTurnForExecution } from "@opengeni/db";
+type TurnConnectionInput = {
     db: Database;
     settings: Settings;
-    connectionCredentials?: ConnectionCredentialsPort | null;
     accountId: string;
     workspaceId: string;
     sessionId: string;
-    rootSessionId: string;
     attemptId: string;
     turn: SessionTurnForExecution;
+    /** Policy identities before account expansion; never used to select credentials. */
+    canonicalMcpServerIds?: readonly string[];
     authorizeAcceptedUse?: typeof resolveAcceptedConnectionUse;
-    /** Test seam; production always reads the canonical active-attempt projection. */
-    getHostTurnForAttempt?: typeof getSessionTurnForAttempt;
-    /** Test seam for the activation fence on pre-snapshot workspace refs. */
-    isSessionTenancyProductActivated?: typeof sessionTenancyProductActivated;
-    /** Optional; used only for content-free compatibility-lane counters. */
-    observability?: Observability | null | undefined;
-}): (request: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
+};
+type CredentialResolver = (request: ResolveConnectionCredentialInput) => Promise<ResolveConnectionCredentialResult>;
+export declare function connectionTokenResolverForTurn(input: TurnConnectionInput): CredentialResolver;
+/** Bind the ordinary credential resolver to one immutable accepted turn.
+ * Credential acquisition and refresh stay inside the native connection engine;
+ * this layer adds the exact execution context and physical-request checks. */
+export declare function bindNativeConnectionCredentialsToTurn(input: TurnConnectionInput, nativeResolver: CredentialResolver): CredentialResolver;
+export {};

package/dist/activities/mcp-operation-authority.d.ts

@@ -1,16 +1,11 @@
 import type { ConnectionUseAttribution } from "@opengeni/contracts/connection-authority";
-import type { HostMcpAcceptedAuthority } from "@opengeni/contracts/host-mcp-bindings";
 import type { ResolveConnectionCredentialInput } from "@opengeni/db";
 /** Metadata only. Callers must obtain authority from a current live fence.
  * This equality key is never authorization and never replaces physical-use checks. */
 export declare function mcpOperationAuthorityDigest(request: ResolveConnectionCredentialInput, authority: {
     native: ConnectionUseAttribution;
-    host?: never;
     principal?: {
         kind: string;
         subjectId?: string;
     };
-} | {
-    host: HostMcpAcceptedAuthority;
-    native?: never;
 }): string;

package/dist/activities/rig-verification.d.ts

@@ -4,7 +4,6 @@ import { acquireLease, commitWarmingToWarm, failWarmingToCold, markWarmLeaseInst
 import { createTurnToolCancellationController, establishSandboxSessionFromEnvelope, serializeEstablishedSandboxEnvelope, tagModalSandbox, type EstablishedSandboxSession, type TurnSandboxCommandArgs, type TurnSandboxCommandSession } from "@opengeni/runtime/sandbox";
 import type { Context } from "@temporalio/activity";
 import type { ControlActivityServices } from "./types.js";
-import { type WorkspacePackRuntime } from "./packs.js";
 type SandboxLifecycleCommandRunner = (session: TurnSandboxCommandSession, args: TurnSandboxCommandArgs) => Promise<unknown>;
 export type RigVerificationWorkflowInput = {
     workspaceId: string;
@@ -29,7 +28,7 @@ export type RigPlatformCheckResult = CommandResult & RigCheck;
  */
 export declare function rigPlatformChecksForSettings(settings: ControlActivityServices["settings"]): RigCheck[];
 export declare const RIG_VERIFICATION_OWNER_TTL_MS: number;
-export declare const RIG_VERIFICATION_OWNERS_DISABLED_MESSAGE = "Rig verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
+export declare const RIG_VERIFICATION_OWNERS_DISABLED_MESSAGE = "Sandbox Environment verification lease ownership is disabled; refusing to create an unowned verifier sandbox";
 export declare class RigVerificationActivityDeadlineError extends Error {
     readonly startToCloseTimeoutMs: number;
     readonly cleanupReserveMs: number;
@@ -146,7 +145,7 @@ export declare function buildVerifiedRigProviderImage(input: {
     lifecycle: RigVerificationActivityLifecycle;
     signal: AbortSignal;
 }): Promise<RigProviderImage>;
-export declare function settingsForRigVerification(settings: ControlActivityServices["settings"], packRuntime: WorkspacePackRuntime, rigImage: string | null): ControlActivityServices["settings"];
+export declare function settingsForRigVerification(settings: ControlActivityServices["settings"], rigImage: string | null): ControlActivityServices["settings"];
 export declare function createRigVerificationActivities(services: () => Promise<ControlActivityServices>): {
     verifyRigChange: (input: {
         workspaceId: string;

package/dist/activities/sandbox-images.d.ts

@@ -1 +1 @@
-export { resolveRigProviderImageSelection, rigProviderImageSourceImage, settingsWithPackSandboxImage, settingsWithRigImage, settingsWithRigProviderImage, type RigProviderImageSelectionReason, } from "@opengeni/core";
+export { resolveRigProviderImageSelection, rigProviderImageSourceImage, settingsWithRigImage, settingsWithRigProviderImage, type RigProviderImageSelectionReason, } from "@opengeni/core";

package/dist/activities/sandbox-lease.d.ts

@@ -60,7 +60,7 @@ export type DrainCaptureDisposition = "capture_required" | "archive_published";
  *  Test seams may return the legacy boolean shorthand. Production returns the
  *  typed outcome so the cold commit can distinguish a clean stop from definitive
  *  provider disappearance before capture. */
-export type TerminateBoxFn = (settings: ActivityServices["settings"], lease: NonNullable<Awaited<ReturnType<typeof readLease>>>, observability: ActivityServices["observability"], persistArchive: PersistArchiveFn, providerCaptureRequestId?: string, captureDisposition?: DrainCaptureDisposition, capturePolicy?: ProviderWorkspaceCapturePolicy | null, diskBackedArchives?: boolean, releaseFailedCapture?: () => Promise<void>) => Promise<boolean | ProviderTerminationOutcome>;
+export type TerminateBoxFn = (settings: ActivityServices["settings"], lease: NonNullable<Awaited<ReturnType<typeof readLease>>>, observability: ActivityServices["observability"], persistArchive: PersistArchiveFn, providerCaptureRequestId?: string, captureDisposition?: DrainCaptureDisposition, capturePolicy?: ProviderWorkspaceCapturePolicy | null, diskBackedArchives?: boolean, releaseFailedCapture?: () => Promise<void>, workspaceId?: string) => Promise<boolean | ProviderTerminationOutcome>;
 export type SweepModalOrphansFn = (settings: ActivityServices["settings"], db: ActivityServices["db"], observability: ActivityServices["observability"]) => Promise<number>;
 export type InspectOpenSandboxKubernetesInventoryFn = (input: {
     namespace: string;
@@ -208,4 +208,4 @@ export declare function sandboxDrainReason(lease: Pick<LeaseSnapshot, "rotationR
  * draining until its adapter can prove termination. A truly instance-less or
  * `none`-backed row is a no-op.
  */
-export declare function terminateProviderBox(settings: ActivityServices["settings"], lease: NonNullable<Awaited<ReturnType<typeof readLease>>>, observability: ActivityServices["observability"], persistArchive: PersistArchiveFn, createClientForBackend?: CreateSandboxClientForBackendFn, terminateModalById?: typeof terminateModalSandboxById, providerCaptureRequestId?: string, captureDisposition?: DrainCaptureDisposition, claimedCapturePolicy?: ProviderWorkspaceCapturePolicy | null, diskBackedArchives?: boolean, releaseFailedCapture?: () => Promise<void>): Promise<ProviderTerminationOutcome>;
+export declare function terminateProviderBox(settings: ActivityServices["settings"], lease: NonNullable<Awaited<ReturnType<typeof readLease>>>, observability: ActivityServices["observability"], persistArchive: PersistArchiveFn, createClientForBackend?: CreateSandboxClientForBackendFn, terminateModalById?: typeof terminateModalSandboxById, providerCaptureRequestId?: string, captureDisposition?: DrainCaptureDisposition, claimedCapturePolicy?: ProviderWorkspaceCapturePolicy | null, diskBackedArchives?: boolean, releaseFailedCapture?: () => Promise<void>, workspaceId?: string): Promise<ProviderTerminationOutcome>;

package/dist/activities/session-state.d.ts

@@ -1,4 +1,4 @@
-import { settleSessionAttemptInterruptions, applySessionTurnSettlement, enqueueSessionWorkflowWake, failSessionWorkBeforeAttemptClaim, requestSessionTurnRecovery, recoverSessionDispatch, reconcileSessionAttemptQuiescence, peekSessionWork as peekSessionWorkDb, settleSessionInputWait as settleSessionInputWaitDb, countQueuedTurns, getSessionAttemptActivityRef, getSessionEvent, getSessionTurnForAttempt, expireSessionInteractionIntervention as expireSessionInteractionInterventionDb, expireSessionHumanInputRequest, markSessionAttemptQuiesced, requireSession, settleSessionIdleWithParentOutbox } from "@opengeni/db";
+import { settleSessionAttemptInterruptions, applySessionTurnSettlement, enqueueSessionWorkflowWake, failSessionWorkBeforeAttemptClaim, blockSessionWorkBeforeAttemptClaim, requestSessionTurnRecovery, recoverSessionDispatch, reconcileSessionAttemptQuiescence, peekSessionWork as peekSessionWorkDb, settleSessionInputWait as settleSessionInputWaitDb, countQueuedTurns, getSessionAttemptActivityRef, getSessionEvent, getSessionTurnForAttempt, expireSessionInteractionIntervention as expireSessionInteractionInterventionDb, expireSessionHumanInputRequest, markSessionAttemptQuiesced, requireSession, settleSessionIdleWithParentOutbox } from "@opengeni/db";
 import { publishDurableSessionEvents } from "@opengeni/events";
 import { deliverFailedChildTurnToParent, notifyParentOfChildIdle } from "./parent-wake.js";
 import { recordTurnsQueuedGauge, recordWorkerDeathRecoveryMetrics } from "../observability-metrics.js";
@@ -8,6 +8,7 @@ export type SessionStateActivityOverrides = Partial<{
     applySessionTurnSettlement: typeof applySessionTurnSettlement;
     enqueueSessionWorkflowWake: typeof enqueueSessionWorkflowWake;
     failSessionWorkBeforeAttemptClaim: typeof failSessionWorkBeforeAttemptClaim;
+    blockSessionWorkBeforeAttemptClaim: typeof blockSessionWorkBeforeAttemptClaim;
     requestSessionTurnRecovery: typeof requestSessionTurnRecovery;
     recoverSessionDispatch: typeof recoverSessionDispatch;
     reconcileSessionAttemptQuiescence: typeof reconcileSessionAttemptQuiescence;
@@ -38,7 +39,61 @@ export declare function createSessionStateActivities(services: () => Promise<Con
     reconcileSessionAttemptQuiescence: (input: ReconcileSessionAttemptQuiescenceInput) => Promise<ReconcileSessionAttemptQuiescenceResult>;
     recoverDispatch: (input: RecoverDispatchInput) => Promise<RecoverDispatchResult>;
     recoverEscapedMcpTimeout: (input: RecoverEscapedMcpTimeoutInput) => Promise<RecoverEscapedMcpTimeoutResult>;
-    peekSessionWork: (input: PeekSessionWorkInput) => Promise<import("@opengeni/db").SessionWorkPeek>;
+    peekSessionWork: (input: PeekSessionWorkInput) => Promise<{
+        kind: "unavailable";
+    } | {
+        kind: "attempt-owned";
+        turnId: string;
+        attemptId: string;
+        executionGeneration: number;
+        activityRef: import("@opengeni/db").SessionAttemptActivityRef;
+    } | {
+        kind: "runnable";
+        admissionFence?: import("@opengeni/db").SessionAdmissionFence;
+    } | {
+        kind: "admission-blocked";
+    } | {
+        kind: "sandbox-lifecycle-wait";
+        ref: import("@opengeni/db").SandboxLifecycleWait;
+    } | {
+        kind: "approval-pending";
+        triggerEventId: string;
+        admissionFence?: import("@opengeni/db").SessionAdmissionFence;
+    } | {
+        kind: "approval-wait";
+        humanInputRequestId?: string;
+        interactionInterventionId?: string;
+        expiresAt?: string;
+    } | {
+        kind: "capacity-wait";
+        ref: {
+            provider?: "codex" | "xai";
+            waiterId: string;
+            generation: number;
+            nextCheckAt: string;
+            wakeRevision: number;
+        };
+    } | {
+        kind: "interruption-pending";
+        attemptId: string;
+    } | {
+        kind: "cancellation-wait";
+        attemptId: string;
+    } | {
+        kind: "input-wait";
+        disposition: "held" | "timeout" | "superseded";
+        waitTurnId: string;
+        deadlineAt: string;
+    } | {
+        kind: "idle";
+    } | {
+        kind: "attempt-owned";
+        turnId: string;
+        attemptId: string;
+        executionGeneration: number;
+        activityRef: import("@opengeni/db").SessionAttemptActivityRef;
+        ownerActivityState: "pending" | "settled" | "unknown";
+    }>;
     settleSessionInputWait: (input: SettleSessionInputWaitInput) => Promise<SettleSessionInputWaitResult>;
     expireSessionHumanInput: (input: ExpireSessionHumanInputInput) => Promise<ExpireSessionHumanInputResult>;
     expireSessionInteractionIntervention: (input: ExpireSessionInteractionInterventionInput) => Promise<ExpireSessionInteractionInterventionResult>;

package/dist/activities/types.d.ts

@@ -1,6 +1,6 @@
 import type { Settings } from "@opengeni/config";
 import type { ConnectionCredentialsPort, DocumentAuthorityKind, EntitlementsPort, KnowledgeSourceSyncRunSummary, ScheduledTaskTriggerType, TurnInitiator } from "@opengeni/contracts";
-import type { Database, SessionWorkflowWakeDeliveryResult } from "@opengeni/db";
+import type { Database, SessionWorkflowWakeDeliveryResult, SessionAdmissionFence } from "@opengeni/db";
 import type { DocumentServices } from "@opengeni/documents";
 import type { EventBus } from "@opengeni/events";
 import type { Observability } from "@opengeni/observability";
@@ -191,6 +191,7 @@ export type FailSessionAttemptInput = {
      * committed claim discovered by the control lane can recover the exact
      * attempt instead of terminally failing it. */
     preClaimFailure?: PreClaimFailureDetail;
+    admissionFence?: SessionAdmissionFence;
     /** Added in v4. A claimed attempt that lost operational database access
      * before turn-start completion carries its exact immutable turn identity so
      * the DB-only control lane can recover it instead of terminally failing it. */
@@ -201,6 +202,8 @@ export type FailSessionAttemptInput = {
     error?: string;
 };
 export type FailSessionAttemptResult = {
+    action: "blocked";
+} | {
     action: "failed";
 } | {
     action: "recovering";
@@ -211,10 +214,13 @@ export type FailSessionAttemptResult = {
 } | {
     action: "stale";
 };
-export type PreClaimFailureDisposition = "retryable" | "permanent";
+export type PreClaimFailureDisposition = "retryable" | "permanent" | "blocked";
 export type PreClaimFailureDetail = {
     disposition: PreClaimFailureDisposition;
     code: "db_deadlock" | "db_serialization_failure" | "db_failure" | "claim_invariant";
+    sqlState?: string | null;
+    reason?: "database_claim_rejected" | "initiator_membership_required" | "personal_resource_grant_required";
+    retryPolicy?: "explicit_recheck";
 };
 export declare const PRE_CLAIM_FAILURE_TYPE = "OpenGeniPreClaimFailure";
 export declare const PRE_CLAIM_FAILURE_MESSAGE = "Agent turn admission failed before attempt claim.";
@@ -273,6 +279,9 @@ export type RecoverEscapedMcpTimeoutResult = {
 export type PeekSessionWorkInput = {
     workspaceId: string;
     sessionId: string;
+    includeAdmissionFence?: boolean;
+    /** Versioned workflow observer opt-in, never a caller authorization grant. */
+    observerAccountId?: string;
 };
 export type SettleSessionInputWaitInput = {
     accountId: string;
@@ -334,7 +343,7 @@ export type DispatchScheduledTaskRunResult = {
     action: "deleted";
 } | {
     action: "blocked";
-    reason: "insufficient_credits" | "monthly_model_cost_limit" | "monthly_agent_run_limit" | "malformed_manual_trigger" | "scheduled_task_paused" | "scheduled_authority_exhausted" | "scheduled_run_terminal" | "scheduled_execution_unrepresentable" | "knowledge_source_paused" | "legacy_source_schedule_requires_migration" | "incident_preflight_metadata_missing" | "incident_responder_under_capable" | "incident_data_source_unsuitable";
+    reason: "insufficient_credits" | "monthly_model_cost_limit" | "monthly_agent_run_limit" | "malformed_manual_trigger" | "scheduled_task_paused" | "scheduled_authority_exhausted" | "scheduled_run_terminal" | "scheduled_execution_unrepresentable" | "connection_account_unavailable" | "knowledge_source_paused" | "legacy_source_schedule_requires_migration" | "incident_preflight_metadata_missing" | "incident_responder_under_capable" | "incident_data_source_unsuitable";
 } | {
     action: "start" | "signal";
     accountId: string;