@opengeni/worker-bundle 2.2.0 → 2.2.1-canary.36927100590001

package/dist/activities/agent-run-admission.d.ts

@@ -1,6 +1,6 @@
 import { type Settings } from "@opengeni/config";
 import type { ControlActivityServices } from "./types.js";
-export type AgentRunAdmissionDenial = "insufficient_credits" | "monthly_model_cost_limit" | "monthly_agent_run_limit";
+export type AgentRunAdmissionDenial = "insufficient_credits" | "allowance_exhausted" | "monthly_model_cost_limit" | "monthly_agent_run_limit";
 /** One worker-side admission boundary for service-authored agent runs. */
 export declare function agentRunAdmissionDenial(services: Pick<ControlActivityServices, "db" | "entitlements"> & {
     settings: Settings;
@@ -9,4 +9,6 @@ export declare function agentRunAdmissionDenial(services: Pick<ControlActivitySe
     workspaceId: string;
     model: string;
     requestedAgentRuns: number;
+    /** The accepted work's causal human, not the scheduler/service caller. */
+    initiatingHumanSubjectId?: string | null;
 }): Promise<AgentRunAdmissionDenial | null>;

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

@@ -1,6 +1,6 @@
 import { resolveTurnExecutionPolicyV1, type Settings } from "@opengeni/config";
 import type { TurnActivityServices as ActivityServices } from "../types.js";
-import { type SessionEvent, type SessionTurn, type ToolAuthNeededPayload, type TurnExecutionPolicyV1, type XaiProviderAccountAuthoritySnapshotV1 } from "@opengeni/contracts";
+import { type AllowanceExhaustedRefusal, type SessionEvent, type SessionTurn, type ToolAuthNeededPayload, type TurnExecutionPolicyV1, type XaiProviderAccountAuthoritySnapshotV1 } from "@opengeni/contracts";
 export declare class WorkspaceHumanInputDisabledError extends Error {
     constructor(kind: "resume" | "interruption");
 }
@@ -62,6 +62,27 @@ export declare function stableInteractionInterventionUuid(namespace: string, ses
  */
 export declare class BudgetExhaustedError extends Error {
     readonly serializedRunState: string | null;
-    constructor(message: string, serializedRunState: string | null);
+    readonly allowance: AllowanceRefusal | null;
+    constructor(message: string, serializedRunState: string | null, allowance?: AllowanceRefusal | null);
 }
-export declare function ensureRunAllowed(settings: Settings, db: ActivityServices["db"], accountId: string, workspaceId: string, isExternallyBilledTurn: boolean, entitlements?: ActivityServices["entitlements"], chargesOpenGeniCredits?: boolean, countsTowardTokenCap?: boolean): Promise<void>;
+export type AllowanceRefusal = AllowanceExhaustedRefusal;
+/** Account allowance exhaustion is recoverable state, never a provider failure. */
+export declare class AllowanceExhaustedError extends Error {
+    readonly refusal: AllowanceRefusal;
+    readonly code = "allowance_exhausted";
+    constructor(refusal: AllowanceRefusal);
+}
+/** Revalidate between paid calls without replaying provider work or reserving credits. */
+export declare function ensureRunAllowedBetweenModelCalls(input: {
+    settings: Settings;
+    db: ActivityServices["db"];
+    accountId: string;
+    workspaceId: string;
+    isExternallyBilledTurn: boolean;
+    entitlements?: ActivityServices["entitlements"];
+    chargesOpenGeniCredits: boolean;
+    countsTowardTokenCap: boolean;
+    initiatingHumanSubjectId: string | null;
+    serializedRunState?: () => string | null;
+}): Promise<void>;
+export declare function ensureRunAllowed(settings: Settings, db: ActivityServices["db"], accountId: string, workspaceId: string, isExternallyBilledTurn: boolean, entitlements?: ActivityServices["entitlements"], chargesOpenGeniCredits?: boolean, countsTowardTokenCap?: boolean, initiatingHumanSubjectId?: string | null): Promise<void>;

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

@@ -43,6 +43,7 @@ export type BuildTurnAgentDeps = {
     supportsImageInput: GovernanceModelOk["supportsImageInput"];
     agentHumanInputEnabled: GovernanceModelOk["agentHumanInputEnabled"];
     workspaceAgentInstructions: GovernanceModelOk["workspaceAgentInstructions"];
+    workspaceAgentIdentity: GovernanceModelOk["workspaceAgentIdentity"];
     workspaceGovernance: GovernanceModelOk["workspaceGovernance"];
     structuredWorkspacePolicyActive: GovernanceModelOk["structuredWorkspacePolicyActive"];
     workspaceMemory: GovernanceModelOk["workspaceMemory"];

package/dist/activities/agent-turn/claude-usage-observer.d.ts

@@ -15,5 +15,17 @@ export declare function createClaudeUsageObserver(providers: ReturnType<typeof p
     token: string;
     connectionId: string;
     credentialVersion: number;
-} | null>): Promise<(providerId: string, response: Response) => void>;
+} | null>): Promise<((providerId: string, response: Response) => void) & {
+    binding(providerId: string): {
+        readonly scope: Scope;
+        readonly token: string;
+        readonly expectedConnectionId: string;
+        readonly expectedCredentialVersion: number;
+    } | undefined;
+    renew(providerId: string, credential: {
+        token: string;
+        connectionId: string;
+        credentialVersion: number;
+    }): void;
+}>;
 export {};

package/dist/activities/agent-turn/compaction-prep.d.ts

@@ -37,6 +37,7 @@ export type CompactionPrepDeps = {
     turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
     resolvedModel: GovernanceModelOk["resolvedModel"];
     workspaceAgentInstructions: GovernanceModelOk["workspaceAgentInstructions"];
+    workspaceAgentIdentity: GovernanceModelOk["workspaceAgentIdentity"];
     workspaceGovernance: GovernanceModelOk["workspaceGovernance"];
     structuredWorkspacePolicyActive: GovernanceModelOk["structuredWorkspacePolicyActive"];
     workspaceMemory: GovernanceModelOk["workspaceMemory"];
@@ -82,5 +83,24 @@ export type PostAgentCompactionOutcome = {
 } | {
     ok: PostAgentCompactionOk;
 };
+/**
+ * System instructions for the standalone (chat-provider) compaction request.
+ * A session with an agent configuration uses the same modular composer and
+ * module selection as its turns; a legacy session keeps the historical
+ * persona + CORE + governance + session + memory string byte-for-byte.
+ */
+export declare function standaloneCompactionInstructions(input: {
+    settings: Settings;
+    session: Pick<ClaimTurnOk["session"], "agent" | "instructions" | "resources">;
+    workspaceAgentInstructions: string | null | undefined;
+    workspaceAgentIdentity: string | null;
+    workspaceGovernance: string | null | undefined;
+    structuredWorkspacePolicyActive: boolean;
+    workspaceMemory: string | null | undefined;
+    rig: {
+        name: string;
+        version: number;
+    } | undefined;
+}): string;
 export declare function prepareCompaction(deps: CompactionPrepDeps): Promise<CompactionPrepOutcome>;
 export declare function runPostAgentCompaction(deps: PostAgentCompactionDeps): Promise<PostAgentCompactionOutcome>;

package/dist/activities/agent-turn/credential-restriction.d.ts

@@ -0,0 +1,3 @@
+import { type TurnExecutionPolicyV1 } from "@opengeni/contracts";
+/** Only accepted policies establish the ceiling; ordinary metadata is not authority. */
+export declare function turnCredentialRestriction(acceptedPolicy: TurnExecutionPolicyV1, initialSessionMetadata: unknown): "developer_setup" | undefined;

package/dist/activities/agent-turn/final-reply.d.ts

@@ -0,0 +1,18 @@
+/** One durable, same-logical-turn handoff, not a retry of model/tool effects. */
+export declare function finalReplyNudge(turnId: string): {
+    type: "message";
+    role: "developer";
+    content: {
+        type: "input_text";
+        text: string;
+    }[];
+};
+export declare function hasFinalReplyNudge(history: readonly unknown[], turnId: string): boolean;
+export declare function needsFinalReply(input: {
+    output: unknown;
+    inputWaitYielded: boolean;
+    interrupted: boolean;
+    maintenance: boolean;
+    toolsExecuted: boolean;
+    completedGoal: boolean;
+}): boolean;

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

@@ -40,6 +40,12 @@ export type GovernanceModelOk = {
     /** Deployment and workspace allow the Jev-backed code_search tool. */
     codeSearchEnabled: boolean;
     workspaceAgentInstructions: string | null | undefined;
+    /**
+     * Modular composer identity tier: the explicit workspace default identity,
+     * else the frozen legacy persona without `{{core}}`. Never dropped by
+     * instruction policies (only read for sessions with an agent configuration).
+     */
+    workspaceAgentIdentity: string | null;
     workspaceGovernance: ReturnType<typeof renderWorkspaceGovernanceContext>;
     structuredWorkspacePolicyActive: boolean;
     workspaceMemory: string | null | undefined;

package/dist/activities/agent-turn/model-call-admission.d.ts

@@ -0,0 +1,15 @@
+import type { StreamEvent } from "@openai/agents";
+/** SDK producer/consumer rendezvous. Usage stays on the sole consumer writer. */
+export declare function createModelCallAdmission(input: {
+    signal: AbortSignal;
+    admit: () => Promise<void>;
+}): {
+    beforeModelRequest: () => Promise<void>;
+    onModelResponse: (event: StreamEvent) => Promise<void>;
+    settle: (event: {
+        type: string;
+        data?: unknown;
+    }) => void;
+    fail: (error: unknown) => void;
+    close: () => void;
+};

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

@@ -2,6 +2,7 @@ import { type GitCredentialTokenWriterSession, type NormalizedRunCredentialMater
 import { type Settings } from "@opengeni/config";
 import { type GitHubTokenMintAuthorization, type MintedRunGitCredentials, type loadWorkspaceEnvironmentForRunWithCredentials } from "../environment.js";
 import type { mergeResourceRefs } from "../common.js";
+import type { withFirstPartyTools } from "../goals.js";
 import type { TurnActivityServices as ActivityServices, RunAgentTurnInput } from "../types.js";
 import { type ResumedTurnSandbox } from "../../sandbox-resume.js";
 import type { ClaimTurnOk } from "./claim.js";
@@ -10,6 +11,7 @@ import type { SandboxTurnRuntime } from "./sandbox-runtime.js";
 import type { AttemptIdentityState, EventingState, RenewalState, SandboxRuntimeState } from "./turn-context.js";
 export type PrepareRunCredentialsDeps = {
     localMcpServerIds?: readonly string[];
+    turnTools: ReturnType<typeof withFirstPartyTools>;
     input: RunAgentTurnInput;
     settings: Settings;
     db: ActivityServices["db"];
@@ -24,6 +26,7 @@ export type PrepareRunCredentialsDeps = {
     sandboxRuntime: SandboxTurnRuntime;
     turn: ClaimTurnOk["turn"];
     session: ClaimTurnOk["session"];
+    turnExecutionPolicy: ClaimTurnOk["turnExecutionPolicy"];
     fileAuthoritySubjectId: ClaimTurnOk["fileAuthoritySubjectId"];
     runSettings: GovernanceModelOk["runSettings"];
     workspaceVariableSet: Awaited<ReturnType<typeof loadWorkspaceEnvironmentForRunWithCredentials>>;
@@ -62,6 +65,7 @@ export declare function prepareRunCredentials(deps: PrepareRunCredentialsDeps):
         turnId: string;
         attemptId: string;
         executionGeneration: number;
+        credentialRestriction?: "developer_setup";
     };
     sandboxArtifactRuntime: Readonly<{
         available: boolean;

package/dist/activities/agent-turn/sandbox-establish.d.ts

@@ -35,6 +35,7 @@ export type SandboxRouteOk = {
     machinePrimary: boolean;
     groupBoxBackend: Settings["sandboxBackend"];
     groupBoxImage: ReturnType<typeof rigProviderImageSourceImage>;
+    groupBoxImagePolicy: "new_creates_only";
     sandboxCreationBackend: Settings["sandboxBackend"];
     effectiveRunCredentialBackend: Settings["sandboxBackend"];
 };

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

@@ -1,11 +1,12 @@
 import type { AttemptToolDefinition } from "@opengeni/codemode";
 import { type ModelCapabilitiesV1 } from "@opengeni/config";
 import type { GeneratedSessionTitle, GenerateSessionTitleOptions, OpenGeniRuntime } from "@opengeni/runtime";
-import { ReasoningEffort, type FirstPartyMcpToolName, type Permission, type ToolRef } from "@opengeni/contracts";
+import { ReasoningEffort, type FirstPartyMcpToolName, type Permission, type ResolvedAgentConfig, type ToolRef } from "@opengeni/contracts";
 export declare const SESSION_TITLE_MODEL_TOOL_NAME = "opengeni__set_session_title";
 export declare function shouldRequestMissingSessionTitle(input: {
     title: string | null;
     titleSource: "user" | "agent" | null;
+    agentConfig?: ResolvedAgentConfig | null;
     firstPartyMcpTools: readonly FirstPartyMcpToolName[];
     firstPartyMcpPermissions: readonly Permission[] | null;
 }): boolean;
@@ -20,6 +21,7 @@ export declare function shouldRequestMissingSessionTitle(input: {
 export declare function routeAllowsSessionTitleRequests(resolvedModel: ReturnType<OpenGeniRuntime["resolveTurnModel"]>): boolean;
 export declare function sessionTitleToolPlan(input: {
     tools: readonly ToolRef[];
+    agentConfig?: ResolvedAgentConfig | null;
     selectedFirstPartyMcpTools: readonly FirstPartyMcpToolName[];
     shouldRequestTitle: boolean;
     parallelGenerationAvailable: boolean;

package/dist/activities/agent-turn/stream-attempt.d.ts

@@ -81,6 +81,7 @@ export type TurnStreamAttemptDeps = {
     groupBoxBackend: Settings["sandboxBackend"];
     turnExecutionPolicy: TurnExecutionPolicyV1;
     turn: Pick<SessionTurn, "initiator" | "initiatorContext"> & {
+        initiatingHumanSubjectId: string | null;
         id: string;
         executionGeneration: number;
         model: string;

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

@@ -25,6 +25,7 @@ export type TurnSettleFn = (input: {
     sessionStatus: SessionStatus;
     activeTurnId: string | null;
     suppressGoalContinuation?: boolean;
+    allowanceGoalPause?: ApplySessionTurnSettlementInput["allowanceGoalPause"];
     consumeRequestedCompactionFailure?: boolean;
     runState?: ApplySessionTurnSettlementInput["runState"];
 }) => Promise<boolean>;

package/dist/activities/automations.d.ts

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

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

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

package/dist/activities/goals.d.ts

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

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

@@ -1,4 +1,4 @@
-import type { ConnectionCredentialsPort, CredentialAuthNeededPayload, SandboxBackend, RunCredentialsRequest, Session, SessionTurn } from "@opengeni/contracts";
+import type { ConnectionCredentialsPort, CredentialAuthNeededPayload, SandboxBackend, RunCredentialsRequest, Session, SessionTurn, ToolRef } from "@opengeni/contracts";
 import type { Settings } from "@opengeni/config";
 import { type Database } from "@opengeni/db";
 import { type NormalizedRunCredentialMaterial } from "@opengeni/runtime";
@@ -22,6 +22,8 @@ export type RunCredentialResolutionContext = {
     initiatingHumanSubjectId?: string | null;
     /** Installed in-process API routes must never enter a product callback. */
     localMcpServerIds?: readonly string[];
+    /** Exact execution selection, resolved once at the turn policy boundary. */
+    effectiveTools: readonly ToolRef[];
 };
 export type BoundRunCredentialResolver = {
     resolve(input: {
@@ -29,7 +31,7 @@ export type BoundRunCredentialResolver = {
         forceRefresh: boolean;
     }): Promise<NormalizedRunCredentialMaterial | null>;
 };
-export declare function buildRunCredentialsRequest(input: Omit<RunCredentialResolutionContext, "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId"> & {
+export declare function buildRunCredentialsRequest(input: Omit<RunCredentialResolutionContext, "db" | "connectionCredentials" | "settings" | "initiatingHumanSubjectId" | "effectiveTools"> & {
     rootSessionId: string;
     purpose: "provision" | "renewal";
     forceRefresh: boolean;

package/dist/activities/scheduled-tasks.d.ts

@@ -1,3 +1,4 @@
+import { TurnExecutionPolicyV1 } from "@opengeni/contracts";
 import { updateSessionTitleWithEvent } from "@opengeni/db";
 import type { ControlActivityServices, DispatchScheduledTaskRunInput, DispatchScheduledTaskRunResult } from "./types.js";
 import type { Database } from "@opengeni/db";
@@ -9,43 +10,11 @@ type ScheduledTemporalActivityIdentity = {
     };
     activityId: string;
 };
+export declare function scheduledTaskRunExecutionPolicy(policy: TurnExecutionPolicyV1, input: DispatchScheduledTaskRunInput, creatorRestriction?: "developer_setup"): TurnExecutionPolicyV1;
+/** Only a creator ceiling is standing; a manual caller ceiling is per-run. */
+export declare function scheduledSessionExecutionPolicyMetadata(policy: unknown, creatorRestriction?: "developer_setup"): Record<string, unknown>;
 export declare function scheduledTaskRunProducerKey(input: DispatchScheduledTaskRunInput, suppliedActivityIdentity?: ScheduledTemporalActivityIdentity): string;
 export declare function scheduledTaskGeneratedSessionCreateIdempotencyKey(producerKey: string): string;
-/**
- * Display title for a session the scheduler generates for a task.
- *
- * A scheduled session's `initialMessage` is the task prompt, byte-identical for
- * every run. The task name is the short human-chosen label that actually
- * identifies it, so that is the title.
- *
- * The title is the task name and NOTHING else. It deliberately does not name the
- * run's fire instant, for two independent reasons:
- *
- *   - No run mode guarantees one run per session. `reusable_session` generates
- *     its session on the first fire and then reuses it forever, and even under
- *     `new_session_per_run` alert-occurrence redelivery converges several runs
- *     onto one canonical responder session. `existing_session` never generates a
- *     session at all, so the scheduler never titles one. A run-specific fact
- *     frozen into the title is therefore right for the generating run and a lie
- *     for every run that lands in the same session afterwards.
- *   - A title is one stored string shown to every viewer, while every surface
- *     that renders a run's fire instant renders it viewer-local: the rail row
- *     prints the title beside `relativeTimeLabel(session.updatedAt)`, and the
- *     Schedules run list prints `formatTimestamp(run.firedAt)`, which is
- *     `toLocaleString()`. A wall clock stored in the title therefore disagrees
- *     with the time printed next to it for every viewer outside whichever zone
- *     it was rendered in. The task's own `timeZone` is no escape: it labels the
- *     schedule rule ("Mon Wed 09:00 Europe/Oslo"), not the rendering of a run,
- *     which stays viewer-local. No stored clock can agree with a viewer-local
- *     one, so the title carries none and the instant stays on the surfaces that
- *     already render it correctly.
- *
- * Dropping the clock settles the determinism constraint outright rather than
- * working around it: the same run titled by the normal dispatch or by a later
- * recovery in a different worker process derives one string from `task.name`
- * alone, with no Intl call and so no host ICU or tzdata build to make the two
- * texts differ.
- */
 export declare function scheduledTaskSessionTitle(taskName: string): string;
 /**
  * Title a session the scheduler generated, and emit the same `session.title_set`

package/dist/activities/types.d.ts

@@ -343,11 +343,14 @@ export type DispatchScheduledTaskRunInput = {
     triggerType: Extract<ScheduledTaskTriggerType, "scheduled">;
     agentRunUsageIdempotencyKey?: never;
     initiator?: never;
+    credentialRestriction?: never;
 } | {
     triggerType: Extract<ScheduledTaskTriggerType, "manual" | "initial" | "provider_event" | "retry" | "repair">;
     agentRunUsageIdempotencyKey: string;
     /** Exact identity used by the API-side charge for this same trigger. */
     initiator: TurnInitiator;
+    /** Trusted API-side caller ceiling for this occurrence, not the schedule. */
+    credentialRestriction?: "developer_setup";
 });
 export type DispatchScheduledTaskRunResult = {
     action: "deleted";
@@ -357,7 +360,7 @@ export type DispatchScheduledTaskRunResult = {
     diagnostic?: import("@opengeni/contracts").ConnectionAccountSelectionDiagnostic;
     /** Present when the occurrence was refused as a visible run receipt. */
     refusal?: import("@opengeni/contracts").ScheduledTaskAdmissionRefusal;
-    reason: "insufficient_credits" | "monthly_model_cost_limit" | "monthly_agent_run_limit" | "malformed_manual_trigger" | "scheduled_task_paused" | "scheduled_authority_exhausted" | "scheduled_run_terminal" | "scheduled_execution_unrepresentable" | "connection_account_unavailable" | "scheduled_authority_unavailable" | "machine_target_unavailable" | "machine_enrollment_inactive" | "variable_set_unavailable" | "rig_version_unavailable" | "knowledge_source_paused" | "legacy_source_schedule_requires_migration" | "incident_preflight_metadata_missing" | "incident_responder_under_capable" | "incident_data_source_unsuitable";
+    reason: "insufficient_credits" | "allowance_exhausted" | "monthly_model_cost_limit" | "monthly_agent_run_limit" | "malformed_manual_trigger" | "scheduled_task_paused" | "scheduled_authority_exhausted" | "scheduled_run_terminal" | "scheduled_execution_unrepresentable" | "connection_account_unavailable" | "scheduled_authority_unavailable" | "machine_target_unavailable" | "machine_enrollment_inactive" | "variable_set_unavailable" | "rig_version_unavailable" | "knowledge_source_paused" | "legacy_source_schedule_requires_migration" | "incident_preflight_metadata_missing" | "incident_responder_under_capable" | "incident_data_source_unsuitable";
 } | {
     action: "start" | "signal";
     accountId: string;

package/dist/activities/workspace-capture.d.ts

@@ -108,6 +108,8 @@ export declare function captureWhileIdle(input: {
  * to release() regardless.
  */
 export declare function captureWorkspaceRevision(input: CaptureWorkspaceRevisionInput): Promise<void>;
+/** Count one committed logical capture and observe its end-to-end duration. */
+export declare function recordWorkspaceCaptureCompleted(observability: Pick<Observability, "incrementCounter" | "observeHistogram">, durationMs: number): void;
 /**
  * sha256 over the CHANGE SURFACE only — per-file (path, status, hash, deleted,
  * tooLarge), exact HEAD identity, the working diff summary, and exact committed