@opengeni/core 2.6.4 → 2.7.2-canary.0

package/dist/model-catalog.d.ts

@@ -0,0 +1,105 @@
+import { type ConfiguredModel, type Settings } from "@opengeni/config";
+import { type ModelAvailabilityV1, type ModelCredentialReadinessV1, type WorkspaceModelPolicyContract } from "@opengeni/contracts";
+import { 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";
+    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;
+}): 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 = {
+    settings: Settings;
+    policy: WorkspaceModelPolicyContract | null;
+    codexSubscriptionActive: boolean;
+    xaiSubscriptionActive?: boolean;
+    workspaceGatewayConnectionActive?: boolean;
+    workspaceOpenRouterConnectionActive?: boolean;
+    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;
+};
+/**
+ * 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/sandbox/fleet.d.ts

@@ -128,6 +128,24 @@ export type FleetSwapResult = {
  * 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`:
@@ -238,3 +256,4 @@ export declare function provisionSandbox(services: FleetServices, ctx: FleetCont
     kind: "selfhosted" | "modal";
     name?: string;
 }): Promise<ProvisionResult>;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "2.6.4",
+  "version": "2.7.2-canary.0",
   "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": {
@@ -54,15 +54,15 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/codex": "^0.2.20",
-    "@opengeni/config": "^0.22.5",
-    "@opengeni/contracts": "^2.9.2",
-    "@opengeni/db": "^3.7.4",
-    "@opengeni/documents": "^0.8.14",
-    "@opengeni/events": "^0.4.12",
-    "@opengeni/observability": "^0.8.14",
-    "@opengeni/runtime": "^2.0.1",
-    "@opengeni/storage": "^0.2.115",
+    "@opengeni/codex": "^0.2.20-canary.2",
+    "@opengeni/config": "^0.23.2-canary.0",
+    "@opengeni/contracts": "^2.11.1-canary.0",
+    "@opengeni/db": "^3.8.2-canary.0",
+    "@opengeni/documents": "^0.8.17-canary.0",
+    "@opengeni/events": "^0.4.15-canary.0",
+    "@opengeni/observability": "^0.8.17-canary.0",
+    "@opengeni/runtime": "^2.1.2-canary.0",
+    "@opengeni/storage": "^0.2.118-canary.0",
     "hono": "^4.12.18",
     "zod": "^4.2.1"
   },

package/src/billing/limits.ts

@@ -1,4 +1,8 @@
-import { configuredStaticUsageLimits, resolveModelProvider } from "@opengeni/config";
+import {
+  configuredStaticUsageLimits,
+  resolveModelProviderForTurn,
+  type Settings,
+} from "@opengeni/config";
 import type {
   LimitAction,
   LimitDecision,
@@ -26,14 +30,35 @@ export type LimitCheckInput = {
   workspaceId?: string;
   action: LimitAction;
   quantity?: number;
-  // The turn's model id, when the action represents an agent turn. Externally
-  // billed models consume ZERO OpenGeni credits, so the credit-balance +
-  // model-cost + token gates are skipped. Connected subscriptions still require
-  // live workspace readiness; an explicitly anonymous deployment route is
-  // statically ready by definition. Non-model infra actions leave this undefined.
+  // The turn's model id, when the action represents an agent turn. The model's
+  // deployment cost controls credit/cost gates; upstream metering independently
+  // controls the token cap. Connected subscriptions still require live workspace
+  // readiness. Non-model infra actions leave this undefined.
   model?: string | null;
 };
 
+export function modelFundingForAdmission(
+  settings: Settings,
+  model: string | null | undefined,
+  codexBilled: boolean,
+): { fundedWithoutCredits: boolean; countsTowardTokenCap: boolean } {
+  const resolvedModel = model ? resolveModelProviderForTurn(settings, model)?.model : null;
+  const codexSubscriptionModel =
+    resolvedModel?.credentialSource.kind === "connected_subscription" &&
+    resolvedModel.credentialSource.provider === "codex";
+  return {
+    // A Codex namespace/definition never bypasses credits by itself: the live
+    // workspace credential predicate above remains authoritative. SuperGrok's
+    // static overlay is likewise secret-free; its worker/provider admission
+    // owns live account selection before any upstream request can occur.
+    fundedWithoutCredits:
+      codexBilled ||
+      (resolvedModel != null && !codexSubscriptionModel && resolvedModel.cost !== "credits"),
+    countsTowardTokenCap:
+      !codexBilled && resolvedModel != null && resolvedModel.billing.upstreamPayer === "deployment",
+  };
+}
+
 export async function requireLimit(deps: LimitDependencies, input: LimitCheckInput): Promise<void> {
   const decision = await checkLimit(deps, input);
   if (decision.allowed) {
@@ -59,25 +84,22 @@ export async function checkLimit(
         model: input.model,
       })
     : false;
-  const credentialFreeExternal = input.model
-    ? (() => {
-        const resolved = resolveModelProvider(deps.settings, input.model);
-        return (
-          resolved?.model.billing.metering === "external" &&
-          resolved.model.credentialSource.kind === "deployment" &&
-          resolved.model.credentialSource.mechanism === "none"
-        );
-      })()
-    : false;
-  const externallyBilled = codexBilled || credentialFreeExternal;
-  const creditDecision = await checkCreditBalance(deps, input, externallyBilled);
+  const { fundedWithoutCredits, countsTowardTokenCap } = modelFundingForAdmission(
+    deps.settings,
+    input.model,
+    codexBilled,
+  );
+  const creditDecision = await checkCreditBalance(deps, input, fundedWithoutCredits);
   if (!creditDecision.allowed) {
     return creditDecision;
   }
   if (deps.settings.usageLimitsMode !== "static" && deps.settings.usageLimitsMode !== "managed") {
     return { allowed: true };
   }
-  return await checkStaticCaps(deps, input, externallyBilled);
+  return await checkStaticCaps(deps, input, {
+    fundedWithoutCredits,
+    countsTowardTokenCap,
+  });
 }
 
 async function checkCreditBalance(
@@ -101,10 +123,14 @@ async function checkCreditBalance(
 async function checkStaticCaps(
   deps: LimitDependencies,
   input: LimitCheckInput,
-  externallyBilled: boolean,
+  funding: { fundedWithoutCredits: boolean; countsTowardTokenCap: boolean },
 ): Promise<LimitDecision> {
   const limits = configuredStaticUsageLimits(deps.settings);
-  if (limits.maxMonthlyCostMicrosPerAccount && isCostlyAction(input.action) && !externallyBilled) {
+  if (
+    limits.maxMonthlyCostMicrosPerAccount &&
+    isCostlyAction(input.action) &&
+    !funding.fundedWithoutCredits
+  ) {
     const used = await sumUsageQuantity(deps.db, {
       accountId: input.accountId,
       eventType: "model.cost",
@@ -185,7 +211,11 @@ async function checkStaticCaps(
           );
     }
     case "tokens:consume": {
-      if (externallyBilled || !limits.maxMonthlyTokensPerWorkspace || !input.workspaceId) {
+      if (
+        !funding.countsTowardTokenCap ||
+        !limits.maxMonthlyTokensPerWorkspace ||
+        !input.workspaceId
+      ) {
         return { allowed: true };
       }
       const used = await sumUsageQuantity(deps.db, {

package/src/dependencies.ts

@@ -19,6 +19,7 @@ import type { ManagedAuthSessionAdapter } from "./managed-auth-session-sets";
 import type { ApiSandboxClient, ResumeBoxByIdInput, ResumedSandboxSession } from "./sandbox-types";
 import type { TranscriptionSegmenter, TranscriptionService } from "./transcription";
 import type { EditableArtifactApplicationPort } from "./editable-artifact-live";
+import type { ResolvedCatalogSettings } from "./model-catalog";
 import type {
   EditableArtifactAgentApplication,
   EditableArtifactDurableExportService,
@@ -129,6 +130,13 @@ export type ManagedEmailTransport = {
 
 export type AppDependencies = {
   settings: Settings;
+  /**
+   * Original deployment settings when `settings` is already overlaid with a
+   * deployment/workspace catalog snapshot. Model-bearing request adapters set
+   * this marker so core admission never feeds a synthetic reviewed provider
+   * back through deployment validation.
+   */
+  catalogSourceSettings?: Settings;
   db: Database;
   /**
    * Host-composed editable artifact engine. Standalone startup binds the same
@@ -186,6 +194,8 @@ export type AppDependencies = {
   codexFetch?: typeof fetch;
   /** Injectable GitHub transport for deterministic personal-OAuth tests. */
   githubPersonalFetch?: typeof fetch;
+  /** Injectable credential-free GitHub transport for public repository verification tests. */
+  githubAnonymousFetch?: typeof fetch;
   /** Injectable xAI OAuth/subscription transport for deterministic API/provider tests. */
   xaiFetch?: typeof fetch;
   /** Injectable Slack Web API transport for deterministic bot-connection tests. */
@@ -225,6 +235,7 @@ export type AppDependencies = {
 export type ObjectStorageDependency = ReturnType<typeof createObjectStorage>;
 
 export type ApiRouteDeps = AppDependencies & {
+  resolveCatalogSettings: () => Promise<ResolvedCatalogSettings>;
   managedEmailTransport: ManagedEmailTransport;
   objectStorage: ObjectStorageDependency;
   githubStateSecret: string;
@@ -244,7 +255,12 @@ export type ApiRouteDeps = AppDependencies & {
  */
 export type AcceptSessionUserMessageDependencies = Pick<
   AppDependencies,
-  "settings" | "db" | "bus" | "sessionAuthorization" | "schedulePromptPostCommit"
+  | "settings"
+  | "catalogSourceSettings"
+  | "db"
+  | "bus"
+  | "sessionAuthorization"
+  | "schedulePromptPostCommit"
 > & {
   workflowClient: Pick<SessionWorkflowClient, "wakeSessionWorkflow">;
   objectStorage: ObjectStorageDependency;

package/src/domain/capabilities.ts

@@ -57,6 +57,7 @@ import { hasPermission } from "../access";
 import { isFikenConnection, preferredFikenConnection } from "./fiken";
 import { listSkillLibraryEntries, type SkillLibraryEntry } from "@opengeni/runtime/skill-library";
 import { listCapabilityPacks, listWorkspaceCapabilityPacks } from "./packs";
+import { assertHostMcpAuthoritySourceAdmissionEnabled } from "./host-mcp-authority-source-admission";
 
 const officialMcpRegistryUrl = "https://registry.modelcontextprotocol.io";
 const firstPartyMcpServerIds = new Set(["opengeni", "files", "docs"]);
@@ -403,7 +404,7 @@ function normalizedMcpCredentialHeaders(
 }
 
 async function validateMcpCapabilityConnectionRef(
-  input: { db: Database; grant: AccessGrant; workspaceId: string },
+  input: { db: Database; grant: AccessGrant; workspaceId: string; settings: Settings },
   item: CapabilityCatalogItem,
   ref: McpServerConnectionRef,
 ): Promise<McpServerConnectionRef> {
@@ -426,6 +427,7 @@ async function validateMcpCapabilityConnectionRef(
     providerDomain: ref.providerDomain.trim(),
     subjectScope,
     ...(ref.connectionId ? { connectionId: ref.connectionId } : {}),
+    ...(ref.authoritySource === "host" ? { authoritySource: "host" as const } : {}),
     ...(ref.provider ? { provider: ref.provider.trim() } : {}),
     ...(ref.kind ? { kind: ref.kind } : {}),
     ...(ref.scopes ? { scopes: uniqueStrings(ref.scopes) } : {}),
@@ -449,6 +451,10 @@ async function validateMcpCapabilityConnectionRef(
         "MCP capabilities need a remote streamable HTTP endpoint before they can use a connectionRef",
     });
   }
+  if (normalized.authoritySource === "host") {
+    assertHostMcpAuthoritySourceAdmissionEnabled(input.settings, normalized);
+    return normalized;
+  }
 
   let connection = normalized.connectionId
     ? await getConnectionMetadata(
@@ -1680,12 +1686,22 @@ function installationConnectionRef(
   if (!ref || typeof ref !== "object") {
     return null;
   }
-  const { connectionId, providerDomain, kind, subjectScope } = ref as Record<string, unknown>;
+  const { authoritySource, connectionId, providerDomain, kind, subjectScope } = ref as Record<
+    string,
+    unknown
+  >;
   if (typeof providerDomain !== "string" || typeof kind !== "string") {
     return null;
   }
+  if (authoritySource === "host") {
+    // The internal installation/runtime ref retains the exact host binding.
+    // Public capability catalogs use the existing null representation for an
+    // enabled capability without a native OpenGeni connection, so indefinitely
+    // open old browser bundles cannot treat a host UUID as native OAuth state.
+    return null;
+  }
   if (subjectScope === "subject") {
-    // Never project a personal connection UUID through workspace-visible
+    // Never project a native personal connection UUID through workspace-visible
     // capability configuration, including legacy rows that still contain one.
     return { providerDomain, kind, subjectScope: "subject" };
   }

package/src/domain/host-mcp-authority-source-admission.ts

@@ -0,0 +1,25 @@
+import type { Settings } from "@opengeni/config";
+import type { McpServerConnectionRef } from "@opengeni/contracts";
+import { HTTPException } from "hono/http-exception";
+
+/**
+ * Explicit host-owned MCP refs change which credential authority executes an
+ * opaque connection id. Admit new external refs only after the operator has
+ * completed the two-phase fleet rollout. Readers and inheritance remain
+ * tolerant regardless of this switch, and markerless legacy refs retain their
+ * bounded non-UUID compatibility path.
+ */
+export function assertHostMcpAuthoritySourceAdmissionEnabled(
+  settings: Pick<Settings, "hostMcpAuthoritySourceAdmissionEnabled">,
+  connectionRef: McpServerConnectionRef | null | undefined,
+): void {
+  if (
+    connectionRef?.authoritySource === "host" &&
+    !settings.hostMcpAuthoritySourceAdmissionEnabled
+  ) {
+    throw new HTTPException(422, {
+      message:
+        "new host-owned MCP connection refs are not admitted; upgrade the complete API/worker/web fleet, then set OPENGENI_HOST_MCP_AUTHORITY_SOURCE_ADMISSION_ENABLED=true",
+    });
+  }
+}

package/src/domain/insights.ts

@@ -305,6 +305,8 @@ export async function getWorkspaceInsights(
       creditUsd: microsToUsd(row.pricedCostMicros),
       estimatedProviderUsd: microsToUsd(row.estimatedProviderCostMicros),
       estimatedProviderCostKnownCalls: row.estimatedProviderCostKnownCalls,
+      equivalentCreditUsd: microsToUsd(row.equivalentCreditCostMicros),
+      equivalentCreditCostKnownCalls: row.equivalentCreditCostKnownCalls,
     }))
     .sort((a, b) => b.totalTokens - a.totalTokens);
 
@@ -326,6 +328,22 @@ export async function getWorkspaceInsights(
     (sum, row) => sum + row.estimatedProviderCostKnownCalls,
     0,
   );
+  const equivalentCreditCostMicros = modelRows.reduce(
+    (sum, row) => sum + row.equivalentCreditCostMicros,
+    0,
+  );
+  const priorEquivalentCreditCostMicros = priorModelRows.reduce(
+    (sum, row) => sum + row.equivalentCreditCostMicros,
+    0,
+  );
+  const equivalentCreditCostKnownCalls = modelRows.reduce(
+    (sum, row) => sum + row.equivalentCreditCostKnownCalls,
+    0,
+  );
+  const priorEquivalentCreditCostKnownCalls = priorModelRows.reduce(
+    (sum, row) => sum + row.equivalentCreditCostKnownCalls,
+    0,
+  );
   const modelCalls = modelRows.reduce((sum, row) => sum + row.calls, 0);
   const priorInputTokens = priorModelRows.reduce((sum, row) => sum + row.inputTokens, 0);
   const priorTotalTokens = priorModelRows.reduce((sum, row) => sum + row.totalTokens, 0);
@@ -342,6 +360,8 @@ export async function getWorkspaceInsights(
       costMicros: 0,
       estimatedProviderCostMicros: 0,
       estimatedProviderCostKnownCalls: 0,
+      equivalentCreditCostMicros: 0,
+      equivalentCreditCostKnownCalls: 0,
       inputTokens: 0,
       outputTokens: 0,
       cachedTokens: 0,
@@ -361,6 +381,8 @@ export async function getWorkspaceInsights(
       modelCostUsd: microsToUsd(modelCostMicros),
       estimatedProviderUsd: microsToUsd(facts.estimatedProviderCostMicros),
       estimatedProviderCostKnownCalls: facts.estimatedProviderCostKnownCalls,
+      equivalentCreditUsd: microsToUsd(facts.equivalentCreditCostMicros),
+      equivalentCreditCostKnownCalls: facts.equivalentCreditCostKnownCalls,
       warmSeconds: usageBuckets.get(bucket)?.warmSeconds ?? 0,
       inputTokens: facts.inputTokens,
       outputTokens: facts.outputTokens,
@@ -393,6 +415,8 @@ export async function getWorkspaceInsights(
       creditUsd,
       estimatedProviderUsd: microsToUsd(row.estimatedProviderCostMicros),
       estimatedProviderCostKnownCalls: row.estimatedProviderCostKnownCalls,
+      equivalentCreditUsd: microsToUsd(row.equivalentCreditCostMicros),
+      equivalentCreditCostKnownCalls: row.equivalentCreditCostKnownCalls,
       tokens: row.totalTokens,
       cacheHitPct: cacheHitPct(row.cachedTokens, row.cacheInputTokens),
       pctOfCreditUsd:
@@ -414,6 +438,8 @@ export async function getWorkspaceInsights(
       creditUsd: fact ? microsToUsd(fact.pricedCostMicros) : null,
       estimatedProviderUsd: fact ? microsToUsd(fact.estimatedProviderCostMicros) : null,
       estimatedProviderCostKnownCalls: fact ? fact.estimatedProviderCostKnownCalls : null,
+      equivalentCreditUsd: fact ? microsToUsd(fact.equivalentCreditCostMicros) : null,
+      equivalentCreditCostKnownCalls: fact ? fact.equivalentCreditCostKnownCalls : null,
       tokens: fact ? fact.totalTokens : null,
       cacheHitPct: fact ? cacheHitPct(fact.cachedTokens, fact.cacheInputTokens) : null,
       billing: fact ? billingPathOf(fact.billingPath) : null,
@@ -489,6 +515,8 @@ export async function getWorkspaceInsights(
         row.estimatedProviderCostMicros == null
           ? null
           : microsToUsd(row.estimatedProviderCostMicros),
+      equivalentCreditUsd:
+        row.equivalentCreditCostMicros == null ? null : microsToUsd(row.equivalentCreditCostMicros),
       pricingSource: pricingSourceOf(row.pricingSource),
     })),
     promptContributions,
@@ -522,6 +550,10 @@ export async function getWorkspaceInsights(
     priorEstimatedProviderUsd: microsToUsd(priorEstimatedProviderCostMicros),
     estimatedProviderCostKnownCalls,
     priorEstimatedProviderCostKnownCalls,
+    equivalentCreditUsd: microsToUsd(equivalentCreditCostMicros),
+    priorEquivalentCreditUsd: microsToUsd(priorEquivalentCreditCostMicros),
+    equivalentCreditCostKnownCalls,
+    priorEquivalentCreditCostKnownCalls,
     modelCalls,
     priorInputTokens,
     priorTotalTokens,

package/src/domain/packs.ts

@@ -31,6 +31,7 @@ import {
   PR_REVIEW_AUTOMATION_ADAPTER_ID,
   PR_REVIEW_AUTOMATION_TEMPLATE_ID,
 } from "./pr-review";
+import { OPENGENI_PRODUCT_INTEGRATION_PACK } from "./product-integration-pack";
 
 export const MARKETING_SOCIAL_PACK_ID = "marketing-social-daily-analysis";
 
@@ -277,7 +278,11 @@ const openGeniPrReviewPack: CapabilityPack = {
   },
 };
 
-const packs = [marketingSocialPack, openGeniPrReviewPack] satisfies CapabilityPack[];
+const packs = [
+  marketingSocialPack,
+  openGeniPrReviewPack,
+  OPENGENI_PRODUCT_INTEGRATION_PACK,
+] satisfies CapabilityPack[];
 
 export function listCapabilityPacks(): CapabilityPack[] {
   return packs;
@@ -355,6 +360,7 @@ export type InlinePackSkillInstall = {
   sourcePath: string;
   name: string;
   description: string;
+  activationMode: "workspace_managed" | "session_selected";
   contentSha256: string;
   totalBytes: number;
   files: Array<{ path: string; content: string; byteSize: number; contentSha256: string }>;
@@ -372,19 +378,22 @@ export function inlinePackSkillInstall(
     });
   }
   const normalizedName = skill.name.toLowerCase();
+  const activationMode = skill.activationMode ?? "workspace_managed";
+  const activationIdentity = activationMode === "session_selected" ? "session-selected/" : "";
   const encodedSkill = encodeURIComponent(normalizedName);
-  const sourceUrl = `https://opengeni.invalid/pack-inline-skills/${encodedSkill}/${artifact.contentSha256}`;
-  const capabilityId = `skill:pack-inline/${normalizedName}@${artifact.contentSha256}`;
+  const sourceUrl = `https://opengeni.invalid/pack-inline-skills/${activationIdentity}${encodedSkill}/${artifact.contentSha256}`;
+  const capabilityId = `skill:pack-inline/${activationIdentity}${normalizedName}@${artifact.contentSha256}`;
   return {
     componentKey: `inline-skill/${normalizedName}`,
     capabilityId,
-    pluginKey: `pack-skill/${normalizedName}/${artifact.contentSha256}`,
+    pluginKey: `pack-skill/${activationIdentity}${normalizedName}/${artifact.contentSha256}`,
     sourceUrl,
     repositoryUrl: "https://opengeni.invalid/pack-inline-skills",
     sourceCommit: artifact.contentSha256,
     sourcePath: normalizedName,
     name: artifact.name,
     description: artifact.description,
+    activationMode,
     contentSha256: artifact.contentSha256,
     totalBytes: artifact.totalBytes,
     files: artifact.files.map((file) => ({
@@ -405,21 +414,42 @@ export async function previewCapabilityPackInstallation(
   const { workspaceId } = access;
   const installation = await getPackInstallation(db, workspaceId, pack.id);
   const inlineInstalls = pack.skills.map((skill) => inlinePackSkillInstall(pack, skill));
-  const [referencedComponents, inlineComponents] = await Promise.all([
-    resolvePackComponentReferences(db, workspaceId, pack.components),
-    resolvePackInlineSkillReferences(
-      db,
-      workspaceId,
-      inlineInstalls.map((inline) => ({
-        key: inline.componentKey,
-        capabilityId: inline.capabilityId,
-        name: inline.name,
-        contentSha256: inline.contentSha256,
-      })),
-      installation?.id,
-    ),
-  ]);
   const manifestDigest = capabilityPackManifestDigest(pack);
+  const inlineRequirements = inlineInstalls.map((inline) => ({
+    key: inline.componentKey,
+    capabilityId: inline.capabilityId,
+    name: inline.name,
+    activationMode: inline.activationMode,
+    contentSha256: inline.contentSha256,
+  }));
+  const [referencedComponents, plannedInlineComponents, installedSessionSelectedComponents] =
+    await Promise.all([
+      resolvePackComponentReferences(db, workspaceId, pack.components),
+      resolvePackInlineSkillReferences(db, workspaceId, inlineRequirements, installation?.id),
+      installation?.status === "active" && installation.manifestDigest === manifestDigest
+        ? resolvePackInlineSkillReferences(
+            db,
+            workspaceId,
+            inlineRequirements.filter(
+              (requirement) => requirement.activationMode === "session_selected",
+            ),
+          )
+        : Promise.resolve([]),
+    ]);
+  const installedSessionSelectedByKey = new Map(
+    installedSessionSelectedComponents.map((component) => [component.key, component]),
+  );
+  // Installation planning excludes the Pack's own current ownership so an
+  // update can replace old inline content. For launch affordances, preserve an
+  // independently resolved active facet-installation id on an exact installed
+  // manifest. A missing facet retains the future capability id and therefore
+  // cannot be mistaken for something a new session can select right now.
+  const inlineComponents = plannedInlineComponents.map((component) => {
+    const installed = installedSessionSelectedByKey.get(component.key);
+    return installed?.status === "ready" && installed.resolvedId
+      ? { ...component, resolvedId: installed.resolvedId }
+      : component;
+  });
   const components: PackComponentResolution[] = [...referencedComponents, ...inlineComponents];
   const blockers = components
     .filter((component) => component.required && component.status !== "ready")