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

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/agent-turn/xai-capacity.d.ts

@@ -1,2 +1,3 @@
 import type { CapacityPhaseDeps, CapacityPhaseOutcome } from "./codex-capacity.js";
-export declare function selectXaiTurnCapacity(deps: CapacityPhaseDeps): Promise<CapacityPhaseOutcome>;
+export declare const selectXaiTurnCapacity: (deps: CapacityPhaseDeps) => Promise<CapacityPhaseOutcome>;
+export declare const selectClaudeTurnCapacity: (deps: CapacityPhaseDeps) => Promise<CapacityPhaseOutcome>;

package/dist/activities/automations.d.ts

@@ -1,5 +1,5 @@
 import { assertWorkspaceModelPolicyAllows, createAndStartSessionWithOutcome, recordWorkspaceUsage } from "@opengeni/core";
-import { assertAutomationRunAuthorityInTransaction, claimAutomationRun, settleAutomationRun } from "@opengeni/db";
+import { assertAutomationRunAuthorityInTransaction, claimAutomationRun, settleAutomationRun, requireWorkspace } from "@opengeni/db";
 import { agentRunAdmissionDenial } from "./agent-run-admission.js";
 import type { ControlActivityServices, DispatchAutomationRunInput, DispatchAutomationRunResult } from "./types.js";
 export type AutomationActivityOptions = {
@@ -7,6 +7,8 @@ export type AutomationActivityOptions = {
     settle?: typeof settleAutomationRun;
     assertAuthority?: typeof assertAutomationRunAuthorityInTransaction;
     createSession?: typeof createAndStartSessionWithOutcome;
+    /** Workspace read for agent-configuration defaults (tests inject it). */
+    readWorkspace?: typeof requireWorkspace;
     admit?: typeof agentRunAdmissionDenial;
     assertModelPolicy?: typeof assertWorkspaceModelPolicyAllows;
     recordUsage?: typeof recordWorkspaceUsage;

package/dist/activities/browser-deadline-checkpoint.d.ts

@@ -0,0 +1,29 @@
+import { type Settings } from "@opengeni/config";
+import { readLease, type BrowserDeadlineCheckpointTarget } from "@opengeni/db";
+import { BrowserControlClient } from "@opengeni/runtime";
+import type { ControlActivityServices } from "./types.js";
+type CheckpointController = Pick<BrowserControlClient, "captureState" | "endSession">;
+type CheckpointPlacement = {
+    target: BrowserDeadlineCheckpointTarget;
+    lease: NonNullable<Awaited<ReturnType<typeof readLease>>>;
+    settings: Settings;
+    controllerRoot: string;
+};
+export declare function createBrowserDeadlineCheckpointActivities(services: () => Promise<ControlActivityServices>, connectController?: (placement: CheckpointPlacement) => Promise<CheckpointController>): {
+    listDueBrowserCheckpoints(): Promise<{
+        accountId: string;
+        workspaceId: string;
+        sandboxGroupId: string;
+        leaseId: string;
+        leaseEpoch: number;
+        instanceId: string;
+        browserSessionId: string;
+        controllerGeneration: string;
+    }[]>;
+    checkpointBrowserBeforeDeadline(target: BrowserDeadlineCheckpointTarget): Promise<{
+        status: "skipped";
+    } | {
+        status: "suspended";
+    }>;
+};
+export {};

package/dist/activities/codemode-dispatcher.d.ts

@@ -1,4 +1,5 @@
-import { type AttemptToolEnvironment } from "@opengeni/codemode";
+import { type AttemptToolCatalogEntry, type AttemptToolEnvironment } from "@opengeni/codemode";
+import { type ToolDisplayMetadata, type ToolFamily } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 export type CodemodeDispatcherScope = {
@@ -25,6 +26,9 @@ export declare class CodemodeAttemptDispatcher {
     private readonly scope;
     private readonly turnSignal?;
     private readonly maxConcurrentCalls;
+    private readonly toolDisplayMetadata?;
+    /** Content-free analytics family for a catalog entry; event enrichment only. */
+    private readonly toolFamily?;
     private readonly stopController;
     private readonly inFlight;
     private pendingClaims;
@@ -32,13 +36,16 @@ export declare class CodemodeAttemptDispatcher {
     private closing;
     private readonly claimLeaseMs;
     private readonly claimHeartbeatMs;
-    constructor(db: Database, bus: EventBus, environment: AttemptToolEnvironment, scope: CodemodeDispatcherScope, turnSignal?: AbortSignal | undefined, maxConcurrentCalls?: number, timings?: CodemodeDispatcherTimings);
+    constructor(db: Database, bus: EventBus, environment: AttemptToolEnvironment, scope: CodemodeDispatcherScope, turnSignal?: AbortSignal | undefined, maxConcurrentCalls?: number, timings?: CodemodeDispatcherTimings, toolDisplayMetadata?: ((modelName: string) => ToolDisplayMetadata | undefined) | undefined, 
+    /** Content-free analytics family for a catalog entry; event enrichment only. */
+    toolFamily?: ((entry: AttemptToolCatalogEntry) => ToolFamily | null) | undefined);
     start(): void;
     close(reason?: string): Promise<void>;
     private execute;
     private executeClaimed;
     private ensureToolCallCreated;
     private settleWithOutput;
+    private persistSettlement;
     private failBeforeExecution;
 }
 export declare function codemodeToolCallCreatedClientEventId(operationId: string): string;

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[];
@@ -50,7 +55,18 @@ export declare function armAndReconcileCodexCapacityWait(services: Pick<ControlA
 }>;
 export declare function createCodexCapacityActivities(services: () => Promise<ControlActivityServices>): {
     getCodexCapacityWait: (input: GetCodexCapacityWaitInput) => Promise<{
-        provider?: "xai";
+        provider: "xai";
+        waiterId: string;
+        generation: number;
+        nextCheckAt: string;
+        wakeRevision: number;
+    } | {
+        provider: "claude";
+        waiterId: string;
+        generation: number;
+        nextCheckAt: string;
+        wakeRevision: number;
+    } | {
         waiterId: string;
         generation: number;
         nextCheckAt: string;

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

@@ -1,7 +1,13 @@
 import type { CodexAccountStatus, CodexCredentialLeaseSelectionContext, CodexLeaseAccountStatus, CodexPinSource } from "@opengeni/db";
 export type CodexRotationAccount = CodexAccountStatus | CodexLeaseAccountStatus;
+/**
+ * Model-scoped allocation filter: user connection policy plus proven plan
+ * entitlement. A plan exclusion applies only until it expires (one request
+ * then re-probes the account) or a different plan is observed.
+ */
+export declare function codexAccountServesModel(account: Pick<CodexRotationAccount, "allowedModelIds" | "planType" | "planEntitlementExclusion">, modelId: string, now: Date): boolean;
 /** 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 { 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: {
@@ -77,8 +80,19 @@ 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;
 }>>;
+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/gmail-files.d.ts

@@ -0,0 +1,32 @@
+import type { ObjectStorage } from "@opengeni/storage";
+import type { GmailFileMaterializationRequest } from "@opengeni/runtime/gmail-rest-mcp";
+import type { ConnectorAttachmentMaterializer } from "@opengeni/runtime";
+import type { SandboxChannelAService } from "@opengeni/runtime/sandbox";
+/** Use the selected filesystem namespace, retaining descriptor confinement and
+ * one extra byte to distinguish a complete exact-limit input from truncation. */
+export declare function readGmailFileFromChannel(channel: Pick<SandboxChannelAService, "fsRead">, request: {
+    path: string;
+    maxBytes: number;
+}): Promise<Uint8Array>;
+/** Gmail returns base64url JSON, while the exact filesystem importer consumes
+ * byte streams. Stage only inside the worker; no URL or bytes reach a tool result. */
+export declare function materializeGmailFile(request: GmailFileMaterializationRequest, options: {
+    workspaceId: string;
+    storage: ObjectStorage;
+    downloadStorage: ObjectStorage;
+    materialize: ConnectorAttachmentMaterializer;
+    onCleanupFailure?: (key: string) => void;
+}): Promise<{
+    attachments: {
+        providerAttachmentId: {
+            provider: string;
+            kind: "attachment";
+            value: string;
+        };
+        fileName: string;
+        mediaType: string;
+        byteSize: number;
+        contentSha256: string;
+        sandboxPath: string;
+    }[];
+}>;

package/dist/activities/goals.d.ts

@@ -2,6 +2,7 @@ import { type Settings } from "@opengeni/config";
 import { type SessionGoal, type ToolRef } from "@opengeni/contracts";
 import { getWorkspaceModelPolicy } from "@opengeni/db";
 import type { ControlActivityServices, MaybeContinueGoalInput, MaybeContinueGoalResult } from "./types.js";
+import { agentRunAdmissionDenial } from "./agent-run-admission.js";
 export declare function createGoalActivities(services: () => Promise<ControlActivityServices>): {
     enqueueGoalRetryWake: (input: MaybeContinueGoalInput) => Promise<void>;
     maybeContinueGoal: (input: MaybeContinueGoalInput) => Promise<MaybeContinueGoalResult>;
@@ -27,3 +28,10 @@ export declare function goalContinuationPrompt(_goal: SessionGoal, _autoContinua
  * lists anywhere else in the pipeline. No-op when the server is not configured.
  */
 export declare function withFirstPartyTools(settings: Settings, tools: ToolRef[]): ToolRef[];
+/**
+ * Goals share scheduled admission and pause visibly without synthesizing work.
+ */
+export declare function goalRunBudgetBlocked(services: Parameters<typeof agentRunAdmissionDenial>[0], input: Omit<Parameters<typeof agentRunAdmissionDenial>[1], "requestedAgentRuns">): Promise<{
+    pausedReason: "limits" | "allowance";
+    message: string;
+} | null>;

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/mcp-account-routes.d.ts

@@ -0,0 +1,3 @@
+import type { McpConnectionAccountBinding, ToolAuthNeededPayload } from "@opengeni/contracts";
+export declare function accountRouteAuthNeededPayload(payload: ToolAuthNeededPayload, bindings: readonly McpConnectionAccountBinding[] | null | undefined): ToolAuthNeededPayload;
+export { expandMcpAccountRoutes, expandApiIntegrationAccountRoutes } from "@opengeni/core";

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/model-call-fact-reconciler.d.ts

@@ -0,0 +1,34 @@
+import { listWorkspaceIdsAfter, reconcileModelCallFacts } from "@opengeni/db";
+import type { ControlActivityServices } from "./types.js";
+/** Recent charged calls are rechecked on every run; older gaps use the backfill script. */
+export declare const MODEL_CALL_FACT_RECONCILE_LOOKBACK_MS: number;
+/** Skip the newest calls so a live fact write is not raced by its own repair. */
+export declare const MODEL_CALL_FACT_RECONCILE_SETTLE_MS: number;
+export declare const MODEL_CALL_FACT_RECONCILE_WORKSPACE_LIMIT = 500;
+export declare const MODEL_CALL_FACT_RECONCILE_RUN_BUDGET_MS: number;
+export type ReconcileRecentModelCallFactsResult = {
+    workspaces: number;
+    missing: number;
+    repaired: number;
+    unrepaired: number;
+    /** Workspaces with more missing facts than one bounded pass examines. */
+    truncatedWorkspaces: number;
+    failedWorkspaces: number;
+    budgetExhausted: boolean;
+};
+export type ModelCallFactReconcilerOptions = {
+    now?: () => number;
+    runBudgetMs?: number;
+    startAfterWorkspaceId?: () => string;
+    reconcile?: typeof reconcileModelCallFacts;
+    listWorkspaces?: typeof listWorkspaceIdsAfter;
+};
+/**
+ * Rebuild missing Insights call facts for recently charged model calls. Each
+ * workspace pass is bounded and idempotent, one failure never stops the rest,
+ * and each run starts at a random workspace so a run that exhausts its budget
+ * does not starve the same tail of workspaces every time.
+ */
+export declare function createModelCallFactReconcilerActivities(services: () => Promise<ControlActivityServices>, options?: ModelCallFactReconcilerOptions): {
+    reconcileRecentModelCallFacts: () => Promise<ReconcileRecentModelCallFactsResult>;
+};

package/dist/activities/open-suffix-resume.d.ts

@@ -40,6 +40,19 @@ export declare function matchingOpenSuffixCallId(input: {
 export declare function resolveOpenSuffixResumeTarget(rows: readonly OpenSuffixPendingToolCall[], callId: string | null): OpenSuffixPendingToolCall | null;
 /** True when the paired call and result already exist in durable history. */
 export declare function openSuffixPairPresentInHistory(items: readonly Record<string, unknown>[], callId: string): boolean;
+export declare function resultItemForOpenSuffixMember(input: {
+    agent: Agent<any, any>;
+    row: OpenSuffixPendingToolCall;
+    trigger: Pick<SessionEvent, "type" | "payload">;
+    humanInputResume: {
+        requestId: string;
+        toolCallId: string;
+        response: HumanInputResponse;
+    } | null;
+}): Promise<{
+    resultItem: Record<string, unknown>;
+    eventOutput: unknown;
+}>;
 export declare function settleOpenSuffixResumeIfNeeded(input: {
     db: Database;
     agent: Agent<any, any>;

package/dist/activities/parent-wake.d.ts

@@ -1,6 +1,6 @@
 import type { Settings } from "@opengeni/config";
 import type { Session, SessionGoal } from "@opengeni/contracts";
-import { claimPendingSessionSystemUpdateOutbox, claimPendingSessionWorkflowWakes, claimAutomaticSessionTitleFanout, markAutomaticSessionTitleFanoutDelivered, markAutomaticSessionTitleFanoutFailed, type Database } from "@opengeni/db";
+import { claimPendingSessionSystemUpdateOutbox, claimPendingSessionWorkflowWakes, repairPendingChildTerminalResultWakes, claimAutomaticSessionTitleFanout, markAutomaticSessionTitleFanoutDelivered, markAutomaticSessionTitleFanoutFailed, type Database } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 import type { ActivityServices, WakeSessionWorkflowSignal } from "./types.js";
 export type NotifyServices = {
@@ -15,6 +15,7 @@ export type ReconcileParentSystemUpdateOverrides = Partial<{
 }>;
 export type ReconcileSessionWorkflowWakeOverrides = Partial<{
     claimPendingSessionWorkflowWakes: typeof claimPendingSessionWorkflowWakes;
+    repairPendingChildTerminalResultWakes: typeof repairPendingChildTerminalResultWakes;
 }>;
 export type ReconcileAutomaticSessionTitleFanoutOverrides = Partial<{
     claimAutomaticSessionTitleFanout: typeof claimAutomaticSessionTitleFanout;
@@ -91,16 +92,9 @@ export type WorkflowWakeReconciliationResult = {
 };
 export declare function reconcilePendingSessionWorkflowWakes(svc: NotifyServices, limit?: number, overrides?: ReconcileSessionWorkflowWakeOverrides): Promise<WorkflowWakeReconciliationResult>;
 /**
- * The worker-specific lines for one child (what happened + its goal), WITHOUT
- * the trailing "what to do next" instruction. Kept separate so N child
- * completions can be coalesced into one internal-update inference: the DB layer
- * stores each child's summary and rebuilds a single numbered digest with one
- * shared trailing instruction instead of running N model calls.
+ * The short status line for one child (what happened + its goal). It is also
+ * the timeline preview, so it carries no instructions: the parent reads the
+ * child's answer from the typed payload, and the operational contract says how
+ * to use it. N completions coalesce into one internal-update inference.
  */
 export declare function childCompletionSummary(child: Session, goal: SessionGoal | null, terminalStatus: "idle" | "failed"): string;
-/**
- * The single trailing instruction appended to a child-completion (or digest)
- * inference. Suppresses the "resume it now" nudge when the manager's own goal
- * was paused by the user (paired with the goal_set reactivation guard).
- */
-export declare function childCompletionTrailing(parentGoalUserPaused: boolean): string;

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/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/run-credential-renewal.d.ts

@@ -22,6 +22,7 @@ export type RunCredentialRenewalOptions = {
         errorClass: "RunCredentialRenewalOperationError";
     }) => void;
 };
+export declare function runCredentialRenewalExpiry(material: NormalizedRunCredentialMaterial | null): Date | null;
 export declare function nextRunCredentialRenewalDelay(expiresAt: Date | null, nowMs?: number): number;
 /** Single-flight renewal; late resolves cannot mutate a stopped attempt. */
 export declare function startRunCredentialRenewalLoop(options: RunCredentialRenewalOptions): RunCredentialRenewalController;

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

@@ -1,4 +1,5 @@
-import type { ConnectionCredentialsPort, CredentialAuthNeededPayload, SandboxBackend, RunCredentialsRequest, Session, SessionTurn } from "@opengeni/contracts";
+import type { ConnectionCredentialsPort, CredentialAuthNeededPayload, SandboxBackend, RunCredentialsRequest, Session, SessionTurn, ToolRef } from "@opengeni/contracts";
+import type { Settings } from "@opengeni/config";
 import { type Database } from "@opengeni/db";
 import { type NormalizedRunCredentialMaterial } from "@opengeni/runtime";
 export type RunCredentialResolutionContext = {
@@ -7,13 +8,22 @@ export type RunCredentialResolutionContext = {
     accountId: string;
     workspaceId: string;
     session: Session;
-    turn: SessionTurn;
+    turn: SessionTurn & {
+        initiatingHumanSubjectId?: string | null;
+    };
     attemptId: string;
     effectiveSandboxBackend: SandboxBackend;
     variableSet: {
         id: string;
         name: string;
     } | null;
+    /** Enables the workspace's configured HTTP credential provider. */
+    settings?: Settings;
+    initiatingHumanSubjectId?: string | null;
+    /** Installed in-process API routes must never enter a product callback. */
+    localMcpServerIds?: readonly string[];
+    /** Exact execution selection, resolved once at the turn policy boundary. */
+    effectiveTools: readonly ToolRef[];
 };
 export type BoundRunCredentialResolver = {
     resolve(input: {
@@ -21,7 +31,7 @@ export type BoundRunCredentialResolver = {
         forceRefresh: boolean;
     }): Promise<NormalizedRunCredentialMaterial | null>;
 };
-export declare function buildRunCredentialsRequest(input: Omit<RunCredentialResolutionContext, "db" | "connectionCredentials"> & {
+export declare function buildRunCredentialsRequest(input: Omit<RunCredentialResolutionContext, "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId" | "effectiveTools"> & {
     rootSessionId: string;
     purpose: "provision" | "renewal";
     forceRefresh: boolean;
@@ -32,5 +42,7 @@ export declare function runCredentialModelNote(material: NormalizedRunCredential
  * Freeze the provider-neutral host credential request to this exact admitted
  * turn. The host selects connections and material; the worker never infers a
  * provider from repositories, environment names, or an OpenGeni variable set.
+ * A workspace that configured its own HTTP credential provider uses it in
+ * place of the deployment's injected port.
  */
 export declare function bindRunCredentialResolver(input: RunCredentialResolutionContext): Promise<BoundRunCredentialResolver | null>;

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";