@opengeni/worker-bundle 2.0.1 → 2.0.3-canary.36199476632001

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

@@ -63,6 +63,8 @@ export type BuildTurnAgentDeps = {
     connectorActionPolicy: ConnectorActionPolicyHooks;
     trigger: ClaimTurnOk["trigger"];
     preparationIndependentToolNames: readonly string[];
+    /** The attempt's tool catalog includes the Jev-backed code_search tool. */
+    codeSearchAvailable: boolean;
     videoGenerationAcceptancesByCallId: Map<string, {
         operationId: string;
         requestDigest: string;

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

@@ -0,0 +1,60 @@
+import type { AttemptToolDefinition } from "@opengeni/codemode";
+import { type Settings } from "@opengeni/config";
+import { JevCircuitBreaker, type CodeSearchWorkspace } from "@opengeni/jev";
+import type { Observability } from "@opengeni/observability";
+import { type SandboxChannelAService } from "@opengeni/runtime/sandbox";
+/**
+ * One breaker per worker process. Repeated Jev outages (including an exhausted
+ * account) make `code_search` calls on this worker fail at once for a cooldown
+ * instead of each running a full retry cycle. The breaker never changes which
+ * tools a turn is offered: the tool list and instructions are the start of the
+ * model's cached prompt, and sessions move between workers whose breakers
+ * disagree.
+ */
+export declare const codeSearchCircuitBreaker: JevCircuitBreaker;
+type CodeSearchChannel = Pick<SandboxChannelAService, "codeSearchRipgrep" | "codeSearchPathKinds" | "fsRead">;
+/** Adapt the turn's sandbox or Connected Machine to the code search engine. */
+export declare function codeSearchWorkspaceFromChannel(channel: CodeSearchChannel): CodeSearchWorkspace;
+/** Jev work done by one completed `code_search` call, for per-workspace usage records. */
+export type CodeSearchUsage = {
+    operationId: string;
+    jevRequests: number;
+    jevInputTokens: number;
+    jevCostUsd: number;
+};
+/**
+ * The model-facing `code_search` tool. Jev scores candidates inside the worker;
+ * the sandbox only runs read-only ripgrep and file reads, so the Jev key never
+ * leaves this process. A Jev failure is reported to the model instead of
+ * degrading to keyword-only ranking, which lowered answer quality in testing.
+ */
+export declare function createCodeSearchAttemptToolDefinition(input: {
+    settings: Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">;
+    apiKey: string;
+    workspace: () => Promise<CodeSearchWorkspace>;
+    observability: Observability;
+    /** Records Jev usage against the workspace. Failures are logged, never surfaced. */
+    recordUsage?: (usage: CodeSearchUsage) => Promise<void>;
+    breaker?: JevCircuitBreaker;
+    fetch?: typeof fetch;
+}): AttemptToolDefinition;
+/**
+ * The `code_search` definition for one turn, or none. It is offered only when
+ * the session's frozen decision and the deployment enable it, a usable Jev key
+ * exists, and the turn has compute that can run its POSIX shell commands (not
+ * a Windows Connected Machine). Every input is durable, so the tool list stays
+ * the same from turn to turn and on every worker. Transient Jev health never
+ * hides the tool; the breaker only refuses calls.
+ */
+export declare function codeSearchToolDefinitions(input: {
+    enabled: boolean;
+    settings: Pick<Settings, "jevApiKey" | "jevBaseUrl" | "jevModel" | "jevRequestTimeoutMs">;
+    backend: Settings["sandboxBackend"];
+    /** The turn's Connected Machine workspace root, when a machine is primary. */
+    machineWorkspaceRoot?: string | null;
+    observability: Observability;
+    workspace: () => Promise<CodeSearchWorkspace>;
+    recordUsage?: (usage: CodeSearchUsage) => Promise<void>;
+    breaker?: JevCircuitBreaker;
+}): AttemptToolDefinition[];
+export {};

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

@@ -1,8 +1,21 @@
 import { type Settings } from "@opengeni/config";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput, RunAgentTurnResult } from "../types.js";
 import { createTurnCredentialLeases } from "./credential-leases.js";
+import { type LogThrottle } from "@opengeni/observability";
 import type { ClaimTurnOk } from "./claim.js";
 import type { AttemptIdentityState, BillingState, ClaimedResult, EventingState, ProviderTurnState, TurnControlState } from "./turn-context.js";
+/** The eligible-pool gauge and `opengeni_codex_pool_low_total` stay per turn;
+ * the warning line is the first observation per workspace pool depth, then at
+ * most one per interval with the count it hid. The public log projection drops
+ * the identifiers and counts, so the closed `reason` keeps the depth visible. */
+export declare const CODEX_POOL_LOW_WARNING_INTERVAL_MS: number;
+export declare function warnCodexPoolLow(observability: Pick<ActivityServices["observability"], "warn">, input: {
+    workspaceKey: string;
+    workspaceId: string;
+    eligibleCount: number;
+    connectedCount: number;
+    depth: "zero" | "one";
+}, throttle?: LogThrottle): void;
 export type CapacityPhaseDeps = {
     input: RunAgentTurnInput;
     settings: Settings;

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

@@ -1,4 +1,4 @@
-import { type CompactionProviderRejection, type MaterializationVerificationDiagnostic } from "@opengeni/runtime";
+import { type CompactionProviderRejection, type MaterializationVerificationDiagnostic, type ProviderQuotaExhaustion, type ProviderQuotaScope } from "@opengeni/runtime";
 import { type McpTransportRequestFailureDiagnostic } from "@opengeni/runtime/mcp-network";
 import { ApplicationFailure } from "@temporalio/activity";
 import type { CodexAccountStatus } from "@opengeni/db";
@@ -168,6 +168,7 @@ export declare function compactionFailureTurnEventPayload(error: unknown, overri
     recovery: "user_message";
     compacted: false;
     providerRejection?: CompactionProviderRejection;
+    quotaScope?: ProviderQuotaScope;
 };
 export declare function isCompactionSummaryFailure(error: unknown): boolean;
 export declare function shouldRecoverCompactionProviderFailure(error: unknown): boolean;
@@ -235,6 +236,15 @@ export declare function collectErrorStrings(value: unknown, seen?: WeakSet<objec
 export declare const STATUSLESS_UPSTREAM_CONNECTIVITY_MESSAGE = "unable to connect. is the computer able to access the url?";
 export declare function isExactStatuslessUpstreamConnectivityMessage(message: string): boolean;
 export declare function isTransientProviderError(error: unknown): boolean;
+/**
+ * Recognize an exhausted API-key provider quota (a daily or monthly allowance,
+ * a free-tier day cap, or an account out of credits) as distinct from an
+ * ordinary per-minute rate limit. Retrying within the bounded same-turn budget
+ * cannot succeed, so the turn fails promptly instead. Subscription transports
+ * own their quota semantics through credential rotation and durable capacity
+ * waits, so a Codex or SuperGrok transport error never classifies here.
+ */
+export declare function classifyProviderQuotaExhaustionError(error: unknown): ProviderQuotaExhaustion | null;
 export type XaiCredentialFailure = {
     kind: "auth" | "forbidden" | "rate_limit";
     cooldownMs: number | null;
@@ -271,6 +281,7 @@ declare function baseAgentRunFailurePayload(error: unknown, options?: {
     historyPersistenceStage?: MandatoryHistoryPersistenceStage;
     mcpTransportDiagnostic?: McpTransportRequestFailureDiagnostic;
     materializationDiagnostic?: MaterializationVerificationDiagnostic;
+    quotaScope?: ProviderQuotaScope;
 };
 export type CodexCredentialFailure = {
     kind: "auth" | "forbidden" | "rate_limit" | "quota";

package/dist/activities/agent-turn/failure-settlement.d.ts

@@ -1,4 +1,4 @@
-import type { Settings } from "@opengeni/config";
+import { type Settings } from "@opengeni/config";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput, RunAgentTurnResult } from "../types.js";
 import { createTurnCredentialLeases } from "./credential-leases.js";
 import { createTurnHistorySink } from "./history-sink.js";

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

@@ -37,6 +37,8 @@ export type GovernanceModelOk = {
     rigVersion: NonNullable<Awaited<ReturnType<typeof materializeRigVersionForAttempt>>>["version"] | null;
     rigName: string | null;
     agentHumanInputEnabled: boolean;
+    /** Deployment and workspace allow the Jev-backed code_search tool. */
+    codeSearchEnabled: boolean;
     workspaceAgentInstructions: string | null | undefined;
     workspaceGovernance: ReturnType<typeof renderWorkspaceGovernanceContext>;
     structuredWorkspacePolicyActive: boolean;

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

@@ -49,6 +49,8 @@ export declare function pendingToolCallFromSdkEvent(event: unknown): {
 } | null;
 /** Tools whose intentional visual result must survive inline-media sanitization. */
 export declare function toolCallProducesRetainableSessionImage(name: string | null): boolean;
+/** Browser interactions can carry an image block, including opt-in observe frames. */
+export declare function retainableBrowserScreenshotToolCall(name: string | null): boolean;
 export declare function completedToolCallFromSdkEvent(event: unknown): {
     callId: string;
     resultItem: Record<string, unknown>;

package/dist/activities/agent-turn/media-artifacts.d.ts

@@ -1,5 +1,6 @@
 import { type CodemodeTokenWriterSession, type RetainableSessionImageOutputHook, type TurnToolCancellationFence } from "@opengeni/runtime";
 import type { Settings } from "@opengeni/config";
+import type { RetainedSessionScreenshotKind } from "@opengeni/contracts";
 import type { ResumedTurnSandbox } from "../../sandbox-resume.js";
 import type { SharedActivityServices } from "../types.js";
 import { type GeneratedImageOutput, type GeneratedImageReceipt } from "../generated-images.js";
@@ -35,7 +36,7 @@ export declare class TurnMediaArtifacts {
     readonly retainedScreenshotReceiptsByCallId: Map<string, {
         available: true;
         artifactId: string;
-        kind: "assistant_completion" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
+        kind: "assistant_completion" | "browser_screenshot" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
         contentType: string;
         originalBytes: number;
         sha256: string;
@@ -68,7 +69,7 @@ export declare class TurnMediaArtifacts {
         artifact: {
             available: true;
             artifactId: string;
-            kind: "assistant_completion" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
+            kind: "assistant_completion" | "browser_screenshot" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
             contentType: string;
             originalBytes: number;
             sha256: string;
@@ -98,7 +99,7 @@ export declare class TurnMediaArtifacts {
         artifact: {
             available: true;
             artifactId: string;
-            kind: "assistant_completion" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
+            kind: "assistant_completion" | "browser_screenshot" | "computer_screenshot" | "event_media" | "file" | "generated_image" | "generated_video" | "internal_update" | "tool_result";
             contentType: string;
             originalBytes: number;
             sha256: string;
@@ -128,6 +129,7 @@ export declare class TurnMediaArtifacts {
     sandboxFileDownloadBackend: Settings["sandboxBackend"];
     nativeImageGenerationRetention: NativeImageGenerationRetention | null;
     readonly retainedSessionImageCallIds: Set<string>;
+    readonly retainedSessionImageKindsByCallId: Map<string, RetainedSessionScreenshotKind>;
     constructor(deps: TurnMediaArtifactDeps);
     rememberGeneratedImageCreatedThisTurn: (receipt: GeneratedImageReceipt) => void;
     private prepareGeneratedImageDownload;

package/dist/activities/agent-turn/session-title.d.ts

@@ -1,6 +1,7 @@
 import type { AttemptToolDefinition } from "@opengeni/codemode";
-import type { GeneratedSessionTitle } from "@opengeni/runtime";
-import { type FirstPartyMcpToolName, type Permission, type ToolRef } from "@opengeni/contracts";
+import { type ModelCapabilitiesV1 } from "@opengeni/config";
+import type { GeneratedSessionTitle, GenerateSessionTitleOptions, OpenGeniRuntime } from "@opengeni/runtime";
+import { ReasoningEffort, type FirstPartyMcpToolName, type Permission, type ToolRef } from "@opengeni/contracts";
 export declare const SESSION_TITLE_MODEL_TOOL_NAME = "opengeni__set_session_title";
 export declare function shouldRequestMissingSessionTitle(input: {
     title: string | null;
@@ -8,11 +9,21 @@ export declare function shouldRequestMissingSessionTitle(input: {
     firstPartyMcpTools: readonly FirstPartyMcpToolName[];
     firstPartyMcpPermissions: readonly Permission[] | null;
 }): boolean;
+/**
+ * Whether the turn's route can afford a model request spent only on a title.
+ * The managed OpenRouter free route draws on one deployment-wide per-minute
+ * and per-day request quota that users' turns need, so an untitled session on
+ * it gets no title sidecar and no title tool (whose call would cost a
+ * follow-up request). Clients keep showing the prompt preview, and a later
+ * turn on another route titles the session.
+ */
+export declare function routeAllowsSessionTitleRequests(resolvedModel: ReturnType<OpenGeniRuntime["resolveTurnModel"]>): boolean;
 export declare function sessionTitleToolPlan(input: {
     tools: readonly ToolRef[];
     selectedFirstPartyMcpTools: readonly FirstPartyMcpToolName[];
     shouldRequestTitle: boolean;
     parallelGenerationAvailable: boolean;
+    routeAllowsTitleRequests: boolean;
 }): {
     promoteTitleTool: boolean;
     generateTitleInParallel: boolean;
@@ -20,6 +31,25 @@ export declare function sessionTitleToolPlan(input: {
     preparationIndependentToolNames: string[];
 };
 export declare const PARALLEL_SESSION_TITLE_TIMEOUT_MS = 15000;
+/**
+ * The lowest reasoning effort the resolved model can run, for the auxiliary
+ * title request only. A title needs no deliberation, and a provider default
+ * effort can use most of the output budget before any visible text. Returns
+ * undefined when the model declares no runnable reasoning control, so the
+ * request carries no reasoning parameter.
+ */
+export declare function sessionTitleReasoningEffort(capabilities: Pick<ModelCapabilitiesV1, "reasoning"> | undefined): ReasoningEffort | undefined;
+/**
+ * Options for the parallel title request. It uses the turn's resolved
+ * provider and credential authority, but its own lowest runnable reasoning
+ * effort rather than the turn's effort.
+ */
+export declare function sessionTitleGenerationOptions(input: {
+    resolvedModel: ReturnType<OpenGeniRuntime["resolveTurnModel"]>;
+    modelName: string;
+    serviceTier: GenerateSessionTitleOptions["serviceTier"] | null | undefined;
+    signal: AbortSignal;
+}): GenerateSessionTitleOptions;
 export type ParallelSessionTitleGeneration = {
     finish: () => Promise<GeneratedSessionTitle | null>;
     cancel: () => Promise<void>;

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

@@ -46,6 +46,7 @@ export type PrepareTurnToolRuntimeDeps = {
     turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
     trigger: ClaimTurnOk["trigger"];
     runSettings: GovernanceModelOk["runSettings"];
+    resolvedModel: GovernanceModelOk["resolvedModel"];
     lazyToolTransport: GovernanceModelOk["lazyToolTransport"];
     turnTools: ReturnType<typeof withFirstPartyTools>;
     connectionScope: {
@@ -60,6 +61,8 @@ export type PrepareTurnToolRuntimeDeps = {
     credentialSubjectId: ClaimTurnOk["credentialSubjectId"];
     interactionInterventionResume: ClaimTurnOk["interactionInterventionResume"];
     runWorkspaceMutationForSandbox: SandboxTurnRuntime["runWorkspaceMutationForSandbox"];
+    /** Deployment and workspace allow the Jev-backed code_search tool. */
+    codeSearchEnabled: boolean;
     throwIfWorkerShuttingDown: () => void;
     throwIfTurnCancelled: () => void;
 };
@@ -162,6 +165,7 @@ export declare function prepareTurnToolRuntime(deps: PrepareTurnToolRuntimeDeps)
     generateSessionTitleInParallel: boolean;
     postToolPreparationStartedAt: number;
     preparationIndependentToolNames: string[];
+    codeSearchAvailable: boolean;
     skillCatalog: {
         id: string;
         name: string;

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

@@ -1,5 +1,5 @@
 import { type Database } from "@opengeni/db";
-import { type CompactionItem, type CompactionProviderRejection } from "@opengeni/runtime";
+import { prepareCompactionPromptInput, type CompactionItem, type CompactionProviderRejection } from "@opengeni/runtime";
 import { type Settings } from "@opengeni/config";
 import type { SessionEvent } from "@opengeni/contracts";
 export type MaybeCompactResult = {
@@ -28,7 +28,10 @@ export type MaybeCompactResult = {
  * Codex, call Codex `/codex/responses` with `compaction_trigger` and persist the
  * opaque compaction item. Fail closed — never silently fall back to portable.
  */
-export type CompactionSummarizer = (settings: Settings, input: CompactionItem[]) => Promise<string>;
+export type CompactionSummarizer = ((settings: Settings, input: CompactionItem[]) => Promise<string>) & {
+    /** Model-visible instructions and tool schemas outside the history estimate. */
+    estimatePrefixTokens?: () => number;
+};
 /** Returns the opaque Codex remote compaction v2 item. */
 export type RemoteCompactionV2Requester = (settings: Settings, input: CompactionItem[]) => Promise<CompactionItem>;
 export declare function maybeCompactContext(db: Database, settings: Settings, scope: {
@@ -86,5 +89,10 @@ export declare function settleFailedContextCompactionLandmark(db: Database, scop
 }): Promise<Extract<MaybeCompactResult, {
     compacted: false;
 }>>;
+export declare function summarizeWithCodexOverflowTrimming(summarize: CompactionSummarizer, settings: Settings, activeHistory: CompactionItem[]): Promise<{
+    summaryBody: string;
+    preparation: ReturnType<typeof prepareCompactionPromptInput>;
+    providerCalls: number;
+}>;
 export declare function isContextWindowExceeded(error: unknown, seen?: WeakSet<object>): boolean;
 export declare function isExactContextLengthExceeded(error: unknown, seen?: WeakSet<object>): boolean;

package/dist/activities/knowledge-indexing.d.ts

@@ -1,5 +1,24 @@
 import type { DocumentServices } from "@opengeni/documents";
 import type { ControlActivityServices } from "./types.js";
+/** The configured monthly indexed-chunk limit, not a provider failure. */
+export declare class KnowledgeIndexUsageLimitError extends Error {
+    constructor();
+}
+export type KnowledgeIndexFailureStage = "embedding" | "processing";
+/**
+ * Content-free classification for a deferred Knowledge index batch. Only
+ * protocol constants, an HTTP status, and a PostgreSQL SQLSTATE are retained;
+ * provider messages, bodies, SQL, and identifiers never leave the process.
+ * Outside the embedding call, only a PostgreSQL error in the cause chain is
+ * attributed to the database; any other failure stays a worker failure.
+ */
+export declare function knowledgeIndexFailureDiagnostic(stage: KnowledgeIndexFailureStage, error: unknown): {
+    errorClass: "KnowledgeIndexOperationError";
+    errorCode: "knowledge_index_usage_limit_reached" | "knowledge_index_embedding_failed" | "knowledge_index_persistence_failed" | "knowledge_index_failed";
+    origin: "worker" | "db";
+    status?: number;
+    sqlState?: string;
+};
 export declare function createKnowledgeIndexingActivities(services: () => Promise<ControlActivityServices>, resolveDocumentServices?: () => Promise<DocumentServices>): {
     indexKnowledge: () => Promise<{
         completed: number;

package/dist/activities/retained-screenshots.d.ts

@@ -1,4 +1,4 @@
-import { type RetainedArtifactMetadata, type RetainedOutputUnavailableReason } from "@opengeni/contracts";
+import { type RetainedArtifactMetadata, type RetainedOutputUnavailableReason, type RetainedSessionScreenshotKind } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type ObjectStorage } from "@opengeni/storage";
 export type TypedScreenshotToolOutput = {
@@ -68,6 +68,7 @@ export declare function retainedScreenshotIdentity(input: {
     attemptId: string;
     toolCallId: string;
     toolOutputId: string;
+    kind?: RetainedSessionScreenshotKind | undefined;
 }): {
     artifactId: string;
     settlementKey: string;
@@ -80,8 +81,9 @@ export declare function unavailableRetainedSessionImage(input: {
     toolCallId: string;
     toolOutputId: string;
     reason: RetainedOutputUnavailableReason;
+    kind?: RetainedSessionScreenshotKind | undefined;
 }): RetainedArtifactMetadata;
-export declare function retainComputerScreenshot(input: {
+export declare function retainSessionScreenshot(input: {
     db: Database;
     objectStorage: ObjectStorage | null;
     accountId: string;
@@ -90,10 +92,13 @@ export declare function retainComputerScreenshot(input: {
     turnId: string;
     attemptId: string;
     output: TypedScreenshotToolOutput;
+    kind?: RetainedSessionScreenshotKind | undefined;
     now?: Date;
     retentionMs?: number;
     workspaceQuotaBytes?: number;
 }): Promise<RetainedArtifactMetadata>;
+/** Existing computer callers keep their stable entry point. */
+export declare const retainComputerScreenshot: typeof retainSessionScreenshot;
 /** Replace only new screenshot bytes with a compact receipt before first persistence. */
 export declare function compactRetainedScreenshotHistory(history: Array<Record<string, unknown>>, receiptsByCallId: ReadonlyMap<string, RetainedArtifactMetadata>): Array<Record<string, unknown>>;
 /** Collect durable screenshot receipts before their provider-only expansion. */

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

@@ -20,8 +20,7 @@ export type ReapSandboxLeasesResult = {
     skipped: number;
     /** Warm viewer-only leases that accrued warm-seconds this tick (P2.1). */
     metered: number;
-    /** Viewer-only boxes force-drained because their workspace is over a limit
-     *  (0 balance / over the warm cap) — turn-held boxes are never drained (P2.1). */
+    /** Holderless boxes accelerated to draining by the optional warm cap. */
     forceDrained: number;
     /** Provider-side Modal orphan sandboxes terminated by the defensive sweep. */
     modalOrphansTerminated: number;
@@ -60,7 +59,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>, workspaceId?: string) => 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, beforeProviderStop?: () => Promise<void>) => 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 +207,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>, workspaceId?: string): 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, beforeProviderStop?: () => Promise<void>): Promise<ProviderTerminationOutcome>;