@opengeni/core 0.28.0 → 1.0.0

package/dist/application/modal-native-worker-host-transport.d.ts

@@ -0,0 +1,297 @@
+import type { Settings } from "@opengeni/config";
+import { z } from "zod";
+declare const intent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"declare_preparation">;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"claim_namespace_read">;
+    recordRevision: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"claim_original_command_read">;
+    recordRevision: z.ZodNumber;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"capture_namespace_binding">;
+    acquisition: z.ZodObject<{
+        claimId: z.ZodString;
+        nonce: z.ZodString;
+        claimRevision: z.ZodNumber;
+        recordRevision: z.ZodNumber;
+        captureId: z.ZodString;
+        acquisitionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"capture_original_page">;
+    acquisition: z.ZodObject<{
+        claimId: z.ZodString;
+        nonce: z.ZodString;
+        claimRevision: z.ZodNumber;
+        recordRevision: z.ZodNumber;
+        captureId: z.ZodString;
+        acquisitionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"reconcile_same_capture">;
+    acquisition: z.ZodObject<{
+        claimId: z.ZodString;
+        nonce: z.ZodString;
+        claimRevision: z.ZodNumber;
+        recordRevision: z.ZodNumber;
+        captureId: z.ZodString;
+        acquisitionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    protocol: z.ZodLiteral<"opengeni-modal-native-worker-host-proof">;
+    version: z.ZodLiteral<2>;
+    principalKind: z.ZodLiteral<"worker_host">;
+    purpose: z.ZodLiteral<"original-native-custody-proof">;
+    scope: z.ZodObject<{
+        version: z.ZodLiteral<2>;
+        declarationId: z.ZodString;
+        planId: z.ZodString;
+        creatorId: z.ZodString;
+        accountId: z.ZodString;
+        workspaceId: z.ZodString;
+        sessionId: z.ZodString;
+        turnId: z.ZodString;
+        attemptId: z.ZodString;
+        executionGeneration: z.ZodNumber;
+        triggerEventId: z.ZodString;
+        sandboxGroupId: z.ZodString;
+        routeKind: z.ZodLiteral<"home">;
+        routeTargetId: z.ZodNull;
+        routeEpoch: z.ZodNumber;
+    }, z.core.$strict>;
+    configurationCaptureRef: z.ZodObject<{
+        id: z.ZodString;
+        revision: z.ZodNumber;
+    }, z.core.$strict>;
+    proofGrantRef: z.ZodObject<{
+        id: z.ZodString;
+        epoch: z.ZodNumber;
+    }, z.core.$strict>;
+    requestId: z.ZodString;
+    action: z.ZodLiteral<"settle_original_acquisition">;
+    acquisition: z.ZodObject<{
+        claimId: z.ZodString;
+        nonce: z.ZodString;
+        claimRevision: z.ZodNumber;
+        recordRevision: z.ZodNumber;
+        captureId: z.ZodString;
+        acquisitionId: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>], "action">;
+declare const timing: z.ZodObject<{
+    bodySha256: z.ZodString;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+}, z.core.$strict>;
+type Intent = z.infer<typeof intent>;
+export type NativeWorkerHostTransportDescriptionV2 = Intent & z.infer<typeof timing>;
+declare const transportBrand: unique symbol;
+export type NativeWorkerHostTransport = Readonly<{
+    [transportBrand]: true;
+}>;
+declare const verifiedBrand: unique symbol;
+export type VerifiedNativeWorkerHostTransport = Readonly<{
+    [verifiedBrand]: true;
+}>;
+/** Host startup only. Deliberately DOES NOT call resolveFirstPartyDelegationSecret:
+ * neither configured access-key substitution nor the public local/test fallback
+ * can select this new purpose root. Missing explicit deployment secret is OFF.
+ * No variable lookup, provider request, config mutation or persistence occurs. */
+export declare function configuredNativeWorkerHostTransport(settings: Pick<Settings, "delegationSecret">): NativeWorkerHostTransport | null;
+/** Release only this transport's derived-key copy, not a config/grant/custody
+ * lifecycle or observation slot. Outstanding native I/O needs its own join. */
+export declare function disposeNativeWorkerHostTransport(transport: NativeWorkerHostTransport): void;
+/** Private worker/core transport serialization. The caller MUST first establish
+ * canonical original-host admission. This helper cannot establish that admission
+ * and is intentionally not exported from the core package's public entrypoints. */
+export declare function signNativeWorkerHostTransport(transport: NativeWorkerHostTransport, input: Intent, body: Uint8Array, nowSeconds?: number): string;
+/** Only host transport authenticity is verified. A later narrow authorizer must
+ * independently source-join original live/maintenance authority, configuration,
+ * grant, claim, acquisition, body fields/cursors and exact action-specific CAS. */
+export declare function verifyNativeWorkerHostTransport(transport: NativeWorkerHostTransport, envelope: string, body: Uint8Array, nowSeconds?: number): VerifiedNativeWorkerHostTransport | null;
+/** Request-local inspection of a previously verified MAC, NOT current admission.
+ * The narrow host authorizer must still recheck expiry and current authority/CAS.
+ * Copying a description, token or ref cannot mint grant or native-I/O authority. */
+export declare function nativeWorkerHostTransportDescription(transport: NativeWorkerHostTransport, proof: VerifiedNativeWorkerHostTransport): NativeWorkerHostTransportDescriptionV2;
+export {};

package/dist/application/new-session-drafts.d.ts

@@ -1,8 +1,25 @@
 import { type AccessGrant, type NewSessionDraft as NewSessionDraftValue } from "@opengeni/contracts";
 import type { AppDependencies } from "../dependencies.js";
+import { type AccessGrantAuthorization } from "../access/index.js";
+import { type Settings } from "@opengeni/config";
 type NewSessionDraftDependencies = Pick<AppDependencies, "settings" | "db" | "objectStorage">;
+/**
+ * Whether a stored draft's model policy was the person's choice. A row written
+ * before the marker existed (or by an older client) counts as a choice unless
+ * it is exactly the deployment default policy (model, reasoning, standard
+ * speed), which is what an untouched composer used to save.
+ */
+export declare function draftModelProvided(settings: Settings, draft: Pick<NewSessionDraftValue, "model" | "reasoningEffort" | "latencyMode" | "modelProvided">): boolean;
+type NewSessionDraftReadOptions = {
+    /**
+     * Project a draft that follows the default onto today's resolved default.
+     * Callers that only reuse a chosen model (Slack defaults) skip the
+     * resolution; session creation resolves the default itself.
+     */
+    projectDefaultModel?: boolean;
+};
 /** Read the authenticated actor's server-authoritative pre-session composer state. */
-export declare function getActorNewSessionDraft(deps: Pick<NewSessionDraftDependencies, "settings" | "db">, grant: AccessGrant, workspaceId: string): Promise<NewSessionDraftValue>;
+declare function getActorNewSessionDraftInFileScope(deps: Pick<NewSessionDraftDependencies, "settings" | "db">, grant: AccessGrant, workspaceId: string, readOptions?: NewSessionDraftReadOptions): Promise<NewSessionDraftValue>;
 /**
  * Validate and save one exact actor-private draft revision. Create-time-only
  * checks (live machine target, rig/variable-set state, and permission
@@ -10,5 +27,25 @@ export declare function getActorNewSessionDraft(deps: Pick<NewSessionDraftDepend
  * draft may represent incomplete options, while no invalid option can become a
  * session without passing that single canonical create boundary.
  */
-export declare function saveActorNewSessionDraft(deps: NewSessionDraftDependencies, grant: AccessGrant, workspaceId: string, rawInput: unknown): Promise<NewSessionDraftValue>;
+declare function saveActorNewSessionDraftInFileScope(deps: NewSessionDraftDependencies, grant: AccessGrant, workspaceId: string, rawInput: unknown, 
+/**
+ * `AccessGrantAuthorization.canonicalManagedHumanSession` — did this request
+ * authenticate as the canonical managed cookie that owns `grant.subjectId`?
+ * Defaults to false so every caller that has not proven it fails closed onto
+ * the historical bare-membership fence.
+ */
+canonicalManagedHumanSession?: boolean, externalAuthorization?: AccessGrantAuthorization): Promise<NewSessionDraftValue>;
+export declare function getActorNewSessionDraft(deps: Parameters<typeof getActorNewSessionDraftInFileScope>[0], grant: AccessGrant, workspaceId: string, authorization?: AccessGrantAuthorization, readOptions?: NewSessionDraftReadOptions): Promise<NewSessionDraftValue>;
+export declare function saveActorNewSessionDraft(...args: Parameters<typeof saveActorNewSessionDraftInFileScope>): Promise<NewSessionDraftValue>;
+/**
+ * The model policy the person explicitly chose in the website composer, or an
+ * empty object when their draft follows the default.
+ *
+ * Only the model policy is reused. Connectors, repositories, Variable Sets,
+ * Sandbox Environment and compute target in the draft are the person's last
+ * explicit narrowing of one website chat, so surfaces that start work without
+ * the composer (Slack) resolve those from workspace defaults instead of
+ * silently inheriting that narrowing.
+ */
+export declare function getActorNewSessionModelChoice(deps: Parameters<typeof getActorNewSessionDraft>[0], grant: AccessGrant, workspaceId: string): Promise<Pick<NewSessionDraftValue, "model" | "reasoningEffort" | "latencyMode"> | Record<string, never>>;
 export {};

package/dist/application/sandbox-recovery.d.ts

@@ -0,0 +1,58 @@
+import type { SandboxRecoveryRequest } from "@opengeni/contracts";
+import { type AccessGrantAuthorization } from "../access/index.js";
+import type { AppDependencies } from "../dependencies.js";
+type Dependencies = Pick<AppDependencies, "db" | "sessionAuthorization">;
+/** The read-only projection also serves the exact built-in local human. Its
+ * provenance stamp is set only by the local resolver, never a bearer claim. */
+export declare function requireSandboxRecoveryPreviewHuman(authorization: AccessGrantAuthorization, workspaceId: string): void;
+export declare function getManagedHumanSandboxRecovery(deps: Dependencies, authorization: AccessGrantAuthorization, workspaceId: string, sessionId: string): Promise<{
+    version: 1;
+    status: "blocked" | "consent_accepted" | "eligible" | "restored" | "restoring" | "unsupported";
+    reason: string | null;
+    checkpoint: {
+        version: 1;
+        sessionId: string;
+        sandboxGroupId: string;
+        leaseId: string;
+        routeEpoch: number;
+        authorityEpoch: number;
+        leaseEpoch: number;
+        workspaceGeneration: number;
+        archiveGeneration: number;
+        artifactId: string;
+        revision: string;
+        capturedAt: string;
+    } | null;
+    operationId: string | null;
+    automaticAvailable?: boolean | undefined;
+    automaticLane?: "checkpoint" | "fresh_workspace" | undefined;
+    availableAt?: string | undefined;
+}>;
+export declare function consentManagedHumanSandboxRecovery(deps: Dependencies, authorization: AccessGrantAuthorization, workspaceId: string, sessionId: string, request: SandboxRecoveryRequest): Promise<{
+    outcome: "accepted" | "replayed";
+    operationId: string;
+    recovery: {
+        version: 1;
+        status: "blocked" | "consent_accepted" | "eligible" | "restored" | "restoring" | "unsupported";
+        reason: string | null;
+        checkpoint: {
+            version: 1;
+            sessionId: string;
+            sandboxGroupId: string;
+            leaseId: string;
+            routeEpoch: number;
+            authorityEpoch: number;
+            leaseEpoch: number;
+            workspaceGeneration: number;
+            archiveGeneration: number;
+            artifactId: string;
+            revision: string;
+            capturedAt: string;
+        } | null;
+        operationId: string | null;
+        automaticAvailable?: boolean | undefined;
+        automaticLane?: "checkpoint" | "fresh_workspace" | undefined;
+        availableAt?: string | undefined;
+    };
+}>;
+export {};

package/dist/application/session-commands.d.ts

@@ -1,4 +1,5 @@
 import type { ComposerDraft, DeleteSessionQueueItemRequest, EditSessionQueueItemRequest, MoveSessionQueueItemRequest, SaveComposerDraftRequest, SessionAuthorizationPort, SessionAuthorizationSurface, SessionControlRequest, SessionControlResponse, SessionQueueMutationResponse, SteerSessionQueueItemRequest, WorkspaceInferenceControlRequest, WorkspaceInferenceControlResponse } from "@opengeni/contracts";
+import type { Settings } from "@opengeni/config";
 import { type Database, type SessionCommandReceiptRow } from "@opengeni/db";
 import { type EventBus } from "@opengeni/events";
 import type { SessionWorkflowClient } from "../dependencies.js";
@@ -31,22 +32,28 @@ type SessionAuthorizationCommandDeps = {
     db: Database;
     sessionAuthorization?: SessionAuthorizationPort | null;
 };
+type SessionCommandPostCommitDeps = {
+    /** Historical name; now schedules replayable follow-up for every interactive session command. */
+    schedulePromptPostCommit?: ((task: () => Promise<void>) => void) | undefined;
+};
 export declare function sendAgentSessionMessage(deps: {
     db: Database;
+    settings?: Settings;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: AgentSessionCommandContext, input: {
+} & SessionCommandPostCommitDeps, context: AgentSessionCommandContext, input: {
     targetSessionId: string;
     text: string;
     idempotencyKey: string;
 }): Promise<import("@opengeni/db").AgentInternalUpdateCommandResult>;
 export declare function steerAgentSession(deps: {
     db: Database;
+    settings?: Settings;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: AgentSessionCommandContext, input: {
+} & SessionCommandPostCommitDeps, context: AgentSessionCommandContext, input: {
     targetSessionId: string;
     instruction: string;
     idempotencyKey: string;
@@ -54,9 +61,9 @@ export declare function steerAgentSession(deps: {
 export declare function controlAgentSessionWorkstream(deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: AgentSessionCommandContext, input: {
+} & SessionCommandPostCommitDeps, context: AgentSessionCommandContext, input: {
     targetSessionId: string;
     action: "pause" | "resume";
     idempotencyKey: string;
@@ -64,9 +71,10 @@ export declare function controlAgentSessionWorkstream(deps: {
 }): Promise<{
     receipt: SessionCommandReceiptRow;
     control: import("@opengeni/db").EffectiveSessionControl;
-    sessionControlEventId: string;
-    workspaceControlEventId: string;
+    sessionControlEventId: string | null;
+    workspaceControlEventId: string | null;
     interruptionCount: number;
+    backgroundCommandCount: number;
     wakeCount: number;
     cancelledSessionCount: number;
     cancelledTurnCount: number;
@@ -74,6 +82,8 @@ export declare function controlAgentSessionWorkstream(deps: {
         sessionId: string;
         eventIds: string[];
     }>;
+    workflowWake: import("@opengeni/db").SessionControlWorkflowWake | null;
+    outcome: "changed" | "unchanged" | "replayed";
     replay: boolean;
     authorization: ResolvedSessionAuthorization | null;
 }>;
@@ -81,29 +91,31 @@ export declare function moveHumanQueuePrompt(deps: {
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: HumanSessionCommandContext, turnId: string, input: MoveSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+} & SessionCommandPostCommitDeps, context: HumanSessionCommandContext, turnId: string, input: MoveSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
 export declare function deleteHumanQueuePrompt(deps: {
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: HumanSessionCommandContext, turnId: string, input: DeleteSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+} & SessionCommandPostCommitDeps, context: HumanSessionCommandContext, turnId: string, input: DeleteSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
 export declare function editHumanQueuePrompt(deps: {
     db: Database;
     bus: EventBus;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: HumanSessionCommandContext, turnId: string, input: EditSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+} & SessionCommandPostCommitDeps, context: HumanSessionCommandContext, turnId: string, input: EditSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
 export declare function steerHumanQueuePrompt(deps: {
     db: Database;
     bus: EventBus;
+    workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: HumanSessionCommandContext, turnId: string, input: SteerSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
+} & SessionCommandPostCommitDeps, context: HumanSessionCommandContext, turnId: string, input: SteerSessionQueueItemRequest): Promise<SessionQueueMutationResponse>;
 export declare function controlHumanSessionWorkstreamWithOutcome(deps: {
     db: Database;
     bus: EventBus;
-    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
+    workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch" | "wakeSessionWorkflow">;
     sessionAuthorization?: SessionAuthorizationPort | null;
-}, context: HumanSessionCommandContext, input: SessionControlRequest): Promise<{
+} & SessionCommandPostCommitDeps, context: HumanSessionCommandContext, input: SessionControlRequest): Promise<{
     response: SessionControlResponse;
+    outcome: "changed" | "unchanged" | "replayed";
     replay: boolean;
 }>;
 /** Backward-compatible response path used by the REST control route. */
@@ -112,7 +124,8 @@ export declare function controlHumanWorkspace(deps: {
     db: Database;
     bus: EventBus;
     workflowClient: Pick<SessionWorkflowClient, "requestSessionWorkflowWakeDispatch">;
-}, context: Omit<HumanSessionCommandContext, "sessionId">, input: WorkspaceInferenceControlRequest): Promise<WorkspaceInferenceControlResponse>;
+} & SessionCommandPostCommitDeps, context: Omit<HumanSessionCommandContext, "sessionId">, input: WorkspaceInferenceControlRequest): Promise<WorkspaceInferenceControlResponse>;
 export declare function getHumanComposerDraft(deps: SessionAuthorizationCommandDeps, context: HumanSessionCommandContext): Promise<ComposerDraft>;
 export declare function saveHumanComposerDraft(deps: SessionAuthorizationCommandDeps, context: HumanSessionCommandContext, input: SaveComposerDraftRequest): Promise<ComposerDraft>;
+export declare function controlHumanWorkspaceTimer(deps: Parameters<typeof controlHumanWorkspace>[0], context: Parameters<typeof controlHumanWorkspace>[1], input: import("@opengeni/contracts").WorkspacePauseTimerRequest): Promise<void>;
 export {};

package/dist/application/session-mcp-credential-rotation.d.ts

@@ -0,0 +1,29 @@
+import { RotateSessionMcpCredentialsRequest, type AccessGrant } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+import type { Settings } from "@opengeni/config";
+import { type AccessGrantAuthorization } from "../access/index.js";
+import { type SessionAuthorizationDependencies } from "../session-authorization.js";
+/** HMAC domains separate request identity from key availability. The key tag
+ * carries no request material and neither fingerprint is returned publicly. */
+export declare function sessionMcpRotationFingerprint(key: Uint8Array, scope: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+}, request: RotateSessionMcpCredentialsRequest): {
+    digestKeyTag: string;
+    requestDigest: string;
+};
+/** HTTP/SDK host boundary only. The mandatory callback re-resolves request
+ * authentication with the transaction handle, not a cached route-time grant. */
+export declare function rotateSessionMcpCredentialsForRequest(deps: SessionAuthorizationDependencies & {
+    settings: Settings;
+}, authorization: AccessGrantAuthorization, sessionId: string, raw: unknown, reauthorize: (tx: Database) => Promise<AccessGrant>): Promise<{
+    operationKey: string;
+    sessionId: string;
+    servers: {
+        id: string;
+        credentialVersion: number;
+    }[];
+    appliedAt: string;
+}>;

package/dist/application/session-tenancy.d.ts

@@ -0,0 +1,19 @@
+import { ForkSessionResponse, SessionTenancyCreateCapabilities, UpdateSessionVisibilityResponse, type ForkSessionRequest, type SessionAuthorizationSurface, type UpdateSessionVisibilityRequest } from "@opengeni/contracts";
+import { type AccessGrantAuthorization } from "../access/index.js";
+import type { AppDependencies } from "../dependencies.js";
+type SessionTenancyDependencies = Pick<AppDependencies, "db" | "bus" | "sessionAuthorization" | "settings">;
+export declare class SessionTenancyManagedHumanRequiredError extends Error {
+    readonly name = "SessionTenancyManagedHumanRequiredError";
+    constructor();
+}
+export declare class SessionTenancyPersistenceOutcomeUnknownError extends Error {
+    readonly name = "SessionTenancyPersistenceOutcomeUnknownError";
+    constructor(options?: ErrorOptions);
+}
+export declare function requireCanonicalManagedHuman(authorization: AccessGrantAuthorization, workspaceId: string): void;
+export declare function requireVerifiedOwningUser(authorization: AccessGrantAuthorization, workspaceId: string): void;
+export declare function getManagedHumanSessionCreateCapabilities(deps: Pick<SessionTenancyDependencies, "db">, authorization: AccessGrantAuthorization, workspaceId: string): Promise<SessionTenancyCreateCapabilities>;
+export declare function requireManagedHumanPrivateSessionCreate(deps: Pick<SessionTenancyDependencies, "db">, authorization: AccessGrantAuthorization, workspaceId: string): Promise<void>;
+export declare function updateManagedHumanSessionVisibility(deps: SessionTenancyDependencies, authorization: AccessGrantAuthorization, workspaceId: string, sessionId: string, request: UpdateSessionVisibilityRequest, authorizationSurface?: SessionAuthorizationSurface): Promise<UpdateSessionVisibilityResponse>;
+export declare function forkManagedHumanSession(deps: SessionTenancyDependencies, authorization: AccessGrantAuthorization, workspaceId: string, sourceSessionId: string, request: ForkSessionRequest, authorizationSurface?: SessionAuthorizationSurface): Promise<ForkSessionResponse>;
+export {};

package/dist/application/user-resource-grants.d.ts

@@ -0,0 +1,20 @@
+import type { IssueUserResourceGrantRequest, SessionAuthorizationSurface, UserResourceKind } from "@opengeni/contracts";
+import { type AccessGrantAuthorization } from "../access/index.js";
+import type { AppDependencies } from "../dependencies.js";
+type UserResourceGrantDependencies = Pick<AppDependencies, "db" | "sessionAuthorization">;
+export declare function listManagedHumanUserResourceAuthorities(deps: Pick<UserResourceGrantDependencies, "db">, authorization: AccessGrantAuthorization, workspaceId: string, input: {
+    resourceKind: UserResourceKind;
+    cursor?: string | undefined;
+    limit: number;
+}): Promise<{
+    authorities: import("@opengeni/db").UserResourceAuthoritySummary[];
+    nextCursor: string | null;
+}>;
+export declare function issueManagedHumanUserResourceGrant(deps: UserResourceGrantDependencies, authorization: AccessGrantAuthorization, workspaceId: string, authorityId: string, request: IssueUserResourceGrantRequest, authorizationSurface?: SessionAuthorizationSurface): Promise<import("@opengeni/db").UserResourceAuthorityGrant>;
+export declare function revokeManagedHumanUserResourceGrant(deps: Pick<UserResourceGrantDependencies, "db">, authorization: AccessGrantAuthorization, workspaceId: string, grantId: string): Promise<{
+    grantId: string;
+    generation: number;
+    status: "revoked";
+    revokedAt: string;
+}>;
+export {};

package/dist/billing/limits.d.ts

@@ -1,13 +1,24 @@
+import { type Settings } from "@opengeni/config";
 import type { LimitAction, LimitDecision, SessionTurnSource, TurnInitiator, TurnInitiatorContext } from "@opengeni/contracts";
 import type { ApiRouteDeps } from "../dependencies.js";
 export type LimitDependencies = Pick<ApiRouteDeps, "db" | "settings">;
+/** Deterministic/local embeddings never debit credits, even in paid mode. */
+export declare function paidDocumentEmbedding(settings: Settings): boolean;
+/** Round up each provider request so a positive input cannot become a free debit. */
+export declare function documentEmbeddingCostMicros(settings: Settings, inputBytes: number): number;
 export type LimitCheckInput = {
     accountId: string;
     workspaceId?: string;
+    /** Frozen causal human, never the API key or service admitting the work. */
+    initiatingHumanSubjectId?: string | null;
     action: LimitAction;
     quantity?: number;
     model?: string | null;
 };
+export declare function modelFundingForAdmission(settings: Settings, model: string | null | undefined, codexBilled: boolean): {
+    fundedWithoutCredits: boolean;
+    countsTowardTokenCap: boolean;
+};
 export declare function requireLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<void>;
 export declare function checkLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<LimitDecision>;
 export declare function recordWorkspaceUsage(deps: LimitDependencies, input: {

package/dist/canonical-human-identities.d.ts

@@ -1,12 +1,17 @@
 import type { Database } from "@opengeni/db";
 import type { Context } from "hono";
 import type { ManagedAuth } from "./managed-auth-type.js";
+export { getManagedAuthRequestActorAdmissionStamp, getManagedAuthRequestActorLeaseStamp, markManagedAuthRequestActorTransitionApplied, } from "./managed-session.js";
+import type { ManagedAuthSessionAdapter } from "./managed-auth-session-sets.js";
+import type { ManagedAuthSessionSetMode } from "@opengeni/contracts/managed-auth-session-sets";
 export type CanonicalHumanRequestIdentity = {
     authUserId: string;
     authSessionId: string;
 };
 export declare function requireCanonicalHumanRequestIdentity(context: Context, input: {
     db: Database;
-    managedAuth?: ManagedAuth | null;
-    allowRecovery?: boolean;
+    managedAuth?: ManagedAuth | null | undefined;
+    managedAuthSessionAdapter?: ManagedAuthSessionAdapter | null | undefined;
+    managedAuthSessionSetMode?: ManagedAuthSessionSetMode | undefined;
+    allowRecovery?: boolean | undefined;
 }): Promise<CanonicalHumanRequestIdentity>;