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

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

@@ -0,0 +1,9 @@
+import type { BrowserDeadlineCheckpointTarget } from "@opengeni/db";
+export declare function browserDeadlineCheckpointWorkflow(target: BrowserDeadlineCheckpointTarget): Promise<{
+    status: "skipped";
+} | {
+    status: "suspended";
+}>;
+/** Runs from the existing lease-sweep dispatch. Inventory never performs provider
+ * I/O; each exact browser has an independent durable capture/cleanup child. */
+export declare function browserDeadlineCheckpointSweepWorkflow(): Promise<void>;

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

@@ -1,4 +1,5 @@
 import type { TurnInitiator } from "@opengeni/contracts";
+import type { DispatchScheduledTaskRunInput } from "../activities/types.js";
 type ScheduledTaskFireWorkflowBase = {
     accountId: string;
     workspaceId: string;
@@ -8,10 +9,13 @@ export type ScheduledTaskFireWorkflowInput = ScheduledTaskFireWorkflowBase & ({
     triggerType: "scheduled";
     agentRunUsageIdempotencyKey?: never;
     initiator?: never;
+    credentialRestriction?: never;
 } | {
     triggerType: "manual" | "initial" | "provider_event" | "retry" | "repair";
     agentRunUsageIdempotencyKey: string;
     initiator: TurnInitiator;
+    credentialRestriction?: "developer_setup";
 });
+export declare function scheduledTaskDispatchInput(input: ScheduledTaskFireWorkflowInput, producerKey: string): DispatchScheduledTaskRunInput;
 export declare function scheduledTaskFireWorkflow(input: ScheduledTaskFireWorkflowInput): Promise<void>;
 export {};

package/dist/workflows.d.ts

@@ -6,6 +6,7 @@ export { automationRunWorkflow, type AutomationRunWorkflowInput } from "./workfl
 export { knowledgeSourceSyncWake, knowledgeSourceSyncWorkflow, knowledgeSourceSyncWorkflowId, type KnowledgeSourceSyncWorkflowInput, } from "./workflows/knowledge-source-sync.js";
 export { sandboxDrainWorkflow, sandboxReaperMaintenanceWorkflow, sandboxReaperWorkflow, sandboxReaperWorkflowV2, } from "./workflows/sandbox-reaper.js";
 export { fileUploadReaperWorkflow } from "./workflows/file-upload-reaper.js";
+export { browserDeadlineCheckpointWorkflow, browserDeadlineCheckpointSweepWorkflow, } from "./workflows/browser-deadline-checkpoint.js";
 export { siteAuthMaintenanceWorkflow } from "./workflows/site-auth-maintenance.js";
 export { videoGenerationWorkflow, videoGenerationWorkflowId, type VideoGenerationWorkflowInput, } from "./workflows/video-generation.js";
 export { sessionWorkflowWakeDispatcherWorkflow } from "./workflows/workflow-wake.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/worker-bundle",
-  "version": "2.2.0",
+  "version": "2.2.1-canary.36927100590001",
   "description": "OpenGeni worker entry and reusable embedded lifecycle, shipped with a release-coherent pre-bundled Temporal workflow artifact.",
   "license": "Apache-2.0",
   "repository": {
@@ -54,25 +54,26 @@
   },
   "dependencies": {
     "@llamaindex/liteparse": "2.14.2",
-    "@opengeni/agent-proto": "^0.6.0",
-    "@opengeni/capabilities": "^0.3.4",
-    "@opengeni/codemode": "^0.6.5",
-    "@opengeni/codex": "^0.2.29",
-    "@opengeni/config": "^3.1.1",
-    "@opengeni/contracts": "^5.4.0",
-    "@opengeni/core": "^5.0.0",
-    "@opengeni/db": "^6.2.0",
-    "@opengeni/documents": "^0.8.37",
-    "@opengeni/events": "^0.4.35",
-    "@opengeni/github": "^0.8.0",
-    "@opengeni/jev": "^0.2.0",
-    "@opengeni/network": "^0.3.1",
-    "@opengeni/observability": "^0.8.35",
-    "@opengeni/runtime": "^4.3.0",
-    "@opengeni/sdk": "^7.4.0",
-    "@opengeni/storage": "^0.2.136",
-    "@opengeni/tool-gateway": "^0.1.16",
-    "@opengeni/xai-subscription": "^0.1.4",
+    "@opengeni/agent-proto": "^0.6.1-canary.36927100590001",
+    "@opengeni/capabilities": "^0.3.5-canary.36927100590001",
+    "@opengeni/codemode": "^0.6.6-canary.36927100590001",
+    "@opengeni/codex": "^0.2.30-canary.36927100590001",
+    "@opengeni/config": "^3.2.0-canary.36927100590001",
+    "@opengeni/contracts": "^5.5.0-canary.36927100590001",
+    "@opengeni/core": "^5.0.1-canary.36927100590001",
+    "@opengeni/db": "^6.3.0-canary.36927100590001",
+    "@opengeni/documents": "^0.8.38-canary.36927100590001",
+    "@opengeni/events": "^0.4.36-canary.36927100590001",
+    "@opengeni/github": "^0.8.1-canary.36927100590001",
+    "@opengeni/interaction": "^0.4.44-canary.36927100590001",
+    "@opengeni/jev": "^0.2.1-canary.36927100590001",
+    "@opengeni/network": "^0.3.1-canary.36927100590001",
+    "@opengeni/observability": "^0.8.36-canary.36927100590001",
+    "@opengeni/runtime": "^4.4.0-canary.36927100590001",
+    "@opengeni/sdk": "^7.5.0-canary.36927100590001",
+    "@opengeni/storage": "^0.2.137-canary.36927100590001",
+    "@opengeni/tool-gateway": "^0.1.17-canary.36927100590001",
+    "@opengeni/xai-subscription": "^0.1.5-canary.36927100590001",
     "@temporalio/activity": "^1.17.0",
     "@temporalio/client": "^1.17.0",
     "@temporalio/worker": "^1.17.0",

package/src/activities/agent-run-admission.ts

@@ -1,10 +1,16 @@
 import { configuredStaticUsageLimits, type Settings } from "@opengeni/config";
 import { modelFundingForAdmission } from "@opengeni/core";
-import { getBillingBalance, isCodexBilledTurn, sumUsageQuantity } from "@opengeni/db";
+import {
+  checkWorkspaceAllowance,
+  getBillingBalance,
+  isCodexBilledTurn,
+  sumUsageQuantity,
+} from "@opengeni/db";
 import type { ControlActivityServices } from "./types";
 
 export type AgentRunAdmissionDenial =
   | "insufficient_credits"
+  | "allowance_exhausted"
   | "monthly_model_cost_limit"
   | "monthly_agent_run_limit";
 
@@ -16,6 +22,8 @@ export async function agentRunAdmissionDenial(
     workspaceId: string;
     model: string;
     requestedAgentRuns: number;
+    /** The accepted work's causal human, not the scheduler/service caller. */
+    initiatingHumanSubjectId?: string | null;
   },
 ): Promise<AgentRunAdmissionDenial | null> {
   const codexBilled = await isCodexBilledTurn({
@@ -46,6 +54,14 @@ export async function agentRunAdmissionDenial(
       if (balance.balanceMicros <= 0) return "insufficient_credits";
     }
   }
+  if (!externallyBilled) {
+    const refusal = await checkWorkspaceAllowance(services.db, {
+      accountId: input.accountId,
+      workspaceId: input.workspaceId,
+      subjectId: input.initiatingHumanSubjectId ?? null,
+    });
+    if (refusal) return refusal.code;
+  }
   if (
     services.settings.usageLimitsMode !== "static" &&
     services.settings.usageLimitsMode !== "managed"

package/src/activities/agent-turn/admission.ts

@@ -1,4 +1,4 @@
-import { getBillingBalance, sumUsageQuantity } from "@opengeni/db";
+import { checkWorkspaceAllowance, getBillingBalance, sumUsageQuantity } from "@opengeni/db";
 import {
   configuredStaticUsageLimits,
   resolveTurnExecutionPolicyV1,
@@ -8,6 +8,7 @@ import { selectCodexCredentialId } from "@opengeni/codex";
 import { directPersonalConnectionSubjectId } from "@opengeni/core";
 import type { TurnActivityServices as ActivityServices } from "../types";
 import {
+  type AllowanceExhaustedRefusal,
   type SessionEvent,
   type SessionTurn,
   type ToolAuthNeededPayload,
@@ -243,12 +244,65 @@ export class BudgetExhaustedError extends Error {
   constructor(
     message: string,
     readonly serializedRunState: string | null,
+    readonly allowance: AllowanceRefusal | null = null,
   ) {
     super(message);
     this.name = "BudgetExhaustedError";
   }
 }
 
+export type AllowanceRefusal = AllowanceExhaustedRefusal;
+
+/** Account allowance exhaustion is recoverable state, never a provider failure. */
+export class AllowanceExhaustedError extends Error {
+  readonly code = "allowance_exhausted";
+
+  constructor(readonly refusal: AllowanceRefusal) {
+    super(refusal.message);
+    this.name = "AllowanceExhaustedError";
+  }
+}
+
+/** Revalidate between paid calls without replaying provider work or reserving credits. */
+export async 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> {
+  try {
+    await ensureRunAllowed(
+      input.settings,
+      input.db,
+      input.accountId,
+      input.workspaceId,
+      input.isExternallyBilledTurn,
+      input.entitlements,
+      input.chargesOpenGeniCredits,
+      input.countsTowardTokenCap,
+      input.initiatingHumanSubjectId,
+    );
+  } catch (limitError) {
+    let serializedRunState: string | null = null;
+    try {
+      serializedRunState = input.serializedRunState?.() ?? null;
+    } catch {
+      // Durable history remains authoritative when the SDK state cannot serialize.
+    }
+    throw new BudgetExhaustedError(
+      limitError instanceof Error ? limitError.message : String(limitError),
+      serializedRunState,
+      limitError instanceof AllowanceExhaustedError ? limitError.refusal : null,
+    );
+  }
+}
+
 // Exported for unit testing the external-billing bypass (codex-billing.test.ts); not
 // part of the activity surface. Takes the accepted policy's billing attribution and
 // the optional §7.5 P3 host `entitlements` port (when bound, its `admitRun` REPLACES
@@ -262,6 +316,7 @@ export async function ensureRunAllowed(
   entitlements?: ActivityServices["entitlements"],
   chargesOpenGeniCredits = !isExternallyBilledTurn,
   countsTowardTokenCap = !isExternallyBilledTurn,
+  initiatingHumanSubjectId: string | null = null,
 ): Promise<void> {
   // Upstream settlement and workspace-facing cost are independent. External
   // metering skips the token cap; free/subscription/workspace cost skips the
@@ -302,6 +357,14 @@ export async function ensureRunAllowed(
       throw new Error("insufficient OpenGeni credits");
     }
   }
+  if (chargesOpenGeniCredits) {
+    const refusal = await checkWorkspaceAllowance(db, {
+      accountId,
+      workspaceId,
+      subjectId: initiatingHumanSubjectId,
+    });
+    if (refusal) throw new AllowanceExhaustedError(refusal);
+  }
   if (settings.usageLimitsMode === "static" || settings.usageLimitsMode === "managed") {
     const limits = configuredStaticUsageLimits(settings);
     if (limits.maxMonthlyAgentRunsPerWorkspace) {

package/src/activities/agent-turn/agent-build.ts

@@ -10,6 +10,7 @@ import {
   getSessionTurnForAttempt,
   ensureSessionReasoningConfiguration,
   ensureSessionSkillCatalog,
+  sessionHasToolRouterHistory,
 } from "@opengeni/db";
 import { recoveryAwareSessionInstructions } from "./recovery-warning";
 import {
@@ -52,7 +53,7 @@ import {
 } from "../image-generation-references";
 import { SandboxChannelAService } from "@opengeni/runtime/sandbox";
 import { sandboxRunAs } from "@opengeni/runtime";
-import { VideoGenerationRejectedResult } from "@opengeni/contracts";
+import { VideoGenerationRejectedResult, resolveAgentToolFamilies } from "@opengeni/contracts";
 
 import {
   structuredToolTransportForTurn,
@@ -111,6 +112,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"];
@@ -173,6 +175,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
     supportsImageInput,
     agentHumanInputEnabled,
     workspaceAgentInstructions,
+    workspaceAgentIdentity,
     workspaceGovernance,
     structuredWorkspacePolicyActive,
     workspaceMemory,
@@ -284,7 +287,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
     // Never expose a paid image operation unless its permanent artifact can
     // be committed. Failing after provider execution would leave an
     // unrecoverable outcome-unknown operation with no user-visible image.
-    if (!objectStorage) return {};
+    if (!objectStorage || !resolveAgentToolFamilies(session.agent).media) return {};
     if (nativeImageProviderBinding) {
       media.nativeImageGenerationRetention = {
         ...nativeImageProviderBinding,
@@ -405,7 +408,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
     videoGenerationPolicy.defaultModelId !== null &&
     videoGenerationPolicy.enabledModelIds.length > 0;
   let videoGenerationCredential: VideoGenerationCredentialLease | null = null;
-  if (objectStorage && videoGenerationEnabled) {
+  if (objectStorage && videoGenerationEnabled && resolveAgentToolFamilies(session.agent).media) {
     if (videoGenerationPolicy.fundingSource === "opengeni_credits") {
       videoGenerationCredential = managedVideoGenerationCredentialLease(eventing.modelRunSettings);
     } else if (videoGenerationPolicy.fundingSource === "workspace_gateway") {
@@ -626,6 +629,13 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
           effort: turn.reasoningEffort,
         })
       : turn.reasoningEffort;
+  const toolRouterInHistory = session.agent
+    ? await sessionHasToolRouterHistory(db, {
+        accountId: input.accountId,
+        workspaceId: input.workspaceId,
+        sessionId: input.sessionId,
+      })
+    : false;
   const agent = (() => {
     const agentConstructionStartedAt = performance.now();
     let agentConstructionOutcome: "completed" | "failed" = "completed";
@@ -652,6 +662,7 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
             }
           : {}),
         ...(preparedTools.inputWaitYield ? { inputWaitYield: preparedTools.inputWaitYield } : {}),
+        ...(session.agent ? { agentConfig: session.agent, toolRouterInHistory } : {}),
         reasoningEffort: requestReasoningEffort,
         latencyMode: turnExecutionPolicy.latencyMode,
         ...(serviceTier ? { serviceTier } : {}),
@@ -757,6 +768,16 @@ export async function buildTurnAgent(deps: BuildTurnAgentDeps) {
         onRetainableSessionImageOutput: media.retainSessionImageAtToolBoundary,
         skillCatalog: deps.skillCatalog,
         skillCatalogInHistory: true,
+        // A session with an agent configuration composes the modular prompt
+        // (identity, base behavior, runtime mechanics, capability modules);
+        // its workspace identity survives instruction policies. Null keeps
+        // the legacy composition below byte-for-byte.
+        ...(session.agent
+          ? {
+              agentConfig: session.agent,
+              ...(workspaceAgentIdentity ? { workspaceAgentIdentity } : {}),
+            }
+          : {}),
         ...(!structuredWorkspacePolicyActive && workspaceAgentInstructions
           ? { instructionsTemplate: workspaceAgentInstructions }
           : {}),

package/src/activities/agent-turn/claim.ts

@@ -56,12 +56,15 @@ import {
 import { createTurnCredentialLeases } from "./credential-leases";
 import { createTurnMediaArtifacts } from "./media-artifacts";
 import { readTurnExecutionPolicyV1 } from "@opengeni/contracts";
+import { turnCredentialRestriction } from "./credential-restriction";
 
 import {
   credentialSubjectIdForTurnInitiator,
   turnExecutionPolicyBillingIdentity,
   legacyTurnExecutionPolicyInput,
   ensureRunAllowed,
+  AllowanceExhaustedError,
+  type AllowanceRefusal,
 } from "./admission";
 import { providerRecoveryCountFromMetadata, isWorkerShutdownCancellation } from "./errors";
 import { throwIfTurnOperationCancelled, waitForTurnOperation } from "./sandbox-provision";
@@ -288,10 +291,21 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   const codexAppsCredentialId = capabilitySettings.codexConnectedAppsEnabled
     ? await resolveCodexAppsCredentialIdForRun(db, input.workspaceId)
     : null;
-  const policyForAbsent =
+  const candidatePolicy =
     claimedPolicy.kind === "valid"
       ? claimedPolicy.policy
       : resolveTurnExecutionPolicyV1(capabilitySettings, legacyTurnExecutionPolicyInput(turn));
+  // This context is frozen by the accepted-turn writer from the exact source
+  // turn. Its reserved restriction field cannot come from public service JSON.
+  const credentialRestriction =
+    claimedPolicy.kind === "absent"
+      ? turn.initiatorContext?.credentialRestriction === "developer_setup"
+        ? "developer_setup"
+        : turnCredentialRestriction(candidatePolicy, session.metadata)
+      : undefined;
+  const policyForAbsent = credentialRestriction
+    ? { ...candidatePolicy, credentialRestriction }
+    : candidatePolicy;
   const installedPolicy = await installOrReadTurnExecutionPolicyForAttempt(db, {
     accountId: input.accountId,
     workspaceId: input.workspaceId,
@@ -368,20 +382,27 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
   // bypass OpenGeni credit/token gates)
   // AND the optional host `entitlements` port (when bound, its admitRun replaces
   // the local credit read). Unset port → today's local-ledger path.
-  await waitForTurnOperation(
-    ensureRunAllowed(
-      capabilitySettings,
-      db,
-      input.accountId,
-      input.workspaceId,
-      billingState.isExternallyBilledTurn,
-      entitlements,
-      billingState.chargesOpenGeniCredits,
-      billingState.countsTowardTokenCap,
-    ),
-    cancellationSignal,
-    undefined,
-  );
+  let allowanceRefusal: AllowanceRefusal | null = null;
+  try {
+    await waitForTurnOperation(
+      ensureRunAllowed(
+        capabilitySettings,
+        db,
+        input.accountId,
+        input.workspaceId,
+        billingState.isExternallyBilledTurn,
+        entitlements,
+        billingState.chargesOpenGeniCredits,
+        billingState.countsTowardTokenCap,
+        turn.initiatingHumanSubjectId,
+      ),
+      cancellationSignal,
+      undefined,
+    );
+  } catch (error) {
+    if (!(error instanceof AllowanceExhaustedError)) throw error;
+    allowanceRefusal = error.refusal;
+  }
   // Setup (variableSet load, MCP connects, sandbox restore) does not
   // stream and so never observes cancellation on its own; these explicit
   // checks let a graceful shutdown checkpoint the turn before the worker is
@@ -514,6 +535,9 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
       ...(inputSettlement.suppressGoalContinuation !== undefined
         ? { suppressGoalContinuation: inputSettlement.suppressGoalContinuation }
         : {}),
+      ...(inputSettlement.allowanceGoalPause
+        ? { allowanceGoalPause: inputSettlement.allowanceGoalPause }
+        : {}),
       events: inputs,
       ...(runState ? { runState } : {}),
       ...(compactionRequestFailure ? { compactionRequestFailure } : {}),
@@ -575,6 +599,36 @@ export async function claimTurnAttempt(deps: ClaimTurnDeps): Promise<ClaimTurnOu
     durationSeconds: (performance.now() - activityStarted) / 1_000,
   });
   const turnStartSettlementStartedAt = performance.now();
+  if (allowanceRefusal) {
+    // Claim has frozen the exact human, but no provider or sandbox has started.
+    // Use the same terminal valve as a post-response stop, retaining a usable
+    // session and a visible typed refusal instead of manufacturing a failure.
+    if (
+      !(await eventing.settle({
+        events: [
+          { type: "usage.exhausted", payload: allowanceRefusal },
+          {
+            type: "turn.completed",
+            payload: {
+              output: "",
+              segmentLimit: "budget_exhausted",
+              ...allowanceRefusal,
+            },
+          },
+          { type: "session.status.changed", payload: { status: "idle" } },
+        ],
+        turnStatus: "completed",
+        sessionStatus: "idle",
+        activeTurnId: null,
+        allowanceGoalPause: { rationale: allowanceRefusal.message },
+      }))
+    ) {
+      return { exit: claimedResult({ status: "cancelled" }) };
+    }
+    control.turnMetricOutcome = "completed";
+    control.activityStatus = "idle";
+    return { exit: claimedResult({ status: "idle" }) };
+  }
   if (
     !(await eventing.settle({
       events: [

package/src/activities/agent-turn/claude-usage-observer.ts

@@ -35,6 +35,17 @@ export async function createClaudeUsageObserver(
       .map(async (provider) => {
         const scope: Scope =
           provider.kind === "claude-subscription-workspace" ? "workspace" : "organization";
+        const binding = provider.anthropic?.credentialBinding;
+        if (binding && provider.apiKey)
+          return [
+            provider.id,
+            {
+              scope,
+              token: provider.apiKey,
+              expectedConnectionId: binding.connectionId,
+              expectedCredentialVersion: binding.credentialVersion,
+            },
+          ] as const;
         const credential = await readCredential(scope).catch(() => null);
         if (!credential || credential.token !== provider.apiKey) return null;
         return [
@@ -49,7 +60,7 @@ export async function createClaudeUsageObserver(
       }),
   );
   const captured = new Map(bindings.filter((binding) => binding !== null));
-  return (providerId: string, response: Response) => {
+  const observe = (providerId: string, response: Response) => {
     const binding = captured.get(providerId);
     if (!binding) return;
     const { scope, ...identity } = binding;
@@ -76,4 +87,25 @@ export async function createClaudeUsageObserver(
           : {}),
       });
   };
+  return Object.assign(observe, {
+    binding(providerId: string) {
+      return captured.get(providerId);
+    },
+    renew(
+      providerId: string,
+      credential: {
+        token: string;
+        connectionId: string;
+        credentialVersion: number;
+      },
+    ) {
+      const binding = captured.get(providerId);
+      if (
+        binding &&
+        binding.expectedConnectionId === credential.connectionId &&
+        binding.expectedCredentialVersion === credential.credentialVersion
+      )
+        captured.set(providerId, { ...binding, token: credential.token });
+    },
+  });
 }

package/src/activities/agent-turn/compaction-prep.ts

@@ -4,7 +4,9 @@ import {
   appendSessionInstructions,
   appendWorkspaceGovernance,
   appendWorkspaceMemory,
+  agentPromptResourcesFor,
   composeAgentInstructions,
+  inspectPersistentAgentInstructions,
   requestRemoteCompactionV2,
   preparedCompactionRequest,
   queuePreparedCompaction,
@@ -86,6 +88,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"];
@@ -131,6 +134,59 @@ export type PostAgentCompactionOutcome =
   | { exit: RunAgentTurnResult }
   | { 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 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 {
+  if (input.session.agent) {
+    return inspectPersistentAgentInstructions(input.settings, {
+      agentConfig: input.session.agent,
+      ...(input.workspaceAgentIdentity
+        ? { workspaceAgentIdentity: input.workspaceAgentIdentity }
+        : {}),
+      ...(input.workspaceGovernance ? { workspaceGovernance: input.workspaceGovernance } : {}),
+      ...(input.workspaceMemory ? { workspaceMemory: input.workspaceMemory } : {}),
+      ...(input.session.instructions ? { sessionInstructions: input.session.instructions } : {}),
+      ...(input.rig ? { rig: input.rig } : {}),
+      // Session-level facts only: per-turn attachments do not apply to a
+      // standalone compaction request.
+      agentPromptResources: agentPromptResourcesFor(
+        input.settings,
+        input.session.resources.filter((resource) => resource.kind !== "file"),
+        input.rig ? { rig: input.rig } : {},
+      ),
+    }).composed;
+  }
+  return appendWorkspaceMemory(
+    appendSessionInstructions(
+      appendWorkspaceGovernance(
+        composeAgentInstructions(
+          input.structuredWorkspacePolicyActive
+            ? input.settings.agentInstructionsTemplate
+            : (input.workspaceAgentInstructions ?? input.settings.agentInstructionsTemplate),
+          undefined,
+          input.rig,
+        ),
+        input.workspaceGovernance ?? undefined,
+      ),
+      input.session.instructions ?? undefined,
+    ),
+    input.workspaceMemory ?? undefined,
+  );
+}
+
 export async function prepareCompaction(deps: CompactionPrepDeps): Promise<CompactionPrepOutcome> {
   const {
     input,
@@ -155,6 +211,7 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     turnExecutionPolicy,
     resolvedModel,
     workspaceAgentInstructions,
+    workspaceAgentIdentity,
     workspaceGovernance,
     structuredWorkspacePolicyActive,
     workspaceMemory,
@@ -334,22 +391,16 @@ export async function prepareCompaction(deps: CompactionPrepDeps): Promise<Compa
     !remoteV2CompactionNeedsAgentPrefix &&
     !portableResponsesNeedsAgentPrefix
   ) {
-    const compactionInstructions = appendWorkspaceMemory(
-      appendSessionInstructions(
-        appendWorkspaceGovernance(
-          composeAgentInstructions(
-            structuredWorkspacePolicyActive
-              ? eventing.modelRunSettings.agentInstructionsTemplate
-              : (workspaceAgentInstructions ?? eventing.modelRunSettings.agentInstructionsTemplate),
-            undefined,
-            rigVersion && rigName ? { name: rigName, version: rigVersion.version } : undefined,
-          ),
-          workspaceGovernance ?? undefined,
-        ),
-        session.instructions ?? undefined,
-      ),
-      workspaceMemory ?? undefined,
-    );
+    const compactionInstructions = standaloneCompactionInstructions({
+      settings: eventing.modelRunSettings,
+      session,
+      workspaceAgentInstructions,
+      workspaceAgentIdentity,
+      workspaceGovernance,
+      structuredWorkspacePolicyActive,
+      workspaceMemory,
+      rig: rigVersion && rigName ? { name: rigName, version: rigVersion.version } : undefined,
+    });
     const requested = await isSessionCompactionRequested(db, input.workspaceId, input.sessionId);
     let outcome: Awaited<ReturnType<typeof maybeCompactContext>> | null = null;
     if (requested) {

package/src/activities/agent-turn/credential-restriction.ts

@@ -0,0 +1,14 @@
+import { readTurnExecutionPolicyV1, type TurnExecutionPolicyV1 } from "@opengeni/contracts";
+
+/** Only accepted policies establish the ceiling; ordinary metadata is not authority. */
+export function turnCredentialRestriction(
+  acceptedPolicy: TurnExecutionPolicyV1,
+  initialSessionMetadata: unknown,
+): "developer_setup" | undefined {
+  const initialPolicy = readTurnExecutionPolicyV1(initialSessionMetadata);
+  return acceptedPolicy.credentialRestriction === "developer_setup" ||
+    (initialPolicy.kind === "valid" &&
+      initialPolicy.policy.credentialRestriction === "developer_setup")
+    ? "developer_setup"
+    : undefined;
+}