@opengeni/core 0.28.0 → 1.0.0

package/dist/managed-auth-session-sets.d.ts

@@ -0,0 +1,131 @@
+import type { ManagedAuthSessionSetMode, ManagedAuthSessionSetProjection } from "@opengeni/contracts/managed-auth-session-sets";
+import { type Database, type ManagedAuthDatabaseProjection, type ManagedAuthSelectedSession } from "@opengeni/db";
+export declare const MANAGED_AUTH_SESSION_SET_COOKIE: "opengeni.session_set";
+export declare const MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE: "opengeni.login_transaction";
+export declare const MANAGED_AUTH_CSRF_HEADER: "x-opengeni-session-csrf";
+export declare const MANAGED_AUTH_ACTOR_EPOCH_HEADER: "x-opengeni-actor-epoch";
+export declare const MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE_PATH: "/v1/auth/session-set/transactions";
+export type ManagedAuthResolvedSession = {
+    session: {
+        id: string;
+        userId: string;
+        [key: string]: unknown;
+    };
+    user: {
+        id: string;
+        email: string;
+        name: string;
+        emailVerified: boolean;
+        [key: string]: unknown;
+    };
+};
+/** Provider-neutral boundary; provider credentials and tokens never cross its output. */
+export interface ManagedAuthSessionAdapter {
+    authenticate(input: {
+        provider: "email_password";
+        transactionId: string;
+        credentials: {
+            email: string;
+            password: string;
+        };
+        headers: Headers;
+    }): Promise<{
+        authSessionId: string;
+    }>;
+    /** Verify an ambient provider cookie without sliding expiry or emitting cookies. */
+    resolveAmbientSession(headers: Headers): Promise<ManagedAuthResolvedSession | null>;
+    resolveSelectedSession(input: ManagedAuthSelectedSession): Promise<ManagedAuthResolvedSession | null>;
+    refreshSelectedSession(input: ManagedAuthSelectedSession): Promise<ManagedAuthResolvedSession | null>;
+    revokeSession(input: {
+        authSessionId: string;
+    }): Promise<void>;
+    /** Dual-mode exact selected-session cookie plus stale provider-cache invalidations. */
+    createLegacySelectedSessionCookies(input: ManagedAuthSelectedSession | null, currentCookieHeader?: string | null): Promise<string[]>;
+}
+export declare class ManagedAuthActorChangeError extends Error {
+    readonly name = "ManagedAuthActorChangeError";
+    readonly code = "actor_change_required";
+    constructor();
+}
+export declare class ManagedAuthRequestAdmissionError extends Error {
+    readonly name = "ManagedAuthRequestAdmissionError";
+    readonly code = "origin_rejected";
+}
+export declare class ManagedAuthCompletionOutcomeUnknownError extends Error {
+    readonly name = "ManagedAuthCompletionOutcomeUnknownError";
+    readonly code = "operation_outcome_unknown";
+    constructor(options?: ErrorOptions);
+}
+export declare function requireManagedAuthActorFence(input: {
+    mode: ManagedAuthSessionSetMode;
+    actorEpoch: string;
+    expectedActorEpoch: string | null;
+    selectedAuthSessionId: string | null;
+    legacyAmbientSessionId?: string | null;
+}): void;
+export declare function managedAuthRandomAuthority(): string;
+export declare function managedAuthSha256(value: string): string;
+export declare function managedAuthCsrfHash(authority: string): string;
+export declare function managedAuthCsrfToken(signingSecret: string, authority: string, generation: string): string;
+export declare function managedAuthTransactionSecret(signingSecret: string, authority: string, operationId: string): string;
+export declare function managedAuthDerivedUuid(namespace: string, value: string): string;
+export declare function managedAuthRequestDigest(value: unknown): string;
+export declare function managedAuthSecretRequestDigest(signingSecret: string, value: unknown): string;
+export declare function withManagedAuthCsrfToken(projection: ManagedAuthDatabaseProjection, signingSecret: string, authority: string): ManagedAuthSessionSetProjection;
+export declare function requireManagedAuthMutationAdmission(input: {
+    request: Request;
+    allowedOrigins: readonly string[];
+    authority: string;
+    signingSecret: string;
+    expectedGeneration: string;
+}): void;
+export declare function resolveManagedAuthSelectedSession(input: {
+    db: Database;
+    adapter: ManagedAuthSessionAdapter;
+    authority: string;
+    mode: ManagedAuthSessionSetMode;
+    expectedActorEpoch: string | null;
+    legacyAmbientSessionId?: string | null;
+    allowRecovery?: boolean;
+}): Promise<{
+    session: ManagedAuthResolvedSession | null;
+    projection: ManagedAuthDatabaseProjection;
+} | null>;
+export declare function authenticateAndAdoptManagedAuthSession(input: {
+    db: Database;
+    adapter: ManagedAuthSessionAdapter;
+    isolatedHeaders: Headers;
+    authority: string;
+    csrfHash: string;
+    operationId: string;
+    requestDigest: string;
+    expectedGeneration: string;
+    expectedActorEpoch: string;
+    transactionId: string;
+    transactionSecret: string;
+    email: string;
+    password: string;
+    mode: ManagedAuthSessionSetMode;
+}): Promise<{
+    projection: ManagedAuthDatabaseProjection;
+    returnIntent: string | null;
+}>;
+export declare function adoptManagedAuthSession(input: {
+    db: Database;
+    adapter: ManagedAuthSessionAdapter;
+    authority: string;
+    authorityHash: string;
+    csrfHash: string;
+    operationId: string;
+    requestDigest: string;
+    expectedGeneration: string;
+    expectedActorEpoch: string;
+    transactionId: string;
+    transactionSecretHash: string;
+    authSessionId: string;
+    mode: ManagedAuthSessionSetMode;
+}): Promise<{
+    projection: ManagedAuthDatabaseProjection;
+    returnIntent: string | null;
+}>;
+export declare function isolatedManagedAuthHeaders(request: Request): Headers;

package/dist/managed-auth-session-sets.js

@@ -0,0 +1,51 @@
+import {
+  MANAGED_AUTH_ACTOR_EPOCH_HEADER,
+  MANAGED_AUTH_CSRF_HEADER,
+  MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE,
+  MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE_PATH,
+  MANAGED_AUTH_SESSION_SET_COOKIE,
+  ManagedAuthActorChangeError,
+  ManagedAuthCompletionOutcomeUnknownError,
+  ManagedAuthRequestAdmissionError,
+  adoptManagedAuthSession,
+  authenticateAndAdoptManagedAuthSession,
+  isolatedManagedAuthHeaders,
+  managedAuthCsrfHash,
+  managedAuthCsrfToken,
+  managedAuthDerivedUuid,
+  managedAuthRandomAuthority,
+  managedAuthRequestDigest,
+  managedAuthSecretRequestDigest,
+  managedAuthSha256,
+  managedAuthTransactionSecret,
+  requireManagedAuthActorFence,
+  requireManagedAuthMutationAdmission,
+  resolveManagedAuthSelectedSession,
+  withManagedAuthCsrfToken
+} from "./chunk-QO5GVFFO.js";
+export {
+  MANAGED_AUTH_ACTOR_EPOCH_HEADER,
+  MANAGED_AUTH_CSRF_HEADER,
+  MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE,
+  MANAGED_AUTH_LOGIN_TRANSACTION_COOKIE_PATH,
+  MANAGED_AUTH_SESSION_SET_COOKIE,
+  ManagedAuthActorChangeError,
+  ManagedAuthCompletionOutcomeUnknownError,
+  ManagedAuthRequestAdmissionError,
+  adoptManagedAuthSession,
+  authenticateAndAdoptManagedAuthSession,
+  isolatedManagedAuthHeaders,
+  managedAuthCsrfHash,
+  managedAuthCsrfToken,
+  managedAuthDerivedUuid,
+  managedAuthRandomAuthority,
+  managedAuthRequestDigest,
+  managedAuthSecretRequestDigest,
+  managedAuthSha256,
+  managedAuthTransactionSecret,
+  requireManagedAuthActorFence,
+  requireManagedAuthMutationAdmission,
+  resolveManagedAuthSelectedSession,
+  withManagedAuthCsrfToken
+};
+//# sourceMappingURL=managed-auth-session-sets.js.map

package/dist/managed-auth-session-sets.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/managed-session.d.ts

@@ -1,17 +1,17 @@
 import type { Context } from "hono";
 import type { ManagedAuth } from "./managed-auth-type.js";
 import type { Database } from "@opengeni/db";
-/**
- * Read a Better Auth session without bypassing its sliding-cookie renewal.
- *
- * Better Auth can refresh the durable session while resolving `getSession`.
- * Programmatic callers must explicitly request and forward the returned cookie
- * headers; the HTTP handler does this automatically, but direct API calls do not.
- */
-export declare function getManagedSession(c: Context, auth: ManagedAuth, options?: {
-    db?: Database;
-    allowIdentityRecovery?: boolean;
-}): Promise<{
+import type { ManagedAuthSessionSetMode } from "@opengeni/contracts/managed-auth-session-sets";
+import { type ManagedAuthSessionAdapter } from "./managed-auth-session-sets.js";
+type ActorMutationLeaseRuntime = {
+    monotonicNow: () => number;
+    schedule: (callback: () => void, delayMs: number) => ReturnType<typeof setTimeout>;
+    cancel: (timer: ReturnType<typeof setTimeout>) => void;
+    terminate: () => void;
+};
+/** Bind admission to this auth instance, including all session-set modes. */
+export declare function configureManagedUserAdmission(auth: ManagedAuth, emails: readonly string[] | undefined): void;
+export declare function getManagedSession(...args: Parameters<typeof resolveManagedSession>): Promise<import("./managed-auth-session-sets.js").ManagedAuthResolvedSession | {
     session: {
         id: string;
         createdAt: Date;
@@ -55,3 +55,90 @@ export declare function getManagedSession(c: Context, auth: ManagedAuth, options
         image?: string | null | undefined;
     };
 } | null>;
+export declare function assertManagedUserAdmission(auth: ManagedAuth, user: {
+    email: string;
+    emailVerified: boolean;
+} | null | undefined): void;
+declare function resolveManagedSession(c: Context, auth: ManagedAuth, options?: {
+    db?: Database | undefined;
+    allowIdentityRecovery?: boolean | undefined;
+    sessionSetMode?: ManagedAuthSessionSetMode | undefined;
+    sessionAdapter?: ManagedAuthSessionAdapter | null | undefined;
+}): Promise<import("./managed-auth-session-sets.js").ManagedAuthResolvedSession | {
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    } | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    };
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+} | null>;
+/** Safe response provenance for a request authenticated through session-set authority. */
+export declare function getManagedAuthRequestActorEpoch(request: Request): string | null;
+/** Release the multi-replica actor fence after the outer HTTP handler settles. */
+export declare function releaseManagedAuthRequestActorLease(request: Request): Promise<void>;
+/** Cooperative cancellation signal for actor-scoped provider/external I/O. */
+export declare function getManagedAuthRequestActorAbortSignal(request: Request): AbortSignal | null;
+/** @internal Deterministic lease-clock seam used only by direct lifecycle tests. */
+export declare function installManagedAuthActorLeaseRuntimeForTest(overrides: Partial<ActorMutationLeaseRuntime>): () => void;
+/**
+ * Exact post-handler fence. A finite unsafe response is not released unless
+ * its request-owned lease is still live at the same actor epoch.
+ */
+export declare function validateManagedAuthRequestActorLease(request: Request): Promise<void>;
+export declare class ManagedAuthActorLeaseOutcomeUnknownError extends Error {
+    readonly name = "ManagedAuthActorLeaseOutcomeUnknownError";
+    readonly code = "operation_outcome_unknown";
+    constructor(options?: ErrorOptions);
+}
+/** A known-applied same-request canonical transition intentionally consumes its lease. */
+export declare function markManagedAuthRequestActorTransitionApplied(request: Request): void;
+export type ManagedAuthActorMutationLeaseStamp = {
+    authorityHash: string;
+    actorEpoch: string;
+    requestId: string;
+};
+export type ManagedAuthActorAdmissionStamp = {
+    authorityHash: string;
+    actorEpoch: string;
+};
+/** Verified server-owned actor evidence available to both reads and mutations. */
+export declare function getManagedAuthRequestActorAdmissionStamp(request: Request): ManagedAuthActorAdmissionStamp | null;
+/** Exact request-owned fence passed into a same-transaction actor transition. */
+export declare function getManagedAuthRequestActorLeaseStamp(request: Request): ManagedAuthActorMutationLeaseStamp | null;
+export {};

package/dist/model-catalog.d.ts

@@ -0,0 +1,117 @@
+import { type ConnectionModelRestrictions } from "@opengeni/db";
+import { type ClaudeConnectionCatalog, type ConfiguredModel, type Settings } from "@opengeni/config";
+import { type ModelAvailabilityV1, type ModelCredentialReadinessV1, type WorkspaceModelPolicyContract } from "@opengeni/contracts";
+import { type OrganizationClaudeModelAdmissionAuthority, type Database } from "@opengeni/db";
+export type ResolvedCatalogSettings = {
+    settings: Settings;
+    source: "code" | "database";
+    version: number | null;
+    modelNotes: Record<string, string>;
+};
+/**
+ * Curated workspace Gateway products and workspace-owned custom slugs share
+ * one public prefix. Only the latter have a mutable catalog row whose active
+ * generation must be rechecked at a fresh acceptance commit boundary.
+ */
+export declare function isWorkspaceGatewayCustomModelId(settings: Settings, modelId: string): boolean;
+export declare function isWorkspaceOpenRouterCustomModelId(settings: Settings, modelId: string): boolean;
+export type WorkspaceCustomModelReference = {
+    scope: "workspace" | "organization";
+    providerKind: "vercel_gateway" | "openrouter" | "anthropic" | "claude_subscription";
+    upstreamModelId: string;
+};
+export declare function workspaceCustomModelReference(settings: Settings, modelId: string): WorkspaceCustomModelReference | null;
+export declare function isWorkspaceCustomModelId(settings: Settings, modelId: string): boolean;
+export declare function lockActiveCustomModelForAdmission(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    reference: WorkspaceCustomModelReference;
+    claudeAuthority?: OrganizationClaudeModelAdmissionAuthority;
+}): Promise<boolean>;
+/**
+ * Resolve the deployment catalog without making synchronous env settings read
+ * Postgres. Database mode fails closed when the singleton is absent or invalid;
+ * code mode preserves the already-validated env catalog.
+ */
+export declare function resolveCatalogSettings(db: Database, envSettings: Settings): Promise<ResolvedCatalogSettings>;
+/**
+ * Resolve the deployment catalog and add only the custom Gateway slugs owned by
+ * one workspace. Use this at model-bearing workspace boundaries; public config
+ * and deployment-operator surfaces must continue to use `resolveCatalogSettings`.
+ */
+export declare function resolveWorkspaceCatalogSettings(db: Database, envSettings: Settings, input: {
+    accountId: string;
+    workspaceId: string;
+    retainedProductModelId?: string | null;
+    retainedProductModelIds?: readonly (string | null | undefined)[];
+}): Promise<ResolvedCatalogSettings>;
+export type ModelAvailabilityObservation = {
+    status: "available" | "degraded" | "unavailable";
+    reason: "not_entitled" | "provider_unhealthy" | null;
+    checkedAt: string;
+};
+export type ModelCredentialReadinessObservation = {
+    status: "ready";
+    checkedAt: string;
+} | {
+    status: "not_ready";
+    reason: "prerequisites_missing" | "needs_reauth";
+    checkedAt: string;
+} | {
+    status: "error";
+    reason: "resolver_error";
+    checkedAt: string;
+};
+export declare const MODEL_CREDENTIAL_READINESS_OBSERVATION_MAX_AGE_MS: number;
+export type WorkspaceModelSelectionInput = {
+    connectionModelRestrictions?: ConnectionModelRestrictions;
+    settings: Settings;
+    policy: WorkspaceModelPolicyContract | null;
+    codexSubscriptionActive: boolean;
+    xaiSubscriptionActive?: boolean;
+    workspaceGatewayConnectionActive?: boolean;
+    workspaceOpenRouterConnectionActive?: boolean;
+    claudeConnections?: ClaudeConnectionCatalog;
+    workspaceClaudeConnections?: ClaudeConnectionCatalog;
+    organizationGatewayConnectionActive?: boolean;
+    organizationOpenRouterConnectionActive?: boolean;
+    workspaceGatewayCustomModels?: readonly {
+        upstreamModelId: string;
+        label?: string | null;
+    }[];
+    workspaceOpenRouterCustomModels?: readonly {
+        upstreamModelId: string;
+        label?: string | null;
+    }[];
+    organizationGatewayCustomModels?: readonly {
+        upstreamModelId: string;
+        label?: string | null;
+    }[];
+    organizationOpenRouterCustomModels?: readonly {
+        upstreamModelId: string;
+        label?: string | null;
+    }[];
+    credentialReadinessObservations?: Readonly<Record<string, ModelCredentialReadinessObservation>> | undefined;
+    observations?: Readonly<Record<string, ModelAvailabilityObservation>> | undefined;
+    now?: Date | undefined;
+    credentialReadinessMaxAgeMs?: number | undefined;
+};
+export type WorkspaceModelSelection = {
+    model: ConfiguredModel;
+    credentialReadiness: ModelCredentialReadinessV1;
+    policyAllowed: boolean;
+    availability: ModelAvailabilityV1;
+};
+/**
+ * Stable fresh-selection admission, independent of transient observations.
+ * Missing catalog membership is handled by the caller's lookup. Resolver-based
+ * deployment credentials (Azure AD/managed identity) are resolved at execution;
+ * absent, stale or failed observations cannot make their definition uncreatable.
+ */
+export declare function isWorkspaceModelAdmissible(selection: WorkspaceModelSelection): boolean;
+/**
+ * One shared picker/tool decision. Catalog membership, credential readiness,
+ * workspace policy, and optional provider-health observations are evaluated in
+ * configured catalog order so every consumer exposes the same selectable set.
+ */
+export declare function resolveWorkspaceModelSelection(input: WorkspaceModelSelectionInput): WorkspaceModelSelection[];

package/dist/product-usage-metrics.d.ts

@@ -0,0 +1,30 @@
+import { type SessionTurnSurface } from "@opengeni/contracts";
+import type { Observability } from "@opengeni/observability";
+/**
+ * Live, content-free product usage counters recorded where work is accepted.
+ * Every label is a closed set: the product surface (or `unknown` when no
+ * surface was captured), who created a session (`subject` or `service`), and
+ * whether the session is a root. No workspace, user, model or text value ever
+ * becomes a label.
+ */
+export type ProductUsageMetricsSink = Pick<Observability, "incrementCounter">;
+export declare const PRODUCT_USAGE_SURFACE_LABELS: readonly ["web", "slack", "api_key", "embedded", "scheduled", "agent", "voice", "site", "automation", "mcp", "system", "unknown"];
+export type ProductUsageSurfaceLabel = (typeof PRODUCT_USAGE_SURFACE_LABELS)[number];
+export declare const SESSION_CREATED_BY_KINDS: readonly ["subject", "service"];
+export type SessionCreatedByKind = (typeof SESSION_CREATED_BY_KINDS)[number];
+export declare function productUsageSurfaceLabel(surface: SessionTurnSurface | null | undefined): ProductUsageSurfaceLabel;
+/** Count one newly created session. Never throws; replays must not call it. */
+export declare function recordSessionCreated(sink: ProductUsageMetricsSink | null | undefined, input: {
+    surface: SessionTurnSurface | null | undefined;
+    createdByKind: string | null | undefined;
+    parentSessionId: string | null | undefined;
+}): void;
+/** Count one newly accepted user message. Never throws; replays must not call it. */
+export declare function recordUserMessageAccepted(sink: ProductUsageMetricsSink | null | undefined, input: {
+    surface: SessionTurnSurface | null | undefined;
+}): void;
+/**
+ * Publish every closed series at zero so dashboards can tell a quiet surface
+ * from missing instrumentation. Never throws.
+ */
+export declare function registerProductUsageMetricBaselines(sink: ProductUsageMetricsSink | null | undefined): void;

package/dist/rigs/index.d.ts

@@ -1,10 +1,18 @@
-import type { AccessGrant, CreateRigRequest, RigDefinitionEditPayload, ProposeRigChangeRequest, Rig, RigChange, RigVersion, UpdateRigRequest } from "@opengeni/contracts";
+import type { AccessGrant, CreateRigRequest, RigDefinitionEditPayload, ProposeRigChangeRequest, Rig, RigChange, ResourceAuthorityScope, RigVersion, UpdateRigRequest } from "@opengeni/contracts";
 import { type Database } from "@opengeni/db";
 export * from "./provider-images.js";
 export declare const MAX_RIGS_PER_WORKSPACE = 50;
 export declare const MAX_CHECKS_PER_RIG = 100;
 export declare const MAX_CREDENTIAL_HOOKS_PER_RIG = 50;
 export declare const MAX_DEFAULT_VARIABLE_SETS_PER_RIG = 25;
+export declare const RIG_DEFAULT_VARIABLE_SET_LOAD_CONCURRENCY = 4;
+type VariableSetEnvironment = {
+    values: Record<string, string>;
+} | null;
+/** Load complete rig defaults concurrently while preserving listed precedence. */
+export declare function loadRigDefaultVariableSetEnvironment(variableSetIds: readonly string[], load: (variableSetId: string) => Promise<VariableSetEnvironment>): Promise<Record<string, string>>;
+/** Rig defaults layer below the session's explicitly selected variable set. */
+export declare function mergeRigDefaultVariableSetEnvironment(rigDefaultValues: Record<string, string>, sessionValues: Record<string, string>): Record<string, string>;
 export type RigServices = {
     db: Database;
 };
@@ -16,11 +24,20 @@ export declare function recordRigAuditEvent(db: Database, input: {
     metadata?: Record<string, unknown>;
 }): Promise<void>;
 export declare function rigActorForGrant(grant: AccessGrant): string;
-export declare function requireRigForApi(db: Database, workspaceId: string, rigId: string): Promise<Rig>;
+export declare function requireRigForApi(db: Database, grant: AccessGrant, rigId: string): Promise<Rig>;
 export declare function requireRigChangeForApi(db: Database, workspaceId: string, rigId: string, changeId: string): Promise<RigChange>;
-export declare function createRigForApi(deps: RigServices, grant: AccessGrant, payload: CreateRigRequest): Promise<Rig>;
-export declare function updateRigForApi(deps: RigServices, grant: AccessGrant, rig: Rig, payload: UpdateRigRequest): Promise<Rig>;
-export declare function deleteRigForApi(deps: RigServices, grant: AccessGrant, rig: Rig): Promise<void>;
+/** A resource may depend only on Variable Sets whose audience is no narrower
+ * than its own. User-owned rigs may use anything visible to their owner. */
+export declare function variableSetScopeAllowedForRig(rigScope: ResourceAuthorityScope, variableSetScope: ResourceAuthorityScope): boolean;
+export declare function createRigForApi(deps: RigServices, grant: AccessGrant, payload: CreateRigRequest, options?: {
+    allowOrganization?: boolean;
+}): Promise<Rig>;
+export declare function updateRigForApi(deps: RigServices, grant: AccessGrant, rig: Rig, payload: UpdateRigRequest, options?: {
+    allowOrganization?: boolean;
+}): Promise<Rig>;
+export declare function deleteRigForApi(deps: RigServices, grant: AccessGrant, rig: Rig, options?: {
+    allowOrganization?: boolean;
+}): Promise<void>;
 export declare function proposeRigChangeForApi(deps: RigServices, grant: AccessGrant, rig: Rig, request: ProposeRigChangeRequest, options?: {
     proposedBy?: string;
 }): Promise<RigChange>;

package/dist/rigs/provider-images.d.ts

@@ -1,5 +1,5 @@
 import { type RigChangeVerification, type RigProviderImage, type RigProviderImages, type RigVersion, type SandboxBackend } from "@opengeni/contracts";
-export type RigProviderImageDefinition = Pick<RigVersion, "image" | "setupScript" | "checks" | "credentialHooks" | "defaultVariableSetIds">;
+export type RigProviderImageDefinition = Pick<RigVersion, "setupScript" | "checks" | "credentialHooks" | "defaultVariableSetIds">;
 export declare function rigProviderImageProviderBindingKeyHash(bindingKey: string): string;
 export declare function rigProviderImageSetupHash(definition: Pick<RigProviderImageDefinition, "setupScript">): string;
 /**

package/dist/sandbox/fleet.d.ts

@@ -1,7 +1,8 @@
 import type { Settings } from "@opengeni/config";
+import type { SandboxBackend } from "@opengeni/contracts";
 import { type Database, type SandboxRecord } from "@opengeni/db";
 import type { EventBus } from "@opengeni/events";
-import { type BackendUnresolvableCode, type ControlRpc, type SelfhostedRelayConfig, type SelfhostedOpStreamDeps } from "@opengeni/runtime/sandbox";
+import { type BackendUnresolvableCode, type ControlRpc, type SelfhostedRelayConfig, type SelfhostedOpStreamDeps, type SelfhostedOperationAdmission, type SelfhostedOperationResourcePolicy } from "@opengeni/runtime/sandbox";
 export type FleetServices = {
     db: Database;
     settings: Settings;
@@ -18,11 +19,18 @@ export type FleetReadinessHold = {
 export type FleetContext = {
     accountId: string;
     workspaceId: string;
+    subjectId?: string;
+    attemptAuthority?: {
+        turnId: string;
+        attemptId: string;
+        executionGeneration: number;
+        initiatingHumanSubjectId: string;
+    };
     /** The calling session (the pointer the attach/swap mutates + whose group box
      *  is the default fleet member). */
     sessionId: string;
-    /** The session's own group sandbox backend (modal/selfhosted/…). */
-    sessionBackend: string;
+    /** The session's durable home-compute policy. */
+    sessionBackend: SandboxBackend;
     /** The session's own group sandbox id (the lease group). */
     sessionGroupId: string;
 };
@@ -42,6 +50,8 @@ export declare function buildFleetContextForSession(deps: {
     accountId: string;
     workspaceId: string;
     sessionId: string;
+    subjectId?: string;
+    attemptAuthority?: FleetContext["attemptAuthority"];
 }): Promise<FleetContext>;
 /** The dominant liveness of a fleet member, surfaced to the dock + the agent. */
 export type FleetLiveness = "online" | "reconnecting" | "offline";
@@ -50,14 +60,15 @@ export type FleetOperationAvailability = "ready" | "wakeable" | "recovering" | "
  * A fleet member as the agent + the dock see it (the M8b/M9 UI seam — the
  * `sandboxes_list` response entry the dock renders). STABLE shape: the dock keys
  * on `id`, renders `name`/`kind`/`liveness`, and marks `active`. The session's own
- * Modal group box is a synthetic entry with `id: groupId`, `kind: "modal"`, and a
- * null `enrollmentId`; an enrolled machine carries its sandbox + enrollment ids.
+ * managed group box is a synthetic entry with `id: groupId`, its actual
+ * provisioned backend kind, and a null `enrollmentId`; an enrolled machine
+ * carries its sandbox + enrollment ids.
  */
 export type FleetSandboxEntry = {
     /** The sandbox id used as the attach/swap/run_on `target`. For the session's
      *  own group box this is the group id (a null active pointer == this box). */
     id: string;
-    kind: "modal" | "selfhosted";
+    kind: Exclude<SandboxBackend, "none">;
     name: string;
     liveness: FleetLiveness;
     /** True for the session's currently-active sandbox (the routing target). */
@@ -106,16 +117,35 @@ export type FleetSwapResult = {
     activeSandboxId: string | null;
     activeEpoch: number;
     reason?: string;
-    code?: BackendUnresolvableCode | "concurrent_swap" | "recovery_in_progress" | "recovery_degraded" | "recovery_unrecoverable";
+    code?: BackendUnresolvableCode | "invalid_working_directory" | "concurrent_swap" | "recovery_in_progress" | "recovery_degraded" | "recovery_unrecoverable";
 };
 /**
  * List the fleet: the session's own group box when it has one (a synthetic
  * entry) + the workspace's first-class selfhosted sandboxes (each probed for
  * liveness), each with an `active` marker derived from the session's active
- * pointer. A backend:none session has no synthetic home entry; a null pointer
- * then means no compute is attached.
+ * pointer. A backend:none session and a machine-home session on a deployment
+ * without a managed provider have no synthetic group entry; a null pointer then
+ * means no compute is attached.
  */
 export declare function listFleet(services: FleetServices, ctx: FleetContext): Promise<FleetListResult>;
+type FleetResourceContext = Pick<FleetContext, "accountId" | "workspaceId" | "subjectId">;
+export type CreateTimeSandboxTargetPreflight = {
+    ok: true;
+    targetSandboxId: string;
+    workingDir: string | null;
+} | {
+    ok: false;
+    reason: string;
+    code: BackendUnresolvableCode | "invalid_working_directory";
+};
+/**
+ * Validate a named create-time machine target before any session row exists.
+ * The caller still commits the pointer with `setActiveSandbox` inside the
+ * session-create transaction, which rechecks durable ownership/enrollment
+ * authority and closes the remove/revoke race without holding database locks
+ * across the liveness probe.
+ */
+export declare function preflightCreateTimeSandboxTarget(services: FleetServices, ctx: FleetResourceContext, target: string, workingDir: string | null): Promise<CreateTimeSandboxTargetPreflight>;
 /**
  * THE SWAP (and attach — identical mechanic). Validate the target's ownership +
  * liveness, then repoint the session via the epoch-fenced CAS `setActiveSandbox`:
@@ -157,6 +187,9 @@ export type RunOnResult = {
 export type RunOnSelfhostedMachine = {
     workspaceId: string;
     agentId: string;
+    /** Exact live daemon pinned for this operation. */
+    connectionInstanceId: string;
+    workspaceRoot: string;
     controlRpc: ControlRpc;
     relay: SelfhostedRelayConfig;
     /** Short request/reply deadline for read/write and other control operations. */
@@ -165,6 +198,21 @@ export type RunOnSelfhostedMachine = {
     execTimeoutMs: number;
     /** Streaming transport required when execTimeoutMs is 0 (unbounded). */
     opStream?: SelfhostedOpStreamDeps;
+    operationResourcePolicy?: SelfhostedOperationResourcePolicy;
+    operationResourcePolicySupported?: boolean;
+    operationCpuQuotaSupported?: boolean;
+    /** Last-boundary authority/connection resolver invoked before every physical
+     * provider operation. */
+    resolveOperationAdmission?: () => Promise<SelfhostedOperationAdmission | null>;
+    /**
+     * Exact-attempt values for this one child process. Never persisted on the
+     * enrollment or machine. The caller may supply these only after authenticating
+     * the active attempt that owns the one-off operation.
+     */
+    transientExecEnvironment?: Readonly<Record<string, string>>;
+};
+export type RunOnOptions = {
+    transientExecEnvironment?: Readonly<Record<string, string>>;
 };
 /**
  * Execute the one-off machine operation once the workspace/enrollment lookup has
@@ -182,7 +230,7 @@ export declare function executeRunOnSelfhostedMachine(machine: RunOnSelfhostedMa
  * agent subject; an offline machine surfaces a clear reason, never a wrong-box
  * landing.
  */
-export declare function runOnSandbox(services: FleetServices, ctx: FleetContext, target: string, op: RunOnOp): Promise<RunOnResult>;
+export declare function runOnSandbox(services: FleetServices, ctx: FleetContext, target: string, op: RunOnOp, options?: RunOnOptions): Promise<RunOnResult>;
 export type ProvisionResult = {
     kind: "selfhosted";
     instructions: string;
@@ -208,3 +256,4 @@ export declare function provisionSandbox(services: FleetServices, ctx: FleetCont
     kind: "selfhosted" | "modal";
     name?: string;
 }): Promise<ProvisionResult>;
+export {};