@stigmer/runner 3.5.3 → 3.7.0

package/src/activities/execute-cursor/index.ts

@@ -49,6 +49,10 @@ import { utcTimestamp, persistStatus, reportSetupProgress, slimStatus } from "..
 import { TimingRecorder, emitTimingLog } from "../../shared/cold-start-timing.js";
 import { readContextBridge } from "../../shared/context-bridge.js";
 import { readSenderIdentity } from "../../shared/sender-identity.js";
+import {
+  injectCallerIdentityEnv,
+  resolveCallerIdentity,
+} from "../../shared/caller-identity.js";
 import { readSessionContext } from "../../shared/session-context.js";
 import { withholdSecretContentFromMessages } from "../../shared/tool-row.js";
 import { StallTimeoutError, formatStallFailure } from "../../shared/stall-watchdog.js";
@@ -60,10 +64,12 @@ import { StreamingUpdateScheduler, loadStreamingConfig } from "../../shared/stre
 import { createCursorEventRecorder } from "./cursor-event-recorder.js";
 import { resolveMcpServers, toCursorMcpConfig, validateMcpServerEnv } from "./mcp-resolver.js";
 import { resolveMcpTransportPosture } from "../../shared/mcp-transport-guard.js";
+import { synthesizeDatastoreAttachment } from "../../shared/datastore-attachment.js";
 import {
-  injectDatastoreAttachment,
-  synthesizeDatastoreAttachment,
-} from "../../shared/datastore-attachment.js";
+  discoverChannelMessaging,
+  synthesizeChannelAttachment,
+} from "../../shared/channel-attachment.js";
+import { injectSynthesizedAttachment } from "../../shared/synthesized-attachment.js";
 import { mergeApprovalPolicies } from "./approval-policy.js";
 import { deriveActiveLeases, isUnattendedApprovalMode } from "../../shared/approval-policy.js";
 import { backfillMcpServersIfNeeded } from "./connect-backfill.js";
@@ -115,6 +121,7 @@ import { statusProtoWriter } from "../../shared/execution-status-writer.js";
 import { setInterceptorExecutionId, runWithExecutionContext } from "./fetch-interceptor.js";
 import { closeProxySessions } from "./http2-interceptor.js";
 import { resolveModelId, ensureLoaded as ensurePricingLoaded } from "./model-pricing.js";
+import { resolveEffectiveServiceTier, resolveServiceTierParams } from "./service-tier.js";
 import { UsageAccumulator } from "./usage-accumulator.js";
 import { StreamingUsageSummarySchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/usage_pb";
 import { activityStarted, activityFinished } from "../../idle-watchdog.js";
@@ -590,11 +597,23 @@ async function executeCursorInner(
       }
     }
 
-    // Phase 4: Resolve MCP servers with approval policies
+    // Phase 4: Resolve MCP servers with approval policies.
+    // The MCP-bound env map (and ONLY it — never the agent process env)
+    // carries the reserved caller-identity keys, so a server that declares
+    // them in spec.env can template the platform-verified caller into its
+    // headers. filterEnvToDeclaredKeys keeps every other server blind.
     await reportSetupProgress(client, executionId, "Resolving MCP servers");
     const transportPosture = resolveMcpTransportPosture(config.mode);
+    const mcpEnvVars = injectCallerIdentityEnv(
+      envVars,
+      resolveCallerIdentity(
+        blueprint.sessionSpec.metadata,
+        session.status?.audit?.specAudit?.createdBy,
+      ),
+      sessionId,
+    );
     let mcpResolution = await resolveMcpServers(
-      client, blueprint.mergedMcpServerUsages, envVars, transportPosture,
+      client, blueprint.mergedMcpServerUsages, mcpEnvVars, transportPosture,
     );
     setupTiming.mark("resolve_mcp_servers");
 
@@ -602,11 +621,24 @@ async function executeCursorInner(
     heartbeatPhase = "resolving_mcp_servers";
     const sessionOrg = session.metadata?.org ?? "";
     mcpResolution = await backfillMcpServersIfNeeded(
-      client, mcpResolution, blueprint.mergedMcpServerUsages, envVars, sessionOrg,
+      client, mcpResolution, blueprint.mergedMcpServerUsages, mcpEnvVars, sessionOrg,
       transportPosture, heartbeat, secretKeys,
     );
     setupTiming.mark("backfill_mcp");
 
+    // The synthesized attachments' credential story (DD-006 D4): the
+    // exchanged token authenticates the discovery reads per-call (a
+    // desktop runner's ambient embedded_runner credential is refused by
+    // the messaging reach; undefined lets a cloud sandbox runner's
+    // ambient session-scoped token or OSS's no-auth apply). The
+    // attachment header falls back to the ambient credential where no
+    // exchange happens.
+    const exchangedRunnerToken =
+      await client.acquireScopedRunnerToken({ agentExecutionId: executionId });
+    const attachmentCredential = exchangedRunnerToken
+      ?? config.stigmerTokenRef?.current
+      ?? config.stigmerToken;
+
     // Phase 4a2: Synthesize the datastore records attachment (T05).
     // Deliberately AFTER resolve + backfill: the attachment has no
     // McpServerUsage and reports discovered capabilities, so the
@@ -614,18 +646,38 @@ async function executeCursorInner(
     // delete_record (which on channels would be silently skipped).
     // Empty approval maps keep it approval-free by construction.
     if (blueprint.datastoreUsages.length > 0) {
-      const scopedCredential =
-        (await client.acquireScopedRunnerToken({ agentExecutionId: executionId }))
-        ?? config.stigmerTokenRef?.current
-        ?? config.stigmerToken;
       const attachment = synthesizeDatastoreAttachment(blueprint.datastoreUsages, {
         bridgeEndpoint: config.mcpBridgeEndpoint,
-        credential: scopedCredential,
+        credential: attachmentCredential,
         backendEndpoint: config.stigmerBackendEndpoint,
       });
       if (attachment) {
-        const resolvedServers = injectDatastoreAttachment(
-          mcpResolution.resolvedServers, attachment,
+        const resolvedServers = injectSynthesizedAttachment(
+          mcpResolution.resolvedServers, attachment, "datastore records",
+        );
+        mcpResolution = {
+          resolvedServers,
+          cursorConfig: toCursorMcpConfig(resolvedServers),
+        };
+      }
+    }
+
+    // Phase 4a3: Synthesize the channel messaging attachment (DD-006
+    // D7/D8), the records attachment's twin. The discovery read is the
+    // attachment decision — the control plane runs the SAME candidate
+    // computation the send authorization uses — and every failure mode
+    // (no channel, OSS, registry down, pre-3a control plane) degrades
+    // to honest absence: no tool, no section, execution unharmed.
+    const channelMessaging = await discoverChannelMessaging(client, exchangedRunnerToken);
+    if (channelMessaging.length > 0) {
+      const attachment = synthesizeChannelAttachment(channelMessaging, {
+        bridgeEndpoint: config.mcpBridgeEndpoint,
+        credential: attachmentCredential,
+        backendEndpoint: config.stigmerBackendEndpoint,
+      });
+      if (attachment) {
+        const resolvedServers = injectSynthesizedAttachment(
+          mcpResolution.resolvedServers, attachment, "channel messaging",
         );
         mcpResolution = {
           resolvedServers,
@@ -838,7 +890,9 @@ async function executeCursorInner(
     await ensurePricingLoaded();
     setupTiming.mark("load_pricing");
 
-    // Phase 6: Validate model selection
+    // Phase 6: Validate model selection and resolve the service tier.
+    // UNSPECIFIED → STANDARD resolves here and nowhere else (#357): every
+    // upstream layer preserves the caller's raw enum value.
     const requestedModel = spec.executionConfig?.modelName || "default";
     const validatedModel = resolveModelId(requestedModel);
     if (validatedModel !== requestedModel) {
@@ -846,6 +900,7 @@ async function executeCursorInner(
         `ExecuteCursor model resolved: execution=${executionId}, requested="${requestedModel}", using="${validatedModel}"`,
       );
     }
+    const requestedServiceTier = resolveEffectiveServiceTier(spec.executionConfig?.serviceTier);
 
     heartbeat();
 
@@ -880,10 +935,21 @@ async function executeCursorInner(
       );
     }
 
+    // Translate the tier into the explicit variant params sent with every
+    // create/resume. Never a bare { id }: the catalog's default variant is
+    // account-influenced and picks the price (#357).
+    const modelParams = await resolveServiceTierParams({
+      apiKey: effectiveApiKey,
+      modelId: validatedModel,
+      tier: requestedServiceTier,
+      executionId,
+    });
+
     const createOptions: CreateAgentOptions | CreateCloudAgentOptions = agentMode === "cloud"
       ? {
           apiKey: effectiveApiKey,
           model: validatedModel || undefined,
+          modelParams,
           repos: blueprint.cloudRepos,
           sessionId,
           mcpServers: mcpConfig,
@@ -892,6 +958,7 @@ async function executeCursorInner(
       : {
           apiKey: effectiveApiKey,
           model: validatedModel,
+          modelParams,
           workspaceDirs: blueprint.workspaceDirs,
           sessionId,
           workspaceRootDir: config.workspaceRootDir,
@@ -992,6 +1059,7 @@ async function executeCursorInner(
       userMessage: spec.message,
       skills: skillMetadata,
       datastoreUsages: blueprint.datastoreUsages,
+      channelMessaging,
       subAgents: blueprint.subAgents,
       workspaceDirs: blueprint.workspaceDirs,
       workspaceFileRefs: spec.workspaceFileRefs ?? [],
@@ -1023,7 +1091,11 @@ async function executeCursorInner(
 
     // Phase 10b: Initialize usage accumulator for runner-side token tracking
     await ensurePricingLoaded();
-    const usageAccumulator = new UsageAccumulator(validatedModel);
+    const usageAccumulator = new UsageAccumulator(
+      validatedModel,
+      requestedServiceTier,
+      modelParams,
+    );
 
     // Phase 10c: Start OTel turn span. Coarse-grained — spans the whole turn
     // (agent.send + stream + any recovery retry + the turn boundary), ended once
@@ -1525,14 +1597,36 @@ async function executeCursorInner(
 
     // Phase 13: Map final result
     const result = await run.wait();
-    const sdkResolvedModel = result.model?.id || undefined;
     console.log(
       `ExecuteCursor run.wait() result: execution=${executionId}, result=${JSON.stringify(result)}`,
     );
-    if (sdkResolvedModel && sdkResolvedModel !== validatedModel) {
-      console.log(
-        `ExecuteCursor model divergence: execution=${executionId}, requested=${validatedModel}, sdkResolved=${sdkResolvedModel}`,
-      );
+    // Echo sanity check only: result.model ECHOES the requested selection —
+    // the SDK never reports the variant that actually served the call
+    // (verified against the billing ledger, #357). A mismatch here means the
+    // SDK rewrote our selection (contract change), not variant drift; the
+    // authoritative requested-vs-billed reconciliation is the cloud billing
+    // handler's pricing_variant mismatch metric.
+    const echoedSelection = result.model;
+    if (echoedSelection) {
+      const idMatches = echoedSelection.id === validatedModel;
+      // Compare id/value pairs explicitly, never serialized objects: the SDK
+      // may add fields to ModelParameterValue or reorder keys, and neither
+      // is contract drift.
+      const echoedParams = [...(echoedSelection.params ?? [])]
+        .sort((a, b) => a.id.localeCompare(b.id));
+      const paramsMatch =
+        echoedParams.length === modelParams.length &&
+        echoedParams.every(
+          (p, i) => p.id === modelParams[i].id && p.value === modelParams[i].value,
+        );
+      if (!idMatches || !paramsMatch) {
+        console.warn(
+          `ExecuteCursor model selection echo mismatch (SDK contract drift?): ` +
+          `execution=${executionId}, ` +
+          `requested=${JSON.stringify({ id: validatedModel, params: modelParams })}, ` +
+          `echoed=${JSON.stringify(echoedSelection)}`,
+        );
+      }
     }
     status.completedAt = utcTimestamp();
 
@@ -1605,6 +1699,7 @@ async function executeCursorInner(
             userMessage: spec.message,
             skills: skillMetadata,
             datastoreUsages: blueprint.datastoreUsages,
+            channelMessaging,
             subAgents: blueprint.subAgents,
             workspaceDirs: blueprint.workspaceDirs,
             workspaceFileRefs: spec.workspaceFileRefs ?? [],
@@ -2169,6 +2264,11 @@ export interface BuildPromptInput {
   skills: import("./prompt-builder.js").SkillMetadata[];
   /** Datastores attached via `datastore_usages` — the `<available_datastores>` section. */
   datastoreUsages?: import("@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb").DatastoreUsage[];
+  /**
+   * Serving proactive channels + their templates (the DD-006 D2
+   * discovery read) — the `<available_channel_templates>` section.
+   */
+  channelMessaging?: import("../../shared/channel-attachment.js").ChannelMessagingInfo[];
   subAgents: import("@stigmer/protos/ai/stigmer/agentic/agent/v1/spec_pb").SubAgent[];
   workspaceDirs: string[];
   workspaceFileRefs: string[];
@@ -2276,6 +2376,7 @@ export function buildPrompt(input: BuildPromptInput): string {
     userMessage,
     skills,
     datastoreUsages: input.datastoreUsages ?? [],
+    channelMessaging: input.channelMessaging ?? [],
     subAgents,
     workspaceDirs,
     workspaceFileRefs,

package/src/activities/execute-cursor/model-pricing.ts

@@ -139,6 +139,29 @@ export function getCursorModelPricing(model: string): CursorModelPricing {
   return { ...DEFAULT_PRICING, model };
 }
 
+/**
+ * Look up pricing for a Cursor model under an explicitly requested speed
+ * variant (stigmer/stigmer#357). Unlike the suffix inference above — which
+ * derives the variant from a wire id like "composer-2.5-fast" — this is for
+ * callers that KNOW the variant because they requested it. Falls back to
+ * base rates (with a warning) when the registry prices no such variant;
+ * create-time validation makes that unreachable short of registry drift.
+ */
+export function getCursorModelPricingForVariant(
+  model: string,
+  variant: "fast" | null,
+): CursorModelPricing {
+  const base = getCursorModelPricing(model);
+  if (variant !== "fast") return base;
+  const fast = applyFastVariant(base, model);
+  if (fast) return fast;
+  console.warn(
+    `Requested fast-variant pricing for "${model}" but the registry prices no fast variant — ` +
+    `estimating at base rates (billing reconciliation remains authoritative)`,
+  );
+  return base;
+}
+
 /**
  * Compute USD cost for a single turn.
  *

package/src/activities/execute-cursor/prompt-builder.ts

@@ -22,6 +22,10 @@ import type { PendingApproval } from "@stigmer/protos/ai/stigmer/agentic/agentex
 import { ApprovalAction, InteractionMode } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 import { formatContextBridgeText } from "../../shared/context-bridge.js";
 import { formatDatastoresSection } from "../../shared/datastore-attachment.js";
+import {
+  formatChannelTemplatesSection,
+  type ChannelMessagingInfo,
+} from "../../shared/channel-attachment.js";
 import {
   formatSenderIdentityText,
   type SenderIdentity,
@@ -61,6 +65,12 @@ export interface EnhancedPromptOptions {
    * pointing the model at the synthesized record tools.
    */
   datastoreUsages?: DatastoreUsage[];
+  /**
+   * Serving proactive channels + their approved templates — rendered as
+   * the `<available_channel_templates>` section (proactive-messaging
+   * DD-003 D5) beside the synthesized send_channel_message tool.
+   */
+  channelMessaging?: ChannelMessagingInfo[];
   subAgents: SubAgent[];
   workspaceDirs: string[];
   workspaceFileRefs: string[];
@@ -133,6 +143,15 @@ export function buildEnhancedPrompt(options: EnhancedPromptOptions): string {
     sections.push(formatDatastoresSection(options.datastoreUsages));
   }
 
+  if (options.channelMessaging !== undefined && options.channelMessaging.length > 0) {
+    // "" when nothing is sendable — the tool alone still serves text
+    // sends inside a 24-hour window (DD-006 D6).
+    const channelSection = formatChannelTemplatesSection(options.channelMessaging);
+    if (channelSection !== "") {
+      sections.push(channelSection);
+    }
+  }
+
   if (options.subAgents.length > 0) {
     sections.push(formatSubAgentsSection(options.subAgents));
   }

package/src/activities/execute-cursor/service-tier.ts

@@ -0,0 +1,244 @@
+/**
+ * Service-tier → Cursor variant-parameter translation (stigmer/stigmer#357).
+ *
+ * The platform contract: an execution's model selection is ALWAYS explicit.
+ * A bare `{ id }` lets the Cursor catalog's default variant decide the price
+ * (observed 2026-08-06: composer-2.5 defaults to fast=true at ~4x base
+ * rates, claude-haiku-4-5 to thinking=true), and that default follows an
+ * out-of-band account setting. This module pins every price-bearing variant
+ * parameter the model declares, so the billed variant is a deterministic
+ * function of ExecutionConfig.service_tier:
+ *
+ * - STANDARD: every price-bearing boolean pinned to its base value
+ *   (fast=false, thinking=false where the parameter exists).
+ * - FAST: fast=true, thinking still pinned false.
+ * - Price-neutral parameters (e.g. effort) are deliberately NOT pinned —
+ *   they follow the catalog default and do not change the bill.
+ *
+ * Parameter bundles come from Cursor.models.list() (worker-cached): the
+ * catalog is the only source of a model's parameter ids, and the fetch
+ * rides the same proxy fetch-interceptor as every other SDK call, so it
+ * works identically in proxy and direct modes.
+ *
+ * UNSPECIFIED resolves to STANDARD here and ONLY here — every upstream
+ * layer preserves the caller's raw enum so "user chose standard" stays
+ * distinguishable from "platform default" all the way to the ledger.
+ */
+
+import { Cursor } from "@cursor/sdk";
+import type { ModelListItem, ModelParameterValue } from "@cursor/sdk";
+import { ServiceTier } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+
+/**
+ * The effective tier after platform-default resolution: never UNSPECIFIED.
+ */
+export type EffectiveServiceTier = ServiceTier.STANDARD | ServiceTier.FAST;
+
+/**
+ * Catalog ids that mean "Cursor picks the model" (Auto). Auto's single
+ * catalog variant has an empty parameter set — there is no tier dimension
+ * to pin, a documented v1 limitation. Create-time validation refuses FAST
+ * without a pinned model, so FAST can only reach Auto through registry
+ * drift — handled as a loud failure below.
+ */
+const AUTO_MODEL_IDS = new Set(["default", "auto"]);
+
+/**
+ * Variant parameter ids that change the per-token price. Pinning exactly
+ * these keeps the bill deterministic while leaving latency/effort knobs on
+ * their catalog defaults. Sourced from the Cursor catalog survey
+ * (stigmer-cloud _projects/2026-08/20260806.04.model-service-tier).
+ */
+const FAST_PARAM_ID = "fast";
+const THINKING_PARAM_ID = "thinking";
+
+const CATALOG_CACHE_TTL_MS = 3_600_000; // 1 hour, matching the pricing table TTL
+
+interface CatalogCache {
+  readonly apiKey: string;
+  readonly models: readonly ModelListItem[];
+  readonly expiresAt: number;
+}
+
+let catalogCache: CatalogCache | null = null;
+// Keyed by apiKey: a worker normally serves one org's key, but nothing
+// enforces that — handing execution A a catalog fetched under execution B's
+// key would leak another account's model availability into A's translation.
+let inflightCatalogFetch: { readonly apiKey: string; readonly promise: Promise<readonly ModelListItem[]> } | null = null;
+
+/** Test-only: drop the worker-level catalog cache. */
+export function resetCatalogCacheForTests(): void {
+  catalogCache = null;
+  inflightCatalogFetch = null;
+}
+
+/**
+ * Resolve the configured tier to its effective value. The single place in
+ * the platform where UNSPECIFIED becomes STANDARD.
+ */
+export function resolveEffectiveServiceTier(
+  configured: ServiceTier | undefined,
+): EffectiveServiceTier {
+  return configured === ServiceTier.FAST ? ServiceTier.FAST : ServiceTier.STANDARD;
+}
+
+/** Human-readable tier label for logs and error messages. */
+export function serviceTierLabel(tier: ServiceTier): string {
+  switch (tier) {
+    case ServiceTier.FAST:
+      return "fast";
+    case ServiceTier.STANDARD:
+      return "standard";
+    default:
+      return "unspecified";
+  }
+}
+
+async function listCatalogModels(apiKey: string): Promise<readonly ModelListItem[]> {
+  const now = Date.now();
+  if (catalogCache && catalogCache.apiKey === apiKey && catalogCache.expiresAt > now) {
+    return catalogCache.models;
+  }
+  if (inflightCatalogFetch?.apiKey === apiKey) return inflightCatalogFetch.promise;
+
+  let entry: { apiKey: string; promise: Promise<readonly ModelListItem[]> } | null = null;
+  const promise = (async () => {
+    try {
+      const models = await Cursor.models.list({ apiKey });
+      catalogCache = { apiKey, models, expiresAt: Date.now() + CATALOG_CACHE_TTL_MS };
+      return models;
+    } finally {
+      // Clear only our own entry — a concurrent fetch under another key may
+      // have replaced it.
+      if (inflightCatalogFetch === entry) {
+        inflightCatalogFetch = null;
+      }
+    }
+  })();
+  entry = { apiKey, promise };
+  inflightCatalogFetch = entry;
+  return promise;
+}
+
+function findCatalogModel(
+  models: readonly ModelListItem[],
+  modelId: string,
+): ModelListItem | undefined {
+  return models.find((m) => m.id === modelId || m.aliases?.includes(modelId));
+}
+
+export interface ResolveServiceTierParamsOptions {
+  readonly apiKey: string;
+  /** Validated model id the execution runs on (may be "default" for Auto). */
+  readonly modelId: string;
+  readonly tier: EffectiveServiceTier;
+  /** For log correlation only. */
+  readonly executionId: string;
+}
+
+/**
+ * Translate the effective tier into the explicit variant parameters to send
+ * with every Agent.create/resume for this execution.
+ *
+ * Fail-closed posture: FAST with no pinnable fast dimension is an error,
+ * never a silent downgrade — create-time validation makes this unreachable
+ * unless the registry and the provider catalog have drifted, and that drift
+ * must be heard about, not absorbed.
+ *
+ * STANDARD degrades to empty params on catalog failures rather than failing
+ * the execution — but be clear about what that costs: an unpinned selection
+ * falls to the catalog default variant, which for several models IS the
+ * fast/thinking variant at multiples of base rates (the incident this module
+ * exists to prevent). Failing every standard execution whenever the catalog
+ * endpoint blips would be the worse trade; the WARN below plus billing's
+ * requested-vs-billed mismatch alarm (which catches exactly this window)
+ * are the compensating controls.
+ */
+export async function resolveServiceTierParams(
+  options: ResolveServiceTierParamsOptions,
+): Promise<ModelParameterValue[]> {
+  const { apiKey, modelId, tier, executionId } = options;
+  const tierName = serviceTierLabel(tier);
+
+  if (AUTO_MODEL_IDS.has(modelId)) {
+    if (tier === ServiceTier.FAST) {
+      throw new Error(
+        `service_tier=fast requires a pinned model — Auto ("${modelId}") has no ` +
+        `tier dimension. Execution ${executionId} should have been refused at ` +
+        `create time; the model registry and provider catalog may have drifted.`,
+      );
+    }
+    console.log(
+      `ServiceTier: execution=${executionId} model=${modelId} tier=${tierName} — ` +
+      `Auto has no variant parameters; Cursor picks the model and variant ` +
+      `(documented v1 limitation).`,
+    );
+    return [];
+  }
+
+  let models: readonly ModelListItem[];
+  try {
+    models = await listCatalogModels(apiKey);
+  } catch (err) {
+    if (tier === ServiceTier.FAST) {
+      throw new Error(
+        `service_tier=fast for execution ${executionId} needs the Cursor model ` +
+        `catalog to resolve variant params for "${modelId}", and the catalog ` +
+        `fetch failed: ${err instanceof Error ? err.message : String(err)}`,
+      );
+    }
+    console.warn(
+      `ServiceTier UNPINNED: execution=${executionId} model=${modelId} tier=${tierName} — ` +
+      `catalog fetch failed (${err instanceof Error ? err.message : err}); ` +
+      `sending no variant params, so the catalog DEFAULT variant decides the ` +
+      `price for this execution (fast/thinking on several models — the ` +
+      `expensive direction). Billing's requested-vs-billed mismatch alarm ` +
+      `covers this window.`,
+    );
+    return [];
+  }
+
+  const model = findCatalogModel(models, modelId);
+  if (!model) {
+    if (tier === ServiceTier.FAST) {
+      throw new Error(
+        `service_tier=fast requested for "${modelId}" (execution ${executionId}) ` +
+        `but the Cursor catalog does not list that model — cannot pin a fast ` +
+        `variant. The model registry and provider catalog have drifted.`,
+      );
+    }
+    console.warn(
+      `ServiceTier UNPINNED: execution=${executionId} model=${modelId} tier=${tierName} — ` +
+      `model not in the Cursor catalog; sending no variant params, so the ` +
+      `catalog DEFAULT variant decides the price for this execution.`,
+    );
+    return [];
+  }
+
+  const params: ModelParameterValue[] = [];
+  for (const def of model.parameters ?? []) {
+    if (def.id === FAST_PARAM_ID) {
+      params.push({ id: FAST_PARAM_ID, value: tier === ServiceTier.FAST ? "true" : "false" });
+    } else if (def.id === THINKING_PARAM_ID) {
+      params.push({ id: THINKING_PARAM_ID, value: "false" });
+    }
+    // Any other parameter (e.g. effort) is price-neutral: left to the
+    // catalog default variant on purpose.
+  }
+
+  if (tier === ServiceTier.FAST && !params.some((p) => p.id === FAST_PARAM_ID)) {
+    throw new Error(
+      `service_tier=fast requested for "${modelId}" (execution ${executionId}) ` +
+      `but the Cursor catalog declares no "fast" parameter for it. The model ` +
+      `registry prices a fast variant the provider no longer offers — refusing ` +
+      `rather than silently billing an unknown variant.`,
+    );
+  }
+
+  params.sort((a, b) => a.id.localeCompare(b.id));
+  console.log(
+    `ServiceTier: execution=${executionId} model=${modelId} tier=${tierName} ` +
+    `params=${JSON.stringify(params)}`,
+  );
+  return params;
+}