@opengeni/core 3.0.1 → 3.1.2

package/dist/session-usage-limit-metrics.d.ts

@@ -0,0 +1,60 @@
+import type { Observability } from "@opengeni/observability";
+/**
+ * Content-free diagnostics for per-task usage limits. Every label is
+ * a closed set: where the decision was made and what it was. No workspace,
+ * session, subject, model, prompt or amount ever becomes a label, so the
+ * series count is bounded by these two lists.
+ */
+export type SessionUsageLimitMetricsSink = Pick<Observability, "incrementCounter">;
+export declare const SESSION_USAGE_LIMIT_METRIC_BOUNDARIES: readonly ["create", "child_create", "send", "steer", "goal", "claim", "between_calls", "single_call", "settlement", "write", "import"];
+export type SessionUsageLimitMetricBoundary = (typeof SESSION_USAGE_LIMIT_METRIC_BOUNDARIES)[number];
+export declare const SESSION_USAGE_LIMIT_METRIC_OUTCOMES: readonly [
+/** Admission refused: observed settled usage reached the root limit. */
+"reached", 
+/** The usage state could not be read or written; the request was blocked. */
+"unavailable", 
+/** Settlement could not be recorded; the next dispatch waits for recovery. */
+"accounting_failure", 
+/** A response had no known price: excluded from the total and disclosed. */
+"unpriced", 
+/** A priced response was recorded once. */
+"recorded", 
+/** An exact replay of an already recorded source. */
+"duplicate", 
+/** A previously unpriced source gained its stored price. */
+"filled", 
+/** A different amount was offered for an already recorded source. */
+"source_conflict", 
+/** The session was deleted before its in-flight response settled. */
+"source_gone", 
+/** A write lost its compare-and-set race. */
+"cas_conflict", 
+/** A write targeted a root whose legacy history is still preparing. */
+"preparing", 
+/** A write was refused for an agent, scoped bearer or other non-person actor. */
+"forbidden", 
+/** A new non-null limit was refused because producers are disabled. */
+"disabled", 
+/** A write was refused because the session is not the task root. */
+"not_root", 
+/** An authorized write changed the limit. */
+"set", 
+/** An authorized write removed the limit. */
+"cleared", 
+/** An authorized write repeated an already applied request. */
+"replayed", 
+/** Legacy import pages processed by maintenance. */
+"imported", 
+/** Legacy import maintenance failed and will be retried. */
+"import_failed", 
+/** A settled receipt could not be written yet and is held for a DB-only retry. */
+"held", 
+/** An unfilled single-call custody marker passed its lost window; disclosed as unpriced. */
+"lost_resolved"];
+export type SessionUsageLimitMetricOutcome = (typeof SESSION_USAGE_LIMIT_METRIC_OUTCOMES)[number];
+export declare const SESSION_USAGE_LIMIT_EVENTS_METRIC: {
+    readonly name: "opengeni_session_usage_limit_events_total";
+    readonly help: "Per-task usage limit decisions by boundary and outcome; labels are closed sets.";
+};
+/** Count one usage-limit decision. Never throws: telemetry cannot change the outcome. */
+export declare function recordSessionUsageLimitEvent(sink: SessionUsageLimitMetricsSink | null | undefined, boundary: SessionUsageLimitMetricBoundary, outcome: SessionUsageLimitMetricOutcome, amount?: number): void;

package/dist/session-usage-limits.d.ts

@@ -0,0 +1,89 @@
+import { HTTPException } from "hono/http-exception";
+import { type Database, type SessionUsageLimitWriteActor } from "@opengeni/db";
+import { type Session, type SessionUsageLimit, type SessionUsageLimitReachedRefusal, type SetSessionUsageLimitRequest } from "@opengeni/contracts";
+import { type AccessGrantAuthorization } from "./access/index.js";
+import { type SessionAuthorizationDependencies } from "./session-authorization.js";
+import { type SessionUsageLimitMetricBoundary, type SessionUsageLimitMetricsSink } from "./session-usage-limit-metrics.js";
+/**
+ * Producer flag for per-task usage limits. Off by default. When off, new
+ * non-null limits are rejected (`session_usage_limit_disabled`), but limits
+ * already persisted keep being enforced and clearing stays allowed, so turning
+ * the flag off is never a way to lift a limit or strand one.
+ */
+export declare function sessionUsageLimitsProducerEnabled(settings: {
+    sessionUsageLimitsEnabled?: boolean | undefined;
+}): boolean;
+/** Typed route error with a stable `details.code`. */
+export declare class SessionUsageLimitHttpError extends HTTPException {
+    readonly code: "session_usage_limit_conflict" | "session_usage_limit_not_root" | "session_usage_limit_preparing" | "session_usage_limit_disabled" | "session_usage_limit_forbidden" | "session_usage_limit_unavailable" | "session_not_found";
+    readonly details: Record<string, unknown>;
+    constructor(status: 403 | 404 | 409 | 422 | 503, code: "session_usage_limit_conflict" | "session_usage_limit_not_root" | "session_usage_limit_preparing" | "session_usage_limit_disabled" | "session_usage_limit_forbidden" | "session_usage_limit_unavailable" | "session_not_found", message: string, details?: Record<string, unknown>);
+}
+/**
+ * Who may change a task's usage limit: an authenticated person acting
+ * directly, or the trusted host's server key. Never an agent attempt, a
+ * delegated-human or admin-access agent (an OAuth/MCP dispatch acting as a
+ * person, or a personal API key), a service-delegated token or a session-scoped
+ * bearer. `principalKind` alone is not proof of a present person.
+ */
+export declare function sessionUsageLimitWriteActorForAccess(access: AccessGrantAuthorization, request?: Request): SessionUsageLimitWriteActor;
+/** Projection for a session whose usage state cannot be read right now. Never $0 or unlimited. */
+export declare function unavailableSessionUsageLimit(session: Pick<Session, "id" | "rootSessionId">): SessionUsageLimit;
+/**
+ * Read a session's usage projection for an already-authorized session read.
+ * A read failure yields the `unavailable` projection rather than failing the
+ * whole session read. `prepare` advances a pending historical import inline.
+ */
+export declare function sessionUsageLimitForRead(db: Database, session: Pick<Session, "id" | "rootSessionId" | "accountId" | "workspaceId">, options?: {
+    prepare?: boolean;
+    subjectId?: string | null;
+}): Promise<SessionUsageLimit | undefined>;
+/** GET usage-limit: authorize a session read, then read (advancing a pending import). */
+export declare function getSessionUsageLimitForAccess(deps: SessionAuthorizationDependencies, access: AccessGrantAuthorization, sessionId: string): Promise<SessionUsageLimit>;
+/**
+ * PUT usage-limit: a person or trusted host compare-and-sets a ROOT task's
+ * limit. Appends `session.usage_limit.updated` on change. Never wakes or
+ * resumes work: a paused goal stays paused until someone resumes it.
+ */
+export declare function setSessionUsageLimitForAccess(deps: SessionAuthorizationDependencies & {
+    settings: {
+        sessionUsageLimitsEnabled?: boolean | undefined;
+    };
+    observability?: SessionUsageLimitMetricsSink | undefined;
+}, access: AccessGrantAuthorization, sessionId: string, request: SetSessionUsageLimitRequest, rawRequest?: Request): Promise<SessionUsageLimit>;
+/**
+ * Apply a create-time limit inside the session-creating transaction, before
+ * the initial turn can be claimed. Only a person or trusted host may set it
+ * and only on a new root; children always share their root's limit.
+ */
+export declare function applyInitialSessionUsageLimit(tx: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    limitMicros: number;
+    actor: SessionUsageLimitWriteActor;
+    producerEnabled: boolean;
+}): Promise<void>;
+/**
+ * Edge admission for per-task usage limits. Called after an exact
+ * committed replay has been returned and before any queue, interrupt, draft or
+ * turn side effect, so a refused Send/Steer leaves nothing behind and the
+ * composer keeps its draft.
+ *
+ * - Reached: HTTP 402 whose cause is the typed refusal (`session_usage_limit_reached`).
+ * - Unreadable state: HTTP 503 (`session_usage_limit_unavailable`), never unlimited.
+ */
+export declare function requireSessionUsageLimitAllows(db: Database, input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    /** Server-internal admission for an authorized attempt: fail closed on a missing tree. */
+    runtime?: boolean;
+    /** Runtime only: open a durable custody marker for this single call when admitted. */
+    openSourceId?: string;
+}, metrics?: {
+    sink: SessionUsageLimitMetricsSink | null | undefined;
+    boundary: SessionUsageLimitMetricBoundary;
+}): Promise<void>;
+/** True when this error is the typed edge refusal raised above. */
+export declare function sessionUsageLimitRefusalFromError(error: unknown): SessionUsageLimitReachedRefusal | null;

package/dist/site-agent-clamp.d.ts

@@ -0,0 +1,71 @@
+import type { AccessGrant } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
+/**
+ * Whether an agent acts for a Site page: its session, a spawning ancestor or
+ * its root session was started from a Site (a published Site or an inline or
+ * preview frame), or its current or a spawning ancestor turn arrived from one.
+ * The same evidence the Site Data agent clamp uses
+ * (apps/api/src/site-data/service.ts), plus frame origins without a
+ * published Site id.
+ */
+export type SiteAgentClamp = {
+    clamped: boolean;
+    /** Published Sites in the lineage; empty for frames without a published Site. */
+    originSiteIds: string[];
+};
+/** Null when the grant is not an agent session. */
+export declare function siteAgentClamp(db: Database, grant: AccessGrant): Promise<SiteAgentClamp | null>;
+/**
+ * The Site clamp of an agent running in `sessionId` (and `turnId`, when
+ * known). A turn's clamp is computed once a minute at most per process: the
+ * evidence it reads (where the session, its ancestors and that turn came
+ * from) does not change during the turn. Without a turn id it is always
+ * read fresh.
+ */
+export declare function siteSessionClamp(db: Database, scope: {
+    accountId: string;
+    workspaceId: string;
+}, sessionId: string, turnId: string | null): Promise<SiteAgentClamp>;
+/** What a Site-clamped agent may not create or change. */
+export type SiteClampedResource = "schedules" | "automations" | "Site publications" | "workspace instructions" | "Skills" | "Knowledge" | "secrets" | "workspace members, connections or settings" | "the organization profile" | "Connected Machines" | "sandbox environments" | "browser or computer sessions" | "documents, spreadsheets or presentations the Site did not declare" | "workspace settings";
+/** The refusal message for a Site-clamped agent. */
+export declare function siteClampedAgentMessage(what: SiteClampedResource): string;
+/**
+ * The refusal when a Site-clamped agent reaches for compute beyond its own
+ * session's: `run_on`, attaching, swapping or provisioning a sandbox, or
+ * starting a worker on a chosen machine or another session's sandbox.
+ */
+export declare const SITE_AGENT_COMPUTE_MESSAGE = "An agent started from a Site page cannot run on, attach, provision or choose sandboxes or Connected Machines";
+/**
+ * Refuse a Site-clamped agent's session create that chooses compute: a
+ * machine target, a self-hosted backend or another session's sandbox group.
+ * Its workers run in its own sandbox (shared) or a new managed one.
+ */
+export declare function assertSiteAgentMayChooseCompute(db: Database, grant: AccessGrant, payload: {
+    sandbox?: unknown;
+    sandboxBackend?: unknown;
+    targetSandboxId?: unknown;
+    workingDir?: unknown;
+}): Promise<void>;
+/**
+ * Refuse a Site-clamped agent: an agent started from a Site page acts with
+ * that page's reach and cannot create or change schedules, automations, Site
+ * publications, workspace instructions, Skills, Knowledge, secrets,
+ * workspace members, connections and settings, the organization profile,
+ * Connected Machines, sandbox environments or other workspace settings.
+ */
+export declare function assertNotSiteClampedAgent(db: Database, grant: AccessGrant, what: SiteClampedResource): Promise<void>;
+/**
+ * Whether an agent running in `caller` may message, steer or control
+ * `targetSessionId`. An unclamped agent is not limited here. A Site-clamped
+ * agent reaches only sessions that act for the same Site: clamped themselves
+ * (its own lineage, or another session the Site started) and naming no
+ * published Site the caller does not.
+ */
+export declare function siteAgentMayReachSession(db: Database, scope: {
+    accountId: string;
+    workspaceId: string;
+}, caller: {
+    sessionId: string;
+    turnId: string | null;
+}, targetSessionId: string): Promise<boolean>;

package/dist/site-session-origin.d.ts

@@ -1,7 +1,44 @@
+/**
+ * Which Site page a request came from. Provenance, plus the key the API uses
+ * to keep one Site's pages away from another Site's sessions.
+ *
+ * A published Site has a `siteId` (and `versionId` when the host pinned one).
+ * Inline HTML and Codemode preview frames have no published id: they record
+ * `siteId: null`, the `frame` kind and the host-minted `frameId` of the
+ * mounted page, so a frame reaches only the sessions it started itself.
+ */
 export type SiteSessionOrigin = {
-    siteId: string;
+    siteId: string | null;
     title: string;
+    versionId?: string;
+    frame?: "inline" | "preview";
+    frameId?: string;
 };
-/** Request-local provenance, set only after the API validates a published Site version. */
+export declare const SITE_ORIGIN_METADATA_KEY = "_opengeniSiteOrigin";
+/**
+ * Request-local provenance, set only after the API validated the Site the
+ * request came from (a published Site version the caller can see, or a
+ * host-marked inline or preview frame).
+ */
 export declare function withSiteSessionOrigin<T>(origin: SiteSessionOrigin, run: () => T): T;
 export declare function sessionCreationMetadata(metadata: Record<string, unknown>): Record<string, unknown>;
+/** The validated Site origin of the current request, if any. Provenance only. */
+export declare function currentSiteSessionOrigin(): SiteSessionOrigin | undefined;
+/**
+ * Replace any caller-supplied Site origin in `metadata` with `origin` (or drop
+ * it). Callers never choose their own provenance.
+ */
+export declare function withSiteOriginMetadata(metadata: Record<string, unknown>, origin: SiteSessionOrigin | null | undefined): Record<string, unknown>;
+/**
+ * Read the recorded Site origin from session (or schedule agent config)
+ * metadata. Any object under the key counts as a Site origin, so a malformed
+ * record still marks the session as Site-started (fail closed).
+ */
+export declare function siteSessionOriginFromMetadata(metadata: Record<string, unknown> | null | undefined): SiteSessionOrigin | null;
+/**
+ * Whether a request from the `requester` Site page may reach a session (or
+ * schedule) whose recorded origin is `target`. Same published Site, or, for
+ * frames without a published id, the same mounted frame. Anything without a
+ * Site origin is out of reach for a Site page.
+ */
+export declare function siteOriginsMatch(requester: SiteSessionOrigin, target: SiteSessionOrigin | null | undefined): boolean;

package/dist/transcription.d.ts

@@ -1,9 +1,11 @@
+import type { VoiceInputPricing, VoiceInputUsage } from "@opengeni/config";
 import type { TranscribeAudioResponse, VoiceInputErrorCode } from "@opengeni/contracts";
+import type { CreditDebitAttribution } from "@opengeni/db";
 /**
  * Server-owned upstream budget for one provider attempt. Resumable recording
  * claims remain fenced for longer than this budget before another worker may
  * reclaim them. Provider adapters must honor the supplied AbortSignal and must
- * not return while their upstream request is still live; OpenGeni does not
+ * not return while their upstream request is still live; Opengeni does not
  * claim remote-side idempotency or cancellation for vendors that cannot meet
  * that adapter contract.
  */
@@ -31,21 +33,112 @@ export type TranscriptionRequest = {
     preferredProvider?: string | null | undefined;
     fallbackEnabled?: boolean | undefined;
     excludedProviders?: readonly string[] | undefined;
+    /**
+     * Credit settlement facts for a deployment-funded provider. Required when
+     * the selected provider is deployment-funded and credit billing is active;
+     * the service fails closed without it.
+     */
+    billing?: TranscriptionBillingContext | undefined;
+    /**
+     * Internal: return `settleBilling` instead of settling before returning, so
+     * a resumable segment's transcript commits before any billing write.
+     */
+    deferBillingSettlement?: boolean;
+};
+/**
+ * Trusted, server-built settlement identity for one transcription unit. The
+ * usage receipt and debit idempotency keys derive from `workspaceId` +
+ * `sourceId` (see `voiceInputSettlementKeys`), so a retry or a later
+ * reconciliation settles the same unit exactly once.
+ */
+export type TranscriptionBillingContext = {
+    /**
+     * Server-derived unit identity. Never a client-chosen value: a reused id
+     * settles once, so a client-controlled id would make later calls free.
+     */
+    sourceId: string;
+    /** Trusted payer facts from the authenticated request boundary. */
+    attribution: CreditDebitAttribution;
+    /**
+     * Audio duration measured by the server from WAV bytes it produced (the
+     * resumable segment, or the normalized one-shot upload). Bills whenever the
+     * provider reports no usage this deployment has a price for.
+     */
+    trustedDurationSeconds?: number | undefined;
 };
 export type TranscriptionResult = TranscribeAudioResponse & {
     /** Server-private provider id for operational metrics only. Never returned to clients. */
     providerId: string;
     audioSeconds: number;
     latencyMs: number;
+    /** Opengeni credits charged for this call (0 for subscription/free providers). */
+    creditCostMicros?: number | undefined;
+    /**
+     * Server-only settlement callback; never serialized into a public response.
+     * Never rejects: a settlement failure after provider success is logged and
+     * retried, and the transcript is still delivered.
+     */
+    settleBilling?: () => Promise<void>;
+};
+export type TranscriptionBillingRefusalCode = "insufficient_credits" | "allowance_exhausted" | "monthly_model_cost_limit";
+/**
+ * Pre-use refusal for deployment-funded transcription: 402 for credits and
+ * allowances (same codes as session admission), 429 for a static monthly cap.
+ */
+export declare class TranscriptionBillingRefusedError extends Error {
+    readonly status: 402 | 429;
+    readonly code: TranscriptionBillingRefusalCode;
+    readonly details: {
+        scope?: string;
+        resetsAt?: string | null;
+        subjectId?: string;
+    };
+    constructor(input: {
+        code: TranscriptionBillingRefusalCode;
+        message: string;
+        details?: {
+            scope?: string;
+            resetsAt?: string | null;
+            subjectId?: string;
+        };
+    });
+}
+/**
+ * Credit admission and settlement for deployment-funded transcription.
+ * Subscription providers (Codex, SuperGrok) never reach this port.
+ */
+export type TranscriptionBilling = {
+    /** Refuse before any audio is sent when the payer cannot fund the call. */
+    admit(input: {
+        accountId: string;
+        workspaceId: string;
+        attribution: CreditDebitAttribution;
+    }): Promise<void>;
+    /**
+     * Record usage and debit credits once per unit, after use. The usage receipt
+     * commits before the debit, so a failed debit leaves a durable receipt that
+     * `admit` reconciles on the workspace's next voice request.
+     */
+    settle(input: {
+        accountId: string;
+        workspaceId: string;
+        providerId: string;
+        model: string;
+        pricing: VoiceInputPricing;
+        usage: VoiceInputUsage | null;
+        billing: TranscriptionBillingContext;
+    }): Promise<{
+        creditCostMicros: number;
+    }>;
 };
 export declare class TranscriptionServiceError extends Error {
-    readonly code: VoiceInputErrorCode;
+    readonly code: Exclude<VoiceInputErrorCode, TranscriptionBillingRefusalCode>;
     readonly status: number;
     readonly retryable: boolean;
     /** Explicit rejection before any transcription result; safe to try another provider. */
     readonly fallbackSafe: boolean;
     constructor(input: {
-        code: VoiceInputErrorCode;
+        code: Exclude<VoiceInputErrorCode, TranscriptionBillingRefusalCode>;
         message: string;
         status?: number;
         retryable?: boolean;
@@ -73,6 +166,15 @@ export type TranscriptionProvider = {
     /** The adapter guarantees that its upstream transport honors AbortSignal. */
     readonly supportsServerDeadline: true;
     readonly experimental?: boolean | undefined;
+    /**
+     * Present when the deployment pays the upstream provider (OpenAI/Azure):
+     * the call is admitted against and settled in Opengeni credits. Absent for
+     * the workspace's own subscriptions, which are never charged.
+     */
+    readonly deploymentFunded?: {
+        readonly model: string;
+        readonly pricing: VoiceInputPricing | null;
+    } | undefined;
     /**
      * Deployment readiness when called without a workspace. When `workspaceId` is
      * provided, providers may require a workspace-attached credential (e.g. Codex).
@@ -90,14 +192,27 @@ export type TranscriptionProvider = {
     }): Promise<{
         text: string;
         languages: string[];
+        usage?: VoiceInputUsage | null | undefined;
     }>;
 };
 export type TranscriptionService = {
     limits(): TranscriptionLimits;
     /** True when at least one ready provider can serve requests. */
     available(context?: TranscriptionAvailabilityContext): boolean | Promise<boolean>;
+    availableProviderIds?(context: TranscriptionAvailabilityContext): Promise<string[]>;
     /** Select one provider before a durable segment attempt; retries pin this id. */
     selectProvider?(context: TranscriptionAvailabilityContext): string | null | Promise<string | null>;
+    /**
+     * Credit admission for an exact provider before durable work is claimed.
+     * Resolves for subscription providers; throws TranscriptionBillingRefusedError
+     * when a deployment-funded provider cannot be paid for.
+     */
+    admit?(input: {
+        providerId: string;
+        accountId: string;
+        workspaceId: string;
+        attribution: CreditDebitAttribution;
+    }): Promise<void>;
     transcribe(request: TranscriptionRequest): Promise<TranscriptionResult>;
 };
 export type PreparedTranscriptionSegment = {
@@ -113,6 +228,8 @@ export type TranscriptionSegmenter = {
         sourceMimeType: string;
         totalDurationMilliseconds: number;
         providerSegmentSeconds: number;
+        /** Hard decode ceiling (`ffmpeg -t`); audio past it is never decoded. */
+        maxDecodeSeconds?: number | undefined;
         chunks: AsyncIterable<Uint8Array>;
         signal?: AbortSignal | undefined;
     }): AsyncIterable<PreparedTranscriptionSegment>;

package/dist/turn-surface.d.ts

@@ -0,0 +1,20 @@
+import type { AccessGrant, SessionTurnSurface } from "@opengeni/contracts";
+import type { AccessGrantAuthorization } from "./access/index.js";
+/**
+ * Resolve the content-free product surface a request entered through.
+ *
+ * The result is a label frozen on the accepted turn, mainly for analytics. It
+ * never grants access; the one place it affects authority is Site Data, where a
+ * `site` surface only narrows an agent to viewer reach
+ * (apps/api/src/site-data/service.ts). It reads trusted provenance only where
+ * it already exists: an explicit entry-point choice (Slack, automations, maintenance), the
+ * API-validated Site scope, and the access path the grant was resolved from.
+ * A grant whose path this function cannot place yields null rather than a
+ * guess.
+ */
+export declare function resolveTurnSurface(input: {
+    grant: AccessGrant;
+    authorization?: AccessGrantAuthorization | null | undefined;
+    /** An entry point that knows its surface (for example Slack) passes it here. */
+    requested?: SessionTurnSurface | null | undefined;
+}): SessionTurnSurface | null;

package/dist/user-presence.d.ts

@@ -0,0 +1,32 @@
+import { type Database } from "@opengeni/db";
+import type { Observability } from "@opengeni/observability";
+/**
+ * Throttled, batched server-side presence for managed humans.
+ *
+ * `touch` is called on the request path, so it only does an in-memory map
+ * check: each person is queued at most once per throttle window per process,
+ * and queued people are written in one batched database call after a short
+ * delay, never awaited by the request. API keys, services and embedded-host
+ * subjects are never passed here; anything outside the opaque `user:` shape is
+ * ignored. The database turns a new UTC day into the `user.active` lifecycle
+ * fact, and control workers read windowed counts for `opengeni_active_users`.
+ */
+export type UserPresenceRecorder = {
+    /** Note authenticated activity for one managed human. Never throws. */
+    touch(subjectId: string): void;
+    /** Write everything queued now. Resolves even when the write fails. */
+    flush(): Promise<void>;
+    /** Flush and stop scheduling further writes. */
+    close(): Promise<void>;
+};
+export declare const USER_PRESENCE_THROTTLE_MS = 60000;
+export declare const USER_PRESENCE_FLUSH_DELAY_MS = 5000;
+export declare function createUserPresenceRecorder(options: {
+    db: Database;
+    observability?: Pick<Observability, "incrementCounter" | "warn"> | undefined;
+    throttleMs?: number;
+    flushDelayMs?: number;
+    maxTracked?: number;
+    now?: () => number;
+    record?: (db: Database, subjectIds: readonly string[]) => Promise<number>;
+}): UserPresenceRecorder;

package/dist/workflow-wake-contract.d.ts

@@ -1,6 +1,18 @@
-/** One global Temporal Schedule owns bounded delivery of committed session wakes. */
+/**
+ * Legacy id of the Temporal Schedule that used to start the dispatcher every
+ * period whether or not anything was due. Current control workers delete it at
+ * startup; older releases recreate it, so a rollback keeps its repair cadence.
+ */
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID = "opengeni-session-workflow-wake-dispatcher";
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_TYPE = "sessionWorkflowWakeDispatcherWorkflow";
+/**
+ * The single dispatcher execution. Immediate triggers and the control
+ * worker's repair cadence signal-with-start this id, so a request that lands
+ * while a sweep is running buffers exactly one more sweep instead of starting
+ * a second execution.
+ */
+export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_WORKFLOW_ID = "opengeni-session-workflow-wake-dispatcher";
+export declare const SESSION_WORKFLOW_WAKE_DISPATCH_REQUESTED_SIGNAL = "dispatchRequested";
 export declare const SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS = 10000;
 /**
  * Temporal delivers activity cancellation through heartbeats. Keep both the

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@opengeni/core",
-  "version": "3.0.1",
-  "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
+  "version": "3.1.2",
+  "description": "Opengeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -18,10 +18,6 @@
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    "./remote-mcp-credentials": {
-      "types": "./dist/remote-mcp-credentials.d.ts",
-      "import": "./dist/remote-mcp-credentials.js"
-    },
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
@@ -41,10 +37,6 @@
     "./managed-auth-session-sets": {
       "types": "./dist/managed-auth-session-sets.d.ts",
       "import": "./dist/managed-auth-session-sets.js"
-    },
-    "./connection-authority": {
-      "types": "./dist/domain/connection-authority.d.ts",
-      "import": "./dist/domain/connection-authority.js"
     }
   },
   "publishConfig": {
@@ -53,22 +45,23 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "build": "bun ../../scripts/sync-product-integration-skill.ts --check && bun ../../scripts/build-typescript-package.ts",
+    "build": "bun ../../scripts/build-typescript-package.ts",
     "prepublishOnly": "bash ../../scripts/prepublish-guard"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/capabilities": "^0.3.4",
-    "@opengeni/codex": "^0.2.23",
-    "@opengeni/config": "^1.2.2",
-    "@opengeni/contracts": "^4.1.0",
-    "@opengeni/db": "^5.0.1",
-    "@opengeni/documents": "^0.8.30",
-    "@opengeni/events": "^0.4.28",
-    "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.29",
-    "@opengeni/runtime": "^3.0.1",
-    "@opengeni/storage": "^0.2.130",
+    "@opengeni/capabilities": "3.1.2",
+    "@opengeni/codex": "3.1.2",
+    "@opengeni/config": "3.1.2",
+    "@opengeni/contracts": "3.1.2",
+    "@opengeni/db": "3.1.2",
+    "@opengeni/documents": "3.1.2",
+    "@opengeni/events": "3.1.2",
+    "@opengeni/network": "3.1.2",
+    "@opengeni/observability": "3.1.2",
+    "@opengeni/runtime": "3.1.2",
+    "@opengeni/storage": "3.1.2",
+    "@opengeni/vaults": "3.1.2",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },